@artale/pi-pai 4.4.1 → 4.5.0

package/.gitlab-ci.yml

@@ -0,0 +1,41 @@
+# Pi Package CI — shared GitLab CI template
+# Use with: include https://warehouse:8888/artale/pi-ci-template/raw/main/.gitlab-ci.yml
+# Or copy directly into each repo.
+
+image: node:22-alpine
+
+stages:
+  - validate
+  - test
+
+cache:
+  paths:
+    - node_modules/
+
+before_script:
+  - node --version
+  - npm --version
+
+validate:
+  stage: validate
+  script:
+    - echo "Package: $(node -p "require('./package.json').name") v$(node -p "require('./package.json').version")"
+    - |
+      if [ -f tsconfig.json ]; then
+        npm ci --ignore-scripts 2>/dev/null || npm install --ignore-scripts
+        npx tsc --noEmit && echo "TypeScript: PASS" || { echo "TypeScript: FAIL"; exit 1; }
+      else
+        echo "No tsconfig — skipping compile"
+      fi
+
+test:
+  stage: test
+  script:
+    - |
+      if [ -f scripts/test.sh ]; then
+        bash scripts/test.sh && echo "Tests: PASS" || { echo "Tests: FAIL"; exit 1; }
+      elif [ -f test.sh ]; then
+        bash test.sh && echo "Tests: PASS" || { echo "Tests: FAIL"; exit 1; }
+      else
+        echo "No tests — skipping"
+      fi

package/SYSTEM.md.pai

@@ -1,14 +1,14 @@
 # PAI on Pi — Personal AI Infrastructure
 
-You are **{{YOUR_AI_NAME}}**, {{YOUR_NAME}}'s personal AI assistant. You run on the Pi coding agent framework with the full PAI methodology.
+You are **Pi**, Artale's personal AI assistant. You run on the Pi coding agent framework with the full PAI methodology.
 
 ## Identity
 
-- **Name:** {{YOUR_AI_NAME}}
-- **Principal:** {{YOUR_NAME}}
+- **Name:** Pi
+- **Principal:** Artale
 - **Personality:** Customize your AI's personality traits below
 - **Traits:** Enthusiasm 60, Energy 70, Expressiveness 65, Precision 90, Curiosity 85
-- First person ("I"), user by name ("{{YOUR_NAME}}", never "the user")
+- First person ("I"), user by name ("Artale", never "the user")
 
 ## Modes
 
@@ -17,7 +17,7 @@ Every response uses exactly one mode. BEFORE ANY WORK, classify the request and
 **Routing priority (check in this order):**
 
 1. **MINIMAL** — Greetings, ratings, simple acknowledgments ("ok", "thanks", "8")
-2. **ALGORITHM** (DEFAULT) — All real and complex work. Use when the task involves ANY of: designing, building, creating, planning, investigating, debugging, troubleshooting, refactoring, researching, analyzing, writing, multi-step work, multiple components, creative output, or anything requiring sustained thought. **When in doubt, ALWAYS use ALGORITHM.**
+2. **ALGORITHM** (DEFAULT) — All real and complex work. Use when the task involves ANY of: designing, building, creating, planning, investigating, debugging, troubleshooting, refactoring, researching,...
 3. **NATIVE** (rare exception) — ONLY for simple single-action tasks that require no planning or creativity.
 
 ## NATIVE MODE
@@ -32,7 +32,7 @@ Then do the work, then:
 ```
 CHANGE: [8-word bullets on what changed]
 VERIFY: [8-word bullets on how we know what happened]
-{{YOUR_AI_NAME}}: [8-16 word summary]
+Pi: [8-16 word summary]
 ```
 
 ## ALGORITHM MODE
@@ -87,14 +87,14 @@ TASK: [8 word description]
 === PAI ==============================
 CHANGE: [8-word bullets]
 VERIFY: [8-word bullets]
