supipowers 1.5.3 → 2.0.1

package/src/harness/hooks/pre-edit-dupe-probe.ts

@@ -0,0 +1,224 @@
+/**
+ * Pre-edit duplication probe.
+ *
+ * Registered on `tool_call` for `write` / `edit` (and the legacy `Write` / `Edit`
+ * casing). When the proposed write/edit's content matches an existing implementation
+ * above the configured threshold, the hook returns `{ block: true, reason: ... }` so the
+ * agent re-reads the duplicate path before retrying.
+ *
+ * Performance budget: ≤500 ms p95 on a 50k-LOC repo. We hard-fail the budget after
+ * `timeoutMs` and emit a warning instead of blocking — the contract is "never block on
+ * perf".
+ *
+ * The hook degrades gracefully when:
+ *  - the harness marker is missing,
+ *  - the configured backend isn't available,
+ *  - the proposed write doesn't include enough tokens to meet `min_token_count`.
+ */
+
+import type { Platform } from "../../platform/types.js";
+import type { HarnessHookConfig } from "../../types.js";
+import {
+  type SlopBackend,
+} from "../anti_slop/backend.js";
+import { computeQueueEntryId } from "../anti_slop/queue.js";
+import { appendSlopQueueEntry } from "../storage.js";
+import { getHarnessMarkerPath } from "../project-paths.js";
+import * as fs from "node:fs";
+
+export interface PreEditDupeProbeOptions {
+  /** Backend adapter; pass null for supi-native (probe is then a no-op). */
+  adapter: SlopBackend | null;
+  /** Hook config. */
+  config: HarnessHookConfig["pre_edit_dupe_probe"];
+  /** Override the timeout (ms). Defaults to 500. */
+  timeoutMs?: number;
+}
+
+interface ToolCallEvent {
+  toolName?: string;
+  input?: { path?: string; file?: string; content?: string; text?: string };
+}
+
+const TARGET_TOOLS = new Set(["write", "edit", "Write", "Edit"]);
+
+function countWordTokens(text: string): number {
+  return text.split(/\s+/).filter((t) => t.length > 0).length;
+}
+
+function extractFile(event: ToolCallEvent): string | null {
+  return event.input?.path ?? event.input?.file ?? null;
+}
+
+function extractContent(event: ToolCallEvent): string | null {
+  return event.input?.content ?? event.input?.text ?? null;
+}
+
+export interface ProbeResult {
+  block: boolean;
+  reason: string;
+  duplicates: { path: string; line: number }[];
+  durationMs: number;
+}
+
+/**
+ * Run the probe synchronously-ish: we await the adapter but cap the await with
+ * `timeoutMs`. Tests inject a fake adapter to assert on dispatch shape.
+ */
+export async function runPreEditProbe(input: {
+  platform: Platform;
+  cwd: string;
+  candidateFile: string;
+  proposedContent: string;
+  adapter: SlopBackend;
+  config: HarnessHookConfig["pre_edit_dupe_probe"];
+  timeoutMs?: number;
+}): Promise<ProbeResult> {
+  const startedAt = Date.now();
+  const tokens = countWordTokens(input.proposedContent);
+  if (tokens < input.config.min_token_count) {
+    return {
+      block: false,
+      reason: `proposed content has ${tokens} tokens (< min_token_count ${input.config.min_token_count})`,
+      duplicates: [],
+      durationMs: Date.now() - startedAt,
+    };
+  }
+
+  const timeoutMs = input.timeoutMs ?? 500;
+  const probePromise = input.adapter.dupes(input.platform, {
+    cwd: input.cwd,
+    threshold: input.config.threshold,
+    minTokenCount: input.config.min_token_count,
+    files: [input.candidateFile],
+    proposedWrite: { file: input.candidateFile, content: input.proposedContent },
+    timeoutMs,
+  });
+
+  let result;
+  try {
+    result = await Promise.race([
+      probePromise,
+      new Promise<{ ok: false; reason: "timeout"; message: string }>((resolve) => {
+        setTimeout(
+          () =>
+            resolve({
+              ok: false,
+              reason: "timeout",
+              message: `pre-edit probe exceeded ${timeoutMs} ms; skipping`,
+            }),
+          timeoutMs + 25,
+        );
+      }),
+    ]);
+  } catch (error) {
+    return {
+      block: false,
+      reason: `probe threw: ${error instanceof Error ? error.message : String(error)}`,
+      duplicates: [],
+      durationMs: Date.now() - startedAt,
+    };
+  }
+
+  if (!result.ok) {
+    return {
+      block: false,
+      reason: `probe ${result.reason}: ${result.message}`,
+      duplicates: [],
+      durationMs: Date.now() - startedAt,
+    };
+  }
+
+  const duplicates = result.findings
+    .filter((f) => f.kind === "duplicate" && f.range !== null)
+    .map((f) => ({ path: f.file, line: f.range?.startLine ?? 1 }));
+
+  if (duplicates.length === 0) {
+    return {
+      block: false,
+      reason: "no duplicate above threshold",
+      duplicates: [],
+      durationMs: Date.now() - startedAt,
+    };
+  }
+
+  // Append to the queue so the user sees the violation even though we blocked.
+  for (const finding of result.findings) {
+    if (finding.kind !== "duplicate") continue;
+    const id = computeQueueEntryId({
+      kind: "duplicate",
+      file: finding.file,
+      range: finding.range,
+      ruleHint: typeof finding.details?.rule === "string" ? finding.details.rule : "pre-edit-probe",
+    });
+    appendSlopQueueEntry(input.platform.paths, input.cwd, {
+      id,
+      kind: "duplicate",
+      file: finding.file,
+      range: finding.range,
+      severity: finding.severity,
+      source: finding.source,
+      state: "open",
+      message: finding.message,
+      remediation: finding.remediation,
+      ts: new Date().toISOString(),
+      details: finding.details,
+    });
+  }
+
+  const first = duplicates[0];
+  return {
+    block: true,
+    reason: `Duplicate of ${first.path}:${first.line}; reuse instead of re-implementing`,
+    duplicates,
+    durationMs: Date.now() - startedAt,
+  };
+}
+
+/**
+ * Register the hook. Returns a teardown function. No-op when the adapter is null
+ * (supi-native backend), the marker is missing, or the hook config disables it.
+ */
+export function registerPreEditDupeProbeHook(
+  platform: Platform,
+  options: PreEditDupeProbeOptions,
+): () => void {
+  if (!options.config.enabled || options.adapter === null) {
+    return () => {};
+  }
+  let unregistered = false;
+  const adapter = options.adapter;
+  const config = options.config;
+  const timeoutMs = options.timeoutMs ?? 500;
+
+  const handler = async (event: ToolCallEvent, ctx: unknown) => {
+    if (unregistered) return;
+    if (!event.toolName || !TARGET_TOOLS.has(event.toolName)) return;
+    const cwd = (ctx as { cwd?: string } | undefined)?.cwd ?? process.cwd();
+    if (!fs.existsSync(getHarnessMarkerPath(platform.paths, cwd))) return;
+    const candidateFile = extractFile(event);
+    if (!candidateFile) return;
+    const proposedContent = extractContent(event);
+    if (!proposedContent) return;
+
+    const result = await runPreEditProbe({
+      platform,
+      cwd,
+      candidateFile,
+      proposedContent,
+      adapter,
+      config,
+      timeoutMs,
+    });
+    if (result.block) {
+      return { block: true, reason: result.reason };
+    }
+    return undefined;
+  };
+
+  platform.on("tool_call", handler);
+
+  return () => {
+    unregistered = true;
+  };
+}

