ultimate-pi 0.1.7 → 0.2.2

package/.pi/lib/harness-ui-state.ts

@@ -0,0 +1,311 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+
+export type HarnessPhase =
+	| "plan"
+	| "execute"
+	| "evaluate"
+	| "adversary"
+	| "merge";
+export type HarnessPolicyDecision =
+	| "pass"
+	| "conditional_pass"
+	| "block"
+	| "human_required"
+	| null;
+export type HarnessFlowSubstate =
+	| "idle"
+	| "severity-policy"
+	| "commit-pr"
+	| "blocked"
+	| "human-required";
+
+interface CustomEntryLike {
+	type?: string;
+	customType?: string;
+	data?: unknown;
+}
+
+type DebateStateLike = {
+	round_count?: number;
+	budget_used?: number;
+	max_rounds?: number;
+	debate_global_cap?: number;
+};
+
+type PolicyStateLike = {
+	phase?: HarnessPhase;
+	approvedPlan?: boolean;
+	planId?: string | null;
+};
+
+type ReviewIntegrityStateLike = {
+	violationActive?: boolean;
+	executorSessionId?: string | null;
+};
+
+type ConsensusLike = {
+	policy_decision?: HarnessPolicyDecision;
+	severity_scores?: {
+		correctness?: number;
+		security?: number;
+		architecture?: number;
+		test_integrity?: number;
+	};
+};
+
+type BudgetExhaustedLike = {
+	exhaustion_reason?: string;
+	budget_used?: number;
+	caps?: { debate_global_cap?: number };
+};
+
+type TestIntegrityLike = {
+	severity?: "medium" | "high";
+	reasons?: string[];
+};
+
+type TraceLike = {
+	run_id?: string;
+};
+
+type RoundLike = {
+	round_index?: number;
+	consensus_delta?: number;
+};
+
+export interface HarnessUiState {
+	phase: HarnessPhase;
+	flowSubstate: HarnessFlowSubstate;
+	planApproved: boolean;
+	planId: string | null;
+	reviewIsolationOk: boolean;
+	reviewViolationActive: boolean;
+	budgetExhausted: boolean;
+	budgetReason: string | null;
+	testIntegritySeverity: "none" | "medium" | "high";
+	testIntegrityReasons: string[];
+	debateRound: number;
+	debateMaxRounds: number | null;
+	debateBudgetUsed: number | null;
+	debateBudgetCap: number | null;
+	policyDecision: HarnessPolicyDecision;
+	consensusDelta: number | null;
+	severity: {
+		correctness: number | null;
+		security: number | null;
+		architecture: number | null;
+		testIntegrity: number | null;
+	};
+	traceRunId: string | null;
+}
+
+const DEFAULT_STATE: HarnessUiState = {
+	phase: "plan",
+	flowSubstate: "idle",
+	planApproved: false,
+	planId: null,
+	reviewIsolationOk: true,
+	reviewViolationActive: false,
+	budgetExhausted: false,
+	budgetReason: null,
+	testIntegritySeverity: "none",
+	testIntegrityReasons: [],
+	debateRound: 0,
+	debateMaxRounds: null,
+	debateBudgetUsed: null,
+	debateBudgetCap: null,
+	policyDecision: null,
+	consensusDelta: null,
+	severity: {
+		correctness: null,
+		security: null,
+		architecture: null,
+		testIntegrity: null,
+	},
+	traceRunId: null,
+};
+
+const RELEVANT_CUSTOM_TYPES = new Set([
+	"harness-policy-state",
+	"harness-debate-state",
+	"harness-consensus-packet",
+	"harness-round-result",
+	"harness-budget-exhausted",
+	"harness-review-integrity",
+	"harness-test-integrity-flag",
+	"harness-run-trace",
+	"harness-trace-state",
+]);
+
+function asNumber(value: unknown): number | null {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed)) return null;
+	return parsed;
+}
+
+function pickLatestCustomEntries(entries: unknown[]): Map<string, unknown> {
+	const latest = new Map<string, unknown>();
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const entry = entries[i] as CustomEntryLike;
+		if (entry.type !== "custom") continue;
+		if (!entry.customType || !RELEVANT_CUSTOM_TYPES.has(entry.customType))
+			continue;
+		if (!latest.has(entry.customType)) {
+			latest.set(entry.customType, entry.data);
+		}
+		if (latest.size === RELEVANT_CUSTOM_TYPES.size) break;
+	}
+	return latest;
+}
+
+function deriveFlowSubstate(state: HarnessUiState): HarnessFlowSubstate {
+	if (state.budgetExhausted || state.testIntegritySeverity === "high") {
+		return "blocked";
+	}
+	if (state.policyDecision === "human_required") {
+		return "human-required";
+	}
+	if (state.phase !== "merge") {
+		return "idle";
+	}
+	if (
+		state.policyDecision === "pass" ||
+		state.policyDecision === "conditional_pass"
+	) {
+		return "commit-pr";
+	}
+	if (
+		state.policyDecision === "block" ||
+		state.policyDecision === "human_required"
+	) {
+		return "severity-policy";
+	}
+	if (state.debateRound > 0) {
+		return "severity-policy";
+	}
+	return "idle";
+}
+
+function createStateFromEntries(entries: unknown[]): HarnessUiState {
+	const latest = pickLatestCustomEntries(entries);
+	const state: HarnessUiState = {
+		...DEFAULT_STATE,
+		severity: { ...DEFAULT_STATE.severity },
+	};
+
+	const policy = latest.get("harness-policy-state") as
+		| PolicyStateLike
+		| undefined;
+	if (policy?.phase) state.phase = policy.phase;
+	state.planApproved = Boolean(policy?.approvedPlan);
+	state.planId = typeof policy?.planId === "string" ? policy.planId : null;
+
+	const review = latest.get("harness-review-integrity") as
+		| ReviewIntegrityStateLike
+		| undefined;
+	state.reviewViolationActive = Boolean(review?.violationActive);
+	state.reviewIsolationOk = !state.reviewViolationActive;
+
+	const budget = latest.get("harness-budget-exhausted") as
+		| BudgetExhaustedLike
+		| undefined;
+	if (budget) {
+		state.budgetExhausted = true;
+		state.budgetReason =
+			typeof budget.exhaustion_reason === "string"
+				? budget.exhaustion_reason
+				: "unknown";
+		const budgetUsed = asNumber(budget.budget_used);
+		if (budgetUsed != null) state.debateBudgetUsed = budgetUsed;
+		const cap = asNumber(budget.caps?.debate_global_cap);
+		if (cap != null) state.debateBudgetCap = cap;
+	}
+
+	const testIntegrity = latest.get("harness-test-integrity-flag") as
+		| TestIntegrityLike
+		| undefined;
+	if (
+		testIntegrity?.severity === "high" ||
+		testIntegrity?.severity === "medium"
+	) {
+		state.testIntegritySeverity = testIntegrity.severity;
+		state.testIntegrityReasons = Array.isArray(testIntegrity.reasons)
+			? testIntegrity.reasons.filter((r): r is string => typeof r === "string")
+			: [];
+	}
+
+	const debate = latest.get("harness-debate-state") as
+		| DebateStateLike
+		| undefined;
+	const round = asNumber(debate?.round_count);
+	if (round != null) state.debateRound = round;
+	const maxRounds = asNumber(debate?.max_rounds);
+	if (maxRounds != null) state.debateMaxRounds = maxRounds;
+	const debateBudgetUsed = asNumber(debate?.budget_used);
+	if (debateBudgetUsed != null) state.debateBudgetUsed = debateBudgetUsed;
+	const debateBudgetCap = asNumber(debate?.debate_global_cap);
+	if (debateBudgetCap != null) state.debateBudgetCap = debateBudgetCap;
+
+	const roundResult = latest.get("harness-round-result") as
+		| RoundLike
+		| undefined;
+	const roundIndex = asNumber(roundResult?.round_index);
+	if (roundIndex != null)
+		state.debateRound = Math.max(state.debateRound, roundIndex);
+	const consensusDelta = asNumber(roundResult?.consensus_delta);
+	if (consensusDelta != null) state.consensusDelta = consensusDelta;
+
+	const consensus = latest.get("harness-consensus-packet") as
+		| ConsensusLike
+		| undefined;
+	if (
+		consensus?.policy_decision === "pass" ||
+		consensus?.policy_decision === "conditional_pass" ||
+		consensus?.policy_decision === "block" ||
+		consensus?.policy_decision === "human_required"
+	) {
+		state.policyDecision = consensus.policy_decision;
+	}
+	const correctness = asNumber(consensus?.severity_scores?.correctness);
+	const security = asNumber(consensus?.severity_scores?.security);
+	const architecture = asNumber(consensus?.severity_scores?.architecture);
+	const test = asNumber(consensus?.severity_scores?.test_integrity);
+	if (correctness != null) state.severity.correctness = correctness;
+	if (security != null) state.severity.security = security;
+	if (architecture != null) state.severity.architecture = architecture;
+	if (test != null) state.severity.testIntegrity = test;
+
+	const runTrace = latest.get("harness-run-trace") as TraceLike | undefined;
+	const traceState = latest.get("harness-trace-state") as TraceLike | undefined;
+	state.traceRunId =
+		typeof runTrace?.run_id === "string"
+			? runTrace.run_id
+			: typeof traceState?.run_id === "string"
+				? traceState.run_id
+				: null;
+
+	state.flowSubstate = deriveFlowSubstate(state);
+	return state;
+}
+
+export class HarnessUiStateStore {
+	private lastEntriesLen = -1;
+	private cachedState: HarnessUiState = {
+		...DEFAULT_STATE,
+		severity: { ...DEFAULT_STATE.severity },
+	};
+
+	/** Refresh from session entries with a lightweight length-based memoization. */
+	public refresh(ctx: ExtensionContext): HarnessUiState {
+		const entries = ctx.sessionManager.getEntries();
+		if (entries.length !== this.lastEntriesLen) {
+			this.cachedState = createStateFromEntries(entries);
+			this.lastEntriesLen = entries.length;
+		}
+		return this.cachedState;
+	}
+
+	public snapshot(): HarnessUiState {
+		return this.cachedState;
+	}
+}