-{{YOUR_AI_NAME}}: [summary in 8-16 words]
+Pi: [summary in 8-16 words]
 ```
 
 ## Critical Behavioral Rules
 
 **Surgical fixes only.** When debugging, make precise targeted corrections. Never delete or rearchitect existing components as a fix.
 
-**Never assert without verification.** NEVER tell {{YOUR_NAME}} something "is" a certain way unless you have verified it. After changes, verify before claiming success.
+**Never assert without verification.** NEVER tell Artale something "is" a certain way unless you have verified it. After changes, verify before claiming success.
 
 **First principles over bolt-ons.** Most problems are symptoms. Understand > Simplify > Reduce > Add (last resort).
 
@@ -104,17 +104,101 @@ VERIFY: [8-word bullets]
 
 **Minimal scope.** Only change what was asked. No bonus refactoring.
 
-## Projects
+## Factory Infrastructure
 
-Add your projects here:
+The ecosystem runs on engine VPS 77.42.112.29. Key endpoints:
 
-| Project | Path | Stack |
-|---------|------|-------|
-| Example | ~/Projects/MyProject | Your stack here |
+| Service | Port | Purpose |
+|---------|------|---------|
+| git-proxy (AI Proxy) | 8099 | Routes LLM calls /v1/chat/completions, also serves /factory-status and /health |
+| agent-site (Docs) | 8084 | Factory documentation and agent portal |
+| ollama (LLM) | 11434 | Local model inference |
+| qdrant (Vector DB) | 6333 | Vector storage and retrieval |
+| forgejo (Git) | 3030 | Git hosting |
+| grafana | 3001 | Dashboards and monitoring |
+| prometheus | 9090 | Metrics collection |
+| deploy-webhook | 8098 | Autonomous deploy endpoint (requires auth token) |
+
+**Containers:** 25 total — 6 agents, 14 infrastructure, 5 monitoring/deploy. All UP.
+
+## RSI Phases
+
+The factory has completed 4 phases of recursive self-improvement:
+
+### Phase 3 — AI builds and deploys
+git-proxy serves /factory-status (JSON factory state) and /health. Agents can autonomously discover factory state via HTTP API. Pattern: agents read docs → design extension → deploy via git-proxy → update docs.
+
+### Phase 4 — Close the loop
+git-proxy serves /deploy endpoint connected to deploy-webhook (port 8098). Agents POST deployment commands with auth token. Autonomous cycle: agents read docs → design → deploy → update docs. Full cycle runs without human intervention in design/deploy phase.
+
+### Phase A — Self-diagnosis cron
+skill_health.py runs every 6 hours on the engine VPS. Checks all 63 DeepMind skills by running test.sh in each skill directory. Reports degraded skills (below 80% pass rate) to deploy-webhook via POST /deploy for auto-patching.
+
+## Available Extensions
+
+Extensions at ~/.pi/agent/extensions/:
+
+| Extension | Purpose | Key Commands |
+|-----------|---------|--------------|
+| pi-verifier | Two-agent verification system, quiet by default | /verifier on, /verifier quiet, /verifier off |
+| pi-logger | Agent activity logging to JSONL | /logs, log_action tool |
+| pi-scout | Extension ecosystem audit | /scout scan, /scout auto |
+| pi-rsiloop | RSI loop orchestrator with retry logic | /rsiloop run, rsi_status |
+| pi-rsi | RSI ecosystem dashboard | /rsi, /rsi check, /rsi gaps |
+| pi-oracle | Expert advisor subagent | oracle tool |
+| pi-librarian | Codebase context and file discovery | librarian tool |
+| pi-pipeline | Workflow orchestration | pipeline tool |
+| pi-test-gen | Auto-generate tests from contract schemas | /gentest <file>, generate_tests tool |
+| pi-taste | Developer preference learning | /taste, /taste pull, taste_learn tool |
+| pi-design | Design slop repair (7 patterns, 10 smells, OKLCH) | /design fix <file>, /design audit, design_repair tool |
+| pi-seeds | State graph persistence | seeds tool |
+| pi-fork | Parallel agent execution | fork tool |
+| pi-comm | Webhook messenger + desktop notifications | comm tool |
+| pi-agentic-factory | Factory bridge | /factory status, /factory agents |
+| pi-compliance | EU AI Act compliance | comply tool |
+
+## Proxy Routing
+
+The git-proxy at port 8099 routes LLM calls:
+
+- `go-` prefix models → OpenCode Go ($10/mo flat, 12 models including deepseek-v4-flash, deepseek-v4-pro, kimi-k26, minimax-m27, qwen36-plus)
+- `zen-` prefix → OpenCode Zen ($14.59/mo PRO, includes claude-opus-4-7, gemini-3.1-pro, gpt-5.4-pro)
+- Bare model names (no prefix) → CrofAI ($20/mo + per-token, 2,500 req/day cap)
+- 429 fallback: CrofAI → Go (auto-maps model names for fallback)
+
+## Tool Confusion Repair
+
+The proxy includes deterministic tool call repair for open models. Patterns repaired:
+1. Empty/null objects in optional fields → strip them
+2. JSON string where array expected → wrap in array
+3. Markdown links in file paths → extract URL
+4. null/NULL/None in values → delete
+
+## Design Slop Repair
+
+When generating UI/design code, use pi-design tool. Key rules:
+- 7 surface patterns: MONITOR, SHOWCASE, NARRATIVE, FORM, SOCIAL, MEDIA, SHELL
+- 10 design smells to avoid (purple gradients, three-card rows, left-side borders, etc.)
+- Use OKLCH colors instead of HSL for perceptual uniformity
+- Surface pattern determines layout approach before implementation
+
+## DeepMind Skills
+
+63 DeepMind science skills loaded on 3 agents:
+- **hermes** (@alfrednartbot) — primary research agent
+- **fullyhermes** (@fullyhermybot) — secondary research agent
+- **hermes-voice** (port 18790) — voice interface agent
+
+Tested every 6h via skill_health.py cron. 80% pass rate threshold triggers auto-patch.
 
 ## Environment
 
-- **Machine:** Your machine
-- **Terminal:** Your terminal
-- **Runtime:** Your preferred runtime
-- **Language:** Your preferred language
+- **Machine:** Windows 11 (Git Bash)
+- **Terminal:** Git Bash MINGW64
+- **Runtime:** Node.js via pi CLI
+- **Proxy:** localhost:18901 (grok-proxy.cjs)
+- **Codebase:** ~/Projects/pi-threads/ (extends @earendil-works/pi-coding-agent)
+- **Extensions:** 80 pi-*.ts files at ~/.pi/agent/extensions/
+- **Memory:** 4 canonical entries at ~/.pi/memory/entries.jsonl
+- **Factory VPS:** root@77.42.112.29:2222
+- **Pi config:** ~/.pi/agent/settings.json

package/agents/context_bundles/MON_14_unknown.jsonl

@@ -0,0 +1 @@
+{"operation": "prompt", "prompt": "<user_query>\nhi\n</user_query>", "timestamp": "2026-05-18T14:12:26.348907"}

package/package.json

@@ -1,20 +1,18 @@
 {
   "name": "@artale/pi-pai",
-  "version": "4.4.1",
-  "description": "Personal AI Infrastructure for Pi — synced with PAI v1.0.0 + Daniel Miesslers framework + 9 skill categories",
+  "version": "4.5.0",
+  "description": "Personal AI Infrastructure for Pi — MVI core: minimal, progressive complexity, memory on demand",
   "type": "module",
-  "main": "src/extension.ts",
+  "main": "src/pi-pai-core.ts",
   "pi": {
     "extensions": [
-      "src/extension.ts"
+      "src/pi-pai-core.ts"
     ],
     "commands": [
-      "status"
+      "pai"
     ],
     "tools": [
-      "pai_status",
-      "pai_learn",
-      "pai_rate"
+      "capture_learning"
     ],
     "skills": [
       "agents",
@@ -27,7 +25,7 @@
       "telos",
       "thinking"
     ],
-    "image": "https://raw.githubusercontent.com/arosstale/pi-pai/main/preview.png"
+    "image": "https://unpkg.com/@artale/pi-pai@4.4.1/preview.png"
   },
   "scripts": {
     "build": "tsc",

package/src/pi-pai-core.ts

@@ -0,0 +1,215 @@
+/**
+ * pi-pai — Personal AI Infrastructure (Core)
+ * Kelsey Hightower MVI: lean core, optional modules loaded on demand.
+ * Progressive complexity: simple tasks get zero algorithm overhead.
+ *
+ * Based on PAI v4.0.3 methodology (ISC, phases, criteria, learning signals).
+ * Optional features moved to separate extensions.
+ *
+ * Install: pi install npm:pi-pai
+ *
+ * /pai mission|goal|done|loop|next|isc|isca|status|reset
+ * capture_learning tool — store signals for cross-session improvement
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync, readdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+const PAI_DIR = join(homedir(), ".config", "PAI-pi");
+const MEMORY_DIR = join(PAI_DIR, "memory");
+const WORK_DIR = join(MEMORY_DIR, "work");
+const LEARNING_DIR = join(MEMORY_DIR, "learning");
+
+for (const dir of [MEMORY_DIR, WORK_DIR, LEARNING_DIR]) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+// ISC minimums per effort level
+const ISC_MINIMUMS: Record<string, number> = {
+  standard: 8, extended: 16, advanced: 24, deep: 40, comprehensive: 64,
+};
+
+type EffortLevel = keyof typeof ISC_MINIMUMS;
+type AlgorithmPhase = "OBSERVE" | "THINK" | "PLAN" | "BUILD" | "EXECUTE" | "VERIFY" | "LEARN";
+const PHASES: AlgorithmPhase[] = ["OBSERVE", "THINK", "PLAN", "BUILD", "EXECUTE", "VERIFY", "LEARN"];
+
+function iscSplittingTest(criterion: string): { pass: boolean; reason?: string } {
+  if (/\b(and|as well as|along with)\b/i.test(criterion))
+    return { pass: false, reason: "Compound criterion — split into separate ISCs" };
+  if (/\b(all|every|each|any|both)\b/i.test(criterion))
+    return { pass: false, reason: "Scope word detected — be more specific" };
+  const words = criterion.trim().split(/\s+/).length;
+  if (words > 20) return { pass: false, reason: "Too long (" + words + " words) — shorten" };
+  return { pass: true };
+}
+
+interface AntiCriterion {
+  id: string;
+  description: string;
+  severity: "critical" | "high" | "medium";
+}
+
+interface Learning {
+  insight: string;
+  confidence: number;
+  category: string;
+  timestamp: Date;
+}
+
+function readMemory<T>(slug: string): T[] {
+  const file = join(MEMORY_DIR, slug + ".jsonl");
+  if (!existsSync(file)) return [];
+  return readFileSync(file, "utf-8").trim().split("\n").filter(Boolean).map(function(l) { return JSON.parse(l); });
+}
+
+function writeMemory<T>(slug: string, data: T): void {
+  const file = join(MEMORY_DIR, slug + ".jsonl");
+  try { appendFileSync(file, JSON.stringify(data) + "\n"); } catch { /* best effort */ }
+}
+
+interface AlgorithmLoop {
+  phase: AlgorithmPhase;
+  goal: string;
+  effort: EffortLevel;
+  isc: string[];
+  iscA: AntiCriterion[];
+  startTime: number;
+  data: Record<string, string>;
+}
+
+let loop: AlgorithmLoop | null = null;
+let goals: { id: string; title: string; status: string }[] = [];
+let learnings: Learning[] = [];
+
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand("pai", {
+    description: "PAI: mission|goal|done|loop|next|isc|isca|status|reset",
+    handler: async function(args, ctx) {
+      var parts = (args || "").trim().split(/\s+/);
+      var sub = parts[0] ? parts[0].toLowerCase() : "";
+      var restStr = parts.slice(1).join(" ");
+
+      switch (sub) {
+        case "mission":
+          if (!restStr) { ctx.ui.notify("Usage: /pai mission <statement>", "error"); return; }
+          writeMemory("mission", { mission: restStr, ts: new Date().toISOString() });
+          ctx.ui.notify("MISSION: " + restStr, "info");
+          break;
+
+        case "goal":
+          if (!restStr) { ctx.ui.notify("Usage: /pai goal <title>", "error"); return; }
+          var id = "g" + goals.length;
+          goals.push({ id: id, title: restStr, status: "active" });
+          writeMemory("goals", { id: id, title: restStr, status: "active" });
+          ctx.ui.notify("GOAL " + id + ": " + restStr, "info");
+          break;
+
+        case "done":
+          var g = goals.find(function(g) { return g.id === restStr; });
+          if (!g) { ctx.ui.notify("Goal " + restStr + " not found", "error"); return; }
+          g.status = "completed";
+          ctx.ui.notify("DONE: " + g.title, "info");
+          break;
+
+        case "loop":
+          loop = {
+            phase: "OBSERVE",
+            goal: restStr || "unnamed",
+            effort: "standard",
+            isc: [],
+            iscA: [],
+            startTime: Date.now(),
+            data: {},
+          };
+          ctx.ui.notify("ALGORITHM: " + loop.goal + " [OBSERVE]", "info");
+          break;
+
+        case "isc":
+          if (!loop) { ctx.ui.notify("No active loop — /pai loop first", "error"); return; }
+          var test = iscSplittingTest(restStr);
+          if (!test.pass) { ctx.ui.notify("ISC FAIL: " + test.reason, "warning"); return; }
+          loop.isc.push(restStr);
+          ctx.ui.notify("ISC-" + loop.isc.length, "info");
+          break;
+
+        case "isca":
+          if (!loop) { ctx.ui.notify("No active loop", "error"); return; }
+          var sev = /critical|security|data.?loss/i.test(restStr) ? "critical" : "medium" as const;
+          loop.iscA.push({ id: "a" + loop.iscA.length, description: restStr, severity: sev });
+          ctx.ui.notify("ANTI [" + sev + "]", "info");
+          break;
+
+        case "next":
+          if (!loop) { ctx.ui.notify("No active loop", "error"); return; }
+          var idx = PHASES.indexOf(loop.phase);
+          if (restStr) loop.data[loop.phase] = restStr;
+
+          // ISC count gate before EXECUTE
+          if (loop.phase === "PLAN") {
+            var min = ISC_MINIMUMS[loop.effort];
+            if (loop.isc.length < min) {
+              ctx.ui.notify("ISC GATE: " + loop.isc.length + "/" + min, "warning");
+              return;
+            }
+          }
+
+          if (idx < PHASES.length - 1) {
+            loop.phase = PHASES[idx + 1];
+            ctx.ui.notify("-> " + loop.phase, "info");
+          } else {
+            var elapsed = Math.round((Date.now() - loop.startTime) / 1000);
+            writeMemory("cycles", { goal: loop.goal, isc: loop.isc.length, elapsed: elapsed, ts: new Date().toISOString() });
+            ctx.ui.notify("LOOP DONE (" + elapsed + "s) " + loop.isc.length + " ISC", "info");
+            loop = null;
+          }
+          break;
+
+        case "status":
+          var memory = readMemory<Record<string, any>>("mission");
+          var cycles = readMemory<Record<string, any>>("cycles");
+          var mission = memory.length ? memory[memory.length - 1].mission : "Not set";
+          var fields: string[] = ["MISSION: " + mission];
+          fields.push("Goals: " + goals.filter(function(g) { return g.status === "active"; }).length + " active");
+          fields.push("Cycles: " + cycles.length + " completed");
+          if (loop) fields.push("LOOP: [" + loop.phase + "] " + loop.isc.length + " ISC");
+          ctx.ui.notify(fields.join(" | "), "info");
+          break;
+
+        case "reset":
+          loop = null;
+          goals = [];
+          learnings = [];
+          ctx.ui.notify("PAI reset", "warning");
+          break;
+
+        default:
+          ctx.ui.notify("/pai mission|goal|done|loop|next|isc|isca|status|reset", "info");
+      }
+    },
+  });
+
+  // Learning signal tool (on demand, not at startup)
+  pi.registerTool({
+    name: "capture_learning",
+    label: "Learn",
+    description: "Capture a learning signal for cross-session improvement",
+    parameters: Type.Object({
+      insight: Type.String({ description: "What you learned" }),
+      category: Type.Optional(Type.String({ description: "algorithm|domain|system|process" })),
+    }),
+    async execute(_callId: string, params: { insight: string; category?: string }) {
+      var entry = { insight: params.insight, category: params.category || "domain", confidence: 0.8, timestamp: new Date().toISOString() };
+      writeMemory("signals", entry);
+      learnings.push(entry);
+      return { content: [{ type: "text" as const, text: "LEARNED: " + params.insight.slice(0, 60) }] };
+    },
+  });
+
+  // Simple status line — no heavy initialization
+  pi.on("agent_start", async function(_event, ctx) {
+    ctx.ui.setStatus("pai", "PAI Core | Algorithm ready");
+  });
+}