pi-para 0.6.0 → 0.6.1

package/scripts/gepa/program.py

@@ -1,99 +0,0 @@
-"""DSPy Module proxy for prompt optimization.
-
-Each optimization target is wrapped in a lightweight proxy module.
-The Signature's docstring (instruction) IS the prompt being optimized.
-GEPA evolves the instruction to maximize the metric.
-
-One LLM call per eval (not 10-50 like the full agent loop).
-"""
-
-from __future__ import annotations
-
-import dspy
-
-
-class WikiTaskOutput(dspy.Signature):
-    """You are a wiki knowledge management agent for a PARA-structured knowledge base."""
-
-    task_context: str = dspy.InputField(
-        desc="Context describing the wiki task to perform"
-    )
-    output: str = dspy.OutputField(
-        desc="Structured wiki output following PARA conventions: "
-        "Topic, Key Facts, Insights, Connections with [[wikilinks]], Sources"
-    )
-
-
-class PromptProxy(dspy.Module):
-    """Lightweight proxy for prompt/instruction optimization.
-
-    The Signature's instruction text is what GEPA evolves.
-    forward() runs a single dspy.Predict call (1 LLM call).
-
-    Usage:
-        proxy = PromptProxy.from_instruction(current_prompt_text)
-        # GEPA optimizes proxy → evolved instruction = optimized prompt
-    """
-
-    def __init__(self, instruction: str | None = None):
-        super().__init__()
-
-        if instruction:
-            # Create a signature class with the instruction as docstring
-            class CustomSig(WikiTaskOutput):
-                pass
-            CustomSig.__doc__ = instruction
-            self.predict = dspy.Predict(CustomSig)
-        else:
-            self.predict = dspy.Predict(WikiTaskOutput)
-
-    def forward(self, task_context: str) -> dspy.Prediction:
-        return self.predict(task_context=task_context)
-
-    @classmethod
-    def from_instruction(cls, instruction: str) -> "PromptProxy":
-        """Create a proxy from a prompt/instruction string."""
-        return cls(instruction=instruction)
-
-    def get_instruction(self) -> str | None:
-        """Get the current instruction text."""
-        sig = getattr(self.predict, "signature", None)
-        if sig:
-            inst = getattr(sig, "instructions", None)
-            if inst and not inst.startswith("str(object"):
-                return inst
-            doc = getattr(sig, "__doc__", None)
-            if doc and not doc.startswith("str(object"):
-                return doc
-        return None
-
-
-def extract_evolved_instruction(optimized_proxy: PromptProxy) -> str | None:
-    """Extract the GEPA-evolved instruction from an optimized proxy.
-
-    After GEPA optimization, the proxy's Predict signature contains
-    the evolved instruction text. This extracts it.
-    """
-    # Check predict.signature first
-    if hasattr(optimized_proxy, "predict"):
-        pred = optimized_proxy.predict
-        for attr_name in ("extended_signature", "signature"):
-            sig = getattr(pred, attr_name, None)
-            if sig:
-                for field in ("instructions", "__doc__"):
-                    text = getattr(sig, field, None)
-                    if text and len(text) > 50 and not text.startswith("str(object"):
-                        return text
-
-    # Fallback to named_predictors
-    try:
-        for name, predictor in optimized_proxy.named_predictors():
-            sig = getattr(predictor, "signature", None)
-            if sig:
-                inst = getattr(sig, "instructions", None) or getattr(sig, "__doc__", None)
-                if inst and len(inst) > 50 and not inst.startswith("str(object"):
-                    return inst
-    except Exception:
-        pass
-
-    return None

package/scripts/gepa/pyproject.toml

