@hicaru/pi-rlm 0.2.1 → 0.3.0

package/src/context/library-context.ts

@@ -1,266 +0,0 @@
-/**
- * Resolve load_library(source) into a sandbox-ready payload.
- *
- * Sources: local directory (repomix-packed), single file (utf-8), or remote git URL
- * (shallow clone then pack). Host-side only — never runs in the sandbox.
- *
- * Every successful payload is a namespaced list of ContextFile under
- * `lib/<source_id>/…` so the worker can append into the single `context` variable.
- * Source ids include a short content fingerprint so two libraries that share a
- * basename never collide.
- */
-
-import { createHash } from "node:crypto";
-import { execFile } from "node:child_process";
-import { mkdtemp, readFile, rm, stat } from "node:fs/promises";
-import { basename, isAbsolute, join, resolve } from "node:path";
-import { tmpdir } from "node:os";
-import { promisify } from "node:util";
-import {
-  packRepository,
-  serializeForSandbox,
-  type ContextBundle,
-  type ContextFile,
-} from "./repomix-context.ts";
-import { estimateTokens } from "../text/tokens.ts";
-import type { Result } from "../util/errors.ts";
-import { errorMessage } from "../util/errors.ts";
-
-const execFileP = promisify(execFile);
-
-/** Single-file sources above this must use open() + llm_query_chunked in the REPL. */
-export const MAX_LIBRARY_FILE_BYTES = 8 * 1024 * 1024;
-
-/** Legacy catch-all prefix for pre-namespace string sidecars — never an identity key. */
-const LEGACY_UNKNOWN_PREFIX = "lib/unknown/";
-
-export interface LibrarySource {
-  /** Always a namespaced file list (dirs, single files, and git clones). */
-  readonly payload: readonly ContextFile[];
-  readonly files: number;
-  /** Sum of raw content lengths — what the model should size batches against. */
-  readonly chars: number;
-  readonly sourceId: string;
-  readonly pathPrefix: string;
-}
-
-export interface LibraryNamespace {
-  readonly sourceId: string;
-  readonly pathPrefix: string;
-}
-
-/** https://host/… or git@host:… — option-injection safe (never starts with "-"). */
-const GIT_URL = /^(https:\/\/|git@)[\w.-]+[:/]\S+$/;
-
-/** Short, stable discriminator so two sources never share a namespace. */
-function sourceFingerprint(canonical: string): string {
-  return createHash("sha256").update(canonical).digest("hex").slice(0, 8);
-}
-
-/**
- * Sanitize a path/url basename into a stable, filesystem-safe source id.
- * `resolvedPath` (absolute path) or the git URL is fingerprinted into the id so
- * distinct sources sharing a basename get distinct namespaces
- * (`lib/utils-3f9a1c02/` vs `lib/utils-a1b2c3d4/`).
- */
-export function librarySourceId(source: string, resolvedPath?: string): string {
-  const trimmed = source.trim();
-  const isGit = GIT_URL.test(trimmed);
-  let raw: string;
-  if (isGit) {
-    const m = trimmed.match(/(?:\/|:)([\w.-]+?)(?:\.git)?\/?\s*$/);
-    raw = m?.[1] ?? "repo";
-  } else {
-    raw = basename(resolvedPath ?? trimmed);
-  }
-  const cleaned = raw
-    .replace(/\.git$/i, "")
-    .replace(/[^\w.-]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 80);
-  const canonical = isGit ? trimmed : (resolvedPath ?? trimmed);
-  return `${cleaned.length > 0 ? cleaned : "lib"}-${sourceFingerprint(canonical)}`;
-}
-
-export function pathPrefixFor(sourceId: string): string {
-  return `lib/${sourceId}/`;
-}
-
-/**
- * Derive the namespace for a source string without packing (host-side idempotency).
- * Returns both sourceId and pathPrefix so callers never un-parse the prefix.
- */
-export function libraryNamespace(source: string, cwd: string): LibraryNamespace {
-  const trimmed = source.trim();
-  const sourceId = GIT_URL.test(trimmed)
-    ? librarySourceId(trimmed)
-    : librarySourceId(trimmed, isAbsolute(trimmed) ? trimmed : resolve(cwd, trimmed));
-  return Object.freeze({ sourceId, pathPrefix: pathPrefixFor(sourceId) });
-}
-
-/** Derive the path prefix for a source string without packing. */
-export function libraryPathPrefix(source: string, cwd: string): string {
-  return libraryNamespace(source, cwd).pathPrefix;
-}
-
-/** Namespaced files plus summed content chars (one pass). */
-export function namespaceLibraryFilesWithChars(
-  payload: unknown,
-  sourceId: string,
-): { readonly files: readonly ContextFile[]; readonly chars: number } {
-  const prefix = pathPrefixFor(sourceId);
-  if (typeof payload === "string") {
-    return Object.freeze({
-      files: Object.freeze([
-        Object.freeze({
-          path: `${prefix}content`,
-          content: payload,
-          tokens: Math.max(1, estimateTokens(payload.length)),
-        }),
-      ]),
-      chars: payload.length,
-    });
-  }
-  if (!Array.isArray(payload)) return Object.freeze({ files: Object.freeze([]), chars: 0 });
-  const out = new Array<ContextFile>(payload.length);
-  let n = 0;
-  let chars = 0;
-  for (const item of payload) {
-    if (item === null || typeof item !== "object") continue;
-    const rec = item as Record<string, unknown>;
-    const content = typeof rec.content === "string" ? rec.content : String(rec.content ?? "");
-    let path = typeof rec.path === "string" ? rec.path : "unknown";
-    path = path.replace(/^\/+/, "");
-    if (!path.startsWith(prefix)) path = `${prefix}${path}`;
-    const tokens = typeof rec.tokens === "number" && Number.isFinite(rec.tokens)
-      ? Math.max(0, Math.floor(rec.tokens))
-      : Math.max(1, estimateTokens(content.length));
-    out[n++] = Object.freeze({ path, content, tokens });
-    chars += content.length;
-  }
-  out.length = n;
-  return Object.freeze({ files: Object.freeze(out), chars });
-}
-
-/** Namespace file entries under `lib/<sourceId>/…` (single shared implementation). */
-export function namespaceLibraryFiles(
-  payload: unknown,
-  sourceId: string,
-): readonly ContextFile[] {
-  return namespaceLibraryFilesWithChars(payload, sourceId).files;
-}
-
-/** First `lib/<id>/` prefix found in the payload, or undefined. Skips `lib/unknown/`. */
-export function payloadPrefix(payload: readonly unknown[]): string | undefined {
-  for (let i = 0; i < payload.length; i++) {
-    const item = payload[i];
-    if (item === null || typeof item !== "object") continue;
-    const path = (item as { path?: unknown }).path;
-    if (typeof path !== "string") continue;
-    const m = /^(lib\/[^/]+\/)/.exec(path);
-    // `lib/unknown/` is the legacy catch-all: never treat it as an identity.
-    if (m?.[1] !== undefined && m[1] !== LEGACY_UNKNOWN_PREFIX) return m[1];
-  }
-  return undefined;
-}
-
-/**
- * Append a library payload into an existing list context (host-side resume merge).
- * Skips a payload whose path prefix is already present (resume-safe dedup).
- */
-export function mergeLibraryIntoContext(base: unknown, libraryPayload: unknown): unknown {
-  if (!Array.isArray(base)) return base;
-  if (Array.isArray(libraryPayload)) {
-    if (libraryPayload.length === 0) return base;
-    const prefix = payloadPrefix(libraryPayload);
-    if (prefix !== undefined) {
-      for (let i = 0; i < base.length; i++) {
-        const item = base[i];
-        if (item !== null && typeof item === "object"
-          && typeof (item as { path?: unknown }).path === "string"
-          && (item as { path: string }).path.startsWith(prefix)) {
-          return base; // already present
-        }
-      }
-    }
-    const merged = new Array<unknown>(base.length + libraryPayload.length);
-    for (let i = 0; i < base.length; i++) merged[i] = base[i];
-    for (let i = 0; i < libraryPayload.length; i++) merged[base.length + i] = libraryPayload[i];
-    return merged;
-  }
-  if (typeof libraryPayload === "string") {
-    // Legacy string sidecars: wrap once under an unknown prefix.
-    return mergeLibraryIntoContext(base, namespaceLibraryFiles(libraryPayload, "unknown"));
-  }
-  return base;
-}
-
-function toLibrarySource(payload: unknown, sourceId: string): LibrarySource {
-  const { files, chars } = namespaceLibraryFilesWithChars(payload, sourceId);
-  return {
-    payload: files,
-    files: files.length,
-    chars,
-    sourceId,
-    pathPrefix: pathPrefixFor(sourceId),
-  };
-}
-
-export async function resolveLibrarySource(
-  source: string,
-  cwd: string,
-  signal?: AbortSignal,
-): Promise<Result<LibrarySource, string>> {
-  const trimmed = source.trim();
-  if (trimmed === "") return { ok: false, error: "load_library: empty source" };
-  if (GIT_URL.test(trimmed)) return await cloneAndPack(trimmed, signal);
-  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)) {
-    return { ok: false, error: `unsupported URL scheme (only https:// and git@ are allowed): ${trimmed}` };
-  }
-  const path = isAbsolute(trimmed) ? trimmed : resolve(cwd, trimmed);
-  let s: Awaited<ReturnType<typeof stat>>;
-  try {
-    s = await stat(path);
-  } catch {
-    return { ok: false, error: `load_library: path not found: ${path}` };
-  }
-  const sourceId = librarySourceId(trimmed, path);
-  if (s.isDirectory()) return await packDir(path, sourceId, signal);
-  if (s.size > MAX_LIBRARY_FILE_BYTES) {
-    return {
-      ok: false,
-      error: `load_library: ${path} is ${s.size.toLocaleString()} bytes `
-        + `(limit ${MAX_LIBRARY_FILE_BYTES.toLocaleString()}) — `
-        + "open() it in the REPL and delegate with llm_query_chunked instead",
-    };
-  }
-  const text = await readFile(path, "utf-8");
-  return { ok: true, value: toLibrarySource(text, sourceId) };
-}
-
-async function packDir(
-  dir: string,
-  sourceId: string,
-  signal?: AbortSignal,
-): Promise<Result<LibrarySource, string>> {
-  const packed = await packRepository(dir, signal);
-  if (!packed.ok) return { ok: false, error: `pack failed for ${dir} — ${packed.error}` };
-  return { ok: true, value: bundleToSource(packed.value, sourceId) };
-}
-
-function bundleToSource(bundle: ContextBundle, sourceId: string): LibrarySource {
-  return toLibrarySource(serializeForSandbox(bundle), sourceId);
-}
-
-async function cloneAndPack(url: string, signal?: AbortSignal): Promise<Result<LibrarySource, string>> {
-  const dir = await mkdtemp(join(tmpdir(), "rlm-lib-"));
-  const sourceId = librarySourceId(url);
-  try {
-    await execFileP("git", ["clone", "--depth", "1", "--", url, dir], { signal, timeout: 120_000 });
-    return await packDir(dir, sourceId, signal);
-  } catch (err: unknown) {
-    return { ok: false, error: `git clone failed for ${url} — ${errorMessage(err)}` };
-  } finally {
-    await rm(dir, { recursive: true, force: true }).catch(() => {});
-  }
-}

