litmus-cli 1.4.32 → 1.4.33

package/dist/lib/hook-logger.cjs

@@ -7,10 +7,13 @@
  * Reads the tool's JSON payload on stdin and normalizes it to one of:
  *   { ts, type: "ai_prompt",   tool, prompt, sessionId? }  — prompt-submit hooks
  *   { ts, type: "ai_response", tool, text,   sessionId? }  — post-response hooks (ENG-1323)
+ *   { ts, type: "capture_selftest_probe", tool, nonce }    — the CLI's own capture
+ *                                                            self-test (ENG-2477)
  * appends it to the assessment's activity.jsonl, and uploads it (awaited,
  * bounded — see uploadEvent). Which shape applies is decided by the payload's
  * `hook_event_name`, not argv — the same logger command is registered for both
- * event kinds per tool.
+ * event kinds per tool — except the probe, which is marked by a
+ * `litmus_selftest` field no tool sends (see main()).
  *
  * An `ai_response` may additionally carry the turn's metering, when the tool's
  * payload has it: `model`, `input_tokens`, `output_tokens`, `cache_read_tokens`,
@@ -27,6 +30,9 @@
  *           `stop` and this branch is unreachable there)
  *           stop payload -> read transcript_path (JSONL), the final turn's
  *           answer, plus the payload's own model + token counts
