supipowers 2.0.0 → 2.0.2

package/README.md

@@ -77,8 +77,12 @@ The installer scans for these and offers to install missing tooling where it can
 | `/supi:generate`        | Documentation drift detection                                |
 | `/supi:update`           | Update supipowers to the latest version                       |
 | `/supi:agents`           | Manage review agents                                          |
+| `/supi:ultraplan`        | Multi-stage authoring pipeline (intake → scout → discover → research → synthesize → review → approve) |
+| `/supi:harness`          | Harness engineering pipeline and anti-slop guardrails         |
+| `/supi:memory`           | Manage native MemPalace memory integration (`status`, `setup`) |
+| `/supi:clear`            | Clear metrics, cache, session knowledge, and memory           |
 
-Most commands steer the AI session. These are TUI-only — they open native dialogs without triggering the AI: `/supi`, `/supi:config`, `/supi:status`, `/supi:review`, `/supi:update`, `/supi:doctor`, `/supi:mcp`, `/supi:model`, `/supi:context`, `/supi:optimize-context`, `/supi:commit`, `/supi:release`, `/supi:checks`, `/supi:agents`.
+Most commands steer the AI session. These are TUI-only — they open native dialogs without triggering the AI: `/supi`, `/supi:config`, `/supi:status`, `/supi:review`, `/supi:update`, `/supi:doctor`, `/supi:mcp`, `/supi:model`, `/supi:context`, `/supi:optimize-context`, `/supi:commit`, `/supi:release`, `/supi:checks`, `/supi:agents`, `/supi:ultraplan`, `/supi:harness`, `/supi:memory`, `/supi:clear`.
 
 ## How it works
 
@@ -213,6 +217,7 @@ Supipowers ships runtime-loaded prompt skills that are also available to the age
 | `release`               | `/supi:release`         |
 | `context-mode`          | Context window guidance |
 | `creating-supi-agents`  | Agent creation guidance  |