package/.pi/mcp.json

@@ -2,6 +2,10 @@
 	"mcpServers": {
 		"context-mode": {
 			"command": "context-mode"
+		},
+		"sentrux": {
+			"command": "sentrux",
+			"args": ["--mcp"]
 		}
 	}
 }

package/.pi/model-router.json

@@ -1,95 +1,95 @@
 {
-  "defaultProfile": "auto",
-  "debug": false,
-  "classifierModel": "opencode-go/qwen3.6-plus",
-  "phaseBias": 0.5,
-  "maxSessionBudget": 1.0,
-  "largeContextThreshold": 100000,
-  "rules": [
-    {
-      "matches": [
-        "deploy",
-        "production",
-        "release"
-      ],
-      "tier": "high",
-      "reason": "Safety check for production tasks"
-    },
-    {
-      "matches": "changelog",
-      "tier": "low"
+    "defaultProfile": "auto",
+    "debug": false,
+    "classifierModel": "opencode-go/qwen3.6-plus",
+    "phaseBias": 0.5,
+    "maxSessionBudget": 1.0,
+    "largeContextThreshold": 100000,
+    "rules": [
+        {
+            "matches": [
+                "deploy",
+                "production",
+                "release"
+            ],
+            "tier": "high",
+            "reason": "Safety check for production tasks"
+        },
+        {
+            "matches": "changelog",
+            "tier": "low"
+        }
+    ],
+    "profiles": {
+        "auto": {
+            "high": {
+                "model": "opencode-go/deepseek-v4-pro",
+                "thinking": "high",
+                "fallbacks": [
+                    "opencode-go/qwen3.6-plus",
+                    "opencode-go/kimi-k2.6"
+                ]
+            },
+            "medium": {
+                "model": "opencode-go/qwen3.6-plus",
+                "thinking": "medium",
+                "fallbacks": [
+                    "opencode-go/deepseek-v4-pro"
+                ]
+            },
+            "low": {
+                "model": "opencode-go/deepseek-v4-flash",
+                "thinking": "low",
+                "fallbacks": [
+                    "opencode-go/qwen3.5-plus"
+                ]
+            }
+        },
+        "cheap": {
+            "high": {
+                "model": "opencode-go/qwen3.6-plus",
+                "thinking": "low",
+                "fallbacks": [
+                    "opencode-go/qwen3.5-plus"
+                ]
+            },
+            "medium": {
+                "model": "opencode-go/qwen3.5-plus",
+                "thinking": "off",
+                "fallbacks": [
+                    "opencode-go/deepseek-v4-flash"
+                ]
+            },
+            "low": {
+                "model": "opencode-go/deepseek-v4-flash",
+                "thinking": "off",
+                "fallbacks": [
+                    "opencode-go/qwen3.5-plus"
+                ]
+            }
+        },
+        "deep": {
+            "high": {
+                "model": "opencode-go/deepseek-v4-pro",
+                "thinking": "xhigh",
+                "fallbacks": [
+                    "opencode-go/kimi-k2.6"
+                ]
+            },
+            "medium": {
+                "model": "opencode-go/kimi-k2.6",
+                "thinking": "medium",
+                "fallbacks": [
+                    "opencode-go/deepseek-v4-pro"
+                ]
+            },
+            "low": {
+                "model": "opencode-go/qwen3.6-plus",
+                "thinking": "low",
+                "fallbacks": [
+                    "opencode-go/deepseek-v4-flash"
+                ]
+            }
+        }
     }
-  ],
-  "profiles": {
-    "auto": {
-      "high": {
-        "model": "opencode-go/deepseek-v4-pro",
-        "thinking": "high",
-        "fallbacks": [
-          "opencode-go/qwen3.6-plus",
-          "opencode-go/kimi-k2.6"
-        ]
-      },
-      "medium": {
-        "model": "opencode-go/qwen3.6-plus",
-        "thinking": "medium",
-        "fallbacks": [
-          "opencode-go/deepseek-v4-pro"
-        ]
-      },
-      "low": {
-        "model": "opencode-go/deepseek-v4-flash",
-        "thinking": "low",
-        "fallbacks": [
-          "opencode-go/qwen3.5-plus"
-        ]
-      }
-    },
-    "cheap": {
-      "high": {
-        "model": "opencode-go/qwen3.6-plus",
-        "thinking": "low",
-        "fallbacks": [
-          "opencode-go/qwen3.5-plus"
-        ]
-      },
-      "medium": {
-        "model": "opencode-go/qwen3.5-plus",
-        "thinking": "off",
-        "fallbacks": [
-          "opencode-go/deepseek-v4-flash"
-        ]
-      },
-      "low": {
-        "model": "opencode-go/deepseek-v4-flash",
-        "thinking": "off",
-        "fallbacks": [
-          "opencode-go/qwen3.5-plus"
-        ]
-      }
-    },
-    "deep": {
-      "high": {
-        "model": "opencode-go/deepseek-v4-pro",
-        "thinking": "xhigh",
-        "fallbacks": [
-          "opencode-go/kimi-k2.6"
-        ]
-      },
-      "medium": {
-        "model": "opencode-go/kimi-k2.6",
-        "thinking": "medium",
-        "fallbacks": [
-          "opencode-go/deepseek-v4-pro"
-        ]
-      },
-      "low": {
-        "model": "opencode-go/qwen3.6-plus",
-        "thinking": "low",
-        "fallbacks": [
-          "opencode-go/deepseek-v4-flash"
-        ]
-      }
-    }
-  }
-}
+}

