omni-pi 0.2.0 → 0.3.0

package/README.md

@@ -1,8 +1,8 @@
 # Omni-Pi
 
-Omni-Pi: Guided software delivery for everyone.
+Omni-Pi is a Pi package built around one user-facing brain.
 
-Omni-Pi is an opinionated Pi package and branded launcher published on npm as `omni-pi`. It helps people move from a blank repo to a structured plan, implemented work, and explicit verification without having to assemble the workflow themselves.
+The goal is simple: talk to a helpful agent, let it interview you until the request is precise, have it write the spec and task breakdown into `.omni/`, then implement the work in bounded slices with explicit verification and progress notes.
 
 Requires Node.js 22 or newer.
 
@@ -10,134 +10,89 @@ Requires Node.js 22 or newer.
 [![npm version](https://img.shields.io/npm/v/omni-pi.svg)](https://www.npmjs.com/package/omni-pi)
 [![CI](https://github.com/EdGy2k/Omni-Pi/actions/workflows/ci.yml/badge.svg)](https://github.com/EdGy2k/Omni-Pi/actions/workflows/ci.yml)
 
-## Why Omni-Pi
+## What It Does
 
-- Guided step-by-step workflow keeps the process moving without blank-canvas paralysis.
-- Durable project memory in `.omni/` survives across sessions.
-- Automatic verification infers checks from the language and project shape.
-- Expert fallback takes over when the worker agent gets stuck.
-
-## Quick Start
-
-Install Omni-Pi from npm, then run it in your project:
-
-```bash
-npm install -g omni-pi
-cd your-project
-omni
-```
+- One friendly brain talks to the user.
+- `.omni/` remains the durable memory layer for goals, specs, tasks, checks, progress, and decisions.
+- Work is still broken into small, verifiable slices before code changes happen.
+- Verification remains explicit and should be recorded alongside implementation progress.
 
 ## Install
 
-Install the published package globally with npm:
-
-```bash
-npm install -g omni-pi
-```
-
-Confirm the launcher is available:
+Install the package into Pi:
 
 ```bash
-omni --help
+pi install npm:omni-pi
 ```
 
-Then open any project directory and start Omni-Pi:
+For a project-local install instead of a global one:
 
 ```bash
-cd your-project
-omni
+pi install -l npm:omni-pi
 ```
 
-To upgrade later:
+For local development from this checkout:
 
 ```bash
-npm install -g omni-pi@latest
+pi install /Users/edgy/personal/Omni-Pi
 ```
 
-Omni-Pi launches the bundled Pi runtime and loads the Omni-Pi package automatically, so you do not need to manually wire extensions, skills, or prompts after installing from npm.
-
-## Model Providers
-
-Omni-Pi now ships the upstream provider mix needed for practical multi-provider use on top of Pi.
-
-- Built into the underlying Pi runtime: `anthropic`, `openai`, `openai-codex`, `google`, `google-vertex`, `amazon-bedrock`, `azure-openai-responses`, `openrouter`, `xai`, `zai`, `mistral`, `groq`, `cerebras`, `huggingface`, `github-copilot`, `kimi-coding`, `minimax`, `minimax-cn`, `opencode`, `opencode-go`
-- Added by Omni-Pi: `nvidia`, `together`, `synthetic`, `nanogpt`, `xiaomi`, `moonshot`, `venice`, `kilo`, `gitlab-duo`, `qwen-portal`, `qianfan`, `cloudflare-ai-gateway`
-- Auto-discovered when running locally: `ollama`, `lm-studio`, `llama.cpp`, `litellm`, `vllm`
-
-For users who do not want to rely on Anthropic OAuth inside Pi, Omni-Pi also exposes opt-in Claude Agent SDK model aliases:
-
-- `claude-agent/claude-sonnet-4-6`
-- `claude-agent/claude-opus-4-6`
-
-These are intended for Omni-Pi's worker and expert subagents. Configure a role with `/omni-model` and Omni-Pi will run that subagent through the Claude Agent SDK instead of Pi's normal Anthropic provider path.
-
-Common provider env vars:
+## Use
 
-- `NVIDIA_API_KEY`, `TOGETHER_API_KEY`, `SYNTHETIC_API_KEY`, `NANO_GPT_API_KEY`
-- `XIAOMI_API_KEY`, `MOONSHOT_API_KEY`, `VENICE_API_KEY`, `KILO_API_KEY`
-- `GITLAB_TOKEN`, `QWEN_OAUTH_TOKEN` or `QWEN_PORTAL_API_KEY`, `QIANFAN_API_KEY`
-- `CLOUDFLARE_AI_GATEWAY_API_KEY` and `CLOUDFLARE_AI_GATEWAY_BASE_URL`
+Start Pi in the project you want to work on, with Omni-Pi installed, and describe what you want.
 
-For local providers, Omni-Pi registers models only when the endpoint is reachable:
+Example:
 
-- `OLLAMA_BASE_URL` / `OLLAMA_API_KEY`
-- `LM_STUDIO_BASE_URL` / `LM_STUDIO_API_KEY`
-- `LLAMA_CPP_BASE_URL` / `LLAMA_CPP_API_KEY`
-- `LITELLM_BASE_URL` / `LITELLM_API_KEY`
-- `VLLM_BASE_URL` / `VLLM_API_KEY`
-
-## Commands
-
-| Command | Description |
-|---------|-------------|
-| `/omni-init` | Initialize `.omni/` project memory, run quick-start wizard, scan repo signals, run health checks (`--quick` to skip wizard) |
-| `/omni-plan` | Create or refresh spec, tasks, and tests (supports `--preset bugfix/feature/refactor/spike/security-audit`) |
-| `/omni-work` | Run the next task through worker, verifier, and expert fallback |
-| `/omni-status` | Show current phase, task, blockers, next step (add `metrics` for agent stats) |
-| `/omni-sync` | Update durable memory files from recent progress |
-| `/omni-skills` | Inspect installed, recommended, deferred, and rejected skills |
-| `/omni-explain` | Explain what Omni-Pi is doing in simple language |
-| `/omni-model` | Interactively select the model for a specific agent role, or enter any canonical `provider/model` reference |
-| `/omni-commit` | Create a branch and commit for the last completed task |
-| `/omni-doctor` | Run diagnostic health checks and detect stuck tasks |
-
-## How It Works
+```text
+Build a small CLI notes app for me. I want add, list, and search commands. Store data locally in JSON. Ask me any questions you need before you start coding.
+```
 
-Omni-Pi follows a simple agent pipeline: Brain, Planner, Worker, Expert. The Brain handles conversation, the Planner turns intent into concrete steps and checks, and the Worker executes bounded tasks with filesystem-backed state in `.omni/`.
+Expected behavior:
 
-When the Worker gets stuck or verification fails repeatedly, the Expert role steps in to recover the task, adapt the approach, or surface the blocker clearly instead of letting the session stall.
+- Omni-Pi interviews first when the request is underspecified.
+- It writes and updates `.omni/PROJECT.md`, `.omni/SPEC.md`, `.omni/TASKS.md`, `.omni/TESTS.md`, and `.omni/STATE.md`.
+- It hides internal implementation machinery instead of talking about planner/worker/expert handoffs.
+- It implements one bounded slice at a time and runs the planned checks.
 
-On first use inside a project, Omni-Pi creates and updates `.omni/` state so plans, task progress, verification steps, and recovery context persist across sessions.
+## Durable Memory
 
-## Features
+Omni-Pi keeps its working notes in `.omni/`:
 
-- Core workflow with durable `.omni/` project memory, typed planning and execution contracts, filesystem-backed init/planning/status, and retry-aware task execution.
-- Language-aware verification that infers test commands for common stacks and supports custom checks in `.omni/TESTS.md`.
-- Workflow presets for bugfix, feature, refactor, spike, and security-audit work.
-- Doctor checks for init state, config validity, repo signals, task health, and stuck detection.
-- Plan and progress memory with dated plan files, an index tracker, and timestamped progress logs.
-- Context-aware file selection for different workflow phases.
-- Subagent integration for worker and expert execution with raw output persistence and model overrides.
-- Persistent dashboard state for phase, task, blockers, next step, and health status.
-- Git integration for branch creation and task-derived commits.
-- Interactive planning for constraints, user context, and skill install tracking.
+- `PROJECT.md` captures the problem, users, constraints, and success criteria.
+- `SPEC.md` captures the exact requested behavior and implementation shape.
+- `TASKS.md` breaks work into bounded slices.
+- `TESTS.md` records the checks for the current slice.
+- `STATE.md`, `SESSION-SUMMARY.md`, and `DECISIONS.md` keep progress and rationale durable across sessions.
 
 ## Development
 
-For local checkout development, see [CONTRIBUTING.md](CONTRIBUTING.md).
-
 ```bash
 git clone https://github.com/EdGy2k/Omni-Pi.git
 cd Omni-Pi
 npm install
-npm test
+npm run chat
+```
+
+`npm run chat` launches Pi with this package loaded from the local checkout.
+
+For local verification:
+
+```bash
 npm run check
 npm run lint
+npm test
+```
+
+For package verification:
+
+```bash
+npm pack
+npm publish --dry-run
 ```
 
 ## Attribution
 
-Omni-Pi builds on the Pi ecosystem. See [CREDITS.md](CREDITS.md) for full attribution.
+Omni-Pi builds on the Pi ecosystem. See [CREDITS.md](CREDITS.md).
 
 ## License
 

package/agents/brain.md

@@ -1,24 +1,24 @@
 ---
 name: brain
 model: friendly-primary-model
-description: User-facing orchestrator for Omni-Pi.
+description: User-facing agent for Omni-Pi.
 ---
 
 # Brain
 
-You are the user-facing guide for Omni-Pi.
+You are the single user-facing brain for Omni-Pi.
 
 ## Responsibilities
 
 - Talk to the user in plain English.
-- Keep the user oriented with simple progress updates.
+- Interview the user until the requested behavior, constraints, and success criteria are exact.
 - Update durable project memory through the `.omni/` file model.
-- Decide when to invoke the planner, worker, verifier, or expert roles.
-- Hide internal complexity unless the user asks for technical detail.
+- Break the work into bounded, verifiable slices before changing code.
+- Implement the slices and report progress without exposing internal machinery unless asked.
 
 ## Rules
 
 - Prefer clarity over jargon.
-- Keep tasks small before handing them off.
+- Keep tasks small before implementing them.
 - Record important changes in `.omni/STATE.md`, `.omni/SESSION-SUMMARY.md`, and `.omni/DECISIONS.md`.
-- Route only relevant skills to each subagent.
+- Use only the skills that materially help the current slice.

package/agents/expert.md

@@ -1,12 +1,12 @@
 ---
 name: expert
 model: strongest-implementation-model
-description: Advanced fallback subagent for difficult tasks.
+description: Archived recovery notes for Omni-Pi.
 ---
 
-# Expert
+# Recovery Notes
 
-You take over tasks that remain blocked after repeated worker failures or that require deeper reasoning.
+This file is retained as recovery guidance, but Omni-Pi now exposes a single brain to the user instead of separate expert agents.
 
 ## Responsibilities
 

package/agents/planner.md

@@ -1,12 +1,12 @@
 ---
 name: planner
 model: strongest-reasoning-model
-description: Spec writer and task decomposer for Omni-Pi.
+description: Archived planner notes for Omni-Pi.
 ---
 
-# Planner
+# Planner Notes
 
-You turn user intent and project context into a detailed implementation spec.
+This file is retained as planning guidance, but Omni-Pi now exposes a single brain to the user instead of separate planning agents.
 
 ## Responsibilities
 

package/agents/worker.md

@@ -1,12 +1,12 @@
 ---
 name: worker
 model: cheap-fast-model
-description: Narrow implementation subagent for Omni-Pi.
+description: Archived implementation notes for Omni-Pi.
 ---
 
-# Worker
+# Implementation Notes
 
-You execute one bounded task brief at a time.
+This file is retained as implementation guidance, but Omni-Pi now exposes a single brain to the user instead of separate worker agents.
 
 ## Responsibilities
 

package/extensions/omni-core/index.ts

@@ -1,22 +1,25 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 
-import { createOmniCommands } from "../../src/commands.js";
 import {
-  registerOmniMessageRenderer,
-  registerPiCommands,
-} from "../../src/pi.js";
+  buildBrainSystemPromptSuffix,
+  ensureOmniInitialized,
+} from "../../src/brain.js";
+import { registerOmniMessageRenderer } from "../../src/pi.js";
 
 export default function omniCoreExtension(api: ExtensionAPI): void {
   registerOmniMessageRenderer(api);
-  const commands = createOmniCommands().filter((command) =>
-    [
-      "omni-init",
-      "omni-plan",
-      "omni-work",
-      "omni-sync",
-      "omni-model",
-      "omni-commit",
-    ].includes(command.name),
-  );
-  registerPiCommands(api, commands);
+
+  api.on("session_start", async (_event, ctx) => {
+    await ensureOmniInitialized(ctx.cwd);
+    ctx.ui.setStatus("omni", undefined);
+  });
+
+  api.on("before_agent_start", async (event, ctx) => {
+    await ensureOmniInitialized(ctx.cwd);
+    const brainPrompt = await buildBrainSystemPromptSuffix(ctx.cwd);
+
+    return {
+      systemPrompt: `${event.systemPrompt}\n\n${brainPrompt}`,
+    };
+  });
 }

package/extensions/omni-memory/index.ts

@@ -8,7 +8,7 @@ import type {
 
 import type { OmniState } from "../../src/contracts.js";
 import { runDoctor } from "../../src/doctor.js";
-import { renderCompactStatus } from "../../src/status.js";
+import { renderCompactStatusWidget } from "../../src/status.js";
 
 async function readState(cwd: string): Promise<OmniState | null> {
   try {
@@ -49,7 +49,7 @@ async function updateWidget(ctx: ExtensionContext): Promise<void> {
     const report = await runDoctor(ctx.cwd);
     ctx.ui.setWidget(
       "omni-dashboard",
-      renderCompactStatus(state, report.overall),
+      (_tui, theme) => renderCompactStatusWidget(state, theme, report.overall),
       { placement: "aboveEditor" },
     );
   } else {

package/extensions/omni-providers/index.ts

@@ -1,9 +1,5 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-
-import { registerOmniProviders } from "../../src/providers.js";
-
 export default async function omniProvidersExtension(
-  api: ExtensionAPI,
+  _api: unknown,
 ): Promise<void> {
-  await registerOmniProviders(api);
+  return;
 }

package/extensions/omni-skills/index.ts

@@ -1,11 +1,5 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 
-import { createOmniCommands } from "../../src/commands.js";
-import { registerPiCommands } from "../../src/pi.js";
-
-export default function omniSkillsExtension(api: ExtensionAPI): void {
-  const commands = createOmniCommands().filter((command) =>
-    ["omni-skills"].includes(command.name),
-  );
-  registerPiCommands(api, commands);
+export default function omniSkillsExtension(_api: ExtensionAPI): void {
+  // The simplified single-agent flow no longer exposes slash commands.
 }

package/extensions/omni-status/index.ts

@@ -1,11 +1,5 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 
-import { createOmniCommands } from "../../src/commands.js";
-import { registerPiCommands } from "../../src/pi.js";
-
-export default function omniStatusExtension(api: ExtensionAPI): void {
-  const commands = createOmniCommands().filter((command) =>
-    ["omni-status", "omni-explain", "omni-doctor"].includes(command.name),
-  );
-  registerPiCommands(api, commands);
+export default function omniStatusExtension(_api: ExtensionAPI): void {
+  // The simplified single-agent flow no longer exposes slash commands.
 }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "omni-pi",
-  "version": "0.2.0",
-  "description": "Opinionated Pi package for guided, beginner-friendly planning and implementation workflows.",
+  "version": "0.3.0",
+  "description": "Single-agent Pi package that interviews the user, documents the spec, and implements work in bounded slices.",
   "type": "module",
   "license": "MIT",
   "author": "Eduard-David Gyarmati",
   "repository": {
     "type": "git",
-    "url": "https://github.com/EdGy2k/Omni-Pi.git"
+    "url": "git+https://github.com/EdGy2k/Omni-Pi.git"
   },
   "homepage": "https://github.com/EdGy2k/Omni-Pi#readme",
   "bugs": {
@@ -16,19 +16,15 @@
   "engines": {
     "node": ">=22"
   },
-  "bin": {
-    "omni": "./bin/omni.js"
-  },
   "keywords": [
     "pi-package",
     "pi",
     "agent",
     "planning",
-    "skills",
-    "orchestration"
+    "implementation",
+    "interview"
   ],
   "files": [
-    "bin",
     "agents",
     "extensions",
     "prompts",
@@ -39,6 +35,7 @@
     "CREDITS.md"
   ],
   "scripts": {
+    "chat": "node ./node_modules/@mariozechner/pi-coding-agent/dist/cli.js -e .",
     "check": "tsc --noEmit",
     "lint": "biome check .",
     "format": "biome check --write .",
@@ -54,13 +51,9 @@
   },
   "pi": {
     "extensions": [
-      "./node_modules/pi-subagents/index.ts",
-      "./node_modules/pi-subagents/notify.ts",
       "./extensions/omni-providers/index.ts",
       "./extensions/omni-core/index.ts",
-      "./extensions/omni-memory/index.ts",
-      "./extensions/omni-skills/index.ts",
-      "./extensions/omni-status/index.ts"
+      "./extensions/omni-memory/index.ts"
     ],
     "skills": [
       "./skills"

package/src/brain.ts

@@ -0,0 +1,117 @@
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+
+import type { OmniState } from "./contracts.js";
+import { initializeOmniProject, readOmniStatus } from "./workflow.js";
+
+const BRAIN_SYSTEM_APPEND = `## Omni-Pi Single-Brain Mode
+
+You are Omni-Pi's only user-facing brain.
+
+Your workflow is mandatory:
+1. Interview the user until the requested behavior, constraints, and success criteria are concrete enough to implement safely.
+2. Before editing code, make sure the durable project notes in .omni/ reflect the current understanding.
+3. Break the requested work into bounded, verifiable slices in .omni/TASKS.md before implementation.
+4. Implement one slice at a time.
+5. Run the planned checks, record progress in .omni/STATE.md and .omni/SESSION-SUMMARY.md, and tighten the plan if a slice fails.
+
+Behavior rules:
+- Stay friendly, plain-spoken, and direct.
+- Do not expose planner/worker/expert role handoffs. Everything happens behind the scenes.
+- Ask targeted follow-up questions when the request is underspecified.
+- Do not start editing code until the spec is explicit enough to avoid guessing.
+- Keep documentation current in .omni/PROJECT.md, .omni/SPEC.md, .omni/TASKS.md, .omni/TESTS.md, .omni/STATE.md, and .omni/DECISIONS.md when relevant.
+- When the user request is clear and bounded, move from interview to implementation without asking unnecessary extra questions.
+`;
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readOptional(filePath: string): Promise<string | null> {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+function renderStateSummary(state: OmniState | null): string {
+  if (!state) {
+    return "No durable Omni-Pi state exists yet.";
+  }
+
+  return [
+    `Current phase: ${state.currentPhase}`,
+    `Active task: ${state.activeTask}`,
+    `Status summary: ${state.statusSummary}`,
+    `Blockers: ${state.blockers.length > 0 ? state.blockers.join("; ") : "None"}`,
+    `Next step: ${state.nextStep}`,
+  ].join("\n");
+}
+
+function clipSection(value: string | null, maxChars: number): string {
+  if (!value) {
+    return "- Missing";
+  }
+  const trimmed = value.trim();
+  if (trimmed.length <= maxChars) {
+    return trimmed;
+  }
+  return `${trimmed.slice(0, maxChars)}…`;
+}
+
+export async function ensureOmniInitialized(
+  cwd: string,
+): Promise<"initialized" | "existing"> {
+  const statePath = path.join(cwd, ".omni", "STATE.md");
+  if (await fileExists(statePath)) {
+    return "existing";
+  }
+
+  await initializeOmniProject(cwd);
+  return "initialized";
+}
+
+export async function buildBrainSystemPromptSuffix(
+  cwd: string,
+): Promise<string> {
+  const projectPath = path.join(cwd, ".omni", "PROJECT.md");
+  const specPath = path.join(cwd, ".omni", "SPEC.md");
+  const tasksPath = path.join(cwd, ".omni", "TASKS.md");
+  const testsPath = path.join(cwd, ".omni", "TESTS.md");
+
+  const state = await readOmniStatus(cwd).catch(() => null);
+  const [project, spec, tasks, tests] = await Promise.all([
+    readOptional(projectPath),
+    readOptional(specPath),
+    readOptional(tasksPath),
+    readOptional(testsPath),
+  ]);
+
+  return `${BRAIN_SYSTEM_APPEND}
+
+## Current Durable State
+
+${renderStateSummary(state)}
+
+## Current Omni Files
+
+### .omni/PROJECT.md
+${clipSection(project, 1600)}
+
+### .omni/SPEC.md
+${clipSection(spec, 1600)}
+
+### .omni/TASKS.md
+${clipSection(tasks, 1600)}
+
+### .omni/TESTS.md
+${clipSection(tests, 1200)}
+`;
+}