package/src/context/repomix-context.ts

@@ -1,204 +0,0 @@
-/**
- * repomix-context — pre-packs the entire codebase into a structured JSON array
- * for the RLM sandbox. Replaces the legacy filesystem-tool context
- * (buildProjectManifest / listProjectFiles / gitLsFiles).
- *
- * Uses repomix internally (worker-thread pool, built-in gitignore support)
- * and caches results in a module-level Map with TTL to avoid re-packing on
- * every run within the same process.
- */
-
-import { pack } from "repomix";
-import type { PackResult as RepomixPackResult } from "repomix";
-/** repomix's own config parameter type — `satisfies` keeps the literal checked against it. */
-type PackConfig = NonNullable<Parameters<typeof pack>[1]>;
-import { resolve } from "node:path";
-import { tmpdir } from "node:os";
-import { errorMessage } from "../util/errors.ts";
-import { estimateTokens } from "../text/tokens.ts";
-
-// ── Public types ──
-
-export interface ContextFile {
-  readonly path: string;
-  readonly content: string;
-  readonly tokens: number;
-}
-
-export interface ContextBundle {
-  readonly files: readonly ContextFile[];
-  readonly totalFiles: number;
-  readonly totalTokens: number;
-  readonly totalChars: number;
-}
-
-export interface PackSuccess {
-  readonly ok: true;
-  readonly value: ContextBundle;
-}
-
-export interface PackFailure {
-  readonly ok: false;
-  readonly error: string;
-}
-
-export type PackResult = PackSuccess | PackFailure;
-
-// ── Module-level cache ──
-
-interface CacheEntry {
-  readonly bundle: ContextBundle;
-  readonly ts: number;
-}
-
-const cache = new Map<string, CacheEntry>();
-const DEFAULT_CACHE_TTL_MS = 30_000;
-
-function cacheKey(cwd: string): string {
-  return resolve(cwd);
-}
-
-function cacheGet(key: string, ttlMs: number): ContextBundle | undefined {
-  const entry = cache.get(key);
-  if (!entry) return undefined;
-  if (Date.now() - entry.ts > ttlMs) {
-    cache.delete(key);
-    return undefined;
-  }
-  return entry.bundle;
-}
-
-function cacheSet(key: string, bundle: ContextBundle): void {
-  cache.set(key, { bundle, ts: Date.now() });
-}
-
-// ── Core functions ──
-
-export async function packRepository(
-  cwd: string,
-  signal?: AbortSignal,
-  ttlMs: number = DEFAULT_CACHE_TTL_MS,
-): Promise<PackResult> {
-  if (signal?.aborted) return { ok: false, error: "aborted" };
-
-  const key = cacheKey(cwd);
-  const cached = cacheGet(key, ttlMs);
-  if (cached) return { ok: true, value: cached };
-
-  try {
-    const result: RepomixPackResult = await Promise.race([
-      pack([cwd], {
-        input: { maxFileSize: 1048576 },
-        cwd,
-        output: {
-          filePath: `${tmpdir()}/repomix-out-${Date.now()}.txt`,
-          style: "plain",
-          filePathStyle: "cwd-relative",
-          parsableStyle: false,
-          headerText: undefined,
-          instructionFilePath: undefined,
-          fileSummary: false,
-          directoryStructure: false,
-          files: true,
-          removeComments: false,
-          removeEmptyLines: false,
-          compress: false,
-          topFilesLength: 5,
-          showLineNumbers: false,
-          truncateBase64: false,
-          copyToClipboard: false,
-          includeEmptyDirectories: undefined,
-          includeFullDirectoryStructure: false,
-          splitOutput: undefined,
-          tokenCountTree: false,
-          tokenBudget: undefined,
-          git: {
-            sortByChanges: true,
-            sortByChangesMaxCommits: 100,
-            includeDiffs: false,
-            includeLogs: false,
-            includeLogsCount: 50,
-          },
-        },
-        include: [],
-        ignore: {
-          useGitignore: true,
-          useDotIgnore: true,
-          useDefaultPatterns: true,
-          customPatterns: [],
-        },
-        security: { enableSecurityCheck: false },
-        tokenCount: { encoding: "o200k_base" as const },
-      } satisfies PackConfig),
-      new Promise<never>((_, reject) => {
-        signal?.addEventListener("abort", () => reject(new Error("aborted")), { once: true });
-      }),
-    ]);
-
-    const processedFiles = result.processedFiles;
-    const files = new Array<ContextFile>(processedFiles.length);
-    const tokenCounts = result.fileTokenCounts;
-    let totalTokens = 0;
-    let totalChars = 0;
-
-    for (let i = 0; i < processedFiles.length; i++) {
-      const file = processedFiles[i];
-      const tokens = tokenCounts[file.path] ?? estimateTokens(file.content.length);
-      files[i] = { path: file.path, content: file.content, tokens };
-      totalTokens += tokens;
-      totalChars += file.content.length;
-    }
-
-    const bundle: ContextBundle = {
-      files,
-      totalFiles: files.length,
-      totalTokens,
-      totalChars,
-    };
-    cacheSet(key, bundle);
-    return { ok: true, value: bundle };
-  } catch (err: unknown) {
-    if (signal?.aborted) return { ok: false, error: "aborted" };
-    return {
-      ok: false,
-      error: errorMessage(err),
-    };
-  }
-}
-
-export function serializeForSandbox(
-  bundle: ContextBundle,
-): readonly ContextFile[] {
-  return bundle.files;
-}
-
-/** Maximum files shown in the compact LLM listing before truncation. */
-const MAX_LLM_LISTING_FILES = 200;
-
-/**
- * Produces a compact human-readable text block for the parent LLM's context window.
- * Shows file paths and token estimates — NOT full file contents (those are too large
- * for the context window). The LLM inspects files via repl() over the pre-loaded context variable.
- */
-export function formatForLLM(bundle: ContextBundle): string {
-  const files = bundle.files.slice(0, MAX_LLM_LISTING_FILES);
-  const truncated = bundle.totalFiles > MAX_LLM_LISTING_FILES
-    ? `... and ${bundle.totalFiles - MAX_LLM_LISTING_FILES} more files (truncated)`
-    : "";
-
-  const listing = files.map((f) =>
-    `${f.path} (${f.tokens.toLocaleString()} tok, ${f.content.length.toLocaleString()} chars)`,
-  ).join("\n");
-
-  return [
-    `Repository context: ${bundle.totalFiles.toLocaleString()} files, ${bundle.totalTokens.toLocaleString()} estimated tokens, ${bundle.totalChars.toLocaleString()} total characters.`,
-    "",
-    listing,
-    truncated,
-    "",
-    "All file contents are pre-loaded in the REPL `context` variable — file-reading tools are disabled.",
-    "Use repl({code}) and delegate semantic reading to llm_query / llm_query_batched / llm_query_chunked.",
-  ].join("\n");
-}
-
-

