opencode-harness-kit 0.5.4 → 0.5.6

package/src/tasks.js

@@ -195,6 +195,12 @@ export const isBlocked = (t) => t.status === "blocked"
  * and its output became one string, and the driver handed that string to a
  * shell. A separate field cannot be mistaken for a command.
  *
+ * The writes happen in ONE order, and the order is part of the contract: the
+ * previous output is removed first, then the status is written, then the new
+ * output is written. A field line ends the output block, so a status line
+ * written before the old output was removed cut that block in half - and the
+ * half that survived was folded into the status by the parser.
+ *
  * @param {string} text
  * @param {Task} task
  * @param {{ status: string, verifyOutput?: string }} outcome
@@ -202,46 +208,100 @@ export const isBlocked = (t) => t.status === "blocked"
  */
 export function markTask(text, task, { status, verifyOutput }) {
   const lines = String(text).split("\n")
-  const boxLine = lines[task.start] ?? ""
+  // The lines of the task as they are RIGHT NOW.
+  //
+  // Every edit below moves the lines under it, so the range of the task is
+  // tracked here. The task the caller parsed was parsed before any of these
+  // edits, so its `end` goes stale as soon as one of them lands.
+  const range = { start: task.start, end: task.end }
+
+  const boxLine = lines[range.start] ?? ""
   // The indentation is part of the document: a task nested under a heading
   // keeps its nesting when it is marked.
-  lines[task.start] = boxLine.replace(
+  lines[range.start] = boxLine.replace(
     /^(\s*)-\s*\[[ xX]\]/,
     (_match, indent) => `${indent}- ${status === "done" ? "[x]" : "[ ]"}`,
   )
 
-  let statusLine = -1
-  for (let i = task.start; i <= task.end + 1 && i < lines.length; i++) {
-    const f = lines[i]?.match(fieldRe)
-    if (f && f[1] === "status") {
-      statusLine = i
-      break
+  // The PREVIOUS output is removed FIRST, before anything else is written
+  // into the task.
+  //
+  // A task that is marked twice keeps one output block, not two.
+  //
+  // It used to be removed after the status line had been written. The
+  // status line is a field line, and a field line ends the output block, so
+  // the removal took the FIRST line of the old output and left its wrapped
+  // lines behind. The parser folds a wrapped line back into the field above
+  // it, so those leftovers were folded into the status - and the status read
+  // back as "done old line 2 old line 3" instead of "done". The task was not
+  // done; it was done with a story attached.
+  if (verifyOutput) {
+    const previous = outputBlock(lines, range)
+    if (previous) {
+      const removed = previous.end - previous.start + 1
+      lines.splice(previous.start, removed)
+      if (previous.end <= range.end) range.end -= removed
     }
   }
-  if (statusLine >= 0) lines[statusLine] = lines[statusLine].replace(
-    /(\s-\s+status\s*:).*$/,
-    `$1 ${status}`,
-  )
 
-  if (verifyOutput) {
-    // A task that is marked twice keeps one output block, not two.
-    const previous = outputBlock(lines, task)
-    if (previous) lines.splice(previous.start, previous.end - previous.start + 1)
+  const statusLine = fieldLine(lines, range, "status")
+  if (statusLine >= 0) {
+    lines[statusLine] = lines[statusLine].replace(
+      /(\s-\s+status\s*:).*$/,
+      `$1 ${status}`,
+    )
+  } else {
+    // A task with no `status:` field had the status EVAPORATE.
+    //
+    // The status was only ever written into a status line that already
+    // existed, so a task marked blocked without one kept its unticked box
+    // and nothing else. The parser reads the status back from that box, so
+    // the block became "pending" - and `nextPending()` offered the blocked
+    // work again. The driver contract says blocked work is never retried.
+    //
+    // The status line is written where the other fields are, so the parser
+    // reads it back the way it reads them - and AFTER the whole block of
+    // the last field, not after the field line itself.
+    //
+    // Written after the field line, the status line landed INSIDE the block
+    // of a field that has wrapped lines under it: the output field, once the
+    // driver has run the task. The parser folded the wrapped lines into the
+    // status, so it read back as "blocked continued", the block was gone,
+    // and the blocked work was offered again.
+    const block = lastFieldBlock(lines, range)
+    const indent = fieldIndent(lines, range, block.field)
+    lines.splice(block.end + 1, 0, `${indent}- status: ${status}`)
+    range.end += 1
+  }
 
-    const verifyLine = fieldLine(lines, task, "verify")
-    const anchor = verifyLine >= 0 ? verifyLine : lastFieldLine(lines, task)
-    const source = lines[anchor] ?? lines[task.start] ?? ""
+  if (verifyOutput) {
+    // The output goes into its own `output:` field rather than under the
+    // `verify:` line. It used to be written as continuation lines under
+    // `verify:`, and the parser folded a continuation back into the field
+    // above it - so the command and its output became one string, and the
+    // driver handed that string to a shell. A separate field cannot be
+    // mistaken for a command.
+    //
+    // It is written after the whole block of the `verify:` field, so it
+    // cannot land inside that block either - a wrapped line under the
+    // verify field would be folded into the output above it.
+    const verifyAt = fieldLine(lines, range, "verify")
+    const block =
+      verifyAt >= 0
+        ? { field: verifyAt, end: fieldBlockEnd(lines, range, verifyAt) }
+        : lastFieldBlock(lines, range)
     // The field line sits at the same level as the field it belongs to; only
     // the continuation lines under it are indented deeper.
-    const fieldIndent = (source.match(/^\s*/) ?? [""])[0]
-    const contIndent = `${fieldIndent}  `
+    const indent = fieldIndent(lines, range, block.field)
+    const contIndent = `${indent}  `
     const quoted = String(verifyOutput)
       .trimEnd()
       .split("\n")
       .map((l) => `${contIndent}${l}`)
     // The first line rides on the field, the rest are continuations of it.
-    const block = [`${fieldIndent}- output: ${quoted[0].trim()}`, ...quoted.slice(1)]
-    lines.splice(anchor + 1, 0, ...block)
+    const written = [`${indent}- output: ${quoted[0].trim()}`, ...quoted.slice(1)]
+    lines.splice(block.end + 1, 0, ...written)
+    range.end += written.length
   }
 
   return lines.join("\n")
@@ -249,46 +309,139 @@ export function markTask(text, task, { status, verifyOutput }) {
 
 /**
  * The line a named field sits on, or -1.
+ *
+ * The scan stops at a task line or a heading: the fields under a nested
+ * task belong to that task, not to the one above it.
+ *
  * @param {string[]} lines
- * @param {Task} task
+ * @param {{ start: number, end: number }} range
  * @param {string} name
  * @returns {number}
  */
-function fieldLine(lines, task, name) {
-  for (let i = task.start; i <= task.end + 1 && i < lines.length; i++) {
-    const f = lines[i]?.match(fieldRe)
+function fieldLine(lines, range, name) {
+  // The scan starts below the task's own line: that line is the task, not
+  // one of its fields.
+  for (let i = range.start + 1; i <= range.end + 1 && i < lines.length; i++) {
+    const line = lines[i] ?? ""
+    if (taskRe.test(line) || headingRe.test(line)) break
+    const f = line.match(fieldRe)
     if (f && f[1] === name) return i
   }
   return -1
 }
 
 /**
- * The last field line of a task, or the task's own line when it has none.
+ * The last line of a field's block: the field line plus the lines wrapped
+ * under it.
+ *
+ * A field line is where a field is written, but it is not the end of the
+ * field: the parser folds a wrapped line back into the value above it, so
+ * the end of the block is the end of the value as the parser reads it. A
+ * field written inside that block takes the wrapped lines with it.
+ *
  * @param {string[]} lines
- * @param {Task} task
+ * @param {{ start: number, end: number }} range
+ * @param {number} fieldAt the line the field is written on
  * @returns {number}
  */
-function lastFieldLine(lines, task) {
-  let last = task.start
-  for (let i = task.start; i <= task.end + 1 && i < lines.length; i++) {
-    if (fieldRe.test(lines[i] ?? "")) last = i
+function fieldBlockEnd(lines, range, fieldAt) {
+  let end = fieldAt
+  for (let i = fieldAt + 1; i <= range.end + 1 && i < lines.length; i++) {
+    const line = lines[i] ?? ""
+    // A task, a heading or the next field ends the block.
+    if (taskRe.test(line) || headingRe.test(line)) break
+    if (fieldRe.test(line)) break
+    // A blank line is not part of the value, but it does not end the block
+    // either: the parser skips it and folds the wrapped line under it back
+    // into the field.
+    if (!line.trim()) continue
+    // A line that is not indented deeper is not a wrapped line.
+    if (!/^\s{4,}\S/.test(line)) break
+    end = i
+  }
+  return end
+}
+
+/**
+ * The last field of a task: the line it is written on, and the last line of
+ * its block.
+ *
+ * `field` is -1 when the task has no field of its own, and `end` is then
+ * the task's own line - the place a first field is written.
+ *
+ * @param {string[]} lines
+ * @param {{ start: number, end: number }} range
+ * @returns {{ field: number, end: number }}
+ */
+function lastFieldBlock(lines, range) {
+  let field = -1
+  // The scan starts below the task's own line: that line is the task, not
+  // one of its fields.
+  for (let i = range.start + 1; i <= range.end + 1 && i < lines.length; i++) {
+    const line = lines[i] ?? ""
+    if (taskRe.test(line) || headingRe.test(line)) break
+    if (fieldRe.test(line)) field = i
   }
-  return last
+  if (field < 0) return { field: -1, end: range.start }
+  return { field, end: fieldBlockEnd(lines, range, field) }
+}
+
+/**
+ * The indentation a field line of a task is written with.
+ *
+ * The fields of a task sit one level deeper than the task itself, so a
+ * field inserted into a task that has none yet follows that convention: a
+ * field at the task's own level reads as a task of its own, or as prose the
+ * parser skips.
+ *
+ * @param {string[]} lines
+ * @param {{ start: number, end: number }} range
+ * @param {number} fieldAt the line the field is written on, or -1 when the
+ *   task has no field of its own yet
+ * @returns {string}
+ */
+function fieldIndent(lines, range, fieldAt) {
+  const source = lines[fieldAt >= 0 ? fieldAt : range.start] ?? ""
+  const own = (source.match(/^\s*/) ?? [""])[0]
+  if (fieldAt < 0) return `${own}  `
+  return own
 }
 
 /**
  * The lines a task's `output:` field occupies, or null when it has none.
+ *
+ * The block ends at the first line that is NOT part of the output - and a
+ * task line or a heading is never part of it, however deeply it is indented.
+ *
+ * The indentation heuristic alone said otherwise: a nested task indented
+ * four spaces or more looked like a continuation of the output above it, so
+ * the block swallowed it and the rewrite DELETED it. The file's own header
+ * promises that every byte the loop does not own survives a rewrite, and a
+ * task the loop never owned was destroyed by marking the task above it.
+ *
+ * A blank line at the end of the block is not part of it: it belongs to the
+ * file, not to the output, and the rewrite must not swallow it.
+ *
  * @param {string[]} lines
- * @param {Task} task
+ * @param {{ start: number, end: number }} range
  * @returns {{ start: number, end: number } | null}
  */
-function outputBlock(lines, task) {
-  const start = fieldLine(lines, task, "output")
+function outputBlock(lines, range) {
+  const start = fieldLine(lines, range, "output")
   if (start < 0) return null
   let end = start
-  for (let i = start + 1; i <= task.end + 1 && i < lines.length; i++) {
-    if (fieldRe.test(lines[i] ?? "")) break
-    if (lines[i].trim() && !/^\s{4,}\S/.test(lines[i])) break
+  for (let i = start + 1; i <= range.end + 1 && i < lines.length; i++) {
+    const line = lines[i] ?? ""
+    // A task or a heading ends the block. This is checked BEFORE the
+    // indentation heuristic, because a nested task is indented deeper than
+    // the field it sits under - that is what nesting means here.
+    if (taskRe.test(line) || headingRe.test(line)) break
+    if (fieldRe.test(line)) break
+    // A blank line is not part of the output, but it does not end the block
+    // either: the parser skips it and folds the wrapped line under it back
+    // into the output.
+    if (!line.trim()) continue
+    if (!/^\s{4,}\S/.test(line)) break
     end = i
   }
   return { start, end }

package/src/telemetry-store.ts

@@ -11,7 +11,7 @@
 //
 // The file is a JSONL in the project, gitignored, and never a network call.
 
-import { appendFileSync, existsSync, mkdirSync, statSync, renameSync } from "node:fs"
+import { appendFileSync, existsSync, mkdirSync, rmSync, statSync, renameSync } from "node:fs"
 import { join } from "node:path"
 
 /** Rotate above this, so a long-running project cannot fill its disk. */
@@ -33,10 +33,33 @@ export function logFiles(dir: string): string[] {
   return out
 }
 
-/** Rotate by size so a long-running project cannot fill its disk. */
-function rotate(file: string) {
+/**
+ * Rotate by size so a long-running project cannot fill its disk.
+ *
+ * THREE generations are kept: the current file, `.1` and `.2`. The reader
+ * enumerates all three, so the writer has to produce all three.
+ *
+ * The rotation used to rename the current file straight to `.1`, and a
+ * rename REPLACES the destination on POSIX - so the previous generation was
+ * destroyed on every rotation and `.2` never came into existence. Two
+ * rotations after the fact, the oldest history was gone and the third
+ * generation the reader looks for was missing: the history a project lost
+ * was lost on a schedule nobody was watching.
+ *
+ * So the oldest is shifted out of the way first, and the oldest of the
+ * three is dropped - the disk use stays bounded at three files, and the
+ * generation that is dropped is the one that was already two rotations
+ * old.
+ *
+ * @param file the file to rotate
+ * @param maxBytes the size above which it is rotated
+ */
+export function rotate(file: string, maxBytes: number = MAX_BYTES) {
   try {
-    if (existsSync(file) && statSync(file).size > MAX_BYTES) {
+    if (existsSync(file) && statSync(file).size > maxBytes) {
+      const oldest = `${file}.2`
+      if (existsSync(oldest)) rmSync(oldest, { force: true })
+      if (existsSync(`${file}.1`)) renameSync(`${file}.1`, oldest)
       renameSync(file, `${file}.1`)
     }
   } catch {

package/src/telemetry.ts

@@ -27,10 +27,24 @@
 // one with a duration, so "how long does this lane take" and "was this lane
 // called at all" are answered from the same file without guessing.
 //
-// The `chat.message` hook is deliberately not used for this. Measured on
-// OpenCode 1.19, its `agent` field is undefined, so it cannot attribute a
-// call to a lane; and a second counter that cannot be correlated with the
-// first would double-count every call.
+// WHERE THE LANE NAME COMES FROM
+//
+// Not from the message. opencode's AssistantMessage has no `agent` field - it
+// has id, role, model, tokens, time and parentID - and the plugin read the
+// agent from exactly that missing field. The lane record was therefore never
+// written: not once, in any session, on any machine. The measurement that
+// decides whether the fleet stays at ten lanes was reading a file that could
+// not exist.
+//
+// The agent name is on the REQUEST. `chat.params` carries the agent and the
+// model of the call that is about to be made, and the user message that call
+// belongs to; the assistant message names that user message as its parent, so
+// the two join.
+//
+// The `chat.message` hook is not used for this. Measured on OpenCode 1.19 its
+// `agent` field is undefined, while `chat.params` declares it as required -
+// and a second counter that cannot be correlated with the first would
+// double-count every call.
 //
 // WHAT A DENIAL LOOKS LIKE HERE
 //
@@ -69,7 +83,47 @@ export const TelemetryPlugin: Plugin = async ({ worktree, directory }) => {
   const opened = new Set<string>()
   const closed = new Set<string>()
 
+  // The lane a request ran on, and the model it ran on, keyed by the id of
+  // the user message the request was made from.
+  //
+  // The assistant message names that user message as its parent, so this is
+  // how a call is attributed to a lane.
+  //
+  // The map is bounded: a long session makes a lot of requests, and the map
+  // is only a bridge between a request and the assistant message that
+  // answers it. The oldest entries are dropped once it grows past what a
+  // session needs, so the plugin cannot grow without limit.
+  const requests = new Map<string, { agent?: string; model?: string; provider?: string }>()
+  const REQUEST_MEMORY = 500
+
+  /**
+   * Remember which lane a request was made from.
+   *
+   * @param {any} input the `chat.params` input
+   */
+  const rememberRequest = (input: any) => {
+    const id = input?.message?.id
+    if (typeof id !== "string") return
+    const model = input?.model
+    requests.set(id, {
+      agent: typeof input?.agent === "string" ? input.agent : undefined,
+      model: typeof model?.modelID === "string" ? model.modelID : undefined,
+      provider: typeof model?.providerID === "string" ? model.providerID : undefined,
+    })
+    if (requests.size > REQUEST_MEMORY) {
+      // The oldest first: a Map keeps its insertion order.
+      const oldest = requests.keys().next()
+      if (!oldest.done) requests.delete(oldest.value)
+    }
+  }
+
   return {
+    "chat.params": async (input: any) => {
+      // The lane and the model of the call that is about to be made. This is
+      // the only place opencode says which agent is running.
+      rememberRequest(input)
+    },
+
     event: async ({ event }: any) => {
       // Events are provider-specific and opencode may add shapes we have never
       // seen. Anything unrecognised is ignored rather than trusted.
@@ -91,7 +145,7 @@ export const TelemetryPlugin: Plugin = async ({ worktree, directory }) => {
       // on which model, and how long it took. That record is what makes "cut
       // the lanes nobody uses" a measurement instead of a guess.
       if (type === "message.updated") {
-        const lane = laneOf(event)
+        const lane = laneOf(event, requests)
         if (!lane || !lane.id) return
         if (lane.ms !== undefined) {
           // The completed event. Written once, and only if the open record
@@ -142,7 +196,10 @@ export const TelemetryPlugin: Plugin = async ({ worktree, directory }) => {
  *
  * The message id is what makes the record countable: one message is one call.
  */
-function laneOf(event: unknown): {
+function laneOf(
+  event: unknown,
+  requests: Map<string, { agent?: string; model?: string; provider?: string }>,
+): {
   id?: string
   agent?: string
   model?: string
@@ -159,9 +216,12 @@ function laneOf(event: unknown): {
   if (info.role && info.role !== "assistant") return null
 
   const id = typeof info.id === "string" ? info.id : undefined
-  const agent = typeof info.agent === "string" ? info.agent : undefined
-  const modelId = info.model?.modelID ?? info.modelID
-  const providerId = info.model?.providerID ?? info.providerID
+  // The request this message answers. The message does not name the agent;
+  // the request does, and the parent id is the join.
+  const parent = typeof info.parentID === "string" ? requests.get(info.parentID) : undefined
+  const agent = parent?.agent ?? (typeof info.agent === "string" ? info.agent : undefined)
+  const modelId = parent?.model ?? info.model?.modelID ?? info.modelID
+  const providerId = parent?.provider ?? info.model?.providerID ?? info.providerID
   const time = info.time ?? {}
   const created = typeof time.created === "number" ? time.created : undefined
   const completed = typeof time.completed === "number" ? time.completed : undefined