@fiale-plus/pi-rogue 0.2.0

package/README.md

@@ -0,0 +1,50 @@
+# @fiale-plus/pi-rogue
+
+`@fiale-plus/pi-rogue` is the **single consolidated public artefact** for Pi-Rogue.
+
+It stitches together (and bundles for a true single-package install):
+
+- `@fiale-plus/pi-core` (shared contracts/helpers)
+- `@fiale-plus/pi-rogue-advisor` (logic; direct releases paused)
+- `@fiale-plus/pi-rogue-context-broker` (context-broker runtime; registered by default with an env kill switch)
+- `@fiale-plus/pi-rogue-orchestration` (logic; direct releases paused)
+
+Direct installs of the advisor/orchestration packages are paused (marked private). All users and future releases go through the bundle. See `docs/release.md` and root `AGENTS.md` / `README.md` for the release policy.
+
+## Install (recommended)
+
+```bash
+pi install npm:@fiale-plus/pi-rogue
+```
+
+For local monorepo dev:
+
+```bash
+# from repo root
+npm install
+# then use workspace packages as needed (e.g. for testing changes to advisor/orch before a bundle release)
+```
+
+## Scope boundaries
+
+- **Lab / internal helpers are excluded from this bundle.**
+- The context-broker runtime is bundled and registered by default in the bundle.
+- Consumers can import the runtime through the bundle subpath: `@fiale-plus/pi-rogue/context-broker`.
+- Set `PI_CONTEXT_BROKER_ENABLED=false` before starting Pi to disable the `/context` command surface and prompt-load rewriting.
+- Optional durable broker storage can be enabled with `PI_CONTEXT_BROKER_DURABLE=true` or `PI_CONTEXT_BROKER_STORE_DIR=/path/to/store`; it defaults to SQLite/FTS and supports `PI_CONTEXT_BROKER_BACKEND=jsonl` for the legacy JSONL/blob backend.
+- `@fiale-plus/pi-rogue` is the only published surface for the logic.
+- Internal helper packages (`@fiale-plus/pi-rogue-guardrails`, `@fiale-plus/pi-rogue-brain`, `@fiale-plus/pi-rogue-repo-arch`) are maintained separately in the lab section and not published.
+
+## Command surface
+
+- Default: `/advisor`, `/goal`, `/loop`, `/autoresearch`, `/autoresearch-lab` plus status/config/command paths (all provided via the bundle).
+- Context broker: enabled by default; `PI_CONTEXT_BROKER_ENABLED=false` disables `/context status`, `/context brief`, `/context lookup <handle|text>`, `/context pin <handle>`, `/context export <handle>`, and `/context prune` with autocomplete.
+
+## Status
+
+- **Published:** yes (single artefact)
+- The advisor and orchestration packages continue to receive code changes in this repo; they ship inside bundle releases via `bundledDependencies`.
+
+## Release notes
+
+Only `pi-rogue-<semver>` tags/releases are produced. See `docs/release.md` for the full clean policy and checklist.

package/node_modules/@fiale-plus/pi-core/README.md

@@ -0,0 +1,13 @@
+# Pi-Rogue Core
+
+Shared helpers for the Pi-Rogue workspace.
+
+Includes shared bounded context broker contracts:
+
+- `BoundedContextBroker`
+- `ContextArtifact` / `ContextArtifactInput`
+- lookup, retention, and status type definitions
+
+The executable in-memory implementation lives in `@fiale-plus/pi-rogue-context-broker`.
+
+Install locally from this repo root: `npm install`

package/node_modules/@fiale-plus/pi-core/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@fiale-plus/pi-core",
+  "version": "0.1.0",
+  "description": "Shared helpers for the Pi-Rogue workspace.",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "pi-package"
+  ],
+  "scripts": {
+    "test": "cd ../.. && vitest run packages/core/src/*.test.ts"
+  },
+  "private": true,
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/node_modules/@fiale-plus/pi-core/src/context-broker.ts

