@hicaru/pi-rlm 0.2.1 → 0.2.2

package/src/util/concurrency.ts

@@ -80,10 +80,14 @@ export interface SubcallGates {
 }
 
 /**
- * Worst case is `maxDepth × limit` concurrent child engines (each owning a Python
- * subprocess) plus `limit` leaf completions, so keep `limit` modest — see
- * DEFAULT_CONFIG.maxConcurrentSubcalls.
+ * Worst case is `(maxDepth - 1) × childLimit` concurrent child engines — the cap short-circuits
+ * at `childDepth >= maxDepth`, so engines exist at depths 1..maxDepth-1 — plus `leafLimit` leaf
+ * completions.
+ *
+ * Children get their own, smaller bound because they are far heavier than leaves: each owns a
+ * Python subprocess AND its own copy of the context it inherited from its parent, where a leaf
+ * is one HTTP request. See DEFAULT_CONFIG.maxConcurrentChildren.
  */
-export function createSubcallGates(limit: number): SubcallGates {
-  return Object.freeze({ leaf: new Semaphore(limit), rlm: new DepthGates(limit) });
+export function createSubcallGates(leafLimit: number, childLimit: number = leafLimit): SubcallGates {
+  return Object.freeze({ leaf: new Semaphore(leafLimit), rlm: new DepthGates(childLimit) });
 }

package/src/bridge/fallback-todo.ts

@@ -1,148 +0,0 @@
-import { formatError } from "../util/errors.ts";
-
-type TaskStatus = "pending" | "in_progress" | "completed" | "deleted";
-
-interface Task {
-  readonly id: number;
-  readonly subject: string;
-  readonly description?: string;
-  readonly status: TaskStatus;
-  readonly activeForm?: string;
-  readonly blockedBy?: readonly number[];
-  readonly owner?: string;
-}
-
-interface TodoParams {
-  readonly id?: number;
-  readonly subject?: string;
-  readonly description?: string;
-  readonly status?: TaskStatus;
-  readonly activeForm?: string;
-  readonly blockedBy?: readonly number[];
-  readonly addBlockedBy?: readonly number[];
-  readonly removeBlockedBy?: readonly number[];
-  readonly owner?: string;
-  readonly filterStatus?: string;
-  readonly includeDeleted?: boolean;
-}
-
-const TODO_STATUSES = Object.freeze(new Set<unknown>(["pending", "in_progress", "completed", "deleted"]));
-
-function isTaskStatus(value: unknown): value is TaskStatus {
-  return TODO_STATUSES.has(value);
-}
-
-function numericArray(value: unknown): readonly number[] | undefined {
-  return Array.isArray(value) ? Object.freeze(value.filter((n): n is number => typeof n === "number")) : undefined;
-}
-
-function toTodoParams(raw: Record<string, unknown>): TodoParams {
-  const blockedBy = numericArray(raw.blockedBy);
-  const addBlockedBy = numericArray(raw.addBlockedBy);
-  const removeBlockedBy = numericArray(raw.removeBlockedBy);
-  return Object.freeze({
-    ...(typeof raw.id === "number" ? { id: raw.id } : {}),
-    ...(typeof raw.subject === "string" ? { subject: raw.subject } : {}),
-    ...(typeof raw.description === "string" ? { description: raw.description } : {}),
-    ...(isTaskStatus(raw.status) ? { status: raw.status } : {}),
-    ...(typeof raw.activeForm === "string" ? { activeForm: raw.activeForm } : {}),
-    ...(blockedBy ? { blockedBy } : {}),
-    ...(addBlockedBy ? { addBlockedBy } : {}),
-    ...(removeBlockedBy ? { removeBlockedBy } : {}),
-    ...(typeof raw.owner === "string" ? { owner: raw.owner } : {}),
-    ...(typeof raw.filterStatus === "string" ? { filterStatus: raw.filterStatus } : {}),
-    ...(raw.includeDeleted === true ? { includeDeleted: true } : {}),
-  });
-}
-
-function patchedBlockedBy(task: Task, params: TodoParams): readonly number[] | undefined {
-  if (params.blockedBy) return params.blockedBy;
-
-  let next = task.blockedBy ?? Object.freeze([] as readonly number[]);
-  if (params.addBlockedBy) next = Object.freeze([...next, ...params.addBlockedBy]);
-
-  if (params.removeBlockedBy) {
-    const removeSet = new Set(params.removeBlockedBy);
-    next = Object.freeze(next.filter((n) => !removeSet.has(n)));
-  }
-  return next.length ? next : undefined;
-}
-
-function taskLines(task: Task): readonly string[] {
-  const lines: string[] = [`#${task.id} [${task.status}] ${task.subject}`];
-  if (task.description) lines.push(`  description: ${task.description}`);
-  if (task.activeForm) lines.push(`  activeForm: ${task.activeForm}`);
-  if (task.blockedBy?.length) lines.push(`  blockedBy: ${task.blockedBy.map((n) => `#${n}`).join(", ")}`);
-  if (task.owner) lines.push(`  owner: ${task.owner}`);
-  return lines;
-}
-
-function withPatch(task: Task, params: TodoParams): Task {
-  const blockedBy = patchedBlockedBy(task, params);
-  return Object.freeze({
-    ...task,
-    ...(params.subject !== undefined ? { subject: params.subject } : {}),
-    ...(params.description !== undefined ? { description: params.description } : {}),
-    ...(params.status !== undefined ? { status: params.status } : {}),
-    ...(params.activeForm !== undefined ? { activeForm: params.activeForm } : {}),
-    ...(blockedBy ? { blockedBy } : {}),
-    ...(params.owner !== undefined ? { owner: params.owner } : {}),
-  });
-}
-
-/** The actions `worker.py::_todo` documents. Anything else is a caller error, not a missing task. */
-const TODO_ACTIONS: ReadonlySet<string> = Object.freeze(new Set([
-  "create", "update", "list", "get", "delete", "clear",
-]));
-
-export function createTodoFallback(): (action: string, params: Record<string, unknown>) => Promise<string> {
-  let nextId = 1;
-  let tasks: readonly Task[] = Object.freeze([]);
-  const fmt = (task: Task): string => taskLines(task)[0] ?? `#${task.id}`;
-
-  const apply = (action: string, rawParams: Record<string, unknown>): string => {
-    // Validated BEFORE the id lookup below: an unknown action used to fall through to it and
-    // report "task #? not found", which reads as a missing task rather than a bad action.
-    if (!TODO_ACTIONS.has(action)) {
-      return formatError(`unknown todo action '${action}' — expected ${[...TODO_ACTIONS].join(", ")}`);
-    }
-    const params = toTodoParams(rawParams);
-    if (action === "clear") {
-      const count = tasks.length;
-      tasks = Object.freeze([]);
-      nextId = 1;
-      return `Cleared ${count} task(s).`;
-    }
-    if (action === "create") {
-      const subject = typeof params.subject === "string" && params.subject.trim() ? params.subject.trim() : undefined;
-      if (!subject) return formatError("create requires subject");
-      const task = withPatch(Object.freeze({ id: nextId, subject, status: "pending" }), params);
-      nextId += 1;
-      tasks = Object.freeze([...tasks, task]);
-      return `Created ${fmt(task)}`;
-    }
-    if (action === "list") {
-      const filter = params.filterStatus ?? params.status;
-      const includeDeleted = params.includeDeleted === true;
-      const rows = tasks.filter((task) => (includeDeleted || task.status !== "deleted") && (!filter || task.status === filter)).map(fmt);
-      return rows.length ? rows.join("\n") : "No tasks.";
-    }
-    const id = params.id;
-    const task = id !== undefined ? tasks.find((item) => item.id === id) : undefined;
-    if (!task) return formatError(`task #${id ?? "?"} not found`);
-    if (action === "get") return taskLines(task).join("\n");
-    if (action === "delete") {
-      const deleted = Object.freeze({ ...task, status: "deleted" as const });
-      tasks = Object.freeze(tasks.map((item) => item.id === task.id ? deleted : item));
-      return `Deleted ${fmt(deleted)}`;
-    }
-    if (action === "update") {
-      const updated = withPatch(task, params);
-      tasks = Object.freeze(tasks.map((item) => item.id === task.id ? updated : item));
-      return `Updated ${fmt(updated)}`;
-    }
-    // Unreachable: every TODO_ACTIONS member is handled above. Kept as the exhaustiveness arm.
-    return formatError(`unhandled todo action '${action}'`);
-  };
-  return async (action, params) => apply(action, params);
-}

package/src/bridge/interactive.ts

@@ -1,65 +0,0 @@
-import type { AskAnswer, AskQuestion } from "../sandbox/protocol.ts";
-import type { SubLlmHandlers } from "../sandbox/sandbox.ts";
-import type { RlmEmitter } from "../tool/rlm-events.ts";
-import { formatError } from "../util/errors.ts";
-
-export interface InteractiveBridgeOpts {
-  readonly onAskUserQuestion?: (questions: readonly AskQuestion[]) => Promise<AskAnswer[]>;
-  readonly onTodo?: (action: string, params: Record<string, unknown>) => Promise<string>;
-  readonly onTodoRow?: (action: string, params: Record<string, unknown>, result: string) => void | Promise<void>;
-  readonly emitter?: RlmEmitter;
-  readonly depth: number;
-  readonly parentId?: string;
-}
-
-export function buildInteractiveHandlers(opts: InteractiveBridgeOpts): {
-  askUserQuestion: SubLlmHandlers["askUserQuestion"];
-  todo: SubLlmHandlers["todo"];
-} {
-  return {
-    async askUserQuestion(questions, depth) {
-      if (depth > 0) return questions.map((q) => ({
-        question: q.question,
-        selected: [],
-        custom: formatError("ask_user_question not available inside rlm_query sub-calls"),
-      }));
-
-      const id = opts.emitter?.emitSubcallCreated({
-        kind: "tool", parentId: opts.parentId,
-        label: "ask_user_question",
-        args: `${questions.length} question(s)`,
-        depth,
-      });
-      try {
-        const cb = opts.onAskUserQuestion;
-        if (!cb) throw new Error("ask_user_question not configured (no onAskUserQuestion callback)");
-        const answers = await cb(questions);
-        if (id) opts.emitter?.emitSubcallUpdated({ id, status: "done" });
-        return answers;
-      } catch (err) {
-        if (id) opts.emitter?.emitSubcallUpdated({ id, status: "error", detail: String(err) });
-        throw err;
-      }
-    },
-
-    async todo(action, params, depth) {
-      const id = opts.emitter?.emitSubcallCreated({
-        kind: "tool", parentId: opts.parentId,
-        label: `todo:${action}`,
-        args: params.subject ? String(params.subject) : String(params.id ?? ""),
-        depth,
-      });
-      try {
-        const cb = opts.onTodo;
-        if (!cb) throw new Error("todo not configured (no onTodo callback)");
-        const result = await cb(action, params);
-        await opts.onTodoRow?.(action, params, result);
-        if (id) opts.emitter?.emitSubcallUpdated({ id, status: "done", resultPreview: result.slice(0, 80) });
-        return result;
-      } catch (err) {
-        if (id) opts.emitter?.emitSubcallUpdated({ id, status: "error", detail: String(err) });
-        throw err;
-      }
-    },
-  };
-}

package/src/bridge/pi-interactive.ts

@@ -1,41 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { InteractiveDeps } from "../core/types.ts";
-import type { AskAnswer, AskQuestion } from "../sandbox/protocol.ts";
-import { formatError } from "../util/errors.ts";
-import { createTodoFallback } from "./fallback-todo.ts";
-
-async function askViaUi(ctx: ExtensionContext, questions: readonly AskQuestion[]): Promise<AskAnswer[]> {
-  if (!ctx.hasUI) throw new Error("ask_user_question requires UI");
-  const answers = new Array<AskAnswer>(questions.length);
-  for (let i = 0; i < questions.length; i++) {
-    const q = questions[i];
-    if (!q) {
-      answers[i] = { question: "", selected: [], custom: formatError("malformed question") };
-      continue;
-    }
-    if (q.multiSelect) {
-      const selected: string[] = [];
-      while (true) {
-        const pick = await ctx.ui.select(`${q.header}: ${q.question}`, [...q.options.map((o) => o.label), "Done"]);
-        if (!pick || pick === "Done") break;
-        if (!selected.includes(pick)) selected.push(pick);
-      }
-      answers[i] = { question: q.question, selected };
-      continue;
-    }
-    const pick = await ctx.ui.select(`${q.header}: ${q.question}`, [...q.options.map((o) => o.label), "Type something."]);
-    if (!pick) answers[i] = { question: q.question, selected: [], custom: formatError("user cancelled") };
-    else if (pick === "Type something.") answers[i] = { question: q.question, selected: [], custom: await ctx.ui.input(q.question) ?? "" };
-    else answers[i] = { question: q.question, selected: [pick] };
-  }
-  return answers;
-}
-
-export function createPiInteractiveDeps(ctx: ExtensionContext): InteractiveDeps {
-  const fallbackTodo = createTodoFallback();
-  return Object.freeze({
-    onAskUserQuestion: (questions: readonly AskQuestion[]): Promise<AskAnswer[]> => askViaUi(ctx, questions),
-    onTodo: (action: string, params: Record<string, unknown>): Promise<string> =>
-      Promise.resolve(fallbackTodo(action, params)),
-  });
-}

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")}`;
-}