omegon 0.6.4 → 0.6.6

package/bin/omegon.mjs

@@ -2,39 +2,79 @@
 /**
  * Omegon entry point.
  *
- * Sets PI_CODING_AGENT_DIR to the omegon package root so the bundled agent
- * core loads all agent configuration (extensions, themes, skills, AGENTS.md)
- * from omegon rather than from ~/.pi/agent/.
+ * Keeps mutable user state in the shared pi-compatible agent directory while
+ * injecting Omegon-packaged resources from the installed package root.
  *
  * Resolution order for the underlying agent core:
  *   1. vendor/pi-mono (dev mode — git submodule present)
  *   2. node_modules/@styrene-lab/pi-coding-agent (installed via npm)
  */
+import { copyFileSync, cpSync, existsSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { existsSync } from "node:fs";
+import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 const __filename = fileURLToPath(import.meta.url);
 const omegonRoot = dirname(dirname(__filename));
+const defaultStateDir = join(homedir(), ".pi", "agent");
+const stateDir = process.env.PI_CODING_AGENT_DIR || defaultStateDir;
+const usingExplicitStateOverride = Boolean(process.env.PI_CODING_AGENT_DIR);
 
 const vendorCli = join(omegonRoot, "vendor/pi-mono/packages/coding-agent/dist/cli.js");
 const npmCli = join(omegonRoot, "node_modules/@styrene-lab/pi-coding-agent/dist/cli.js");
 const cli = existsSync(vendorCli) ? vendorCli : npmCli;
 const resolutionMode = cli === vendorCli ? "vendor" : "npm";
 
+function migrateLegacyStatePath(relativePath, kind = "file") {
+  if (usingExplicitStateOverride) {
+    return;
+  }
+
+  const legacyPath = join(omegonRoot, relativePath);
+  const targetPath = join(stateDir, relativePath);
+  if (!existsSync(legacyPath) || existsSync(targetPath)) {
+    return;
+  }
+
+  mkdirSync(dirname(targetPath), { recursive: true });
+  if (kind === "directory") {
+    cpSync(legacyPath, targetPath, { recursive: true, force: false });
+    return;
+  }
+  copyFileSync(legacyPath, targetPath);
+}
+
+function injectBundledResourceArgs(argv) {
+  const injected = [...argv];
+  const pushPair = (flag, value) => {
+    if (existsSync(value)) {
+      injected.push(flag, value);
+    }
+  };
+
+  pushPair("--extension", omegonRoot);
+  pushPair("--skill", join(omegonRoot, "skills"));
+  pushPair("--prompt-template", join(omegonRoot, "prompts"));
+  pushPair("--theme", join(omegonRoot, "themes"));
+  return injected;
+}
+
 if (process.argv.includes("--where")) {
   process.stdout.write(JSON.stringify({
     omegonRoot,
     cli,
     resolutionMode,
-    agentDir: process.env.PI_CODING_AGENT_DIR ?? omegonRoot,
+    agentDir: stateDir,
+    stateDir,
     executable: "omegon",
   }, null, 2) + "\n");
   process.exit(0);
 }
 
-if (!process.env.PI_CODING_AGENT_DIR) {
-  process.env.PI_CODING_AGENT_DIR = omegonRoot;
-}
+process.env.PI_CODING_AGENT_DIR = stateDir;
+migrateLegacyStatePath("auth.json");
+migrateLegacyStatePath("settings.json");
+migrateLegacyStatePath("sessions", "directory");
+process.argv = injectBundledResourceArgs(process.argv);
 
 await import(cli);

package/extensions/bootstrap/index.ts

@@ -442,6 +442,7 @@ export interface PiResolutionInfo {
 	cli: string;
 	resolutionMode: "vendor" | "npm";
 	agentDir: string;
+	stateDir?: string;
 }
 
 export interface OmegonBinaryVerification {

package/extensions/cleave/dispatcher.ts

@@ -1,13 +1,13 @@
 /**
  * cleave/dispatcher — Child process dispatch and monitoring.
  *
- * Spawns `pi` subprocesses for each child task, using the same
+ * Spawns Omegon-owned subprocesses for each child task, using the same
  * subagent pattern as pi's example extension. Each child runs in
  * its own git worktree with an isolated context.
  *
  * Supports two backends:
- * - "cloud": spawns a full `pi` process (uses cloud API)
- * - "local": spawns `pi` with --model pointing to a local Ollama model
+ * - "cloud": spawns a full Omegon child process (uses cloud API)
+ * - "local": spawns Omegon with --model pointing to a local Ollama model
  *
  * The dispatcher handles:
  * - Dependency-ordered wave execution
@@ -26,6 +26,7 @@ import { computeDispatchWaves } from "./planner.ts";
 import { executeWithReview, type ReviewConfig, type ReviewExecutor, DEFAULT_REVIEW_CONFIG } from "./review.ts";
 import { saveState } from "./workspace.ts";
 import { resolveTier, getDefaultPolicy, getViableModels, type ProviderRoutingPolicy, type RegistryModel } from "../lib/model-routing.ts";
+import { resolveOmegonSubprocess } from "../lib/omegon-subprocess.ts";
 
 // ─── Large-run threshold ────────────────────────────────────────────────────
 
@@ -370,7 +371,8 @@ async function spawnChild(
 	localModel?: string,
 	onLine?: (line: string) => void,
 ): Promise<ChildResult> {
-	const args = ["-p", "--no-session"];
+	const omegon = resolveOmegonSubprocess();
+	const args = [...omegon.argvPrefix, "-p", "--no-session"];
 	if (localModel) {
 		args.push("--model", localModel);
 	}
@@ -380,7 +382,7 @@ async function spawnChild(
 		let stderr = "";
 		let killed = false;
 
-		const proc = spawn("pi", args, {
+		const proc = spawn(omegon.command, args, {
 			cwd,
 			stdio: ["pipe", "pipe", "pipe"],
 			env: {

package/extensions/cleave/index.ts

@@ -29,6 +29,7 @@ import { debug } from "../lib/debug.ts";
 import { emitOpenSpecState } from "../openspec/dashboard-state.ts";
 import { getSharedBridge, buildSlashCommandResult } from "../lib/slash-command-bridge.ts";
 import { buildAssessBridgeResult } from "./bridge.ts";
+import { resolveOmegonSubprocess } from "../lib/omegon-subprocess.ts";
 import {
 	assessDirective,
 	PATTERNS,
@@ -755,11 +756,12 @@ async function runSpecAssessmentSubprocess(
 		...(input.diffContent ? ["### Recent Changes", "", "```diff", input.diffContent, "```", ""] : []),
 	].join("\n");
 
-	const args = ["--mode", "json", "--plan", "-p", "--no-session"];
+	const omegon = resolveOmegonSubprocess();
+	const args = [...omegon.argvPrefix, "--mode", "json", "--plan", "-p", "--no-session"];
 	if (input.modelId) args.push("--model", input.modelId);
 
 	return await new Promise<SpecAssessmentRunnerOutput>((resolve, reject) => {
-		const proc = spawn("pi", args, {
+		const proc = spawn(omegon.command, args, {
 			cwd: input.repoPath,
 			shell: false,
 			stdio: ["pipe", "pipe", "pipe"],
@@ -1454,12 +1456,13 @@ async function runDesignAssessmentSubprocess(
 		"}",
 	].join("\n");
 
-	const args = ["--mode", "json", "--plan", "-p", "--no-session"];
+	const omegon = resolveOmegonSubprocess();
+	const args = [...omegon.argvPrefix, "--mode", "json", "--plan", "-p", "--no-session"];
 	if (modelId) args.push("--model", modelId);
 
 	return await new Promise<{ findings: DesignAssessmentFinding[]; nodeTitle: string; structuralPass: boolean }>(
 		(resolve, reject) => {
-			const proc = spawn("pi", args, {
+			const proc = spawn(omegon.command, args, {
 				cwd: repoPath,
 				shell: false,
 				stdio: ["pipe", "pipe", "pipe"],

package/extensions/lib/omegon-subprocess.ts

@@ -0,0 +1,29 @@
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+export interface OmegonSubprocessSpec {
+  command: string;
+  argvPrefix: string[];
+  omegonEntry: string;
+}
+
+let cached: OmegonSubprocessSpec | null = null;
+
+/**
+ * Resolve the canonical Omegon-owned subprocess entrypoint without relying on PATH.
+ *
+ * Internal helpers should spawn `process.execPath` with `bin/omegon.mjs` explicitly,
+ * rather than assuming a `pi` or `omegon` binary on PATH points back to this install.
+ */
+export function resolveOmegonSubprocess(): OmegonSubprocessSpec {
+  if (cached) return cached;
+
+  const here = dirname(fileURLToPath(import.meta.url));
+  const omegonEntry = join(here, "..", "..", "bin", "omegon.mjs");
+  cached = {
+    command: process.execPath,
+    argvPrefix: [omegonEntry],
+    omegonEntry,
+  };
+  return cached;
+}

package/extensions/project-memory/extraction-v2.ts

@@ -15,6 +15,7 @@
 import { spawn, type ChildProcess } from "node:child_process";
 import type { MemoryConfig } from "./types.ts";
 import type { Fact, Edge } from "./factstore.ts";
+import { resolveOmegonSubprocess } from "../lib/omegon-subprocess.ts";
 
 // ---------------------------------------------------------------------------
 // Shared subprocess runner
@@ -95,7 +96,9 @@ function spawnExtraction(opts: {
       return;
     }
 
+    const omegon = resolveOmegonSubprocess();
     const args = [
+      ...omegon.argvPrefix,
       "--model", opts.model,
       "--no-session", "--no-tools", "--no-extensions",
       "--no-skills", "--no-themes", "--thinking", "off",
@@ -103,7 +106,7 @@ function spawnExtraction(opts: {
       "-p", opts.userMessage,
     ];
 
-    const proc = spawn("pi", args, {
+    const proc = spawn(omegon.command, args, {
       cwd: opts.cwd,
       stdio: ["ignore", "pipe", "pipe"],
       // Detach into new session so child has no controlling terminal.

package/extensions/project-memory/factstore.ts

@@ -91,6 +91,30 @@ function loadDatabase(): any {
 
 const Database = loadDatabase();
 
+function buildSafeFtsQuery(query: string, joiner: "AND" | "OR" = "AND"): string {
+  const tokens = query
+    .split(/\s+/)
+    .map(token => token.trim())
+    .filter(token => token.length > 0)
+    .map(token => token.replace(/"/g, '""'))
+    .filter(token => /[\p{L}\p{N}]/u.test(token))
+    .map(token => `"${token}"`);
+
+  return tokens.join(` ${joiner} `);
+}
+
+function isIgnorableFtsQueryError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false;
+  const message = error.message.toLowerCase();
+  return (
+    message.includes("fts5")
+    || message.includes("malformed match expression")
+    || message.includes("syntax error")
+    || message.includes("unterminated string")
+    || message.includes("no such column")
+  );
+}
+
 /** Generate a short unique ID */
 function nanoid(size = 12): string {
   const bytes = crypto.randomBytes(size);
@@ -234,6 +258,7 @@ export class FactStore {
     fs.mkdirSync(memoryDir, { recursive: true });
     this.db = new Database(this.dbPath);
     this.db.pragma("journal_mode = WAL");
+    this.db.pragma("busy_timeout = 5000");
     this.db.pragma("foreign_keys = ON");
     this.initSchema();
     this.runMigrations();
@@ -1027,47 +1052,56 @@ export class FactStore {
 
   /** Full-text search across all facts (all minds, all statuses) */
   searchFacts(query: string, mind?: string): Fact[] {
-    // FTS5 match syntax
-    const ftsQuery = query.split(/\s+/).filter(t => t.length > 0).join(" AND ");
+    const ftsQuery = buildSafeFtsQuery(query, "AND");
     if (!ftsQuery) return [];
 
-    if (mind) {
+    try {
+      if (mind) {
+        return this.db.prepare(`
+          SELECT f.* FROM facts f
+          JOIN facts_fts fts ON f.rowid = fts.rowid
+          WHERE facts_fts MATCH ? AND f.mind = ?
+          ORDER BY rank
+        `).all(ftsQuery, mind) as Fact[];
+      }
+
       return this.db.prepare(`
         SELECT f.* FROM facts f
         JOIN facts_fts fts ON f.rowid = fts.rowid
-        WHERE facts_fts MATCH ? AND f.mind = ?
+        WHERE facts_fts MATCH ?
         ORDER BY rank
-      `).all(ftsQuery, mind) as Fact[];
+      `).all(ftsQuery) as Fact[];
+    } catch (error) {
+      if (isIgnorableFtsQueryError(error)) return [];
+      throw error;
     }
-
-    return this.db.prepare(`
-      SELECT f.* FROM facts f
-      JOIN facts_fts fts ON f.rowid = fts.rowid
-      WHERE facts_fts MATCH ?
-      ORDER BY rank
-    `).all(ftsQuery) as Fact[];
   }
 
   /** Search archived/superseded facts (replaces searchArchive) */
   searchArchive(query: string, mind?: string): Fact[] {
-    const ftsQuery = query.split(/\s+/).filter(t => t.length > 0).join(" AND ");
+    const ftsQuery = buildSafeFtsQuery(query, "AND");
     if (!ftsQuery) return [];
 
-    if (mind) {
+    try {
+      if (mind) {
+        return this.db.prepare(`
+          SELECT f.* FROM facts f
+          JOIN facts_fts fts ON f.rowid = fts.rowid
+          WHERE facts_fts MATCH ? AND f.mind = ? AND f.status IN ('archived', 'superseded')
+          ORDER BY f.created_at DESC
+        `).all(ftsQuery, mind) as Fact[];
+      }
+
       return this.db.prepare(`
         SELECT f.* FROM facts f
         JOIN facts_fts fts ON f.rowid = fts.rowid
-        WHERE facts_fts MATCH ? AND f.mind = ? AND f.status IN ('archived', 'superseded')
+        WHERE facts_fts MATCH ? AND f.status IN ('archived', 'superseded')
         ORDER BY f.created_at DESC
-      `).all(ftsQuery, mind) as Fact[];
+      `).all(ftsQuery) as Fact[];
+    } catch (error) {
+      if (isIgnorableFtsQueryError(error)) return [];
+      throw error;
     }
-
-    return this.db.prepare(`
-      SELECT f.* FROM facts f
-      JOIN facts_fts fts ON f.rowid = fts.rowid
-      WHERE facts_fts MATCH ? AND f.status IN ('archived', 'superseded')
-      ORDER BY f.created_at DESC
-    `).all(ftsQuery) as Fact[];
   }
 
   /** Get a single fact by ID */
@@ -1850,9 +1884,8 @@ export class FactStore {
     const ftsRanked: Map<string, number> = new Map(); // fact.id → rank (0-indexed)
     if (queryText.length > 2) {
       // Use OR mode for broader recall — AND is too restrictive for injection
-      const tokens = queryText.split(/\s+/).filter(t => t.length > 1);
-      if (tokens.length > 0) {
-        const ftsQuery = tokens.join(" OR ");
+      const ftsQuery = buildSafeFtsQuery(queryText, "OR");
+      if (ftsQuery) {
         try {
           let query = `
             SELECT f.* FROM facts f

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "omegon",
-	"version": "0.6.4",
+	"version": "0.6.6",
 	"description": "Omegon — an opinionated distribution of pi (by Mario Zechner) with extensions for lifecycle management, memory, orchestration, and visualization",
 	"bin": {
 		"omegon": "bin/omegon.mjs",