opencode-goal-plugin 0.6.1 → 0.6.3

package/src/goal-plugin.js

@@ -88,6 +88,7 @@ function createRuntimeState() {
     activeContinues: new Map(),
     continuationControllers: new Map(),
     seenIdleEventIDs: new Set(),
+    readOnlyCommandGuards: new Set(),
     ledgerSink: null,
     persistenceLease: null,
     migrationLease: null,
@@ -143,6 +144,7 @@ const seenOutputTokens = runtimeCollection("seenOutputTokens")
 const activeContinues = runtimeCollection("activeContinues")
 const CLEAR_COMMANDS = new Set(["clear", "stop", "off", "reset", "none", "cancel"])
 const PAUSE_COMMANDS = new Set(["pause"])
+const READ_ONLY_COMMAND_TOOLS = new Set(["goal_status", "get_goal", "get_goal_history", "read", "glob", "grep"])
 const GOAL_FLAG_SPECS = {
   "--max-turns": {
     optionKey: "maxTurns",
@@ -206,7 +208,7 @@ function messageHasToolCall(message) {
 
 const GOAL_MODES = new Set(["normal", "ordered"])
 
-// Goal "mode" field (item 4.3): normal vs ordered (a.k.a. sisyphus). `ordered`
+// Goal mode: normal vs ordered (a.k.a. sisyphus). `ordered`
 // signals a strict execution sequence; `sisyphus` is accepted as an alias.
 // Returns the canonical mode or null when unrecognized.
 function normalizeMode(value) {
@@ -289,12 +291,12 @@ function makeHistoryEntry(type, detail, timestamp = Date.now()) {
   }
 }
 
-// Append-only lifecycle ledger (item 2.3). pushHistory emits every lifecycle
+// Append-only lifecycle ledger. pushHistory emits every lifecycle
 // event to this sink, which a configured plugin instance points at a JSONL
 // file. Because the in-memory history is truncated to MAX_HISTORY_ENTRIES, the
 // ledger is the durable record used to reconstruct state if the main state file
 // is lost or corrupted, and it captures terminal events even when the main
-// state write fails (fail-closed, item 2.5).
+// state write fails (fail closed).
 function setLedgerSink(sink) {
   currentRuntime().ledgerSink = typeof sink === "function" ? sink : null
 }
@@ -705,6 +707,7 @@ function clearRuntimeState() {
   activeContinues.clear()
   runtime.continuationControllers.clear()
   runtime.seenIdleEventIDs.clear()
+  runtime.readOnlyCommandGuards.clear()
 }
 
 function pruneGoalResults(options) {
@@ -1001,7 +1004,7 @@ async function assertSafeProjectPersistencePath({ stateFilePath, projectRoot, en
   }
 }
 
-// Command surface options (item 8.2): `commandName` lets the plugin own a
+// Command surface options: `commandName` lets the plugin own a
 // different slash command (e.g. /objective) and `registerCommand: false` makes
 // the plugin skip the command hook entirely (agent/programmatic use only). A
 // leading slash in commandName is tolerated and stripped.
@@ -1418,7 +1421,7 @@ async function loadPersistedState(persistenceOptions, client) {
 
 // Last-resort recovery: when the main state file is absent, rebuild still-active
 // goals from the append-only ledger so a lost/rotated state file does not drop
-// in-flight goals (item 2.3). Recovered goals are paused (via deserializeGoal).
+// in-flight goals. Recovered goals are paused (via deserializeGoal).
 async function reconstructFromLedger(persistenceOptions, client) {
   const entries = await readLedgerEntries(persistenceOptions.ledgerFilePath, {
     maxBytes: persistenceOptions.ledgerMaxBytes,
@@ -1753,11 +1756,16 @@ function buildContinueMessage(
     )
   } else {
     lines.push(
-      "Continue with the next concrete step; inspect current state and repair failures.",
+      "Continue the next concrete step; inspect and repair failures.",
     )
   }
 
-  lines.push("Complete only after verification: `[goal:evidence] …` then `[goal:complete]`. If only user input can unblock work, state why then `[goal:blocked]`.")
+  lines.push(
+    "Completion format—consecutive plain lines; no Markdown/backticks/blank line:",
+    "[goal:evidence] <proof>",
+    "[goal:complete]",
+    "Need user input? State why before [goal:blocked].",
+  )
   const limitWarning = buildLimitWarning(goal)
   if (limitWarning) lines.push(limitWarning.trim())
 
@@ -1788,7 +1796,7 @@ function buildContinueMessage(
 
 // Deterministic progress summary built from the plugin's persisted goal record
 // (checkpoints + lifecycle history) rather than from chat memory, so it is
-// stable and reproducible across a compaction (item 6.3).
+// stable and reproducible across a compaction.
 function buildCompactionProgressSummary(goal, { maxCheckpoints = 3, maxEvents = 6 } = {}) {
   const lines = []
   const checkpoints = Array.isArray(goal.checkpoints) ? goal.checkpoints.slice(-maxCheckpoints) : []
@@ -2069,7 +2077,7 @@ function isPluginContinuationMessage(message) {
 
 // "Latest instruction wins": detect a real (human) user message that arrived
 // after the plugin's most recent continuation prompt. Plugin-generated
-// continuation/audit messages are ignored (item 5.2). Detection requires the
+// continuation/audit messages are ignored. Detection requires the
 // loop to be running (turnCount > 0) and a plugin continuation to be visible in
 // the recent window, so the first idle after /goal set and sessions where the
 // continuations have scrolled out of view are never misread as intervention.
@@ -2139,7 +2147,7 @@ function buildGoalState(sessionID, condition, options, meta = {}, lastStatus = "
 const AGENT_UPDATE_STATUSES = new Set(["complete", "blocked", "paused", "resumed"])
 
 // Programmatic equivalents of the /goal command, exposed to the agent as tools
-// (megalist items 7.1 / 7.2). Each handler operates on a session id and mutates
+// Each handler operates on a session id and mutates
 // the same in-memory state the command path uses, persisting through the
 // provided `persist` callback, and returns a human-readable string for the tool
 // result. Goal creation/replacement routes through the multi-goal registry
@@ -2356,12 +2364,9 @@ function buildAgentToolHandlers({ defaultGoalOptions, persist, persistTerminalSt
       } else if (status === "resumed") {
         if (!goal.stopped)
           return "Goal is already running. Pause or stop it first if you want to reset the budget window."
-        const previousGoalId = goal.goalId
         resetGoalBudget(goal)
-        // resetGoalBudget always rotates goalId via randomUUID; unconditionally
-        // re-key the registry so the goal stays findable by its new id.
-        removeSessionGoal(sessionID, previousGoalId)
-        registerSessionGoal(goal)
+        // goalId is stable across budget windows; runId is the execution epoch.
+        // Keeping the existing registry entry also preserves multi-goal order.
         focusGoal(sessionID, goal)
         goal.stopped = false
         goal.stopReason = ""
@@ -2594,7 +2599,7 @@ function formatGoalList(sessionID, commandName = "goal") {
   return lines.join("\n")
 }
 
-// Visible audit messages (item 2.4): when the plugin audits a completion or
+// Visible audit messages: when the plugin audits a completion or
 // blocker it announces the audit and its result instead of doing the work
 // silently. Delivery is via this default messenger (structured app log, the
 // channel OpenCode surfaces to the user) or a caller-supplied `auditMessenger`
@@ -2623,7 +2628,7 @@ async function defaultAuditMessenger(client, sessionID, text) {
   }
 }
 
-// Completion auditor (item 2.2). When an auditor is configured, a [goal:complete]
+// Completion auditor. When an auditor is configured, a [goal:complete]
 // is verified before the goal is archived: an approved verdict archives it, a
 // rejected verdict restores the goal (pauses it with the reason) instead of
 // archiving. The auditor is a function `({ goal, sessionID, latestText }) =>
@@ -2783,7 +2788,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
   }
   runtime.drainPersistence = () => persistChain.catch(() => false)
 
-  // Fail-closed (item 2.5): when persisting a terminal state (complete/blocked)
+  // Fail closed when persisting a terminal state (complete/blocked)
   // fails, surface it loudly. The terminal event is already in the append-only
   // ledger, so it stays recoverable across a restart even though the main state
   // file write did not land.
@@ -2810,7 +2815,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
     setLedgerSink(null)
   }
 
-  // Visible audit announcements (item 2.4).
+  // Visible audit announcements.
   const auditMessagesEnabled = pluginOptions.auditMessages !== false
   const auditMessenger =
     typeof pluginOptions.auditMessenger === "function"
@@ -2885,6 +2890,14 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
       })
       if (pluginOptions.completionAudit) verifierRegistrationReady = true
     },
+    "tool.execute.before": async (input) => {
+      const sessionID = input?.sessionID
+      if (!sessionID || !currentRuntime().readOnlyCommandGuards.has(sessionID)) return
+      if (READ_ONLY_COMMAND_TOOLS.has(input?.tool)) return
+      throw new Error(
+        `This /${commandName} control command is read-only for the routed model turn. Tool "${input?.tool || "unknown"}" was blocked. Wait for a separate user turn; do not modify work or goal state now.`,
+      )
+    },
     "command.execute.before": async (input, output) => {
       if (!input || input.command !== commandName || !output) return
 
@@ -2898,10 +2911,12 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
       }
       const args = input.arguments.trim()
       const sessionID = input.sessionID
+      currentRuntime().readOnlyCommandGuards.delete(sessionID)
       pruneGoalResults(defaultGoalOptions)
 
       if (!args || args === "status") {
         const goal = goalStates.get(sessionID)
+        currentRuntime().readOnlyCommandGuards.add(sessionID)
         const lastResult = lastGoalResults.get(sessionID)
         output.parts = [
           makeTextPart(
@@ -2917,6 +2932,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
 
       if (args === "history") {
         const goal = goalStates.get(sessionID)
+        currentRuntime().readOnlyCommandGuards.add(sessionID)
         const lastResult = lastGoalResults.get(sessionID)
         output.parts = [
           makeTextPart(
@@ -2943,6 +2959,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
       }
 
       if (CLEAR_COMMANDS.has(args)) {
+        currentRuntime().readOnlyCommandGuards.add(sessionID)
         // Record the clear in the ledger before cleanupGoal removes the goal
         // object, so reconstructFromLedger can identify cleared goals and skip
         // them rather than reconstructing them after a missing state file.
@@ -2962,6 +2979,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
       }
 
       if (PAUSE_COMMANDS.has(args)) {
+        currentRuntime().readOnlyCommandGuards.add(sessionID)
         const goal = goalStates.get(sessionID)
         if (!goal) {
           output.parts = [makeTextPart(`No active goal. Set one with \`/${commandName} <condition>\`.`)]
@@ -2987,12 +3005,9 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
           return
         }
 
-        const previousGoalId = goal.goalId
         resetGoalBudget(goal)
-        // resetGoalBudget always rotates goalId via randomUUID; unconditionally
-        // re-key the registry so a later clear/replace removes the right entry.
-        removeSessionGoal(sessionID, previousGoalId)
-        registerSessionGoal(goal)
+        // goalId is stable across budget windows; runId is the execution epoch.
+        // Keeping the existing registry entry also preserves multi-goal order.
         focusGoal(sessionID, goal)
         goal.stopped = false
         goal.stopReason = ""
@@ -3052,6 +3067,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
       }
 
       if (args === "list") {
+        currentRuntime().readOnlyCommandGuards.add(sessionID)
         output.parts = [makeTextPart(formatGoalList(sessionID, commandName))]
         return
       }
@@ -3394,6 +3410,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
       if (!isIdleEvent(event)) return
 
       const sessionID = getSessionID(event)
+      currentRuntime().readOnlyCommandGuards.delete(sessionID)
       const eventID = typeof event?.id === "string" ? event.id : ""
       const seenIdleEventIDs = currentRuntime().seenIdleEventIDs
       if (eventID && seenIdleEventIDs.has(eventID)) return
@@ -3478,7 +3495,7 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
             // bail out without archiving — archiving a cleared goal would resurrect
             // it in memory and potentially in the persisted state.
             if (!activeGoal(sessionID, goalID, runID)) return
-            // Optional independent auditor (item 2.2): an approved verdict
+            // Optional independent auditor: an approved verdict
             // archives; a rejected verdict restores (pauses) the goal instead.
             if (completionAuditor) {
               let verdict
@@ -3867,7 +3884,6 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
 
       const goal = goalStates.get(input.sessionID)
       if (!goal) return
-      if (goal.stopped) return
       const systemBlocks = Array.isArray(output.system) ? [...output.system] : []
       if (systemBlocks.some((block) => systemBlockContainsGoal(block, goal.goalId))) return
 
@@ -3880,14 +3896,23 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
       // on every continuation turn via buildContinueMessage (buildLimitWarning
       // and <progress_budget>), which is sufficient — the model doesn't need
       // them in the system prompt mid-turn.
-      const goalBlock = [
-        `<opencode_goal_plugin id="${goal.goalId}">`,
-        buildGoalBlock(goal),
-        "Keep working until the goal is fully satisfied.",
-        "When fully satisfied, put a `[goal:evidence]` line summarizing what you verified immediately before `[goal:complete]`. A `[goal:complete]` without evidence is rejected.",
-        "If user input is required, explain the concrete blocker in the line immediately before `[goal:blocked]`. A `[goal:blocked]` without a concrete blocker is rejected.",
-        "</opencode_goal_plugin>",
-      ].join("\n")
+      const goalBlock = goal.stopped
+        ? [
+            `<opencode_goal_plugin id="${goal.goalId}">`,
+            "<goal_state>paused</goal_state>",
+            "A goal exists for this session, but it is paused. Do not continue or modify work toward it, and do not call completion or blocker tools, unless the current user message explicitly asks to resume it.",
+            "For status or history requests, only report the goal state; do not change files or goal state.",
+            `To continue, the user can run /${commandName} resume or explicitly ask you to call goal_resume before doing any goal work.`,
+            "</opencode_goal_plugin>",
+          ].join("\n")
+        : [
+            `<opencode_goal_plugin id="${goal.goalId}">`,
+            buildGoalBlock(goal),
+            "Keep working until the goal is fully satisfied.",
+            "When fully satisfied, put a `[goal:evidence]` line summarizing what you verified immediately before `[goal:complete]`. A `[goal:complete]` without evidence is rejected.",
+            "If user input is required, explain the concrete blocker in the line immediately before `[goal:blocked]`. A `[goal:blocked]` without a concrete blocker is rejected.",
+            "</opencode_goal_plugin>",
+          ].join("\n")
 
       if (systemBlocks.length === 0) {
         output.system = [goalBlock]
@@ -3930,13 +3955,13 @@ async function createGoalPlugin({ client, directory } = {}, pluginOptions = {})
     },
   }
 
-  // register_command toggle (item 8.2): when disabled, the plugin does not own
+  // register_command toggle: when disabled, the plugin does not own
   // a slash command and only the event/transform/compaction hooks remain.
   if (!registerCommand) {
     delete hooks["command.execute.before"]
   }
 
-  // Register agent-facing tools (megalist 7.1 / 7.2) when @opencode-ai/plugin is
+  // Register agent-facing tools when @opencode-ai/plugin is
   // available (it provides the `tool` helper and zod-style schema). Disabled via
   // `registerTools: false`. When the helper is absent the command/event hooks
   // still work; only the programmatic tool surface is omitted, preserving the

package/scripts/behavior-benchmark.mjs

@@ -1,272 +0,0 @@
-#!/usr/bin/env node
-
-import assert from "node:assert/strict"
-import { promises as fs } from "node:fs"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import { GoalPlugin } from "../src/goal-plugin.js"
-
-const startedAt = performance.now()
-const temporaryDirectories = []
-
-function assistantMessage(sessionID, text, id = `assistant-${sessionID}`) {
-  return {
-    info: {
-      id,
-      role: "assistant",
-      sessionID,
-      tokens: { input: 20, output: 120, reasoning: 0 },
-    },
-    parts: [{ type: "text", text }],
-  }
-}
-
-function createHost(messageForSession = () => "Working with tools.") {
-  const prompts = []
-  const notices = []
-  return {
-    prompts,
-    notices,
-    client: {
-      app: { log: async () => {} },
-      session: {
-        messages: async ({ path }) => ({
-          data: [assistantMessage(path.id, messageForSession(path.id))],
-        }),
-        promptAsync: async (input) => {
-          prompts.push(input)
-          return {}
-        },
-      },
-    },
-  }
-}
-
-function promptCharacters(prompts) {
-  return prompts.reduce(
-    (total, prompt) => total + (prompt?.body?.parts || []).reduce(
-      (partTotal, part) => partTotal + (typeof part?.text === "string" ? part.text.length : 0),
-      0,
-    ),
-    0,
-  )
-}
-
-async function makeDirectory(label) {
-  const directory = await fs.mkdtemp(join(tmpdir(), `goal-benchmark-${label}-`))
-  temporaryDirectories.push(directory)
-  return directory
-}
-
-async function createHooks(host, options = {}) {
-  return GoalPlugin(
-    { client: host.client, directory: await makeDirectory("workspace") },
-    {
-      persistState: false,
-      registerTools: false,
-      registerAgents: false,
-      minDelayMs: 1,
-      noProgressTokenThreshold: 1,
-      noProgressTurnsBeforePause: 10,
-      noToolCallTurnsBeforePause: 2,
-      ...options,
-    },
-  )
-}
-
-async function goalCommand(hooks, sessionID, argumentsText) {
-  const output = { parts: [] }
-  await hooks["command.execute.before"](
-    { command: "goal", sessionID, arguments: argumentsText },
-    output,
-  )
-  return output.parts.map((part) => part.text || "").join("\n")
-}
-
-async function idle(hooks, sessionID, id) {
-  await hooks.event({
-    event: {
-      id,
-      type: "session.status",
-      properties: { sessionID, status: { type: "idle" } },
-    },
-  })
-}
-
-async function scenario(name, points, run) {
-  const scenarioStartedAt = performance.now()
-  try {
-    const telemetry = await run()
-    return {
-      name,
-      passed: true,
-      points,
-      durationMs: Number((performance.now() - scenarioStartedAt).toFixed(2)),
-      ...telemetry,
-    }
-  } catch (error) {
-    return {
-      name,
-      passed: false,
-      points: 0,
-      possiblePoints: points,
-      durationMs: Number((performance.now() - scenarioStartedAt).toFixed(2)),
-      error: error instanceof Error ? error.message : String(error),
-    }
-  }
-}
-
-const results = []
-
-results.push(await scenario("verified-success", 20, async () => {
-  const sessionID = "benchmark-success"
-  const host = createHost(() => "Tests pass.\n[goal:evidence] npm test: 210/210\n[goal:complete]")
-  const hooks = await createHooks(host, {
-    auditor: async () => ({ approved: true, reason: "evidence independently accepted" }),
-  })
-  await goalCommand(hooks, sessionID, "ship a verified release")
-  await idle(hooks, sessionID, "success-idle")
-  const status = await goalCommand(hooks, sessionID, "status")
-  assert.match(status, /State: achieved/)
-  await hooks.dispose()
-  return {
-    continuationPrompts: host.prompts.length,
-    continuationCharacters: promptCharacters(host.prompts),
-    status: "archived",
-  }
-}))
-
-results.push(await scenario("false-completion", 20, async () => {
-  const sessionID = "benchmark-false-completion"
-  const host = createHost(() => "Looks done.\n[goal:evidence] guessed from source\n[goal:complete]")
-  const hooks = await createHooks(host, {
-    auditor: async () => ({ approved: false, reason: "no executed verification" }),
-  })
-  await goalCommand(hooks, sessionID, "do not accept an unverified claim")
-  await idle(hooks, sessionID, "false-idle")
-  const status = await goalCommand(hooks, sessionID, "status")
-  assert.match(status, /audit rejected/i)
-  assert.doesNotMatch(status, /No active goal/)
-  await hooks.dispose()
-  return {
-    continuationPrompts: host.prompts.length,
-    continuationCharacters: promptCharacters(host.prompts),
-    status: "rejected",
-  }
-}))
-
-results.push(await scenario("loop-circuit-breaker", 15, async () => {
-  const sessionID = "benchmark-loop"
-  let turn = 0
-  const host = createHost(() => `Still discussing the work, turn ${turn++}.`)
-  const hooks = await createHooks(host)
-  await goalCommand(hooks, sessionID, "stop self-chat loops")
-  await idle(hooks, sessionID, "loop-1")
-  await idle(hooks, sessionID, "loop-2")
-  await idle(hooks, sessionID, "loop-3")
-  const status = await goalCommand(hooks, sessionID, "status")
-  assert.match(status, /no tool calls|self-chat loop/i)
-  assert.equal(host.prompts.length, 2)
-  await hooks.dispose()
-  return {
-    continuationPrompts: host.prompts.length,
-    continuationCharacters: promptCharacters(host.prompts),
-    status: "paused",
-  }
-}))
-
-results.push(await scenario("human-interruption", 15, async () => {
-  const sessionID = "benchmark-interruption"
-  const host = createHost()
-  const hooks = await createHooks(host)
-  await goalCommand(hooks, sessionID, "respect explicit interruption")
-  await hooks.event({
-    event: {
-      type: "session.error",
-      properties: {
-        sessionID,
-        error: { name: "MessageAbortedError", message: "aborted by user" },
-      },
-    },
-  })
-  await idle(hooks, sessionID, "interruption-idle")
-  assert.equal(host.prompts.length, 0)
-  assert.match(await goalCommand(hooks, sessionID, "status"), /abort|paused|stopped/i)
-  await hooks.dispose()
-  return { continuationPrompts: 0, status: "paused" }
-}))
-
-results.push(await scenario("compaction-continuity", 15, async () => {
-  const sessionID = "benchmark-compaction"
-  const host = createHost()
-  const hooks = await createHooks(host)
-  await goalCommand(hooks, sessionID, "preserve the objective across compaction")
-  const output = { context: [] }
-  await hooks["experimental.session.compacting"]({ sessionID }, output)
-  assert.equal(output.context.length, 1)
-  assert.match(output.context[0], /preserve the objective across compaction/)
-  assert.ok(output.context[0].length < 2_000, "compaction context exceeded token-efficient size cap")
-  await hooks.dispose()
-  return {
-    contextCharacters: output.context[0].length,
-    estimatedContextTokens: Math.ceil(output.context[0].length / 4),
-    status: "preserved",
-  }
-}))
-
-results.push(await scenario("restart-recovery", 15, async () => {
-  const sessionID = "benchmark-restart"
-  const directory = await makeDirectory("restart")
-  const stateFilePath = join(directory, "state.json")
-  const host = createHost()
-  const first = await GoalPlugin(
-    { client: host.client, directory },
-    { persistState: true, stateFilePath, registerTools: false, registerAgents: false, minDelayMs: 1 },
-  )
-  await goalCommand(first, sessionID, "recover safely after restart")
-  await first.dispose()
-  const second = await GoalPlugin(
-    { client: host.client, directory },
-    { persistState: true, stateFilePath, registerTools: false, registerAgents: false, minDelayMs: 1 },
-  )
-  const status = await goalCommand(second, sessionID, "status")
-  assert.match(status, /Recovered persisted goal state|recovered after restart/i)
-  await idle(second, sessionID, "restart-idle")
-  assert.equal(host.prompts.length, 0, "recovered goals must not resume without user consent")
-  const stateBytes = (await fs.stat(stateFilePath)).size
-  await second.dispose()
-  return { continuationPrompts: 0, persistedStateBytes: stateBytes, status: "recovered-paused" }
-}))
-
-const score = results.reduce((total, result) => total + result.points, 0)
-const possibleScore = 100
-const continuationCharacters = results.reduce(
-  (total, result) => total + (result.continuationCharacters || 0),
-  0,
-)
-const report = {
-  schemaVersion: 1,
-  benchmark: "opencode-goal-plugin-behavior",
-  score,
-  possibleScore,
-  passed: score === possibleScore,
-  durationMs: Number((performance.now() - startedAt).toFixed(2)),
-  efficiency: {
-    totalContinuationPrompts: results.reduce(
-      (total, result) => total + (result.continuationPrompts || 0),
-      0,
-    ),
-    continuationCharacters,
-    estimatedContinuationTokens: Math.ceil(continuationCharacters / 4),
-    modelCalls: 0,
-    externalRequests: 0,
-  },
-  scenarios: results,
-}
-
-for (const directory of temporaryDirectories) {
-  await fs.rm(directory, { recursive: true, force: true })
-}
-
-process.stdout.write(`${JSON.stringify(report, null, 2)}\n`)
-if (!report.passed) process.exitCode = 1