@@ -1,19 +0,0 @@
-[project]
-name = "pi-para-gepa"
-version = "0.1.0"
-description = "GEPA optimizer for pi-para prompts, tools, and skills"
-requires-python = ">=3.11"
-dependencies = [
-    "dspy>=2.6.0",
-    "anthropic>=0.52.0",
-    "openai>=1.30.0",
-    "pyyaml>=6.0.0",
-]
-
-[tool.hatch.build.targets.wheel]
-packages = ["lm_providers", "wiki_reader", "dataset", "program", "metric", "optimize"]
-include = ["*.py"]
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"

package/scripts/gepa/run-all.sh

@@ -1,53 +0,0 @@
-#!/bin/bash
-# Run GEPA optimization one target at a time.
-# Default: Sonnet for task/judge (fast, cheap), Opus for reflection (smart mutations).
-# Each target invocation re-reads auth.json for fresh token.
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-PROJECT_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)"
-MODEL="${1:-anthropic/claude-sonnet-4-20250514}"
-REFLECTION_MODEL="${2:-anthropic/claude-opus-4-6}"
-AUTO="${3:-light}"
-
-echo "[gepa-all] Model: $MODEL | Reflection: $REFLECTION_MODEL | Budget: $AUTO"
-echo "[gepa-all] Started at $(date)"
-
-# Get target list
-TARGETS=$(cd "$PROJECT_DIR" && node dist/cli.js gepa targets 2>/dev/null | awk '{print $1}')
-
-TOTAL=$(echo "$TARGETS" | wc -l)
-CURRENT=0
-SUCCEEDED=0
-FAILED=0
-
-for TARGET in $TARGETS; do
-  CURRENT=$((CURRENT + 1))
-  echo ""
-  echo "================================================================"
-  echo "[gepa-all] [$CURRENT/$TOTAL] Optimizing: $TARGET"
-  echo "[gepa-all] $(date)"
-  echo "================================================================"
-  
-  cd "$PROJECT_DIR"
-  if node dist/cli.js gepa optimize \
-    --target "$TARGET" \
-    --model "$MODEL" \
-    --reflection-model "$REFLECTION_MODEL" \
-    --auto "$AUTO" 2>&1; then
-    SUCCEEDED=$((SUCCEEDED + 1))
-    echo "[gepa-all] ✅ $TARGET done"
-  else
-    FAILED=$((FAILED + 1))
-    echo "[gepa-all] ❌ $TARGET failed"
-  fi
-  
-  # Brief pause between targets to avoid rate limits
-  sleep 5
-done
-
-echo ""
-echo "================================================================"
-echo "[gepa-all] ALL DONE at $(date)"
-echo "[gepa-all] Succeeded: $SUCCEEDED / $TOTAL, Failed: $FAILED"
-echo "================================================================"

package/scripts/gepa/wiki_reader.py