package/src/harness/hooks/register.ts

@@ -0,0 +1,118 @@
+/**
+ * Hook registrar — wires every harness hook (pre-edit dupe probe, post-session sweep,
+ * layer-context-inject) onto the platform.
+ *
+ * **Project-scoped**: hooks are gated by `<repo>/.omp/supipowers/harness/marker.json`.
+ * The registrar runs at extension boot but each individual hook checks the marker on
+ * every event so a repo without the harness installed sees no behavior change.
+ *
+ * Hook activation also depends on the per-hook `enabled` flag in
+ * `.omp/supipowers/config.json`; we read that lazily inside each hook so config edits
+ * take effect on the next event without restarting OMP.
+ */
+
+import type { Platform } from "../../platform/types.js";
+import type { HarnessConfig, HarnessHookConfig } from "../../types.js";
+import { buildBackendAdapter } from "../anti_slop/backend-factory.js";
+import {
+  registerLayerContextInjectHook,
+} from "./layer-context-inject.js";
+import {
+  registerPostSessionSweepHook,
+} from "./post-session-sweep.js";
+import {
+  registerPreEditDupeProbeHook,
+} from "./pre-edit-dupe-probe.js";
+
+export const DEFAULT_HARNESS_HOOK_CONFIG: HarnessHookConfig = {
+  pre_edit_dupe_probe: { enabled: true, threshold: 0.85, min_token_count: 30 },
+  post_session_sweep: { enabled: true, block_on_new_dead_code: false },
+  layer_context_inject: { enabled: true, addendum_max_chars: 800 },
+  score_floor: { strict: 75, lenient: 90, release_blocking: false },
+};
+
+export const DEFAULT_HARNESS_CONFIG: HarnessConfig = {
+  anti_slop: DEFAULT_HARNESS_HOOK_CONFIG,
+  implement_in_session_threshold: 10,
+};
+
+export interface HarnessHookRegistration {
+  /** Tear down every registered hook. Used by tests for clean isolation. */
+  dispose(): void;
+  /** True if any hook actually subscribed (i.e. config + backend allow it). */
+  active: boolean;
+}
+
+export interface RegisterHooksOptions {
+  /** Backend to use for the duplicate / dead-code adapters. Defaults to fallow. */
+  backend?: "fallow" | "desloppify" | "supi-native" | "hybrid";
+  /** Hook config snapshot. Defaults to DEFAULT_HARNESS_HOOK_CONFIG. */
+  hooks?: HarnessHookConfig;
+  /**
+   * Extracts the candidate file the agent is about to edit. Implementations consult
+   * session state. Defaults to a no-op resolver (the layer-inject hook becomes a no-op
+   * unless a real resolver is wired).
+   */
+  resolveCandidateFile?: (event: unknown, ctx: unknown) => string | null;
+}
+
+// Re-export so existing call sites keep working without an import path change.
+export { buildBackendAdapter };
+
+/**
+ * Register every harness hook. Idempotent at the dispose boundary: calling
+ * `dispose()` twice is safe.
+ */
+export function registerHarnessHooks(
+  platform: Platform,
+  options: RegisterHooksOptions = {},
+): HarnessHookRegistration {
+  const backend = options.backend ?? "fallow";
+  const hooks = options.hooks ?? DEFAULT_HARNESS_HOOK_CONFIG;
+  const adapter = buildBackendAdapter(backend);
+
+  const teardowns: Array<() => void> = [];
+  let active = false;
+
+  if (hooks.pre_edit_dupe_probe.enabled && adapter) {
+    teardowns.push(
+      registerPreEditDupeProbeHook(platform, {
+        adapter,
+        config: hooks.pre_edit_dupe_probe,
+      }),
+    );
+    active = true;
+  }
+  if (hooks.post_session_sweep.enabled && adapter) {
+    teardowns.push(
+      registerPostSessionSweepHook(platform, {
+        adapter,
+        config: hooks.post_session_sweep,
+      }),
+    );
+    active = true;
+  }
+  if (hooks.layer_context_inject.enabled) {
+    teardowns.push(
+      registerLayerContextInjectHook(platform, {
+        config: hooks.layer_context_inject,
+        resolveCandidateFile: options.resolveCandidateFile ?? (() => null),
+      }),
+    );
+    active = true;
+  }
+
+  return {
+    active,
+    dispose() {
+      while (teardowns.length > 0) {
+        const t = teardowns.pop();
+        try {
+          t?.();
+        } catch {
+          // best-effort
+        }
+      }
+    },
+  };
+}