+| `harness`               | `/supi:harness`         |
 
 ## Development
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supipowers",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Workflow extension for OMP coding agents.",
   "type": "module",
   "scripts": {

package/src/commands/clear.ts

@@ -269,14 +269,14 @@ function parseArgs(args: string | undefined): ParsedArgs {
   return { scope, dryRun };
 }
 
-export function handleClear(
+export async function handleClear(
   platform: Platform,
   ctx: PlatformContext,
   args?: string,
-): void {
+): Promise<void> {
   if (!ctx.hasUI) return;
 
-  void (async () => {
+  try {
     const { scope, dryRun } = parseArgs(args);
     const store = getMetricsStore();
     const sessionId = getSessionId();
@@ -419,16 +419,16 @@ export function handleClear(
         "error",
       );
     }
-  })().catch((err) => {
+  } catch (err) {
     ctx.ui.notify(`Clear error: ${(err as Error).message}`, "error");
-  });
+  }
 }
 
 export function registerClearCommand(platform: Platform): void {
   platform.registerCommand("supi:clear", {
     description: "Clear metrics, cache, current-session knowledge, and memory for the active session (or `all` for the project)",
     async handler(args: string | undefined, ctx: any) {
-      handleClear(platform, ctx, args);
+      await handleClear(platform, ctx, args);
     },
   });
 }

package/src/commands/release.ts

@@ -51,6 +51,9 @@ import {
 import {
   checkDocDrift,
   buildFixPrompt,
+  loadState as loadDriftState,
+  saveState as saveDriftState,
+  getHeadCommit,
 } from "../docs/drift.js";
 import { runQualityGates } from "../quality/runner.js";
 import { REVIEW_GATE_REGISTRY } from "../quality/review-gates.js";
@@ -492,7 +495,6 @@ export async function handleRelease(platform: Platform, ctx: any, args?: string)
           progress.activate("doc-drift", "Fixing documentation");
           notifyInfo(ctx, "Updating documentation", driftResult.summary);
           const fixPrompt = buildFixPrompt(driftResult.findings);
-          const { loadState: loadDriftState, saveState: saveDriftState, getHeadCommit } = await import("../docs/drift.js");
           const driftHead = await getHeadCommit(platform, repoRoot);
           const driftState = loadDriftState(platform.paths, repoRoot);
           saveDriftState(platform.paths, repoRoot, { ...driftState, lastCommit: driftHead, lastRunAt: new Date().toISOString() });

package/src/commands/update.ts

@@ -106,7 +106,7 @@ async function updateSupipowers(
       cpSync(binSource, join(extDir, "bin"), { recursive: true });
     }
     // skills/ must live inside the extension dir — src/commands/agents.ts
-    // uses a static `import from "../../skills/..."` resolved relative to src/.
+    // uses a static skills markdown import resolved relative to src/.
     const skillsDirSource = join(downloadedRoot, "skills");
     if (existsSync(skillsDirSource)) {
       cpSync(skillsDirSource, join(extDir, "skills"), { recursive: true });

package/src/context/analyzer.ts

@@ -59,41 +59,71 @@ export interface ParsedSkill {
 export function parseIndividualSkills(systemPrompt: string): ParsedSkill[] {
   if (!systemPrompt) return [];
 
-  // OMP renders skills as markdown headings under "# Skills":
-  //   ## skill-name
-  //   Description text...
-  // Find the Skills section bounded by the next h1 heading or end of text.
-  const skillsSectionMatch = systemPrompt.match(
-    /^# Skills\n[\s\S]*?\n(?=##\s)/m,
-  );
-  if (!skillsSectionMatch) return [];
-
-  // Extract the region from first ## to the next # (h1) or end of text
-  const sectionStart = skillsSectionMatch.index! + skillsSectionMatch[0].length;
-  const afterSection = systemPrompt.slice(sectionStart);
-  const nextH1 = afterSection.search(/^# [^#]/m);
-  const skillsBody =
-    skillsSectionMatch[0].slice(skillsSectionMatch[0].indexOf("\n## ") + 1) +
-    (nextH1 === -1 ? afterSection : afterSection.slice(0, nextH1));
-
-  // Split on ## headings
-  const skills: ParsedSkill[] = [];
+  // Locate `# Skills` and bound the section by the next h1 heading or end of
+  // text. The legacy bound used `^##\s`, which let the section bleed past
+  // sibling h2 headings (e.g. `## MCP Server Instructions`) into unrelated
+  // content and misidentify them as skills.
+  const headerMatch = systemPrompt.match(/^# Skills\b[^\n]*\n/m);
+  if (!headerMatch) return [];
+  const bodyStart = headerMatch.index! + headerMatch[0].length;
+  const after = systemPrompt.slice(bodyStart);
+  const nextH1 = after.search(/^# [^#]/m);
+  const skillsBody = nextH1 === -1 ? after : after.slice(0, nextH1);
+
+  // Modern OMP (≥14.7) renders skills as a bullet list: "- name: description"
+  // with descriptions that may wrap across multiple lines.
+  const bulletRegex = /^- ([a-zA-Z0-9._-]+):/gm;
+  const bullets: { name: string; index: number }[] = [];
+  let bm: RegExpExecArray | null;
+  while ((bm = bulletRegex.exec(skillsBody)) !== null) {
+    bullets.push({ name: bm[1], index: bm.index });
+  }
+
+  if (bullets.length > 0) {
+    // Defensive upper bound for the last bullet: stop at any inline markdown
+    // heading inside the body. Real OMP prompts already terminate at an h1
+    // boundary, but synthetic / older prompts may not.
+    let bodyEnd = skillsBody.length;
+    const headingScan = /^#{1,6}\s/gm;
+    let hsm: RegExpExecArray | null;
+    while ((hsm = headingScan.exec(skillsBody)) !== null) {
+      if (hsm.index > bullets[bullets.length - 1].index) {
+        bodyEnd = hsm.index;
+        break;
+      }
+    }
+
+    const bulletSkills: ParsedSkill[] = [];
+    for (let i = 0; i < bullets.length; i++) {
+      const start = bullets[i].index;
+      const end = i + 1 < bullets.length ? bullets[i + 1].index : bodyEnd;
+      const content = skillsBody.slice(start, end).trimEnd();
+      bulletSkills.push({
+        name: bullets[i].name,
+        bytes: byteLength(content),
+        tokens: estimateTokens(content),
+        content,
+      });
+    }
+    return bulletSkills;
+  }
+
+  // Legacy / synthetic shape: "## name" h2 sub-headings under `# Skills`.
   const headingRegex = /^## (.+)$/gm;
   const headings: { name: string; index: number }[] = [];
-  let match;
-
-  while ((match = headingRegex.exec(skillsBody)) !== null) {
-    headings.push({ name: match[1].trim(), index: match.index });
+  let hm: RegExpExecArray | null;
+  while ((hm = headingRegex.exec(skillsBody)) !== null) {
+    headings.push({ name: hm[1].trim(), index: hm.index });
   }
 
+  const skills: ParsedSkill[] = [];
   for (let i = 0; i < headings.length; i++) {
     const start = headings[i].index;
     const end = i + 1 < headings.length ? headings[i + 1].index : skillsBody.length;
     const content = skillsBody.slice(start, end).trimEnd();
-    const bytes = byteLength(content);
     skills.push({
       name: headings[i].name,
-      bytes,
+      bytes: byteLength(content),
       tokens: estimateTokens(content),
       content,
     });
@@ -218,26 +248,45 @@ function extractXmlSections(
   sections: PromptSection[],
   consumed: Set<number>,
 ): void {
-  // Project section FIRST (so nested <file> tags inside <project> are consumed)
-  const projMatch = text.match(/<project>([\s\S]*?)<\/project>/);
-  if (projMatch) {
+  // Project section FIRST (so nested <file> tags inside the wrapper are consumed).
+  // Modern OMP uses `<|START_PROJECT|>...<|END_PROJECT|>` pipe markers; older OMP
+  // and synthetic test inputs use the legacy `<project>...</project>` XML form.
+  const projectPatterns: RegExp[] = [
+    /<\|START_PROJECT\|>[\s\S]*?<\|END_PROJECT\|>/,
+    /<project>[\s\S]*?<\/project>/,
+  ];
+  for (const pattern of projectPatterns) {
+    const projMatch = text.match(pattern);
+    if (!projMatch) continue;
     sections.push({
       label: "Project context",
       bytes: byteLength(projMatch[0]),
       content: projMatch[0],
     });
     markConsumed(consumed, projMatch.index!, projMatch.index! + projMatch[0].length);
+    break;
   }
 
-  // Instructions section
-  const instrMatch = text.match(/<instructions>([\s\S]*?)<\/instructions>/);
-  if (instrMatch) {
+  // Environment envelope (OMP ≥14.9.3) — workstation, tool catalog, LSP guidance.
+  const envMatch = text.match(/<\|START_ENV\|>[\s\S]*?<\|END_ENV\|>/);
+  if (envMatch) {
     sections.push({
-      label: "Extension instructions",
-      bytes: byteLength(instrMatch[0]),
-      content: instrMatch[0],
+      label: "Environment",
+      bytes: byteLength(envMatch[0]),
+      content: envMatch[0],
     });
-    markConsumed(consumed, instrMatch.index!, instrMatch.index! + instrMatch[0].length);
+    markConsumed(consumed, envMatch.index!, envMatch.index! + envMatch[0].length);
+  }
+
+  // Contract envelope (OMP ≥14.9.3) — inviolable rules, yielding criteria.
+  const contractMatch = text.match(/<\|START_CONTRACT\|>[\s\S]*?<\|END_CONTRACT\|>/);
+  if (contractMatch) {
+    sections.push({
+      label: "Contract",
+      bytes: byteLength(contractMatch[0]),
+      content: contractMatch[0],
+    });
+    markConsumed(consumed, contractMatch.index!, contractMatch.index! + contractMatch[0].length);
   }
 
   // File sections — skip if already consumed (e.g., nested inside <project>)
@@ -318,6 +367,26 @@ function extractHeadingSections(
     }
   }
 
+  // Skills aggregate (OMP ≥14.7): markdown bullet list under `# Skills`.
+  // The legacy `<skills>` XML form is handled in extractXmlSections; this picks
+  // up the modern markdown shape rendered by OMP runtime. Bounded by the next
+  // h1/h2 heading so we don't swallow MCP instructions / Tools blocks.
+  const skillsHeading = text.match(/^# Skills\b[^\n]*\n/m);
+  if (skillsHeading && !consumed.has(skillsHeading.index!)) {
+    const start = skillsHeading.index!;
+    const afterHeading = text.slice(start + skillsHeading[0].length);
+    const nextHeading = afterHeading.search(/^#{1,2}\s/m);
+    const end = nextHeading === -1
+      ? text.length
+      : start + skillsHeading[0].length + nextHeading;
+    const content = text.slice(start, end);
+    const bulletCount = (content.match(/^- [a-zA-Z0-9._-]+:/gm) || []).length;
+    if (bulletCount > 0) {
+      sections.push({ label: `Skills (${bulletCount})`, bytes: byteLength(content), content });
+      markConsumed(consumed, start, end);
+    }
+  }
+
   // Also recognize bare memory:// blocks without a heading
   if (!sections.some((s) => s.label === "Memory")) {
     const memoryMatch = text.match(/memory:\/\/\S+/);

package/src/mempalace/bridge.ts

@@ -54,6 +54,14 @@ function mergeDiagnostics(...parts: Array<Record<string, unknown> | undefined>):
   return Object.assign({}, ...parts.filter(Boolean));
 }
 
+function resolveToolTimeoutMs(params: MempalaceParams, bridgeTimeoutMs: number): number {
+  if (typeof params.timeout !== "number") return bridgeTimeoutMs;
+
+  // Public tool schemas express timeouts in seconds, matching the rest of the
+  // OMP tool surface. The bridge runner uses milliseconds internally.
+  return Math.min(params.timeout * 1000, bridgeTimeoutMs);
+}
+
 export function createMempalaceBridge(options: CreateMempalaceBridgeOptions): MempalaceBridgeFacade {
   const resolveBridge = options.runtime?.resolveBridgeScriptPath ?? (() => resolveBridgeScriptPath());
   const runBridge = options.runtime?.runBridgeRequest ?? runBridgeRequest;
@@ -71,9 +79,7 @@ export function createMempalaceBridge(options: CreateMempalaceBridgeOptions): Me
       }
 
       const venv = resolveManagedVenvPaths(options.config.managedVenvPath);
-      const timeoutMs = typeof params.timeout === "number"
-        ? Math.min(params.timeout, options.config.timeouts.bridgeMs)
-        : options.config.timeouts.bridgeMs;
+      const timeoutMs = resolveToolTimeoutMs(params, options.config.timeouts.bridgeMs);
       const palacePath = params.palace ?? options.config.palacePath;
       const runResult = await runBridge({
         pythonPath: venv.python,

package/src/mempalace/installer-helper.ts

@@ -176,8 +176,8 @@ export function steerMempalaceInitialization(
     "",
     "Please initialize and seed memory for this project by running these tool calls in order:",
     "",
-    `1. \`mempalace(action="init", dir=".", yes=true)\` — register this project's wing in the palace.`,
-    `2. \`mempalace(action="mine", dir=".", limit=20)\` — seed initial drawers from project files.`,
+    `1. \`mempalace(action="init", dir=".", yes=true, timeout=30)\` — register this project's wing in the palace.`,
+    `2. \`mempalace(action="mine", dir=".", limit=20, timeout=30)\` — seed initial drawers from project files.`,
     "",
     "Step 2 is recommended but optional; skip it if the user prefers an empty wing or is mid-task. After running, summarize what was indexed.",
   ].join("\n");

package/src/mempalace/runtime.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import type { ResolvedMempalaceConfig } from "./config.js";
 import type { MempalaceAction, MempalaceParams } from "./schema.js";
+import { ensureUv, type UvFetcher } from "./uv.js";
 
 export interface MempalaceRuntimeError {
   code: string;
@@ -111,7 +112,7 @@ export interface SetupMempalaceRuntimeOptions {
   managedBinDir: string;
   managedPythonVersion?: string;
   runner?: ProcessRunner;
-  fetcher?: import("./uv.js").UvFetcher;
+  fetcher?: UvFetcher;
   uvVersion?: string;
   onProgress?: (message: string) => void;
   /**
@@ -427,7 +428,6 @@ export async function setupMempalaceRuntime(
   const runner = options.runner ?? defaultProcessRunner;
 
   // 1. Ensure uv is available (download + verify if needed).
-  const { ensureUv } = await import("./uv.js");
   const uv = await ensureUv({
     managedBinDir: options.managedBinDir,
     runner,

package/src/mempalace/schema.ts

@@ -201,7 +201,11 @@ export const mempalaceToolParameters = {
     include_ignored: { type: "boolean" },
     no_gitignore: { type: "boolean" },
     yes: { type: "boolean" },
-    timeout: { type: "integer", minimum: 1 },
+    timeout: {
+      type: "integer",
+      minimum: 1,
+      description: "Optional bridge timeout in seconds; capped by the configured MemPalace bridge timeout.",
+    },
   },
   required: ["action"],
 } as const;

package/src/ui-design/session.ts

@@ -784,8 +784,6 @@ function getUiDesignWritePaths(toolName: string, input: Record<string, unknown>)
           : "",
       );
     }
-    case "notebook":
-      return [typeof input.notebook_path === "string" ? input.notebook_path : ""];
     default:
       return undefined;
   }