package/.pi/prompts/graphify.md

@@ -0,0 +1,23 @@
+---
+description: Bootstrap or update the Graphify knowledge graph. Reads the graphify skill and runs setup/build workflow.
+argument-hint: "[directory]"
+---
+
+Read the `graphify` skill. Then run the setup workflow:
+
+1. Check if Graphify is installed (`pip show graphifyy`). If not, install it:
+   ```bash
+   pip install graphifyy && graphify install
+   ```
+2. Check if a graph already exists (`graphify-out/graph.json`). If yes, report
+   current graph stats (nodes, edges, communities, last built).
+3. If no graph exists, build one: `graphify ${ARGUMENTS:-.} --wiki`
+4. Read and summarize `graphify-out/GRAPH_REPORT.md` — show god nodes,
+   surprising connections, and suggested questions.
+5. Tell user: "Graph built. Open `graphify-out/graph.html` for interactive
+   exploration. Run `graphify query \"question\"` to ask anything."
+
+If the graph already exists:
+- Report graph stats from `graph.json`
+- Offer to update: `graphify . --update`
+- Show recent god nodes from GRAPH_REPORT.md

package/.pi/prompts/harness-abort.md

@@ -0,0 +1,41 @@
+---
+description: Safely abort the current harness run and force clean re-entry.
+argument-hint: "[optional reason]"
+---
+
+# harness-abort
+
+Safely abort the current harness run in this session.
+
+## What this does
+
+- resets policy state to:
+  - `phase: plan`
+  - `approvedPlan: false`
+  - `planId: null`
+- records abort metadata for observability.
+- enables a hard safety lock that blocks mutating tools until a new approved plan is attached.
+
+## Usage
+
+`/harness-abort [optional reason]`
+
+Examples:
+
+- `/harness-abort`
+- `/harness-abort scope changed, restarting safely`
+
+## Safety guarantees
+
+- no mutating work should continue under the previous run context.
+- a fresh approved plan is required before mutation can resume.
+
+## Next step
+
+Run:
+
+`/harness-plan "<task>"`
+
+Then proceed with:
+
+`/harness-run --plan <path-to-plan-packet.json>`

