supipowers 2.0.2 → 2.2.0

package/src/tool-catalog/active-tool-controller.ts

@@ -4,17 +4,11 @@ import { getMetricsStore, getSessionId } from "../context-mode/hooks.js";
 import { getProjectStateDir } from "../workspace/state-paths.js";
 import type { Platform } from "../platform/types.js";
 import { normalizeSystemPromptBlocks, systemPromptText } from "../platform/system-prompt.js";
-import type { McpRegistry } from "../mcp/types.js";
 import type { SupipowersConfig } from "../types.js";
 import { planActiveTools } from "./active-tool-planner.js";
 import { detectContextMode } from "../context-mode/detector.js";
 import { getShadowedNativeTools } from "../context-mode/routing.js";
 
-export interface ActiveToolControllerDeps {
-  loadMcpRegistryForCwd(cwd: string): McpRegistry;
-  consumePendingTags(): string[];
-}
-
 type BeforeAgentStartEventLike = {
   prompt?: string;
   systemPrompt?: string | string[];
@@ -33,7 +27,6 @@ type BeforeAgentStartContextLike = {
 export function registerActiveToolController(
   platform: Platform,
   config: SupipowersConfig,
-  _deps: ActiveToolControllerDeps,
 ): void {
   if (!config.contextMode.enabled || !config.contextMode.lazyTools.enabled) return;
 
@@ -46,19 +39,6 @@ export function registerActiveToolController(
     if (typeof ctx.getSystemPrompt !== "function") return undefined;
 
     const cwd = typeof ctx.cwd === "string" && ctx.cwd.length > 0 ? ctx.cwd : process.cwd();
-    let registry: McpRegistry = { schemaVersion: 1, servers: {} };
-    try {
-      registry = _deps.loadMcpRegistryForCwd(cwd);
-    } catch (error) {
-      (platform as any).logger?.warn?.("supi-lazy-tools: failed to load MCP registry", error);
-    }
-
-    let pendingTags: string[] = [];
-    try {
-      pendingTags = _deps.consumePendingTags();
-    } catch (error) {
-      (platform as any).logger?.warn?.("supi-lazy-tools: failed to consume MCP tags", error);
-    }
 
     let plan;
     try {
@@ -67,8 +47,6 @@ export function registerActiveToolController(
         currentActive: platform.getActiveTools(),
         allTools: platform.getAllTools(),
         lazyTools: config.contextMode.lazyTools,
-        mcpServers: registry.servers,
-        pendingTags,
         cacheHandlesEnabled: config.contextMode.cacheHandles.enabled,
       });
     } catch (error) {

package/src/tool-catalog/active-tool-planner.ts

@@ -1,10 +1,7 @@
-import { computeActiveServers } from "../mcp/activation.js";
-import type { ServerConfig } from "../mcp/types.js";
 import type { ContextModeLazyToolsConfig } from "../types.js";
 import {
   BALANCED_KEYWORD_TOOLS,
   CONTEXT_MODE_TOOL_NAMES,
-  MCPC_MANAGER_TOOL_NAME,
   isSupiOwnedTool,
   orderOwnedTools,
 } from "./tool-groups.js";
@@ -12,8 +9,6 @@ import {
 export interface ActiveToolPlannerDiagnostics {
   unknownConfiguredTools: string[];
   unavailableTools: string[];
-  unmatchedTags: string[];
-  missingMcpGatewayTools: string[];
 }
 
 export interface PlanActiveToolsInput {
@@ -21,8 +16,6 @@ export interface PlanActiveToolsInput {
   currentActive: string[];
   allTools: string[];
   lazyTools: ContextModeLazyToolsConfig;
-  mcpServers?: Record<string, ServerConfig>;
-  pendingTags?: string[];
   cacheHandlesEnabled?: boolean;
 }
 
@@ -41,8 +34,6 @@ export function planActiveTools(input: PlanActiveToolsInput): ActiveToolPlan {
   const diagnostics: ActiveToolPlannerDiagnostics = {
     unknownConfiguredTools: [],
     unavailableTools: [],
-    unmatchedTags: [],
-    missingMcpGatewayTools: [],
   };
 
   const addRegisteredTool = (toolName: string, source: "config" | "policy"): void => {
@@ -69,7 +60,6 @@ export function planActiveTools(input: PlanActiveToolsInput): ActiveToolPlan {
     for (const toolName of CONTEXT_MODE_TOOL_NAMES) {
       if (!RARE_CONTEXT_TOOLS.has(toolName)) addRegisteredTool(toolName, "policy");
     }
-    addRegisteredTool(MCPC_MANAGER_TOOL_NAME, "policy");
   }
 
   for (const toolName of getTriggeredTools(input.prompt, BALANCED_KEYWORD_TOOLS)) {
@@ -81,20 +71,6 @@ export function planActiveTools(input: PlanActiveToolsInput): ActiveToolPlan {
   }
 
 
-  const mcpServers = input.mcpServers ?? {};
-  const pendingTags = input.pendingTags ?? [];
-  const knownServerNames = new Set(Object.keys(mcpServers));
-  for (const tag of pendingTags) {
-    if (!knownServerNames.has(tag)) diagnostics.unmatchedTags.push(tag);
-  }
-  for (const serverName of computeActiveServers(mcpServers, input.prompt, pendingTags)) {
-    const gatewayToolName = `mcpc_${serverName}`;
-    if (registeredOwnedTools.has(gatewayToolName)) {
-      selectedOwnedTools.add(gatewayToolName);
-    } else {
-      diagnostics.missingMcpGatewayTools.push(gatewayToolName);
-    }
-  }
   for (const toolName of getCommandAllowlistTools(input.prompt, input.lazyTools.commandAllowlist)) {
     addRegisteredTool(toolName, "config");
   }
@@ -206,7 +182,5 @@ function dedupeDiagnostics(diagnostics: ActiveToolPlannerDiagnostics): ActiveToo
   return {
     unknownConfiguredTools: [...new Set(diagnostics.unknownConfiguredTools)],
     unavailableTools: [...new Set(diagnostics.unavailableTools)],
-    unmatchedTags: [...new Set(diagnostics.unmatchedTags)],
-    missingMcpGatewayTools: [...new Set(diagnostics.missingMcpGatewayTools)],
   };
 }

package/src/tool-catalog/tool-groups.ts

@@ -14,9 +14,6 @@ export const CONTEXT_MODE_TOOL_NAMES = [
 
 export type ContextModeToolName = (typeof CONTEXT_MODE_TOOL_NAMES)[number];
 
-export const MCPC_MANAGER_TOOL_NAME = "mcpc_manager";
-export const MCPC_TOOL_PREFIX = "mcpc_";
-
 export const OWNED_TOOL_PRIORITY = [
   "ctx_execute",
   "ctx_search",
@@ -29,7 +26,6 @@ export const OWNED_TOOL_PRIORITY = [
   "ctx_purge",
   "ctx_repomap",
   "ctx_symbol",
-  MCPC_MANAGER_TOOL_NAME,
 ] as const;
 
 const CONTEXT_MODE_TOOL_SET = new Set<string>(CONTEXT_MODE_TOOL_NAMES);
@@ -81,12 +77,8 @@ export function isContextModeTool(name: string): boolean {
   return CONTEXT_MODE_TOOL_SET.has(name);
 }
 
-export function isMcpcGatewayTool(name: string): boolean {
-  return name.startsWith(MCPC_TOOL_PREFIX) && /^mcpc_[^_].+/.test(name);
-}
-
 export function isSupiOwnedTool(name: string): boolean {
-  return isContextModeTool(name) || name === MCPC_MANAGER_TOOL_NAME || isMcpcGatewayTool(name);
+  return isContextModeTool(name);
 }
 
 export function orderOwnedTools(names: Iterable<string>): string[] {

package/src/types.ts

@@ -545,12 +545,6 @@ export interface ContextModeConfig {
   memory: ContextModeMemoryConfig;
 }
 
-/** MCP management settings */
-export interface McpManagementConfig {
-  /** Close mcpc sessions on agent shutdown (default: false) */
-  closeSessionsOnExit: boolean;
-}
-
 /** MemPalace native integration default wing derivation mode */
 export type MempalaceWingStrategy = "repo-name" | "project-slug" | "explicit";
 
@@ -590,10 +584,19 @@ export interface MempalaceConfig {
      * one-line refresher instead. `1` = always inject (legacy behavior).
      */
     wakeUpInjectionEvery: number;
+    /** Minimum cosine similarity (0–1) for a hit to be injected by auto-search. Default 0.55. */
+    autoSearchSimilarityFloor: number;
+    /** Minimum BM25 score for a hit to be injected by auto-search. Default 0.3. */
+    autoSearchBm25Floor: number;
   };
   timeouts: {
     setupMs: number;
     bridgeMs: number;
+    /**
+     * Per-hook bridge timeout in milliseconds. Keep this at or above 6000
+     * when autoSearchOnPrompt is enabled; MemPalace 3.3.5 can sleep before
+     * retrying a transient search-index lookup.
+     */
     hookMs: number;
   };
 }
@@ -665,7 +668,6 @@ export interface SupipowersConfig {
   };
   ultraplan: UltraPlanConfig;
   contextMode: ContextModeConfig;
-  mcp: McpManagementConfig;
   mempalace: MempalaceConfig;
 }
 
@@ -1542,6 +1544,7 @@ export type HarnessStage =
   | "design"
   | "plan"
   | "implement"
+  | "docs"
   | "validate";
 
 /** Operational status of a harness stage. Mirrors UltraPlanAuthoringStageStatus. */
@@ -1682,6 +1685,38 @@ export interface HarnessConfig {
   backend?: HarnessAntiSlopBackend;
   /** Threshold above which Implement defers to ultraplan batch. Default 10. */
   implement_in_session_threshold?: number;
+  /** Per-layer agent-docs stage config. Absent → defaults treated as "simple" tier. */
+  docs?: HarnessDocsConfig;
+}
+
+/** Per-layer agent-docs configuration. */
+export interface HarnessDocsConfig {
+  /**
+   * Doc tier toggle. `simple` makes the `docs` stage a no-op (Tier 1 docs unchanged);
+   * `extensive` fans out one subagent per layer to produce `docs/layers/<id>.md` and a
+   * mechanical `docs/README.md` index.
+   */
+  tier: "simple" | "extensive";
+  /** Hard cap on total LOC per per-layer doc, including frontmatter. Default 150. */
+  max_per_doc_loc: number;
+  /** Hard cap on the `## Agent context` section LOC. Default 30. */
+  agent_context_loc: number;
+  /** Hard cap on `docs/README.md` LOC. Default 50. */
+  max_index_loc: number;
+  /** Defensive cap on the number of layers the stage will process. Default 12. */
+  max_units: number;
+  /**
+   * Concurrency cap for subagent dispatch. `null` = unbounded (bounded only by `max_units`);
+   * any positive integer caps `Promise.all` parallelism.
+   */
+  max_concurrent_subagents: number | null;
+  /** Validate-stage drift warning toggle. */
+  drift_warning: { enabled: boolean };
+  /**
+   * Minimum stale-layer count before bare-entry Harden surfaces the pre-regen preview.
+   * Default 1 (always show when any layer is stale).
+   */
+  regen_preview_threshold: number;
 }
 
 /** Discover artifact (`<session>/discover.json`). */
@@ -1704,7 +1739,6 @@ export interface HarnessDiscoverArtifact {
     hasSupipowers: boolean;
     skills: string[];
     reviewAgents: string[];
-    mcpServers: string[];
     plansCount: number;
   };
   /** Existing anti-slop tooling. */
@@ -1762,6 +1796,18 @@ export interface HarnessQualityGate {
   failSafe: string;
 }
 
+/** Configuration for the PR sticky comment posted by `/supi:harness pr-comment`. */
+export interface HarnessPrCommentConfig {
+  /** When false, the workflow step is a no-op (still safe to call). */
+  enabled: boolean;
+  /**
+   * Post cadence:
+   *  - "every-push": update the sticky comment on every CI run.
+   *  - "on-status-change": only re-post when status (passed/warned/failed) flips.
+   */
+  mode: "every-push" | "on-status-change";
+}
+
 /** CI and local counterpart wiring chosen during harness design. */
 export interface HarnessCiConfig {
   provider: "github-actions";
@@ -1772,6 +1818,54 @@ export interface HarnessCiConfig {
   localCommand: string;
   /** CI workflow path relative to repo root. */
   workflowPath: string;
+  /**
+   * Optional PR comment behaviour. When absent the subcommand falls back to built-in
+   * defaults (mode `every-push`); the explicit invocation of `/supi:harness pr-comment`
+   * is treated as the user opt-in. Set `enabled: false` to suppress posting outside
+   * `--dry-run`. The CI workflow permission warning in `ci-local-wiring` is gated on
+   * an explicit truthy `enabled`, so legacy specs do not trip it.
+   */
+  prComment?: HarnessPrCommentConfig;
+  /**
+   * Optional Git topology + branch-protection wiring captured by the interactive
+   * `git-verify` sub-step run between Design and Plan. Absent on legacy specs.
+   *
+   *  - `mainBranch` is the canonical protected branch (typically `main` or `master`).
+   *  - `devBranch` is the development branch dev work flows through; `null` when the user
+   *    opts out of the convention.
+   *  - `enforceMainFromDevOnly` controls both the CI-side guardrail (a `verify-pr-source`
+   *    job appended to the rendered workflow) and the opportunistic server-side ruleset
+   *    applied via `gh api`. The CI guardrail is deterministic; the ruleset is best-effort.
+   *  - `verification` records what the interactive helper actually did. `appliedProtections`
+   *    is the set of enforcement layers that landed (e.g. `"ci-guardrail"`, `"ruleset"`).
+   *    `findings` carries non-fatal issues surfaced during the run; the validate stage
+   *    folds them into its report. `manualInstructionsPath` points at the rendered
+   *    fallback doc when `gh` is unavailable or lacks scope.
+   */
+  git?: HarnessCiGitConfig;
+}
+
+/** Git/branch-protection block recorded by the interactive verification helper. */
+export interface HarnessCiGitConfig {
+  mainBranch: string;
+  devBranch: string | null;
+  enforceMainFromDevOnly: boolean;
+  verification: HarnessCiGitVerification | null;
+}
+
+/** Result block recorded by `runGitVerificationQa` for downstream stages to consume. */
+export interface HarnessCiGitVerification {
+  checkedAt: string;
+  appliedProtections: string[];
+  findings: HarnessCiGitFinding[];
+  /** Relative path (under the session dir) to the rendered manual-instructions doc, or null. */
+  manualInstructionsPath: string | null;
+}
+
+export interface HarnessCiGitFinding {
+  severity: "info" | "warning" | "error";
+  message: string;
+  remediation?: string;
 }
 
 
@@ -1880,6 +1974,8 @@ export interface HarnessSession {
   iteration: number;
   /** Re-run mode user chose at bare entry (when applicable). */
   reRunMode?: HarnessReRunMode;
+  /** Per-layer agent-docs tier resolved at end-of-Design. Absent → treated as "simple". */
+  docsTier?: "simple" | "extensive";
   /** Recorded blocker, if any. */
   blocker: { code: string; message: string; detectedAt: string } | null;
   /** Artifacts produced so far (relative to <session>/). */
@@ -1895,6 +1991,29 @@ export interface HarnessArtifactRefs {
   plan?: string;
   implementLog?: string;
   validateReport?: string;
+  /** Per-layer agent docs (relative to <session>/docs/layers/<id>.md). */
+  docs?: { layerId: string; path: string }[];
+}
+
+/**
+ * Metadata describing a single per-layer agent knowledge document. Used by the docs stage
+ * to track provenance, source-hash invalidation, and atomic promotion to the repo. The
+ * canonical rendered doc lives at `docs/layers/<id>.md`; this record is part of the
+ * stage's run result and the session staging artifacts.
+ */
+export interface HarnessDocsArtifact {
+  /** Layer id this doc covers (matches HarnessLayerRule.layer). */
+  layerId: string;
+  /** Layer glob list, copied verbatim from the layer rule at render time. */
+  layerGlobs: string[];
+  /** Hash of every input that should invalidate the doc when changed. */
+  sourceHash: string;
+  /** Hash of the doc body after the provenance marker (excludes the marker itself). */
+  contentHash: string;
+  /** ISO timestamp the doc was generated. */
+  generatedAt: string;
+  /** Session that generated the doc. */
+  sessionId: string;
 }
 
 /** Append-only pipeline log entry. */

package/src/ui-design/session.ts

@@ -108,15 +108,19 @@ function snapshotSessionProgress(sessionDir: string): string | null {
     for (const entry of entries) {
       const absolutePath = path.join(currentDir, entry.name);
       const relativePath = path.relative(sessionDir, absolutePath);
-      const stats = fs.statSync(absolutePath);
-
       if (entry.isDirectory()) {
-        hash.update(`dir:${relativePath}:${stats.mtimeMs}\n`);
+        hash.update("dir\0");
+        hash.update(relativePath);
+        hash.update("\0");
         visit(absolutePath);
         continue;
       }
 
-      hash.update(`file:${relativePath}:${stats.size}:${stats.mtimeMs}\n`);
+      hash.update("file\0");
+      hash.update(relativePath);
+      hash.update("\0");
+      hash.update(fs.readFileSync(absolutePath));
+      hash.update("\0");
     }
   };
 
@@ -765,6 +769,106 @@ function discardSessionDir(sessionDir: string): void {
   }
 }
 
+function buildCompletionRepairSteer(
+  sessionDir: string,
+  manifest: Manifest,
+  completionIssues: string[],
+): string {
+  return manifest.backend === "pencil-mcp"
+    ? REPAIR_COMPLETE_STEER_TEMPLATE_PENCIL(sessionDir, manifest.penFilePath, completionIssues)
+    : REPAIR_COMPLETE_STEER_TEMPLATE(sessionDir, completionIssues);
+}
+
+function sendNoUiPauseMessage(
+  platform: Platform,
+  sessionDir: string,
+  status: ManifestStatus,
+): void {
+  const message = [
+    `ui-design session paused with status \`${status}\` in a no-UI runtime.`,
+    `Artifacts were preserved at \`${sessionDir}\`.`,
+    "Interactive review is unavailable here. Continue manually by inspecting that directory or rerun `/supi:ui-design` in an interactive TUI.",
+  ].join("\n");
+  platform.sendMessage(
+    {
+      customType: "supi-ui-design-paused-no-ui",
+      content: [{ type: "text", text: message }],
+      display: true,
+    },
+    { deliverAs: "steer", triggerTurn: false },
+  );
+}
+
+async function handleNoUiUiDesignAgentEnd(
+  platform: Platform,
+  ctx: any,
+  session: UiDesignSession,
+  manifest: Manifest | null,
+): Promise<void> {
+  const sessionDir = session.dir;
+
+  if (!manifest) {
+    await runCleanup();
+    ctx?.ui?.notify?.(
+      `ui-design session state is unreadable; artifacts preserved at ${sessionDir}.`,
+      "warning",
+    );
+    cancelUiDesignTracking("manifest_missing_no_ui");
+    return;
+  }
+
+  if (manifest.status === "complete") {
+    const completion = validateCompletionProof(sessionDir, manifest);
+    const validatedManifest = completion.validatedManifest;
+    if (
+      !sameCritiqueSummary(manifest.critique, validatedManifest.critique) ||
+      manifest.approvedAt !== validatedManifest.approvedAt
+    ) {
+      writeManifest(sessionDir, validatedManifest);
+    }
+
+    if (completion.issues.length > 0) {
+      await resumeSession(
+        platform,
+        ctx,
+        session,
+        buildCompletionRepairSteer(sessionDir, manifest, completion.issues),
+      );
+      return;
+    }
+
+    writeManifest(sessionDir, { ...validatedManifest, acknowledged: true });
+    await runCleanup();
+    ctx?.ui?.notify?.(`ui-design complete; artifacts kept at ${sessionDir}.`, "info");
+    cancelUiDesignTracking("complete_no_ui");
+    return;
+  }
+
+  if (manifest.status === "discarded") {
+    await runCleanup();
+    discardSessionDir(sessionDir);
+    cancelUiDesignTracking("discarded_no_ui");
+    return;
+  }
+
+  if (
+    manifest.status === "in-progress" ||
+    manifest.status === "critiquing" ||
+    manifest.status === "awaiting-review"
+  ) {
+    if (sessionMadeProgress(sessionDir)) {
+      await resumeSession(platform, ctx, session, RESUME_STEER_TEMPLATE(sessionDir));
+      return;
+    }
+
+    sendNoUiPauseMessage(platform, sessionDir, manifest.status);
+    ctx?.ui?.notify?.(`ui-design paused; artifacts preserved at ${sessionDir}.`, "warning");
+    await runCleanup();
+    cancelUiDesignTracking("paused_no_ui");
+  }
+}
+
+
 function getUiDesignWritePaths(toolName: string, input: Record<string, unknown>): string[] | undefined {
   switch (toolName) {
     case "write":
@@ -850,11 +954,15 @@ export function registerUiDesignToolGuard(platform: Platform): void {
 export function registerUiDesignApprovalHook(platform: Platform): void {
   platform.on("agent_end", async (_event: any, ctx: any) => {
     const session = activeSession;
-    if (!session || !ctx?.hasUI) return;
+    if (!session) return;
 
     const sessionDir = session.dir;
     const manifest = readManifest(sessionDir);
 
+    if (!ctx?.hasUI) {
+      await handleNoUiUiDesignAgentEnd(platform, ctx, session, manifest);
+      return;
+    }
     // Missing / unparseable manifest — unsafe to resume
     if (!manifest) {
       const choice = await ctx.ui.select(
@@ -888,9 +996,7 @@ export function registerUiDesignApprovalHook(platform: Platform): void {
           // Pencil manifests always cite pencil artifacts in their repair steer,
           // even when `penFilePath` is missing — the HTML template would point
           // at files pencil sessions never produce.
-          const repairSteer = manifest.backend === "pencil-mcp"
-            ? REPAIR_COMPLETE_STEER_TEMPLATE_PENCIL(sessionDir, manifest.penFilePath, completion.issues)
-            : REPAIR_COMPLETE_STEER_TEMPLATE(sessionDir, completion.issues);
+          const repairSteer = buildCompletionRepairSteer(sessionDir, manifest, completion.issues);
           await resumeSession(
             platform,
             ctx,

package/src/utils/executable.ts

@@ -36,8 +36,17 @@ function isFile(filePath: string): boolean {
   }
 }
 
+function defaultSearchPath(): string {
+  if (process.env.PATH !== undefined) {
+    return process.env.PATH;
+  }
+
+  const pathKey = Object.keys(process.env).find((key) => key.toLowerCase() === "path");
+  return pathKey ? process.env[pathKey] ?? "" : "";
+}
+
 function resolveSearchDirectories(options: ExecutableSearchOptions): string[] {
-  const pathDirs = (options.searchPath ?? process.env.PATH ?? "")
+  const pathDirs = (options.searchPath ?? defaultSearchPath())
     .split(path.delimiter)
     .filter(Boolean);
   const localDirs = (options.localDirs ?? []).map((dir) =>

package/src/workspace/state-paths.ts

@@ -17,7 +17,7 @@ function splitWorkspacePath(relativeDir: string): string[] {
 // Team-shared (local) state: <cwd-or-repoRoot>/.omp/supipowers/<...>
 //
 // These paths are committed (or at least shareable) across a team clone. Used for
-// config.json, model.json, review-agents/config.yml, mcpc manifests, etc.
+// config.json, model.json, review-agents/config.yml, etc.
 // ──────────────────────────────────────────────────────────────────────────
 
 export function getRootStateDir(paths: PlatformPaths, repoRoot: string): string {