@@ -1,113 +0,0 @@
-"""Read wiki pages from disk for training data.
-
-Parses YAML frontmatter + markdown body from ~/.pi/wiki/{category}/{slug}.md.
-"""
-
-from __future__ import annotations
-
-import os
-import re
-from dataclasses import dataclass, field
-from pathlib import Path
-
-import yaml
-
-
-PARA_CATEGORIES = ("projects", "areas", "resources", "archives")
-
-
-@dataclass
-class WikiPage:
-    """A parsed wiki page."""
-    category: str
-    slug: str
-    title: str
-    scope: list[str] = field(default_factory=list)
-    tags: list[str] = field(default_factory=list)
-    links: list[str] = field(default_factory=list)
-    body: str = ""
-    created: str = ""
-    updated: str = ""
-
-    @property
-    def path(self) -> str:
-        return f"{self.category}/{self.slug}"
-
-
-def parse_page(filepath: str) -> WikiPage | None:
-    """Parse a wiki markdown file into a WikiPage."""
-    try:
-        with open(filepath, "r", encoding="utf-8") as f:
-            content = f.read()
-    except (IOError, OSError):
-        return None
-
-    # Split frontmatter from body
-    fm_match = re.match(r"^---\s*\n(.*?\n)---\s*\n(.*)", content, re.DOTALL)
-    if not fm_match:
-        return None
-
-    try:
-        fm = yaml.safe_load(fm_match.group(1))
-    except yaml.YAMLError:
-        return None
-
-    if not isinstance(fm, dict):
-        return None
-
-    body = fm_match.group(2).strip()
-    path = Path(filepath)
-    slug = path.stem
-    category = path.parent.name
-
-    return WikiPage(
-        category=category,
-        slug=slug,
-        title=fm.get("title", slug),
-        scope=fm.get("scope", []) or [],
-        tags=fm.get("tags", []) or [],
-        links=fm.get("links", []) or [],
-        body=body,
-        created=str(fm.get("created", "")),
-        updated=str(fm.get("updated", "")),
-    )
-
-
-def load_all_pages(wiki_dir: str) -> list[WikiPage]:
-    """Load all wiki pages from disk."""
-    pages = []
-    for cat in PARA_CATEGORIES:
-        cat_dir = os.path.join(wiki_dir, cat)
-        if not os.path.isdir(cat_dir):
-            continue
-        for fname in sorted(os.listdir(cat_dir)):
-            if not fname.endswith(".md"):
-                continue
-            page = parse_page(os.path.join(cat_dir, fname))
-            if page:
-                pages.append(page)
-    return pages
-
-
-def get_wiki_stats(wiki_dir: str) -> dict:
-    """Get summary stats about the wiki."""
-    pages = load_all_pages(wiki_dir)
-    cat_counts = {}
-    all_scopes = set()
-    all_tags = set()
-    total_links = 0
-
-    for p in pages:
-        cat_counts[p.category] = cat_counts.get(p.category, 0) + 1
-        all_scopes.update(p.scope)
-        all_tags.update(p.tags)
-        total_links += len(p.links)
-
-    return {
-        "total_pages": len(pages),
-        "categories": cat_counts,
-        "unique_scopes": sorted(all_scopes),
-        "unique_tags": sorted(all_tags)[:20],  # top 20
-        "total_links": total_links,
-        "avg_links_per_page": round(total_links / max(len(pages), 1), 1),
-    }

package/src/gepa/index.ts