package/.pi/prompts/harness-auto.md

@@ -0,0 +1,83 @@
+---
+description: Full strict harness pipeline with locked governance decisions.
+argument-hint: "\"<task>\" [--quick] [--risk low|med|high] [--budget <amount>]"
+---
+
+# harness-auto
+
+Run full harness flow in one command:
+
+`plan -> execute -> evaluate -> adversary -> severity-policy decision -> commit+PR (no auto-merge)`
+
+## Step 0 — Parse arguments
+
+Read `$ARGUMENTS` and normalize:
+
+- required task: quoted or unquoted first value
+- optional flags: `--quick`, `--risk low|med|high`, `--budget <amount>`
+
+If task is missing, stop and return:
+
+`Usage: /harness-auto "<task>" [--quick] [--risk low|med|high] [--budget <amount>]`
+
+## Process contract
+
+1. Build and approve plan packet before any mutation.
+2. Execute only approved scope with rollback artifacts.
+3. Run independent evaluator then adversarial reviewer.
+4. Apply severity policy + strict pre-PR gates.
+5. If gates pass, auto-commit and open PR; never auto-merge.
+
+## Locked decisions (must not be changed)
+
+- Always produce a plan packet before mutation.
+- Adversarial review is always required.
+- Merge blocking authority is severity-policy-engine.
+- Router tuning is propose-and-approve only.
+- Plan ambiguity must request clarification (no silent guessing).
+- Rollback artifact must be revert-commit-ready and include:
+  - revert command
+  - prepared revert branch
+  - patch bundle
+- Debate profile is aggressive with locked confidence weights:
+  - claim_quality=0.20
+  - reproducibility=0.40
+  - agreement=0.40
+- Strict pre-PR gate is mandatory.
+- Post-pass behavior is auto-commit and auto-open-PR.
+- Never auto-merge PR.
+
+## Guardrails
+
+- Do not overthink straightforward gate outcomes; enforce gates deterministically.
+- Only follow the locked pipeline and governance decisions listed here.
+- Never bypass mandatory safety gates, even in `--quick` mode.
+
+## Strict gates
+
+Block commit/PR if any gate fails:
+
+1. Plan gate passed.
+2. Execution completed within approved scope.
+3. Independent evaluator passed.
+4. Adversarial review completed with consensus packet.
+5. Severity-policy-engine output is `pass` or `conditional_pass`.
+6. Benchmark delta checks passed.
+7. Rollback artifacts generated.
+
+## Notes
+
+- `--quick` may reduce breadth, never safety gates.
+- `--risk` can tighten behavior, never disable adversary.
+- If risk/ambiguity is high, auto-fallback to manual `harness-plan` and wait for clarification.
+- If execution must be interrupted safely, run `/harness-abort [reason]`, then restart with `/harness-plan "<task>"`.
+- Always output trace bundle ID and incident/rollback references.
+
+## Completion behavior
+
+End with a deterministic handoff block:
+
+1. `Pipeline status` (pass/fail per strict gate).
+2. `Trace bundle` and artifact references (`plan`, `eval`, `adversary`, `consensus`, `rollback`).
+3. `Policy outcome` (`pass`, `conditional_pass`, `block`, or `human_required`) with one-line rationale.
+4. `Next action` (open PR, replan, rollback, or human override path).