package/src/core/artifacts.ts

@@ -1,89 +0,0 @@
-/**
- * Artifact plumbing for the gated RLM pipeline: goal capture, baseline dirty-tree
- * snapshot, and timestamped stage artifact writes under `.rlm/artifacts/`.
- */
-import { execFileSync } from "node:child_process";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import type { Result } from "../util/errors.ts";
-import { errorMessage } from "../util/errors.ts";
-
-export const ARTIFACTS_DIR = ".rlm/artifacts";
-
-const stamp = (): string => new Date().toISOString().replace(/[:.]/g, "-");
-
-export interface GoalCapture {
-  readonly goalPath: string;      // repo-relative
-  readonly baselinePath: string;  // repo-relative
-}
-
-export type SaveOutcome =
-  | { readonly ok: true; readonly path: string }
-  | { readonly ok: false; readonly error: string };
-
-export type GoalCaptureResult =
-  | { readonly ok: true; readonly value: GoalCapture }
-  | { readonly ok: false; readonly error: string };
-
-/**
- * Capture the user's brief VERBATIM: no frontmatter, no headers — the raw file
- * is the only artifact that preserves explicit user constraints unrefracted. The
- * baseline snapshot records paths ALREADY dirty before the run, so validate
- * judges only the run's own delta. Best-effort: git failure ⇒ empty baseline.
- * Failures never throw (unwritable cwd etc.) — returns error for the engine to surface.
- */
-export function captureGoal(cwd: string, brief: string): GoalCaptureResult {
-  try {
-    const ts = stamp();
-    const dir = join(ARTIFACTS_DIR, "goal");
-    mkdirSync(join(cwd, dir), { recursive: true });
-    const goalPath = join(dir, `goal-${ts}.md`);
-    writeFileSync(join(cwd, goalPath), brief, "utf-8");
-    let paths: readonly string[] = [];
-    try {
-      paths = execFileSync("git", ["status", "--short"], {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "ignore"],
-      })
-        .split("\n")
-        .filter((l) => l.trim() !== "")
-        .map((l) => {
-          const rest = l.slice(3).trim();
-          const arrow = rest.indexOf(" -> ");
-          return arrow >= 0 ? rest.slice(arrow + 4).trim() : rest;
-        });
-    } catch {
-      paths = [];
-    }
-    const baselinePath = join(dir, `baseline-${ts}.json`);
-    writeFileSync(join(cwd, baselinePath), JSON.stringify({ paths }, null, 2), "utf-8");
-    return { ok: true, value: { goalPath, baselinePath } };
-  } catch (err) {
-    const message = errorMessage(err);
-    return { ok: false, error: message };
-  }
-}
-
-/** Write a stage artifact under its dir; timestamped so runs never collide. */
-export function saveArtifact(cwd: string, dir: string, slug: string, content: string): SaveOutcome {
-  try {
-    const rel = join(ARTIFACTS_DIR, dir, `${stamp()}_${slug}.md`);
-    mkdirSync(join(cwd, ARTIFACTS_DIR, dir), { recursive: true });
-    writeFileSync(join(cwd, rel), content, "utf-8");
-    return { ok: true, path: rel };
-  } catch (err) {
-    const message = errorMessage(err);
-    return { ok: false, error: message };
-  }
-}
-
-/** Read a previously saved artifact (repo-relative path). Failures never throw. */
-export function readArtifact(cwd: string, relPath: string): Result<string, string> {
-  try {
-    return { ok: true, value: readFileSync(join(cwd, relPath), "utf-8") };
-  } catch (err) {
-    const message = errorMessage(err);
-    return { ok: false, error: `could not read artifact ${relPath}: ${message}` };
-  }
-}