@@ -0,0 +1,109 @@
+export type ContextArtifactKind =
+  | "tool_output"
+  | "diff"
+  | "file_snapshot"
+  | "subagent_result"
+  | "advisor_brief"
+  | "memory_note";
+
+export type ContextArtifactTier = "hot" | "warm" | "cold";
+
+export interface ContextArtifactInput {
+  sessionId: string;
+  kind: ContextArtifactKind;
+  payload: string | Buffer;
+  summary?: string;
+  tags?: string[];
+  paths?: string[];
+  command?: string;
+  branch?: string;
+  tier?: ContextArtifactTier;
+  ttlMs?: number;
+  pinned?: boolean;
+  parentIds?: string[];
+  createdAt?: number;
+}
+
+export interface ContextArtifact {
+  id: string;
+  handle: string;
+  sessionId: string;
+  kind: ContextArtifactKind;
+  createdAt: number;
+  updatedAt: number;
+  bytes: number;
+  sha256: string;
+  payload: string;
+  summary: string;
+  tags: string[];
+  paths: string[];
+  command?: string;
+  branch?: string;
+  tier: ContextArtifactTier;
+  expiresAt?: number;
+  pinned: boolean;
+  parentIds: string[];
+}
+
+export interface ContextLookupQuery {
+  id?: string;
+  handle?: string;
+  sessionId?: string;
+  kind?: ContextArtifactKind;
+  tag?: string;
+  path?: string;
+  commandPrefix?: string;
+  branch?: string;
+  tier?: ContextArtifactTier;
+  text?: string;
+  limit?: number;
+}
+
+export interface ContextBrokerStatus {
+  records: number;
+  bytes: number;
+  pinnedRecords: number;
+  pinnedBytes: number;
+  hotRecords: number;
+  hotBytes: number;
+  warmRecords: number;
+  warmBytes: number;
+  coldRecords: number;
+  coldBytes: number;
+  maxRecords: number;
+  maxBytes: number;
+}
+
+export interface ContextBrokerOptions {
+  maxRecords?: number;
+  maxBytes?: number;
+  globalMaxRecords?: number;
+  globalMaxBytes?: number;
+  defaultTtlMs?: number;
+  hotTtlMs?: number;
+  warmTtlMs?: number;
+  coldTtlMs?: number;
+  hotMaxRecords?: number;
+  warmMaxRecords?: number;
+  coldMaxRecords?: number;
+  hotMaxBytes?: number;
+  warmMaxBytes?: number;
+  coldMaxBytes?: number;
+  summaryBytes?: number;
+  briefBytes?: number;
+}
+
+export interface ContextPurgeOptions {
+  sessionId?: string;
+  keepPinned?: boolean;
+}
+
+export interface BoundedContextBroker {
+  publish(input: ContextArtifactInput): ContextArtifact;
+  lookup(query?: ContextLookupQuery): ContextArtifact[];
+  pin(idOrHandle: string, pinned?: boolean): ContextArtifact | null;
+  prune(now?: number): ContextBrokerStatus;
+  purge(options?: ContextPurgeOptions): ContextBrokerStatus;
+  status(): ContextBrokerStatus;
+  renderBrief(query?: ContextLookupQuery & { budgetBytes?: number }): string;
+}

package/node_modules/@fiale-plus/pi-core/src/index.ts

@@ -0,0 +1,5 @@
+export * from "./context-broker.js";
+export * from "./paths.js";
+export * from "./risk.js";
+export * from "./storage.js";
+export * from "./text.js";

package/node_modules/@fiale-plus/pi-core/src/paths.ts