+ *           afterFileEdit payload -> no event of its own: the file the agent
+ *           edited is ledgered and rides the turn's `ai_response` as
+ *           ENG-2191 `file_writes` (ENG-2344, see the Cursor edits block)
  *   copilot Stop payload -> read transcript_path (JSONL), assistant.message
  *           entries of the final turn (VS Code shape; CLI best-effort)
  *   gemini  AfterAgent payload -> `prompt_response` directly (arrives inline;
@@ -665,11 +671,27 @@ function buildDrainFrame(event, hookEventName) {
   for (const k of ["model", "input_tokens", "output_tokens", "cache_read_tokens", "status"]) {
     if (event[k] !== undefined) frame[k] = event[k]
   }
+  // ENG-2344: the files Cursor's own `afterFileEdit` hook reported the agent
+  // editing on this turn, in ENG-2191's `file_writes` shape. Carried whole
+  // ahead of the body: the attribution is the part of this record a reader
+  // cannot infer from anything else, where a trimmed reply is still a reply.
+  if (event.file_writes && typeof event.file_writes === "object") {
+    frame.file_writes = event.file_writes
+  }
   frame.text = body
   // Trim the BODY only, so the metering and the pairing ids always survive —
   // they are what makes a truncated record still worth having, and they cost a
   // fixed ~200 bytes.
-  if (!trimEventToBytes(frame, "text", MAX_DRAIN_FRAME_BYTES)) return null
+  if (!trimEventToBytes(frame, "text", MAX_DRAIN_FRAME_BYTES)) {
+    // The writes alone outgrew the datagram (forty long paths can). Losing the
+    // whole reply frame to them would be the wrong trade — the file copy still
+    // holds them — so drop them from THIS copy, say so, and trim the body again.
+    if (frame.file_writes === undefined) return null
+    delete frame.file_writes
+    frame.fileWritesDropped = true
+    frame.text = body
+    if (!trimEventToBytes(frame, "text", MAX_DRAIN_FRAME_BYTES)) return null
+  }
   if (!frame.text) return null   // trimmed to nothing: a husk with a turn id and
                                  // no content reads downstream as a captured
                                  // prompt that said nothing. Send no frame.
@@ -1338,13 +1360,250 @@ function startTurn(sessionId) {
 
 /** The turn id of this session's most recent prompt, if any. */
 function currentTurn(sessionId) {
-  if (!sessionId) return null
+  return currentTurnRecord(sessionId).turnId
+}
+
+/** The most recent prompt's turn id AND the instant it was minted, so a
+ *  ledger keyed on the session can be cut at the turn's start. */
+function currentTurnRecord(sessionId) {
+  if (!sessionId) return { turnId: null, ts: null }
   try {
     const data = JSON.parse(fs.readFileSync(turnFile(sessionId), "utf8"))
-    return typeof data.turnId === "string" ? data.turnId : null
+    return {
+      turnId: typeof data.turnId === "string" ? data.turnId : null,
+      ts: typeof data.ts === "number" && Number.isFinite(data.ts) ? data.ts : null,
+    }
+  } catch {
+    return { turnId: null, ts: null }
+  }
+}
+
+// ── Cursor's agent edits (ENG-2344) ──────────────────────────────────
+// Composer routes its model traffic to Cursor's own backend, so neither the
+// gateway nor the in-container MITM ever sees the tool call that writes a file
+// — ENG-2191's extractor names Cursor's agent as its one blind spot. And the
+// editor-capture extension (ENG-2211) sees an agent write to a file that is not
+// open in a tab only as a bare watcher item: a path and a count, with none of
+// the shape the reader turns into "AI wrote". Measured on production (candidate
+// retest, 2026-09-16): the whole record of a Composer rewrite was one `fs` item.
+// So the report could show what was asked and what the model answered, and
+// nothing in it said the model wrote the file.
+//
+// Cursor's hooks API carries that fact itself. `afterFileEdit` fires AFTER the
+// agent modifies a file, with `file_path` and the `edits` it applied
+// (cursor.com/docs/agent/hooks; one of the six events measured on 3.17.19,
+// litmus-firstboot §5b). It is Cursor's own statement that its agent edited
+// the file — the direct mechanism, where correlating a prompt with a nearby
+// `fs_write` would be a guess dressed as a record.
+//
+// WHAT IS RECORDED, AND WHERE. Metadata only, in ENG-2191's `file_writes`
+// shape so every reader of that field renders it with no Cursor branch: the
+// path, the byte count of what was placed, and the number of edits. Never the
+// edit text — `old_string`/`new_string` are file contents, and storing them is
+// the cap decision ENG-2191 deferred. Each hook invocation is its own process,
+// so an edit is written as ONE FILE OF ITS OWN into a per-session ledger
+// directory beside the turn file, and the invocation that writes the turn's
+// `ai_response` folds the ledger into it as intents each paired with an
+// `ok: true` outcome: the tool reported the edit applied, which is exactly what
+// ENG-2191's "confirmed" state means. Not more — a candidate can revert every
+// line afterwards, and nothing here sees that.
+//
+// THE LEDGER NEVER LOSES AN EDIT TO A RACE, AND NEVER REPORTS ONE TWICE, BY
+// CONSTRUCTION. Three shapes were tried and rejected on review of #2606: a
+// shared append-only file consumed by read-then-unlink deletes an append that
+// lands between the two; claiming it by rename only narrows that window; and a
+// directory of one file per edit that the consumer lists, reads and later
+// unlinks lets TWO consumers (the IDE fires `afterAgentResponse` and `stop` for
+// one turn, as separate processes) fold the same edit into two replies, and
+// deleted edits past the cap unread. So: each edit is written to a temp name
+// and renamed into the directory (a consumer never sees a partial file), and a
+// consumer CLAIMS each file by renaming it to a name only it knows, which is
+// atomic and exclusive — of two consumers racing for one file, exactly one
+// rename succeeds. It claims at most the cap and leaves the rest untouched,
+// unlinks its claims ONLY AFTER the reply carrying them is in `activity.jsonl`,
+// and hands them back under their original names if that append fails. A
+// claim a crashed consumer left behind is handed back by the next consumer
+// once it is older than any hook could still be running. Whatever is left for
+// a later reply is carried flagged `late` (it belongs to an earlier turn)
+// rather than dropped: a lost edit is unobservable, so a reader can never
+// report it, and a flagged one is a visible fact. The only remaining loss is a
+// `stop` that never fires at all, which is the dependency ENG-2191 also has on
+// the next request for its outcomes.
+//
+// FOLDED ONTO THE REPLY, NOT EMITTED PER EDIT. One turn routinely edits several
+// files; one event per edit would be one drain frame, one row and one dedupe
+// key each, and would bury the reply under its own edits.
+//
+// NOT FORGE-RESISTANT, like everything on this lane: the hook is in the
+// candidate's own config and the event is `selfReported`. A missing record is
+// "not captured", never a finding.
+const CURSOR_EDIT_EVENT = "afterFileEdit"
+// The `tool` an intent carries: Cursor's own name for the event, since the wire
+// names no tool. It is what the reader keys its "reported editing" heading on.
+const CURSOR_EDIT_TOOL = "afterFileEdit"
+// ENG-2191's caps, restated so the two lanes' records are the same size.
+const MAX_EDIT_INTENTS = 40
+const MAX_EDIT_PATH_CHARS = 512
+// A claim older than this belongs to a consumer that died between claiming
+// and committing (no hook runs for ten minutes), and is handed back.
+const EDIT_CLAIM_STALE_MS = 10 * 60 * 1000
+const EDIT_CLAIM_PREFIX = ".claimed."
+
+function editLedgerDir(sessionId) {
+  const safe = String(sessionId).replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 128)
+  return path.join(TURNS_DIR, `${safe}.edits`)
+}
+
+/** Bytes of UTF-8 an `afterFileEdit` payload's edits placed in the file. */
+function editBytes(edits) {
+  let bytes = 0
+  for (const e of edits) {
+    if (e && typeof e === "object" && typeof e.new_string === "string") {
+      bytes += Buffer.byteLength(e.new_string, "utf8")
+    }
+  }
+  return bytes
+}
+
+/**
+ * One `afterFileEdit` payload -> one ledger line, or nothing. Returns the line
+ * written (for tests), null when the payload carried no usable path.
+ *
+ * Claimed like a prompt is, keyed on the generation and the edit itself: Cursor
+ * merges every config source it finds, so a version that starts honouring the
+ * baked enterprise file would fire this twice per edit with identical payloads.
+ */
+function recordCursorFileEdit(data, sessionId, assessmentRoot) {
+  if (!data || typeof data !== "object" || !sessionId) return null
+  const filePath = typeof data.file_path === "string" ? data.file_path.trim() : ""
+  if (!filePath) return null
+  // The edited FILE must sit inside the assessment that resolved, not merely
+  // beside one of the session's roots: a multi-root Cursor window can hold the
+  // assessment and an unrelated project, and `workspace_roots` resolving is a
+  // statement about the window, not about this path (Greptile on #2606).
+  // realpath'd on both sides for the macOS /var and symlinked-home reason
+  // `realpathOrNull` gives; a path that does not exist yet (a `Write` of a new
+  // file the hook reports before it is visible) is compared as given.
+  if (!assessmentRoot) return null
+  const root = realpathOrNull(assessmentRoot) || assessmentRoot
+  const real = realpathOrNull(filePath) || path.resolve(filePath)
+  if (!isAtOrUnder(real, root) || real === root) return null
+  const edits = Array.isArray(data.edits) ? data.edits : []
+  const line = {
+    id: crypto.randomUUID(),
+    tool: CURSOR_EDIT_TOOL,
+    path: filePath.length > MAX_EDIT_PATH_CHARS ? filePath.slice(0, MAX_EDIT_PATH_CHARS - 1) + "…" : filePath,
+    bytes: editBytes(edits),
+    edits: edits.length,
+    ts: Date.now(),
+  }
+  const digest = crypto.createHash("sha256").update(JSON.stringify([filePath, edits])).digest("hex").slice(0, 16)
+  const gen = typeof data.generation_id === "string" && data.generation_id ? data.generation_id : null
+  if (gen && !claimPrompt(`${gen}.edit.${digest}`)) return null
+  try {
+    const dir = editLedgerDir(sessionId)
+    fs.mkdirSync(dir, { recursive: true })
+    // Written whole under a temp name and renamed into place, so a consumer
+    // listing the directory never reads a half-written file. The name sorts by
+    // arrival, and the id keeps two edits in one millisecond apart.
+    const name = `${String(line.ts).padStart(15, "0")}-${line.id}.json`
+    const tmp = path.join(dir, `.${name}.tmp`)
+    fs.writeFileSync(tmp, JSON.stringify(line))
+    fs.renameSync(tmp, path.join(dir, name))
+  } catch {
+    return null // unwritable HOME: the edit is not recorded, and nothing else is affected
+  }
+  return line
+}
+
+/**
+ * Claim up to the cap of this session's ledger files for the reply being
+ * written now, and fold them into a `file_writes` value. Returns null when
+ * there is nothing to say; otherwise `{ writes, commit, abort }`, where
+ * `commit` deletes exactly the files claimed and `abort` hands them back
+ * under their original names. Nothing is deleted here: the caller commits
+ * only once the reply carrying these writes is in `activity.jsonl`.
+ *
+ * Each file is claimed by an exclusive rename before it is read, so two
+ * consumers running at once (the IDE's `afterAgentResponse` and `stop`) can
+ * never fold the same edit twice, and files past the cap are not touched at
+ * all — they ride the next reply. An entry older than this turn's start
+ * belongs to an earlier turn and is carried flagged `late` rather than
+ * dropped, for the reason in the ledger block above. A claimed file that does
+ * not parse is handed straight back: it is either damaged or not ours, and
+ * deleting it is the one way to make it unobservable.
+ */
+function takeCursorFileEdits(sessionId, turnStartMs) {
+  if (!sessionId) return null
+  const dir = editLedgerDir(sessionId)
+  let entries = []
+  try {
+    entries = fs.readdirSync(dir)
   } catch {
     return null
   }
+  // Hand back what a dead consumer left claimed, so it is not lost with it.
+  const now = Date.now()
+  for (const name of entries) {
+    if (!name.startsWith(EDIT_CLAIM_PREFIX)) continue
+    const original = name.slice(name.indexOf(".", EDIT_CLAIM_PREFIX.length) + 1)
+    try {
+      if (now - fs.statSync(path.join(dir, name)).mtimeMs > EDIT_CLAIM_STALE_MS && original) {
+        fs.renameSync(path.join(dir, name), path.join(dir, original))
+      }
+    } catch { /* raced with its owner, or already handed back */ }
+  }
+  let names = []
+  try {
+    names = fs.readdirSync(dir).filter((n) => n.endsWith(".json") && !n.startsWith(".")).sort()
+  } catch {
+    return null
+  }
+  const intents = []
+  const outcomes = []
+  const claimed = []   // [claimedName, originalName]
+  for (const name of names) {
+    if (intents.length >= MAX_EDIT_INTENTS) break
+    const mine = `${EDIT_CLAIM_PREFIX}${process.pid}.${name}`
+    try {
+      fs.renameSync(path.join(dir, name), path.join(dir, mine))
+      // A rename keeps the file's mtime, which is when the EDIT was recorded.
+      // The stale check above measures when it was CLAIMED, so stamp that now
+      // (Greptile on #2606): without it a live claim on an edit that waited
+      // ten minutes for its reply reads as abandoned and is claimed twice.
+      const t = new Date()
+      try { fs.utimesSync(path.join(dir, mine), t, t) } catch { /* age reads as the edit's; see below */ }
+    } catch {
+      continue // another consumer has it, or it is already gone
+    }
+    let line
+    try { line = JSON.parse(fs.readFileSync(path.join(dir, mine), "utf8")) } catch { line = null }
+    if (!line || typeof line !== "object" || typeof line.path !== "string" || typeof line.id !== "string") {
+      try { fs.renameSync(path.join(dir, mine), path.join(dir, name)) } catch { /* leave it */ }
+      continue
+    }
+    claimed.push([mine, name])
+    const intent = { id: line.id, tool: CURSOR_EDIT_TOOL, path: line.path }
+    if (typeof line.bytes === "number" && Number.isFinite(line.bytes)) intent.bytes = Math.max(0, Math.trunc(line.bytes))
+    if (typeof line.edits === "number" && Number.isFinite(line.edits)) intent.edits = Math.max(0, Math.trunc(line.edits))
+    if (typeof turnStartMs === "number" && typeof line.ts === "number" && line.ts < turnStartMs) intent.late = true
+    intents.push(intent)
+    outcomes.push({ id: line.id, ok: true })
+  }
+  if (intents.length === 0) return null
+  return {
+    writes: { intents, outcomes },
+    commit() {
+      for (const [mine] of claimed) {
+        try { fs.unlinkSync(path.join(dir, mine)) } catch { /* already gone */ }
+      }
+    },
+    abort() {
+      for (const [mine, name] of claimed) {
+        try { fs.renameSync(path.join(dir, mine), path.join(dir, name)) } catch { /* already gone */ }
+      }
+    },
+  }
 }
 
 // Keep the markers from accumulating in the candidate's HOME forever. Cheap: this
@@ -1411,6 +1670,40 @@ function claimPrompt(generationId) {
   }
 }
 
+/**
+ * The assessment's `.litmus` dir for this payload, or null.
+ *
+ * Where the TOOL says this session is: workspace roots (Cursor) or the
+ * payload's own cwd (Claude Code, Codex, Copilot CLI). VS Code Copilot Chat
+ * reports neither. Two uses: checking the explicit path (ENG-1311), and
+ * picking the RIGHT registry entry when walk-up finds nothing (ENG-1323 — see
+ * findLitmusDir).
+ *
+ * Explicit hint first: it is correct by construction — but only once it
+ * agrees with the session's own reported location, since the hook config
+ * naming it can be copied into another project (ENG-1311). On disagreement
+ * it is dropped and the session resolves on its own merits.
+ *
+ * Those merits include every location the tool reported, cwd included. The
+ * reported cwd beats this process's cwd (a hook runner's need not be the
+ * session's) and is the only pointer left once a copied explicit path has
+ * been rejected — without it a rejected Copilot prompt, which carries no
+ * workspace roots, would fall through to the registry and be filed against
+ * an unrelated assessment.
+ */
+function resolveAssessmentDir(parsed, workspaceRoots) {
+  const sessionDirs = [
+    ...(workspaceRoots || []),
+    ...(parsed && typeof parsed.cwd === "string" && parsed.cwd ? [parsed.cwd] : []),
+  ]
+  const trustExplicit = explicitAssessmentDir
+    && explicitAgreesWithSession(explicitAssessmentDir, sessionDirs)
+  const hintDirs = trustExplicit
+    ? [explicitAssessmentDir, ...sessionDirs]
+    : sessionDirs
+  return findLitmusDir(hintDirs, sessionDirs)
+}
+
 async function main() {
   emitCursorVerdictIfNeeded()
 
@@ -1426,6 +1719,26 @@ async function main() {
   try { parsed = JSON.parse(raw) } catch { /* extractPrompt reports the failure */ }
   const cursorShaped = isCursorPayload(parsed)
 
+  // ENG-2477: a capture SELF-TEST probe. `litmus init` (and `litmus doctor`)
+  // run this script the way the tool would — the tool's own payload shape, on
+  // stdin, through the command string in the tool's own config file — plus
+  // this one field no tool sets, and then ask the backend whether the event
+  // arrived. Everything below runs unchanged on purpose: the tool's real
+  // extractPrompt branch, the real assessment resolution, the real file
+  // append and the real awaited upload, because the thing being proved is the
+  // path a candidate's prompt will take. Only the RECORD differs. It is typed
+  // `capture_selftest_probe`, never `ai_prompt`, so no reader counts it as a
+  // prompt (activity_events.PROMPT_EVENT_TYPES and cli-tracking.ts's channel
+  // map both leave it out), it opens no turn, and it revives no watcher. The
+  // nonce is what the CLI looks for on the other end. A logger from before
+  // this shipped would record the same payload as an `ai_prompt` whose text
+  // carries the nonce — the read-back matches on the nonce, not the type, so
+  // that still reads as "arrived".
+  const selftestNonce = parsed && typeof parsed.litmus_selftest === "string"
+    && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(parsed.litmus_selftest)
+    ? parsed.litmus_selftest.toLowerCase()
+    : null
+
   // The relabel is what makes the claim below label-safe: whichever invocation
   // wins the race, a Cursor-shaped payload is recorded as tool="cursor", so the
   // event never blames Claude Code for a prompt it had no part in.
@@ -1450,6 +1763,19 @@ async function main() {
     return
   }
 
+  // ENG-2344: Cursor's own report that its agent edited a file. Nothing to
+  // upload yet — it is ledgered against the session and rides the turn's reply.
+  // Gated on the same assessment resolution a prompt gets, so an edit in a
+  // project that is not the assessment is not written anywhere.
+  if (effectiveTool === "cursor" && parsed && parsed.hook_event_name === CURSOR_EDIT_EVENT) {
+    const roots = Array.isArray(parsed.workspace_roots) ? parsed.workspace_roots : []
+    const editLitmusDir = resolveAssessmentDir(parsed, roots)
+    if (!editLitmusDir) return
+    recordCursorFileEdit(parsed, parsed.session_id || parsed.conversation_id || null,
+                         path.dirname(editLitmusDir))
+    return
+  }
+
   let content = null
   let sessionId = null
   let workspaceRoots = []
@@ -1472,33 +1798,7 @@ async function main() {
   }
   if (!content) return
 
-  // Where the TOOL says this session is: workspace roots (Cursor) or the
-  // payload's own cwd (Claude Code, Codex, Copilot CLI). VS Code Copilot Chat
-  // reports neither. Two uses: checking the explicit path below (ENG-1311), and
-  // picking the RIGHT registry entry when walk-up finds nothing (ENG-1323 — see
-  // findLitmusDir).
-  const sessionDirs = [
-    ...(workspaceRoots || []),
-    ...(parsed && typeof parsed.cwd === "string" && parsed.cwd ? [parsed.cwd] : []),
-  ]
-
-  // Explicit hint first: it is correct by construction — but only once it
-  // agrees with the session's own reported location, since the hook config
-  // naming it can be copied into another project (ENG-1311). On disagreement
-  // it is dropped and the session resolves on its own merits.
-  //
-  // Those merits include every location the tool reported, cwd included. The
-  // reported cwd beats this process's cwd (a hook runner's need not be the
-  // session's) and is the only pointer left once a copied explicit path has
-  // been rejected — without it a rejected Copilot prompt, which carries no
-  // workspace roots, would fall through to the registry and be filed against
-  // an unrelated assessment.
-  const trustExplicit = explicitAssessmentDir
-    && explicitAgreesWithSession(explicitAssessmentDir, sessionDirs)
-  const hintDirs = trustExplicit
-    ? [explicitAssessmentDir, ...sessionDirs]
-    : sessionDirs
-  const litmusDir = findLitmusDir(hintDirs, sessionDirs)
+  const litmusDir = resolveAssessmentDir(parsed, workspaceRoots)
   if (!litmusDir) return
 
   // Claim as LATE as possible — only once we know we have content and somewhere
@@ -1521,21 +1821,29 @@ async function main() {
 
   // Pair the two invocations: a prompt opens a turn, its response inherits the
   // same id. See the turn-pairing block above.
-  const turnId = responseEvent ? currentTurn(sessionId) : startTurn(sessionId)
+  const turnRecord = responseEvent && !selftestNonce ? currentTurnRecord(sessionId) : null
+  const turnId = selftestNonce ? null : responseEvent ? turnRecord.turnId : startTurn(sessionId)
 
-  const event = responseEvent
+  const event = selftestNonce
     ? {
       ts: new Date().toISOString(),
-      type: "ai_response",
+      type: "capture_selftest_probe",
       tool: effectiveTool,
-      text: truncated,
-    }
-    : {
-      ts: new Date().toISOString(),
-      type: "ai_prompt",
-      tool: effectiveTool,
-      prompt: truncated,
+      nonce: selftestNonce,
     }
+    : responseEvent
+      ? {
+        ts: new Date().toISOString(),
+        type: "ai_response",
+        tool: effectiveTool,
+        text: truncated,
+      }
+      : {
+        ts: new Date().toISOString(),
+        type: "ai_prompt",
+        tool: effectiveTool,
+        prompt: truncated,
+      }
   // ENG-1962: ONE id per captured event, minted here — before either copy is
   // written — so the copy in `activity.jsonl` and the copy that goes down the
   // drain carry the same one and collapse into a single stored event.
@@ -1556,6 +1864,14 @@ async function main() {
   event.id = crypto.randomUUID()
   if (sessionId) event.sessionId = sessionId
   if (turnId) event.turnId = turnId
+  // ENG-2344: the files Cursor's `afterFileEdit` hook reported the agent
+  // editing since this turn's prompt, folded onto its reply. Attached BEFORE
+  // the byte-cap loop, like the metering, so the body is trimmed around it.
+  let editLedger = null
+  if (responseEvent && effectiveTool === "cursor" && !selftestNonce) {
+    editLedger = takeCursorFileEdits(sessionId, turnRecord ? turnRecord.ts : null)
+    if (editLedger) event.file_writes = editLedger.writes
+  }
   // The turn's model and token counts (ENG-1956). Attached BEFORE the byte-cap
   // loop below so their bytes are counted against the same budget the body is
   // trimmed to fit — otherwise a reply trimmed to exactly the cap could be
@@ -1587,11 +1903,19 @@ async function main() {
 
   // 1. Append to activity.jsonl (for submission ZIP)
   const logPath = path.join(litmusDir, "activity.jsonl")
+  let logged = false
   try {
     fs.appendFileSync(logPath, JSON.stringify(event) + "\n")
+    logged = true
   } catch {
     // Non-critical
   }
+  // ENG-2344: the edits this reply carries leave the ledger only now that the
+  // reply is on disk. An append that failed hands them back for the next reply.
+  if (editLedger) {
+    if (logged) editLedger.commit()
+    else editLedger.abort()
+  }
 
   // 1b. Same moment, second copy: onto the root drain, where the candidate
   // cannot edit or delete it afterwards (ENG-1962). Additive — step 1 above
@@ -1605,7 +1929,9 @@ async function main() {
 
   // 3. Revive a dead watcher (ENG-1491). Strictly after the capture/upload
   // work — this is a courtesy, and it must never cost the prompt anything.
-  maybeReviveWatcher(litmusDir, config)
+  // Not on a self-test probe: init is about to start the tracker itself, and
+  // doctor has already dealt with it.
+  if (!selftestNonce) maybeReviveWatcher(litmusDir, config)
 
   // No explicit process.exit() — the event loop drains naturally once the upload
   // has settled and its timers are cleared (the revival spawn is unref'd).
@@ -1617,6 +1943,11 @@ module.exports = {
   reviveThrottleAllows,
   buildDrainFrame,
   trimEventToBytes,
+  recordCursorFileEdit,
+  takeCursorFileEdits,
+  CURSOR_EDIT_EVENT,
+  CURSOR_EDIT_TOOL,
+  MAX_EDIT_INTENTS,
   WATCHER_NONCE_MAX_AGE_MS,
   REVIVE_THROTTLE_MS,
   MAX_DRAIN_FRAME_BYTES,

package/dist/lib/schemas.d.ts

@@ -29,6 +29,10 @@ export declare const SubmitStatusSchema: z.ZodObject<{
     videoUploaded: z.ZodBoolean;
 }, z.core.$strip>;
 export type SubmitStatus = z.infer<typeof SubmitStatusSchema>;
+export declare const CaptureSelftestSchema: z.ZodObject<{
+    arrived: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type CaptureSelftest = z.infer<typeof CaptureSelftestSchema>;
 export declare const WorkspaceConnectionSchema: z.ZodObject<{
     workspace_status: z.ZodString;
     ssh_hostname: z.ZodOptional<z.ZodNullable<z.ZodString>>;

package/dist/lib/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/lib/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,kBAAkB;;;;;;;;;;;iBAgB7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,kBAAkB;;;;;iBAQ7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAK7D,eAAO,MAAM,iBAAiB;;;;iBAI5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,kBAAkB;;iBAE7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAM7D,eAAO,MAAM,yBAAyB;;;;;;iBAQpC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAU3E,eAAO,MAAM,sBAAsB;;;;;iBAKjC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/lib/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,kBAAkB;;;;;;;;;;;iBAgB7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,kBAAkB;;;;;iBAQ7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAK7D,eAAO,MAAM,iBAAiB;;;;iBAI5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,kBAAkB;;iBAE7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAI7D,eAAO,MAAM,qBAAqB;;iBAEhC,CAAA;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAMnE,eAAO,MAAM,yBAAyB;;;;;;iBAQpC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAU3E,eAAO,MAAM,sBAAsB;;;;;iBAKjC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/dist/lib/schemas.js

@@ -33,6 +33,11 @@ export const ServerTimesSchema = z.object({
 export const SubmitStatusSchema = z.object({
     videoUploaded: z.boolean(),
 });
+// ENG-2477: GET /cli/activity/selftest — which of the probe nonces the CLI just
+// fired through the installed hooks have landed in candidate_activity_logs.
+export const CaptureSelftestSchema = z.object({
+    arrived: z.array(z.string()),
+});
 // The shape `litmus connect` reads from POST /workspace/start and
 // GET /workspace/connection. Both share ssh_hostname/ssh_command; only
 // /connection carries `healthy`, so it's optional-default-false so a start

package/dist/lib/schemas.js.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../src/lib/schemas.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../src/lib/schemas.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "litmus-cli",
-  "version": "1.4.32",
+  "version": "1.4.33",
   "description": "CLI tool for Litmus engineering assessments",
   "license": "MIT",
   "author": "elenazhao",