package/src/core/critique.ts

@@ -1,92 +0,0 @@
-/**
- * Preflight critique for stage artifacts — port of codex-bais `model_critique`.
- *
- * Blocking truth comes from `stage.gate` (the same function `advance_phase` runs), so the
- * two can never drift. `warnings` are advisory model-risk diagnostics that never block.
- */
-import {
-  countBulletsUnderHeading,
-  phasesMissingSuccessCriteria,
-  sectionHasNonEmptyBody,
-} from "./gates.ts";
-import type { StageDef, StageGateData } from "./pipeline.ts";
-
-export interface Critique {
-  /** Blocking — `advance_phase` will reject while non-empty. */
-  readonly issues: readonly string[];
-  /** Advisory — surfaced to the model, never blocking. */
-  readonly warnings: readonly string[];
-  /**
-   * Convenience alias for `issues.length === 0` — do not set independently;
-   * always derive from `issues`.
-   */
-  readonly canAdvance: boolean;
-  /** Gate payload when `canAdvance` — reused by advance_phase (no second gate run). */
-  readonly gateData?: StageGateData;
-}
-
-const NO_STRINGS: readonly string[] = Object.freeze([]);
-
-/** Advisory checks per artifact kind. Pure; returns a frozen array. */
-function advisoriesFor(stage: StageDef, content: string): readonly string[] {
-  switch (stage.artifactKind) {
-    case "plan": {
-      const missing = phasesMissingSuccessCriteria(content);
-      if (missing.length > 0) {
-        return Object.freeze([
-          `${missing.join(", ")} ${missing.length === 1 ? "has" : "have"} no `
-          + "'### Success Criteria' — validate cannot check them",
-        ]);
-      }
-      return NO_STRINGS;
-    }
-    case "clarification": {
-      const open = countBulletsUnderHeading(content, "Open Questions");
-      if (open > 0) {
-        return Object.freeze([
-          `${open} Open Question(s) carried into blueprint — re-ask any that block the design`,
-        ]);
-      }
-      return NO_STRINGS;
-    }
-    case "research": {
-      if (!sectionHasNonEmptyBody(content, "Findings")) {
-        return Object.freeze(["research artifact has no '## Findings' section"]);
-      }
-      return NO_STRINGS;
-    }
-    default:
-      return NO_STRINGS;
-  }
-}
-
-export function critiqueArtifact(
-  stage: StageDef,
-  content: string,
-  path: string,
-  cwd: string,
-): Critique {
-  const gate = stage.gate(content, path, cwd);
-  const issues = gate.ok ? NO_STRINGS : Object.freeze([gate.error]);
-  return Object.freeze({
-    issues,
-    warnings: advisoriesFor(stage, content),
-    canAdvance: issues.length === 0,
-    gateData: gate.ok ? gate.value : undefined,
-  });
-}
-
-/** Human-readable renderer for the `save_artifact` return value. */
-export function formatCritique(critique: Critique): string {
-  if (critique.issues.length === 0 && critique.warnings.length === 0) {
-    return "gate: clean — call advance_phase when ready.";
-  }
-  const lines = new Array<string>(critique.issues.length + critique.warnings.length);
-  let n = 0;
-  for (let i = 0; i < critique.issues.length; i++) lines[n++] = `  BLOCKER: ${critique.issues[i]}`;
-  for (let i = 0; i < critique.warnings.length; i++) lines[n++] = `  warning: ${critique.warnings[i]}`;
-  const head = critique.canAdvance
-    ? "gate: passes, with advisories —"
-    : "gate: WOULD REJECT — fix before advance_phase:";
-  return `${head}\n${lines.join("\n")}`;
-}