@foldrun/core 2.5.0 → 2.7.0

package/src/step-exec.ts

@@ -8,6 +8,7 @@
 // results. That is what lets the same function run somewhere the vault, the
 // library and the account do not exist.
 
+import { judgeVerdict, JUDGE_VERDICT_INSTRUCTION } from "./judge-verdict.ts";
 import { runHook, runToolCallHooks, matchesTool, hookLine, resolveHooks, type HookDef, type HookRecord } from "./hooks.ts";
 import fs from "node:fs";
 import os from "node:os";
@@ -133,6 +134,11 @@ export interface ExecOptions {
    *  `matches: re`, `file: path`, `judge: sentence`) — see checkVerify. */
   verify?: string;
   verifyEnv?: Record<string, string>;
+  /** The model `verify: judge:` grades with — the workspace's `judge:` from
+   *  AGENTS.md, resolved; absent, the fast tier. */
+  judgeModel?: string;
+  /** And how long it thinks — `judge: {effort}`; absent, the SDK's default. */
+  judgeEffort?: Effort;
   /** `output: json` — the reply must carry one JSON value; extracting it is
    *  part of finishing the step, and failing to is failing the step. */
   output?: "json";
@@ -1066,6 +1072,8 @@ async function executeStepInner(opts: ExecOptions, runQuery: QueryFn): Promise<E
         data,
         modelEnv: opts.env,
         signal: halt.signal,