@@ -0,0 +1,36 @@
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+
+const ROOT_DIR = join(homedir(), ".pi", "agent", "fiale-plus");
+
+export function appDir(): string {
+  mkdirSync(ROOT_DIR, { recursive: true });
+  return ROOT_DIR;
+}
+
+export function featureDir(feature: string): string {
+  const dir = join(appDir(), feature);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function sessionKey(ctx: any): string {
+  const sessionFile = ctx?.sessionManager?.getSessionFile?.();
+  if (!sessionFile) return "session";
+  return basename(String(sessionFile)).replace(/\.[^.]+$/, "");
+}
+
+export function sessionDir(feature: string, ctx: any): string {
+  const dir = join(featureDir(feature), sessionKey(ctx));
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function featureFile(feature: string, filename: string): string {
+  return join(featureDir(feature), filename);
+}
+
+export function sessionFile(feature: string, ctx: any, filename: string): string {
+  return join(sessionDir(feature, ctx), filename);
+}

package/node_modules/@fiale-plus/pi-core/src/risk.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect } from "vitest";
+import { scanShellCommand, type RiskScan } from "./risk.js";
+
+describe("scanShellCommand", () => {
+  it("returns safe for empty command", () => {
+    const result = scanShellCommand("");
+    expect(result.safe).toBe(true);
+    expect(result.severity).toBe("safe");
+  });
+
+  it("returns safe for a benign command", () => {
+    const result = scanShellCommand("echo hello world");
+    expect(result.safe).toBe(true);
+    expect(result.severity).toBe("safe");
+  });
+
+  it("detects rm as dangerous", () => {
+    const result = scanShellCommand("rm -rf /tmp/foo");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+    expect(result.findings.some((f) => f.id === "rm")).toBe(true);
+  });
+
+  it("detects rm only as a word boundary (not inside other words)", () => {
+    const result = scanShellCommand("program --remove-all");
+    expect(result.safe).toBe(true);
+  });
+
+  it("detects sudo as warning", () => {
+    const result = scanShellCommand("sudo apt update");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("warn");
+    expect(result.findings.some((f) => f.id === "sudo")).toBe(true);
+  });
+
+  it("detects chmod -R as dangerous", () => {
+    const result = scanShellCommand("chmod -R 777 /etc");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+    expect(result.findings.some((f) => f.id === "chmod-r")).toBe(true);
+  });
+
+  it("detects chown as dangerous", () => {
+    const result = scanShellCommand("chown root:root /var");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+  });
+
+  it("detects git push --force as dangerous", () => {
+    const result = scanShellCommand("git push --force origin main");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+    expect(result.findings.some((f) => f.id === "force-push")).toBe(true);
+  });
+
+  it("detects git push --force-with-lease as dangerous", () => {
+    const result = scanShellCommand("git push --force-with-lease origin main");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+    expect(result.findings.some((f) => f.id === "force-push")).toBe(true);
+  });
+
+  it("detects curl | sh as dangerous", () => {
+    const result = scanShellCommand("curl https://example.com/install.sh | sh");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+    expect(result.findings.some((f) => f.id === "curl-shell")).toBe(true);
+  });
+
+  it("detects curl | bash as dangerous", () => {
+    const result = scanShellCommand("curl -fsSL https://example.com/install.sh | bash");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+    expect(result.findings.some((f) => f.id === "curl-shell")).toBe(true);
+  });
+
+  it("detects mkfs as dangerous", () => {
+    const result = scanShellCommand("mkfs.ext4 /dev/sda1");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+  });
+
+  it("detects dd if= as dangerous", () => {
+    const result = scanShellCommand("dd if=/dev/zero of=/tmp/out bs=1M count=10");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+  });
+
+  it("detects shutdown as dangerous", () => {
+    const result = scanShellCommand("shutdown -h now");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+  });
+
+  it("detects reboot as dangerous", () => {
+    const result = scanShellCommand("reboot");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+  });
+
+  it("scans extra fragments", () => {
+    const result = scanShellCommand("docker exec -it container bash", ["docker exec"]);
+    expect(result.safe).toBe(false);
+    expect(result.findings.some((f) => f.id === "extra:docker exec")).toBe(true);
+  });
+
+  it("returns warn severity when only warnings are found", () => {
+    const result = scanShellCommand("sudo echo hello");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("warn");
+  });
+
+  it("returns danger severity when danger items are found even with warnings", () => {
+    const result = scanShellCommand("sudo rm /tmp/foo");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+  });
+
+  it("handles case-insensitive matching", () => {
+    const result = scanShellCommand("RM -rf /");
+    expect(result.safe).toBe(false);
+    expect(result.findings.some((f) => f.id === "rm")).toBe(true);
+  });
+
+  it("ignores empty extra fragments", () => {
+    const result = scanShellCommand("echo foo", ["", "  "]);
+    expect(result.safe).toBe(true);
+  });
+});

package/node_modules/@fiale-plus/pi-core/src/risk.ts

@@ -0,0 +1,97 @@
+export interface RiskFinding {
+  id: string;
+  label: string;
+  severity: "warn" | "danger";
+}
+
+export interface RiskScan {
+  safe: boolean;
+  severity: "safe" | "warn" | "danger";
+  findings: RiskFinding[];
+  reason: string;
+}
+
+const DEFAULT_PATTERNS: RiskFinding[] = [
+  { id: "rm", label: "rm", severity: "danger" },
+  { id: "sudo", label: "sudo", severity: "warn" },
+  { id: "chmod-r", label: "chmod -R", severity: "danger" },
+  { id: "chown", label: "chown", severity: "danger" },
+  { id: "mkfs", label: "mkfs", severity: "danger" },
+  { id: "dd", label: "dd if=", severity: "danger" },
+  { id: "shutdown", label: "shutdown", severity: "danger" },
+  { id: "reboot", label: "reboot", severity: "danger" },
+  { id: "force-push", label: "git push --force", severity: "danger" },
+  { id: "curl-shell", label: "curl | sh", severity: "danger" },
+  { id: "wget-shell", label: "wget | sh", severity: "danger" },
+];
+
+function contains(command: string, fragment: string): boolean {
+  return command.toLowerCase().includes(fragment.toLowerCase());
+}
+
+export function scanShellCommand(command: string, extraFragments: string[] = []): RiskScan {
+  const findings: RiskFinding[] = [];
+  const text = command.trim();
+
+  if (!text) {
+    return { safe: true, severity: "safe", findings, reason: "Empty command." };
+  }
+
+  for (const pattern of DEFAULT_PATTERNS) {
+    switch (pattern.id) {
+      case "rm":
+        if (/\brm\b/i.test(text)) findings.push(pattern);
+        break;
+      case "sudo":
+        if (/\bsudo\b/i.test(text)) findings.push(pattern);
+        break;
+      case "chmod-r":
+        if (/\bchmod\s+-R\b/i.test(text)) findings.push(pattern);
+        break;
+      case "chown":
+        if (/\bchown\b/i.test(text)) findings.push(pattern);
+        break;
+      case "mkfs":
+        if (/\bmkfs(?:\.[\w-]+)?\b/i.test(text)) findings.push(pattern);
+        break;
+      case "dd":
+        if (/\bdd\s+if=/i.test(text)) findings.push(pattern);
+        break;
+      case "shutdown":
+        if (/\bshutdown\b/i.test(text)) findings.push(pattern);
+        break;
+      case "reboot":
+        if (/\breboot\b/i.test(text)) findings.push(pattern);
+        break;
+      case "force-push":
+        if (/\bgit\s+push\b[\s\S]*--force(?:-with-lease)?/i.test(text)) findings.push(pattern);
+        break;
+      case "curl-shell":
+        if (/\bcurl\b[\s\S]*\|\s*(sh|bash)\b/i.test(text)) findings.push(pattern);
+        break;
+      case "wget-shell":
+        if (/\bwget\b[\s\S]*\|\s*(sh|bash)\b/i.test(text)) findings.push(pattern);
+        break;
+    }
+  }
+
+  for (const fragment of extraFragments) {
+    if (!fragment.trim()) continue;
+    if (contains(text, fragment)) {
+      findings.push({ id: `extra:${fragment}`, label: fragment, severity: "danger" });
+    }
+  }
+
+  if (findings.length === 0) {
+    return { safe: true, severity: "safe", findings, reason: "No risky shell fragments found." };
+  }
+
+  const severity = findings.some((finding) => finding.severity === "danger") ? "danger" : "warn";
+  const labels = findings.map((finding) => finding.label).join(", ");
+  return {
+    safe: false,
+    severity,
+    findings,
+    reason: `Detected risky shell fragment(s): ${labels}`,
+  };
+}

package/node_modules/@fiale-plus/pi-core/src/storage.ts

@@ -0,0 +1,39 @@
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+export function ensureParent(filePath: string): string {
+  mkdirSync(dirname(filePath), { recursive: true });
+  return filePath;
+}
+
+export function readText(filePath: string, fallback = ""): string {
+  try {
+    return readFileSync(filePath, "utf8");
+  } catch {
+    return fallback;
+  }
+}
+
+export function writeText(filePath: string, text: string): void {
+  ensureParent(filePath);
+  writeFileSync(filePath, text, "utf8");
+}
+
+export function appendText(filePath: string, text: string): void {
+  ensureParent(filePath);
+  appendFileSync(filePath, text, "utf8");
+}
+
+export function readJson<T>(filePath: string, fallback: T): T {
+  try {
+    const raw = readText(filePath).trim();
+    if (!raw) return fallback;
+    return JSON.parse(raw) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+export function writeJson(filePath: string, value: unknown): void {
+  writeText(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}

package/node_modules/@fiale-plus/pi-core/src/text.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from "vitest";
+import { truncate, safeName } from "./text.js";
+
+describe("truncate", () => {
+  it("returns full text when within limit", () => {
+    expect(truncate("hello", 10)).toBe("hello");
+  });
+
+  it("truncates and appends ellipsis when over limit", () => {
+    const result = truncate("hello world this is long", 12);
+    expect(result).toHaveLength(12);
+    expect(result.endsWith("…")).toBe(true);
+  });
+
+  it("handles empty string", () => {
+    expect(truncate("", 10)).toBe("");
+  });
+});
+
+describe("safeName", () => {
+  it("lowercases and replaces spaces with hyphens", () => {
+    expect(safeName("My Feature Branch")).toBe("my-feature-branch");
+  });
+
+  it("replaces special characters with hyphens", () => {
+    expect(safeName("feature/auth!!@#")).toBe("feature-auth");
+  });
+
+  it("strips leading/trailing hyphens", () => {
+    expect(safeName("--main--")).toBe("main");
+  });
+
+  it("falls back to 'main' for empty input", () => {
+    expect(safeName("")).toBe("main");
+  });
+});

package/node_modules/@fiale-plus/pi-core/src/text.ts

@@ -0,0 +1,14 @@
+export function truncate(text: string, max: number): string {
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(0, max - 1))}…`;
+}
+
+export function safeName(text: string): string {
+  return (
+    text
+      .trim()
+      .toLowerCase()
+      .replace(/[^a-z0-9._-]+/g, "-")
+      .replace(/^-+|-+$/g, "") || "main"
+  );
+}

package/node_modules/@fiale-plus/pi-rogue-advisor/README.md

@@ -0,0 +1,59 @@
+# @fiale-plus/pi-rogue-advisor
+
+> **Releases paused.** This package is now internal. All usage and updates are via the consolidated `@fiale-plus/pi-rogue` artefact (see root README, `docs/release.md`, and AGENTS.md). Direct installs and independent releases are on pause; the package is marked private. Code here continues to evolve and ships inside the canonical package release.
+
+## What this package is
+
+Strategic advisor for Pi sessions with low-overhead preflight/post-review routing, model auto-detection, session memory, and orchestration-managed mid-session check-ins.
+
+- SOTA-first model fallback: `gpt-5.5`/`claude-opus-4-6`/`claude-sonnet-4-6` where available.
+- Keeps command-level behavior simple and explicit.
+
+## Install
+
+**For users:** Use the canonical package (releases for this package are paused):
+
+```bash
+pi install npm:@fiale-plus/pi-rogue
+```
+
+**For local development (monorepo only):**
+
+```bash
+npm install --workspace packages/advisor
+```
+
+(See root README and docs/release.md for the consolidated policy.)
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `/pi-rogue` | Show the Pi-Rogue cockpit + command pointers |
+| `/advisor` | Show status (`/advisor status`) and quick hint |
+| `/advisor status` | Show mode, review policy, check-in status, model selection, counters |
+| `/advisor on` | Enable advisor (auto mode) |
+| `/advisor off` | Disable advisor |
+| `/advisor mode auto\|manual\|off` | Change routing behavior |
+| `/advisor review light\|strict\|off` | Change review strictness |
+| `/advisor pause <N>` | Pause advisor auto-runs for the next N turns |
+| `/advisor unpause` | Resume advisor auto-runs immediately |
+| `/advisor config` | Show current config |
+| `/advisor model <provider>/<model>` | Set explicit model override |
+| `/advisor <question>` | Get one-shot advisory response |
+
+## Notes on defaults
+
+- `mode`: `auto`
+- `review`: `light`
+- `checkins`: `off` (orchestration turns them on when a goal or loop is active)
+- `checkinIntervalMinutes`: `30`
+- `model`: not set (auto-detected)
+- Successful `on_track` review verdicts are recorded silently instead of displayed as follow-up messages.
+
+Check-ins gate on session activity and `checkinIntervalMinutes`, avoid overlapping calls, and use higher/advanced advisor models first with regular model fallback enabled by default. They are lifecycle-managed by orchestration: activating a goal or `/loop` enables them, and clearing either disables them.
+
+## Stability guarantees
+
+- No flattening: the advisor remains its own surface and does not hide orchestration commands.
+- Cockpit is simple and explicit: `/pi-rogue` is the top-level status view.

package/node_modules/@fiale-plus/pi-rogue-advisor/advisor/index.ts

@@ -0,0 +1 @@
+export { default, registerAdvisor } from "../src/extension.js";