package/src/harness/model.ts

@@ -0,0 +1,117 @@
+/**
+ * Per-action-id model resolution for the harness pipeline.
+ *
+ * Mirrors `src/ultraplan/authoring/model.ts`:
+ *  1. `model.json` per-action override (`actions["harness.<stage>"]`)
+ *  2. `model.json#default`
+ *  3. Platform's harness role hint
+ *  4. Main session model
+ *
+ * Action ids are flat strings; researchers fan out per-topic with composable suffixes
+ * (`harness.research.<topicSlug>`) so per-topic overrides are a single lookup.
+ *
+ * The module body registers every fixed action id at load time. Topic-parameterized
+ * researcher ids are registered lazily when the researcher launches each topic — Discover
+ * may produce dozens of topics across runs and we prefer to register what we actually
+ * resolve rather than every theoretically reachable topic.
+ */
+
+import { resolveModelForAction, type ModelPlatformBridge } from "../config/model-resolver.js";
+import { modelRegistry } from "../config/model-registry-instance.js";
+import type { ModelActionRegistry } from "../config/model-registry.js";
+import type { ModelConfig, ResolvedModel } from "../types.js";
+
+/** Action-id namespace. Centralized so call sites never inline the literal. */
+export const HARNESS_ACTION_NAMESPACE = "harness";
+
+/** Fixed (non-parameterized) action ids. */
+export type HarnessFixedActionSlot =
+  | "discover"
+  | "design"
+  | "plan"
+  | "implement"
+  | "validate"
+  | "gc.fix"
+  | "review.architecture";
+
+interface HarnessActionRegistration {
+  id: string;
+  label: string;
+  harnessRoleHint: string;
+}
+
+const FIXED_REGISTRATIONS: readonly HarnessActionRegistration[] = Object.freeze([
+  { id: `${HARNESS_ACTION_NAMESPACE}.discover`, label: "Harness · discover", harnessRoleHint: "research" },
+  { id: `${HARNESS_ACTION_NAMESPACE}.design`, label: "Harness · design", harnessRoleHint: "plan" },
+  { id: `${HARNESS_ACTION_NAMESPACE}.plan`, label: "Harness · plan", harnessRoleHint: "plan" },
+  { id: `${HARNESS_ACTION_NAMESPACE}.implement`, label: "Harness · implement", harnessRoleHint: "default" },
+  { id: `${HARNESS_ACTION_NAMESPACE}.validate`, label: "Harness · validate", harnessRoleHint: "review" },
+  { id: `${HARNESS_ACTION_NAMESPACE}.gc.fix`, label: "Harness · GC fix", harnessRoleHint: "default" },
+  { id: `${HARNESS_ACTION_NAMESPACE}.review.architecture`, label: "Harness · architecture review", harnessRoleHint: "review" },
+]);
+
+/** Action ids exposed for tooling and tests (frozen at module load). */
+export const HARNESS_FIXED_ACTION_IDS: readonly string[] = Object.freeze(
+  FIXED_REGISTRATIONS.map((r) => r.id),
+);
+
+/** Returns the canonical action id for a fixed slot. */
+export function getHarnessActionId(slot: HarnessFixedActionSlot): string {
+  return `${HARNESS_ACTION_NAMESPACE}.${slot}`;
+}
+
+/** Returns the action id for a research topic. Topic slug is sanitized by the caller. */
+export function getHarnessResearchActionId(topicSlug: string): string {
+  return `${HARNESS_ACTION_NAMESPACE}.research.${topicSlug}`;
+}
+
+/** Resolve the model + thinking level for a fixed harness action slot. */
+export function resolveHarnessModel(
+  slot: HarnessFixedActionSlot,
+  config: ModelConfig,
+  registry: ModelActionRegistry,
+  platform: ModelPlatformBridge,
+): ResolvedModel {
+  return resolveModelForAction(getHarnessActionId(slot), registry, config, platform);
+}
+
+/** Resolve the model + thinking level for a research topic action. Registers lazily. */
+export function resolveHarnessResearchModel(
+  topicSlug: string,
+  config: ModelConfig,
+  registry: ModelActionRegistry,
+  platform: ModelPlatformBridge,
+): ResolvedModel {
+  const id = getHarnessResearchActionId(topicSlug);
+  // Registration is idempotent at our boundary — the registry rejects duplicate ids by
+  // design, so we wrap in try/catch to keep lazy registration safe across multiple calls
+  // in the same process.
+  try {
+    registry.register({
+      id,
+      category: "sub-agent",
+      parent: "harness",
+      label: `Harness · research (${topicSlug})`,
+      harnessRoleHint: "research",
+    });
+  } catch {
+    // Already registered — fine.
+  }
+  return resolveModelForAction(id, registry, config, platform);
+}
+
+// ---------------------------------------------------------------------------
+// Module-load registration. Mirrors the ultraplan/authoring/model.ts pattern: every
+// `import "../model.js"` of this file ensures the harness action ids are visible to the
+// shared registry. Cheap and idempotent.
+// ---------------------------------------------------------------------------
+
+for (const action of FIXED_REGISTRATIONS) {
+  modelRegistry.register({
+    id: action.id,
+    category: "sub-agent",
+    parent: "harness",
+    label: action.label,
+    harnessRoleHint: action.harnessRoleHint,
+  });
+}