@@ -1,287 +0,0 @@
-/**
- * GEPA optimizer orchestrator — TypeScript side.
- *
- * 1. Extracts all prompt/tool/skill instruction texts from source
- * 2. Writes targets.json for the Python DSPy GEPA script
- * 3. Reads auth.json → passes API keys as env vars to uv subprocess
- * 4. Calls `uv run scripts/gepa/optimize.py`
- * 5. Reads results.json → saves optimized prompts to disk
- */
-
-import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-
-// -- Types -------------------------------------------------------------------
-
-interface GEPATarget {
-  name: string;
-  type: "prompt" | "tool" | "skill";
-  content: string;
-  sourceFile: string;
-}
-
-interface GEPAResult {
-  target: string;
-  status: "success" | "error";
-  baseline_score?: number;
-  optimized_score?: number;
-  improvement_pct?: number;
-  optimized_instruction?: string;
-  original_instruction?: string;
-  model?: string;
-  auto?: string;
-  error?: string;
-  timestamp?: string;
-}
-
-interface GEPAOutput {
-  results: GEPAResult[];
-  model: string;
-  auto: string;
-  wiki_dir: string;
-  timestamp: string;
-}
-
-export interface GEPAOptions {
-  target?: string;
-  /** Student model — runs the proxy (fast, cheap). */
-  studentModel?: string;
-  /** Teacher/reflection model — proposes mutations (smart, creative). */
-  teacherModel?: string;
-  /** Judge model — scores outputs (fast, cheap). Default: same as student. */
-  judgeModel?: string;
-  /** Shorthand: sets studentModel (backward compat with --model flag) */
-  model?: string;
-  /** Shorthand: sets teacherModel (backward compat with --reflection-model flag) */
-  reflectionModel?: string;
-  auto?: "light" | "medium" | "heavy";
-  maxMetricCalls?: number;
-  threads?: number;
-  seed?: number;
-}
-
-// -- Paths -------------------------------------------------------------------
-
-const WIKI_DIR = join(homedir(), ".pi", "wiki");
-const GEPA_DIR = join(WIKI_DIR, "gepa");
-const INPUT_DIR = join(GEPA_DIR, "input");
-const OUTPUT_DIR = join(GEPA_DIR, "output");
-const OPTIMIZED_DIR = join(GEPA_DIR, "optimized");
-const HISTORY_DIR = join(GEPA_DIR, "history");
-
-// -- Package root ------------------------------------------------------------
-
-function findPackageRoot(): string {
-  let dir = dirname(new URL(import.meta.url).pathname);
-  for (let i = 0; i < 5; i++) {
-    const pkgPath = join(dir, "package.json");
-    if (existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        if (pkg.name === "pi-para" || pkg.name === "@picassio/pi-para") return dir;
-      } catch {}
-    }
-    dir = dirname(dir);
-  }
-  return resolve(dirname(new URL(import.meta.url).pathname), "../..");
-}
-
-// -- Helpers: extract strings from TS source ---------------------------------
-
-function extractTSConst(source: string, name: string): string | null {
-  const m = source.match(new RegExp(`(?:export\\s+)?const\\s+${name}\\s*=\\s*\`([\\s\\S]*?)\`;`));
-  return m ? m[1].trim() : null;
-}
-
-function extractToolInstructions(source: string): Record<string, string> {
-  const tools: Record<string, string> = {};
-  const blocks = [...source.matchAll(
-    /registerTool\(\{[\s\S]*?name:\s*"(wiki_\w+)"[\s\S]*?(?=registerTool\(\{|$)/g,
-  )];
-  for (const block of blocks) {
-    const name = block[1].replace("wiki_", "wiki-");
-    const text = block[0];
-    const descStrs = [...(text.match(/description:\s*\n?\s*([\s\S]*?)(?:promptSnippet:|promptGuidelines:|parameters:)/)?.[1] ?? "").matchAll(/["'`]([^"'`]+)["'`]/g)];
-    const desc = descStrs.map(s => s[1]).join(" ");
-    const snippet = text.match(/promptSnippet:\s*["'`]([^"'`]+)["'`]/)?.[1] ?? "";
-    const guideMatch = text.match(/promptGuidelines:\s*\[([\s\S]*?)\]/);
-    const guides = guideMatch ? [...guideMatch[1].matchAll(/["'`]([^"'`]+)["'`]/g)].map(s => s[1]).join("\n") : "";
-    const combined = [`Tool: ${name}`, desc && `Description: ${desc.trim()}`, snippet && `Snippet: ${snippet}`, guides && `Guidelines:\n${guides}`].filter(Boolean).join("\n");
-    if (combined.length > 50) tools[name] = combined;
-  }
-  return tools;
-}
-
-function toKebab(name: string): string {
-  return name.replace(/_/g, "-").replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
-}
-
-// -- Target extraction -------------------------------------------------------
-
-export function extractTargets(packageRoot?: string): GEPATarget[] {
-  const root = packageRoot ?? findPackageRoot();
-  const targets: GEPATarget[] = [];
-
-  // Prompt templates
-  const promptsFile = join(root, "src", "templates", "prompts.ts");
-  if (existsSync(promptsFile)) {
-    const src = readFileSync(promptsFile, "utf-8");
-    for (const n of ["WIKI_SYSTEM_PROMPT","INGEST_PROMPT","QUERY_PROMPT","CAPTURE_SYSTEM_PROMPT","CAPTURE_PROMPT","EXPLICIT_CAPTURE_PROMPT","SUMMARIZE_SYSTEM_PROMPT","ITERATIVE_UPDATE_PROMPT","OVERVIEW_PROMPT","LINT_PROMPT"]) {
-      const c = extractTSConst(src, n);
-      if (c) targets.push({ name: toKebab(n), type: "prompt", content: c, sourceFile: promptsFile });
-    }
-  }
-
-  // Maintainer + processor prompts
-  for (const [file, constName, targetName] of [
-    ["src/maintainer.ts", "MAINTENANCE_SYSTEM_PROMPT", "maintenance-system-prompt"],
-    ["src/processor.ts", "CAPTURE_SYSTEM_PROMPT", "processor-capture-prompt"],
-  ] as const) {
-    const p = join(root, file);
-    if (existsSync(p)) {
-      const c = extractTSConst(readFileSync(p, "utf-8"), constName);
-      if (c) targets.push({ name: targetName, type: "prompt", content: c, sourceFile: p });
-    }
-  }
-
-  // Tool instructions
-  const toolsFile = join(root, "src", "tools.ts");
-  if (existsSync(toolsFile)) {
-    for (const [n, c] of Object.entries(extractToolInstructions(readFileSync(toolsFile, "utf-8")))) {
-      targets.push({ name: `tool-${n}`, type: "tool", content: c, sourceFile: toolsFile });
-    }
-  }
-
-  // Skills
-  for (const s of ["para", "setup"]) {
-    const p = join(root, "skills", s, "SKILL.md");
-    if (existsSync(p)) {
-      const raw = readFileSync(p, "utf-8");
-      const body = raw.match(/^---\s*\n[\s\S]*?\n---\s*\n([\s\S]*)$/)?.[1]?.trim() ?? raw;
-      targets.push({ name: `skill-${s}`, type: "skill", content: body, sourceFile: p });
-    }
-  }
-
-  return targets;
-}
-
-// -- Auth env vars -----------------------------------------------------------
-
-function getAuthEnvVars(): Record<string, string> {
-  const env: Record<string, string> = {};
-  try {
-    const auth = JSON.parse(readFileSync(join(homedir(), ".pi", "agent", "auth.json"), "utf-8"));
-    if (auth.anthropic?.access) { env.ANTHROPIC_OAUTH_TOKEN = auth.anthropic.access; env.ANTHROPIC_API_KEY = auth.anthropic.access; }
-    else if (auth.anthropic?.key) env.ANTHROPIC_API_KEY = auth.anthropic.key;
-    if (auth.minimax?.key) env.MINIMAX_API_KEY = auth.minimax.key;
-    if (auth.openrouter?.key) env.OPENROUTER_API_KEY = auth.openrouter.key;
-    else if (auth.openrouter?.openrouter_key) env.OPENROUTER_API_KEY = auth.openrouter.openrouter_key;
-  } catch {
-    try {
-      const raw = readFileSync(join(homedir(), ".config", "qmd", "index.yml"), "utf-8");
-      const m = raw.match(/chat:[\s\S]*?key:\s*(.+)/);
-      if (m) { const k = m[1].trim(); if (raw.includes("minimaxi.com")) env.MINIMAX_CN_API_KEY = k; else env.MINIMAX_API_KEY = k; }
-    } catch {}
-  }
-  return env;
-}
-
-// -- Main orchestrator -------------------------------------------------------
-
-export async function runGEPA(options: GEPAOptions = {}): Promise<GEPAOutput> {
-  const root = findPackageRoot();
-  const scriptsDir = join(root, "scripts", "gepa");
-  for (const d of [INPUT_DIR, OUTPUT_DIR, OPTIMIZED_DIR, HISTORY_DIR]) mkdirSync(d, { recursive: true });
-
-  // Load GEPA config from config.json (user-configurable defaults)
-  let gepaConfig: Record<string, unknown> = {};
-  try {
-    const cfg = JSON.parse(readFileSync(join(WIKI_DIR, "config.json"), "utf-8"));
-    gepaConfig = cfg.gepa ?? {};
-  } catch {}
-
-  // Resolution: CLI flag → options → config.json → default
-  const studentModel = options.studentModel ?? options.model
-    ?? (gepaConfig.studentModel as string) ?? "anthropic/claude-sonnet-4-20250514";
-  const teacherModel = options.teacherModel ?? options.reflectionModel
-    ?? (gepaConfig.teacherModel as string) ?? "anthropic/claude-opus-4-6";
-  const judgeModel = options.judgeModel
-    ?? (gepaConfig.judgeModel as string) ?? studentModel;
-  const auto = options.auto ?? (gepaConfig.auto as "light" | "medium" | "heavy") ?? "light";
-  const threads = options.threads ?? (gepaConfig.threads as number) ?? 2;
-  const seed = options.seed ?? (gepaConfig.seed as number) ?? 42;
-
-  const allTargets = extractTargets(root);
-  let targets = options.target ? allTargets.filter(t => t.name === options.target) : allTargets;
-  if (options.target && targets.length === 0) throw new Error(`Target '${options.target}' not found. Available: ${allTargets.map(t => t.name).join(", ")}`);
-
-  console.log(`[gepa] Found ${targets.length} target(s) to optimize`);
-  console.log(`[gepa] Student: ${studentModel}, Teacher: ${teacherModel}, Judge: ${judgeModel}, Budget: ${auto}`);
-
-  const targetsFile = join(INPUT_DIR, "targets.json");
-  writeFileSync(targetsFile, JSON.stringify({ targets: targets.map(t => ({ name: t.name, type: t.type, content: t.content })) }, null, 2));
-
-  const outputFile = join(OUTPUT_DIR, "results.json");
-  const uvArgs = [
-    "run", "--project", scriptsDir, join(scriptsDir, "optimize.py"),
-    "--targets-file", targetsFile, "--wiki-dir", WIKI_DIR, "--output", outputFile,
-    "--model", studentModel,
-    "--reflection-model", teacherModel,
-    "--judge-model", judgeModel,
-    "--auto", auto,
-    "--threads", String(threads),
-    "--seed", String(seed),
-    ...(options.maxMetricCalls ? ["--max-metric-calls", String(options.maxMetricCalls)] : []),
-    ...(options.target ? ["--target", options.target] : []),
-  ];
-
-  console.log(`[gepa] Running: uv ${uvArgs.slice(0, 6).join(" ")} ...`);
-
-  await new Promise<void>((resolve, reject) => {
-    const proc = spawn("uv", uvArgs, { cwd: scriptsDir, env: { ...process.env, ...getAuthEnvVars() }, stdio: ["pipe", "inherit", "inherit"] });
-    proc.on("close", c => c === 0 ? resolve() : reject(new Error(`uv exited with code ${c}`)));
-    proc.on("error", e => reject(new Error(`Failed to spawn uv: ${e.message}`)));
-  });
-
-  if (!existsSync(outputFile)) throw new Error("Output file not created");
-  const output: GEPAOutput = JSON.parse(readFileSync(outputFile, "utf-8"));
-
-  for (const r of output.results) {
-    if (r.status === "success" && r.optimized_instruction) {
-      mkdirSync(OPTIMIZED_DIR, { recursive: true });
-      writeFileSync(join(OPTIMIZED_DIR, `${r.target}.txt`), r.optimized_instruction, "utf-8");
-      const hDir = join(HISTORY_DIR, r.target); mkdirSync(hDir, { recursive: true });
-      writeFileSync(join(hDir, `${new Date().toISOString().replace(/[:.]/g, "-")}.json`), JSON.stringify(r, null, 2));
-      console.log(`[gepa] Saved optimized: ${r.target}`);
-    }
-  }
-  return output;
-}
-
-// -- Query functions ---------------------------------------------------------
-
-export function listOptimized(): { name: string; score: number; timestamp: string; model: string }[] {
-  if (!existsSync(OPTIMIZED_DIR)) return [];
-  const results: { name: string; score: number; timestamp: string; model: string }[] = [];
-  for (const f of readdirSync(OPTIMIZED_DIR).filter(f => f.endsWith(".txt"))) {
-    const name = f.replace(".txt", "");
-    let score = 0, timestamp = "", model = "";
-    try {
-      const entries = readdirSync(join(HISTORY_DIR, name)).filter(f => f.endsWith(".json")).sort().reverse();
-      if (entries[0]) { const d = JSON.parse(readFileSync(join(HISTORY_DIR, name, entries[0]), "utf-8")); score = d.optimized_score ?? 0; timestamp = d.timestamp ?? ""; model = d.model ?? ""; }
-    } catch {}
-    results.push({ name, score, timestamp, model });
-  }
-  return results;
-}
-
-export function compareTarget(targetName: string): { original: string; optimized: string } | null {
-  const target = extractTargets().find(t => t.name === targetName);
-  if (!target) return null;
-  try {
-    const opt = readFileSync(join(OPTIMIZED_DIR, `${targetName}.txt`), "utf-8");
-    return { original: target.content, optimized: opt };
-  } catch { return null; }
-}

package/src/gepa/optimized/capture-prompt.txt

@@ -1,65 +0,0 @@
-You are a knowledge extraction specialist for technical project wikis. Your task is to analyze coding session conversations and capture ALL project-relevant knowledge into wiki pages.
-
-## Input Format
-You will receive:
-- task_context: Brief description of the coding session topic and project
-- session-conversation: The actual conversation content to analyze
-
-## Wiki Page Structure Requirements
-Create wiki pages using this exact structure:
-
-```
-# Page Title (kebab-case for technical terms)
-
-## Topic
-Brief description of what this page covers (1-2 sentences)
-
-## Key Facts
-- Bullet points with specific technical details
-- Include paths, configs, server details, commands
-- Use **bold** for important terms/concepts
-- Capture operational facts - they're often most valuable
-
-## Insights (Optional)
-- Analysis of implications, patterns, or broader context
-- How this connects to larger architectural patterns
-- Lessons learned or best practices identified
-
-## Connections
-- [[Related Wiki Page]] - Brief description of relationship
-- Use kebab-case for technical project names
-- Include both specific project pages and general concept pages
-
-## Sources
-- Session file path or conversation source
-```
-
-## PARA Compliance Requirements
-- Use kebab-case for all project names and technical terms in page titles and connections
-- Technical reference material should be categorized as Resources
-- Include scope indicators through consistent naming and cross-references
-
-## Knowledge Capture Bias
-**Capture bias: when in doubt, capture it.**
-- Small operational facts (paths, configs, commands) are often most valuable
-- Technical architecture details, even if seemingly minor
-- API findings, verification results, compatibility issues
-- Extension systems, plugin architectures, integration points
-- Security considerations and safeguards
-
-## Wiki Management Strategy
-1. **Search first**: Use wiki_query to find existing pages on the topic
-2. **Update over create**: If matching page exists, use wiki_read then wiki_write with exact slug to update
-3. **Create only if needed**: Only make new pages if wiki_query finds no relevant results
-4. **Never pass indexContent**: The index auto-rebuilds from pages on disk
-5. **Always include sources**: Add session file path to Sources section
-
-## Special Project Context
-Based on the examples, you're working with:
-- **pi-mono/pi-para projects**: Modular knowledge management and agent systems
-- **Extension architectures**: Plugin-based systems for AI agents and knowledge tools
-- **Quarto integration**: .qmd files as first-class knowledge artifacts
-- **API verification**: Testing and validation processes for extensions
-- **Security considerations**: Prompt injection safeguards in agent systems
-
-Only respond with "nothing to capture" if the session contains purely greetings or completely off-topic chitchat with zero project knowledge.