+        ...(opts.judgeModel ? { judgeModel: opts.judgeModel } : {}),
+        ...(opts.judgeEffort ? { judgeEffort: opts.judgeEffort } : {}),
       });
     } finally {
       for (const t of clocks) clearTimeout(t);
@@ -1170,6 +1178,9 @@ export async function checkVerify(
     /** The step's own model environment, for `judge:` — it grades on the
      *  fast tier through the same credential the step rode. */
     modelEnv?: Record<string, string | undefined>;
+    /** The judge's model and effort (the workspace's `judge:`). */
+    judgeModel?: string;
+    judgeEffort?: Effort;
     /** Ends a shell check or a judge mid-way: the step's clock ran out, or a
      *  person asked the run to stop. */
     signal?: AbortSignal;
@@ -1233,9 +1244,9 @@ export async function checkVerify(
       // GOOD` on a reply that did (fix-desk, run-muwevg72-7mza): the joined
       // text opened with the narration before it.
       const reply = ctx.conclusion?.trim() ? ctx.conclusion : output;
-      const verdict = await judgeReply(value, reply, output, ctx.modelEnv ?? {}, ctx.signal);
-      const ok = /^\s*PASS\b/i.test(verdict);
-      return { ok, headline: ok ? "PASS" : "FAIL", detail: verdict.slice(0, 300) };
+      const said = await judgeReply(value, reply, output, ctx.modelEnv ?? {}, ctx.signal, ctx.judgeModel, ctx.judgeEffort);
+      const { passed: ok, detail } = judgeVerdict(said);
+      return { ok, headline: ok ? "PASS" : "FAIL", detail };
     }
   }
   return { ok: false, headline: `unknown check "${kind}"`, detail: "" };
@@ -1243,8 +1254,8 @@ export async function checkVerify(
 
 /**
  * A toolless, fast-tier grading call: does the reply satisfy the sentence?
- * Same shape as the eval judge, and answered with one word first so the
- * verdict is a prefix test rather than a reading.
+ * Same shape as the eval judge: reasoning first, then the verdict alone on
+ * the last line (judge-verdict.ts says why).
  */
 export function judgePrompt(rubric: string, reply: string, work: string): string {
   const shown = reply.slice(0, 20_000);
@@ -1253,8 +1264,7 @@ export function judgePrompt(rubric: string, reply: string, work: string): string
       `never this:\n<work>\n${work.slice(-20_000)}\n</work>\n\n`
     : "";
   return (
-    `You are grading a reply against one requirement. Answer with PASS or FAIL as the ` +
-    `first word, then one sentence of reason.\n\nRequirement: ${rubric}\n\n` +
+    `You are grading a reply against one requirement. ${JUDGE_VERDICT_INSTRUCTION}\n\nRequirement: ${rubric}\n\n` +
     context +
     `<reply>\n${shown}\n</reply>`
   );
@@ -1266,6 +1276,8 @@ async function judgeReply(
   work: string,
   env: Record<string, string | undefined>,
   signal?: AbortSignal,
+  model = "haiku",
+  effort?: Effort,
 ): Promise<string> {
   const texts: string[] = [];
   const abortController = new AbortController();
@@ -1275,7 +1287,8 @@ async function judgeReply(
     const q = query({
       prompt: judgePrompt(rubric, reply, work),
       options: {
-        model: "haiku",
+        model,
+        ...(effort ? { effort } : {}),
         systemPrompt: "You grade text against a stated requirement. Be strict and literal.",
         tools: [],
         settingSources: [],

package/src/store.ts

@@ -31,7 +31,7 @@ import { platform } from "./platform.ts";
 import { toLF, asRaw } from "./eol.ts";
 import type { TestEffect } from "./test-mode.ts";
 import type { OperatorEvent } from "./operator.ts";
-import matter from "./matter.ts";
+import matter, { frontmatterErrorText, configMatter } from "./matter.ts";
 import { readAgentsMdKeys } from "./agents-md.ts";
 
 /**
@@ -44,7 +44,7 @@ import { readAgentsMdKeys } from "./agents-md.ts";
  * the runtime, and there is nothing to fail to import.
  */
 export function readFrontmatter(file: string): Record<string, unknown> {
-  return matter(fs.readFileSync(file, "utf8")).data as Record<string, unknown>;
+  return configMatter(fs.readFileSync(file, "utf8")).data as Record<string, unknown>;
 }
 import { ownToolNames, legacyUseNames, retiredToolNames } from "./tool-names.ts";
 import { refNames } from "./refs.ts";
@@ -1602,7 +1602,7 @@ export function listAgents(tenant: string, workspace: string): AgentInfo[] {
       let data: Record<string, any> = {};
       let frontmatterError: string | undefined;
       try {
-        ({ data } = matter(fs.readFileSync(path.join(dir, name, "agent.md"), "utf8")));
+        ({ data } = configMatter(fs.readFileSync(path.join(dir, name, "agent.md"), "utf8")));
       } catch (err) {
         frontmatterError = frontmatterErrorText(err);
       }
@@ -1652,12 +1652,9 @@ export function listAgents(tenant: string, workspace: string): AgentInfo[] {
     });
 }
 
-/** The first line of a YAML parse error, with where it is: what a person
- *  needs to fix the file, without the parser's excerpt. */
-export function frontmatterErrorText(err: unknown): string {
-  const msg = err instanceof Error ? err.message : String(err);
-  return `frontmatter does not parse — ${msg.split("\n")[0].trim()}. Quote a value that contains a colon followed by a space.`;
-}
+// Kept here for callers that import it from the store; it lives in matter.ts
+// so the scanner can use it without the store.
+export { frontmatterErrorText };
 
 /** The body of a file whose frontmatter would not parse: what follows the
  *  closing fence, so a flow's steps can still be read and shown. */
@@ -1839,7 +1836,7 @@ export function parseFlow(file: string, raw: string): FlowInfo {
   let content: string;
   let frontError: string | null = null;
   try {
-    ({ data, content } = matter(raw));
+    ({ data, content } = configMatter(raw));
   } catch (err) {
     frontError = frontmatterErrorText(err);
     content = bodyAfterFrontmatter(raw);
@@ -3297,6 +3294,15 @@ export function sumAttempts(tries: StepAttempt[]): Pick<StepAttempt, "costUsd" |
 export { type TokenUsage, type PromptLayerRecord, tokensOf, sumTokens, cacheHitRate, measuredHitRate, runTokens, promptLayersChanged, promptCacheNote } from "./tokens.ts";
 import { sumTokens, type TokenUsage, type PromptLayerRecord } from "./tokens.ts";
 
+/** The marker rescueStep puts in a rescue's instruction; how a rescue record
+ *  written before `rescueOf` existed is still recognised. */
+export const RESCUE_MARKER = "<rescue>\nYou are taking this step over:";
+
+/** Is this record an on-fail rescue rather than a step of the flow? */
+export function isRescueRecord(step: { rescueOf?: string; instruction?: string | null }): boolean {
+  return !!step.rescueOf || (step.instruction ?? "").includes(RESCUE_MARKER);
+}
+
 export interface StepRecord {
   agent: string;
   instruction: string;
@@ -3450,6 +3456,13 @@ export interface StepRecord {
    *  actually executed in. Carried steps provide context and are never
    *  billed again — the original run's ledger line already paid for them. */
   carriedFrom?: string;
+  /** Set on an on-fail rescue record (runner.ts rescueStep): the agent of the
+   *  failed step it took over. A rescue is not a step of the flow: a resumed
+   *  drive must not launch it as one of its group, and a re-run must not
+   *  copy it as work (21 Oct 2026: one rerun carried 77 fixers as pending
+   *  steps). Records written before this field are recognised by their
+   *  instruction's `<rescue>` block instead — see isRescueRecord. */
+  rescueOf?: string;
   /**
    * Sandbox seconds this step rented, and how many of them were cold start.
    * Set only on the isolated path — an in-process step rents nothing, so