@rubytech/create-realagent 1.0.617 → 1.0.619

package/payload/server/public/index.html

@@ -5,7 +5,7 @@
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Real Agent</title>
   <link rel="icon" href="/favicon.ico">
-  <script type="module" crossorigin src="/assets/admin-Df1liz4Y.js"></script>
+  <script type="module" crossorigin src="/assets/admin-D7LRdkYB.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/chunk-Be6NvmcD.js">
   <link rel="modulepreload" crossorigin href="/assets/preload-helper-rov5CBGT.js">
   <link rel="modulepreload" crossorigin href="/assets/useVoiceRecorder-OB_Gtr0e.js">

package/payload/server/server.js

@@ -6211,14 +6211,22 @@ function purgeOldLogs(logDir, prefix) {
   }
 }
 function teeProcStderrToStreamLog(proc, streamLog) {
+  const pid = proc.pid;
   if (!proc.stderr) {
-    streamLog.write(`[${isoTs()}] [subproc-stderr-skip] reason=no-stderr
+    streamLog.write(`[${isoTs()}] [subproc-stderr-skip] reason=no-stderr pid=${pid}
 `);
     return;
   }
+  if (!streamLog.destroyed && !streamLog.writableEnded) {
+    streamLog.write(`[${isoTs()}] [subproc-stderr-tee-attached] pid=${pid}
+`);
+  }
   const utf8 = new StringDecoder("utf8");
   let buffer = "";
+  let bytesSeen = 0;
+  let linesEmitted = 0;
   proc.stderr.on("data", (chunk) => {
+    bytesSeen += typeof chunk === "string" ? Buffer.byteLength(chunk, "utf8") : chunk.length;
     const text = typeof chunk === "string" ? chunk : utf8.write(chunk);
     buffer += text;
     let idx;
@@ -6229,12 +6237,18 @@ function teeProcStderrToStreamLog(proc, streamLog) {
       if (streamLog.destroyed || streamLog.writableEnded) continue;
       streamLog.write(`[${isoTs()}] [subproc-stderr] ${line}
 `);
+      linesEmitted++;
     }
   });
   proc.stderr.on("end", () => {
     const tail = (buffer + utf8.end()).trim();
     if (tail.length > 0 && !streamLog.destroyed && !streamLog.writableEnded) {
       streamLog.write(`[${isoTs()}] [subproc-stderr] ${tail}
+`);
+      linesEmitted++;
+    }
+    if (!streamLog.destroyed && !streamLog.writableEnded) {
+      streamLog.write(`[${isoTs()}] [subproc-stderr-tee-detached] pid=${pid} bytes=${bytesSeen} lines=${linesEmitted}
 `);
     }
     buffer = "";
@@ -8284,10 +8298,11 @@ async function* runCompactionTurn(accountDir, accountId, systemPrompt, resumeSes
     env: {
       ...process.env,
       PLATFORM_ROOT: PLATFORM_ROOT4,
-      ACCOUNT_DIR: accountDir,
-      // Task 532: network traces on the compaction subprocess too — its tool
-      // calls are part of the same conversation's record.
-      NODE_DEBUG: "http,http2,net,tls,undici,dns"
+      ACCOUNT_DIR: accountDir
+      // Task 535: NODE_DEBUG removed. The Claude Code CLI is a bundled Bun
+      // binary and Bun ignores Node's NODE_DEBUG flag, so setting it here was
+      // a no-op that misled future readers. The [subproc-debug-unavailable]
+      // line below records the source-of-silence explicitly.
     }
   });
   const stderrLog = agentLogStream("claude-agent-compaction-stderr", accountDir, conversationId);
@@ -8298,6 +8313,8 @@ async function* runCompactionTurn(accountDir, accountId, systemPrompt, resumeSes
   streamLog.on("error", () => {
   });
   teeProcStderrToStreamLog(proc, streamLog);
+  streamLog.write(`[${isoTs()}] [subproc-debug-unavailable] reason=bundled-bun-binary-ignores-node-debug pid=${proc.pid} cli=claude
+`);
   streamLog.write(`[${isoTs()}] [compaction-start] resumeSessionId=${resumeSessionId}
 `);
   proc.on("error", (err) => {
@@ -9171,11 +9188,11 @@ async function* invokeAdminAgent(message, systemPrompt, accountDir, accountId, a
     env: {
       ...process.env,
       PLATFORM_ROOT: PLATFORM_ROOT4,
-      ACCOUNT_DIR: accountDir,
-      // Task 532: tee subprocess network activity into the per-conversation
-      // stream log via the existing stderr pipe. Closes the Claude Code
-      // "what was the tool actually doing?" black box during tool waits.
-      NODE_DEBUG: "http,http2,net,tls,undici,dns"
+      ACCOUNT_DIR: accountDir
+      // Task 535: NODE_DEBUG removed. The Claude Code CLI is a bundled Bun
+      // binary and Bun ignores Node's NODE_DEBUG flag, so setting it here was
+      // a no-op that misled future readers. The [subproc-debug-unavailable]
+      // line below records the source-of-silence explicitly.
     }
   });
   const stderrLog = agentLogStream("claude-agent-stderr", accountDir, spawnConvId);
@@ -9186,6 +9203,8 @@ async function* invokeAdminAgent(message, systemPrompt, accountDir, accountId, a
   streamLog.on("error", () => {
   });
   teeProcStderrToStreamLog(proc, streamLog);
+  streamLog.write(`[${isoTs()}] [subproc-debug-unavailable] reason=bundled-bun-binary-ignores-node-debug pid=${proc.pid} cli=claude
+`);
   if (sessionKey) {
     const prev = activeProcesses.get(sessionKey);
     if (prev) {
@@ -9513,10 +9532,11 @@ async function* invokeManagedAdminAgent(message, systemPrompt, accountDir, accou
     env: {
       ...process.env,
       PLATFORM_ROOT: PLATFORM_ROOT4,
-      ACCOUNT_DIR: accountDir,
-      // Task 532: tee subprocess network traces into the per-conversation
-      // stream log via the stderr pipe + dual-consume listener.
-      NODE_DEBUG: "http,http2,net,tls,undici,dns"
+      ACCOUNT_DIR: accountDir
+      // Task 535: NODE_DEBUG removed. The Claude Code CLI is a bundled Bun
+      // binary and Bun ignores Node's NODE_DEBUG flag, so setting it here was
+      // a no-op that misled future readers. The [subproc-debug-unavailable]
+      // line below records the source-of-silence explicitly.
     }
   });
   const stderrLog = agentLogStream("claude-agent-stderr", accountDir, managedConvId);
@@ -9524,6 +9544,8 @@ async function* invokeManagedAdminAgent(message, systemPrompt, accountDir, accou
   });
   proc.stderr?.pipe(stderrLog);
   teeProcStderrToStreamLog(proc, streamLog);
+  streamLog.write(`[${isoTs()}] [subproc-debug-unavailable] reason=bundled-bun-binary-ignores-node-debug pid=${proc.pid} cli=claude
+`);
   if (sessionKey) {
     const prev = activeProcesses.get(sessionKey);
     if (prev) {
@@ -10360,8 +10382,10 @@ var VALID_TYPES = /* @__PURE__ */ new Set([
   "silent-catch",
   "file-write-storm",
   "stale-log",
-  "rate-limit"
+  "rate-limit",
+  "absent-followup"
 ]);
+var MAX_FOLLOWUP_WINDOW_MS = 6e5;
 var VALID_SOURCES = /* @__PURE__ */ new Set([
   "any",
   "server",
@@ -10480,6 +10504,46 @@ function defaultRules() {
       scope: "session",
       suggestedAction: "A tool call has been pending for 30 seconds without a result. Read the adjacent [tool-wait-diag] and [tool-wait-proc] lines in the conversation's stream log to determine whether the network remained healthy, the subprocess held active sockets, and the HTTP request reached the wire. If diag shows a healthy network but the subprocess has no [subproc-stderr] UNDICI/HTTP activity during the wait window, the tool's internal pipeline is stalled \u2014 do not retry the same request against the same target without a change in approach."
     },
+    {
+      // Task 536: detect agents ignoring the WEBFETCH_CANNOT_READ_JS_SPA
+      // structured failure. A single SPA short-circuit per conversation is
+      // expected — the hook is doing its job. Two or more in the same
+      // conversation within 5 minutes means either (a) the agent retried
+      // WebFetch on the same SPA URL despite the directive, or (b) the
+      // owner is asking about multiple SPA URLs in one session and the
+      // pattern needs surfacing as a recurring class. Both signal that the
+      // IDENTITY.md "Tool Failure Discipline" guidance is not landing in the
+      // prompt — revise the copy rather than add mechanical enforcement.
+      id: "webfetch-spa-short-circuit-recurring",
+      name: "WebFetch JS-SPA short-circuit fired repeatedly in conversation",
+      type: "repeated-error",
+      logSource: "system",
+      pattern: "WEBFETCH_CANNOT_READ_JS_SPA",
+      thresholdCount: 2,
+      thresholdWindowMinutes: 5,
+      scope: "session",
+      suggestedAction: "The WebFetch SPA preflight has fired more than once in this conversation. Either the agent is ignoring the loud-failure directive (retrying WebFetch after seeing WEBFETCH_CANNOT_READ_JS_SPA), or multiple SPA URLs are being asked about. Read the conversation's stream log for the [tool-use] / [tool-result] sequence around each occurrence \u2014 if the agent dispatched WebFetch on the same URL or substituted Playwright silently, revisit the IDENTITY.md `Tool Failure Discipline` paragraph that names structured-error handling."
+    },
+    {
+      // Task 538: fires when a [spawn] line appears in a conversation's stream
+      // log but no subprocess-lifecycle marker follows within 10s. The three
+      // acceptable followups are Task 535's contract — at least one must be
+      // emitted immediately at every spawn site. Their absence means
+      // `teeProcStderrToStreamLog` regressed, the markers drifted, or the
+      // spawn site was added without wiring them up. Session scope so a single
+      // broken conversation fires exactly once, not N times for every spawn.
+      id: "subproc-tee-silent-spawn",
+      name: "Subprocess spawn without a stderr-tee lifecycle marker",
+      type: "absent-followup",
+      logSource: "system",
+      pattern: "\\[spawn\\] pid=\\d+",
+      followupPattern: "\\[subproc-stderr-tee-attached\\]|\\[subproc-debug-unavailable\\]|\\[subproc-stderr-skip\\]",
+      followupWindowMs: 1e4,
+      thresholdCount: 0,
+      thresholdWindowMinutes: 0,
+      scope: "session",
+      suggestedAction: "The main-subprocess tee infrastructure has regressed \u2014 a spawn produced no lifecycle marker. Re-check `teeProcStderrToStreamLog` is invoked at the spawn site and that `[subproc-debug-unavailable]` or `[subproc-stderr-skip]` is written immediately when the tee cannot attach (Task 535 contract)."
+    },
     {
       // Task 533: surface every Cloudflare-plugin refusal. The plugin emits
       // exactly one [cloudflare:refuse] line per refusal with a structured
@@ -10638,6 +10702,17 @@ function validateRule(input, label, seenIds) {
   };
   if (typeof r.watchPath === "string") rule.watchPath = r.watchPath;
   if (typeof r.staleHours === "number") rule.staleHours = r.staleHours;
+  if (typeof r.followupPattern === "string") {
+    if (r.followupPattern.length > 0) {
+      try {
+        new RegExp(r.followupPattern);
+      } catch (err) {
+        throw new Error(`${label}: followupPattern is not a valid regex: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    rule.followupPattern = r.followupPattern;
+  }
+  if (typeof r.followupWindowMs === "number") rule.followupWindowMs = r.followupWindowMs;
   if (typeof r.suppressedUntil === "string") rule.suppressedUntil = r.suppressedUntil;
   if (r.scope !== void 0) {
     if (typeof r.scope !== "string" || !VALID_SCOPES.has(r.scope)) {
@@ -10655,6 +10730,17 @@ function validateRule(input, label, seenIds) {
       throw new Error(`${label}: stale-log rules require a positive staleHours`);
     }
   }
+  if (rule.type === "absent-followup") {
+    if (rule.pattern.length === 0) {
+      throw new Error(`${label}: absent-followup rules require a non-empty pattern`);
+    }
+    if (typeof rule.followupPattern !== "string" || rule.followupPattern.length === 0) {
+      throw new Error(`${label}: absent-followup rules require a non-empty followupPattern`);
+    }
+    if (typeof rule.followupWindowMs !== "number" || rule.followupWindowMs <= 0 || rule.followupWindowMs > MAX_FOLLOWUP_WINDOW_MS) {
+      throw new Error(`${label}: absent-followup rules require followupWindowMs in (0, ${MAX_FOLLOWUP_WINDOW_MS}]`);
+    }
+  }
   return rule;
 }
 
@@ -11126,7 +11212,8 @@ function newRuleState() {
     matchTimestampsByScope: /* @__PURE__ */ new Map(),
     lastAlertAt: null,
     cumulativeSinceLastAlert: 0,
-    lastSeenAt: null
+    lastSeenAt: null,
+    pendingFollowups: []
   };
 }
 function evaluateTextRule(rule, lines, state, nowMs) {
@@ -11224,6 +11311,58 @@ function evaluateStaleLogRule(rule, lastMtimeMs, state, nowMs) {
   };
   return { match: match2, state: updated };
 }
+function evaluateAbsentFollowupRule(rule, lines, state, nowMs) {
+  if (isSuppressed(rule, nowMs)) return { matches: [], state };
+  if (!rule.pattern || !rule.followupPattern || !rule.followupWindowMs) {
+    return { matches: [], state };
+  }
+  const triggerRegex = compileRegex(rule.pattern);
+  const followupRegex = compileRegex(rule.followupPattern);
+  const pending = [...state.pendingFollowups ?? []];
+  for (const line of lines) {
+    if (triggerRegex.test(line)) {
+      pending.push({
+        scope: scopeKeyFor(rule, line),
+        timestamp: nowMs,
+        line,
+        fulfilled: false
+      });
+      continue;
+    }
+    if (followupRegex.test(line)) {
+      const scope = scopeKeyFor(rule, line);
+      for (const entry of pending) {
+        if (!entry.fulfilled && entry.scope === scope) {
+          entry.fulfilled = true;
+          break;
+        }
+      }
+    }
+  }
+  const matches = [];
+  const kept = [];
+  for (const entry of pending) {
+    const age = nowMs - entry.timestamp;
+    if (age >= rule.followupWindowMs) {
+      if (!entry.fulfilled) {
+        matches.push({
+          ruleId: rule.id,
+          ruleName: rule.name,
+          matchedAt: nowMs,
+          sampleEvidence: toSample(entry.line),
+          suggestedAction: rule.suggestedAction,
+          missedForMs: age
+        });
+      }
+      continue;
+    }
+    kept.push(entry);
+  }
+  return {
+    matches,
+    state: { ...state, pendingFollowups: kept }
+  };
+}
 var ALERT_WINDOW_MS = 60 * 60 * 1e3;
 function rateLimitDecision(state, nowMs) {
   const since = state.lastAlertAt === null ? Infinity : nowMs - state.lastAlertAt;
@@ -11344,6 +11483,24 @@ async function runScanCycle(runtime) {
         const result = evaluateStaleLogRule(rule, lastMs, state, cycleStart);
         state = result.state;
         match2 = result.match;
+      } else if (rule.type === "absent-followup") {
+        let inputLines = [];
+        if (rule.logSource === "any") {
+          for (const [src, lines] of linesBySource.entries()) {
+            if (src !== "config-dir") inputLines.push(...lines);
+          }
+        } else {
+          inputLines = linesBySource.get(rule.logSource) ?? [];
+        }
+        const result = evaluateAbsentFollowupRule(rule, inputLines, state, cycleStart);
+        state = result.state;
+        for (const m of result.matches) {
+          const safeTrigger = m.sampleEvidence.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+          console.error(
+            `[review-detector] absent-followup rule=${rule.id} trigger="${safeTrigger}" missed_for_ms=${m.missedForMs ?? ""}`
+          );
+          matches.push(m);
+        }
       }
       runtime.ruleState.set(rule.id, state);
       if (match2) matches.push(match2);
@@ -31172,18 +31329,23 @@ async function GET9(request) {
   const accountLogDir2 = account ? resolve19(account.accountDir, "logs") : null;
   if (fileParam) {
     const safe = basename5(fileParam);
+    const searched = [];
     for (const dir of [accountLogDir2, LOG_DIR]) {
       if (!dir) continue;
       const filePath = resolve19(dir, safe);
+      searched.push(filePath);
       try {
         const content = readFileSync20(filePath, "utf-8");
         const headers = { "Content-Type": "text/plain; charset=utf-8" };
         if (download) headers["Content-Disposition"] = `attachment; filename="${safe}"`;
         return new Response(content, { headers });
-      } catch {
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        console.debug(`[admin/logs] miss dir=${dir} name=${safe} reason=${reason}`);
       }
     }
-    return Response.json({ error: `File not found: ${safe}` }, { status: 404 });
+    console.warn(`[admin/logs] not-found name=${safe} searched=[${searched.join(",")}]`);
+    return Response.json({ error: `File not found: ${safe}`, code: "NOT_FOUND" }, { status: 404 });
   }
   if (typeParam) {
     const prefixMap = {
@@ -31195,24 +31357,37 @@ async function GET9(request) {
     };
     const prefix = prefixMap[typeParam];
     if (!prefix) {
-      return Response.json({ error: `Unknown type: ${typeParam}. Valid: stream, error, session, sse, public` }, { status: 400 });
+      console.warn(`[admin/logs] rejected reason=unknown-type type=${typeParam}`);
+      return Response.json(
+        { error: `Unknown type: ${typeParam}. Valid: stream, error, session, sse, public`, code: "UNKNOWN_TYPE" },
+        { status: 400 }
+      );
     }
     if (!conversationIdParam) {
-      return Response.json({ error: `type=${typeParam} requires conversationId (per-conversation log files, no daily fallback)` }, { status: 400 });
+      console.warn(`[admin/logs] rejected type=${typeParam} reason=no-conversationId`);
+      return Response.json(
+        { error: `type=${typeParam} requires conversationId (per-conversation log files, no daily fallback)`, code: "CONVERSATION_ID_REQUIRED" },
+        { status: 400 }
+      );
     }
     const fileName = `${prefix}-${conversationIdParam}.log`;
+    const searched = [];
     for (const dir of [accountLogDir2, LOG_DIR]) {
       if (!dir) continue;
       const filePath = resolve19(dir, fileName);
+      searched.push(filePath);
       try {
         const content = readFileSync20(filePath, "utf-8");
         const headers = { "Content-Type": "text/plain; charset=utf-8" };
         if (download) headers["Content-Disposition"] = `attachment; filename="${fileName}"`;
         return new Response(content, { headers });
-      } catch {
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        console.debug(`[admin/logs] miss dir=${dir} name=${fileName} reason=${reason}`);
       }
     }
-    return Response.json({ error: `Log not found: ${fileName}` }, { status: 404 });
+    console.warn(`[admin/logs] not-found name=${fileName} searched=[${searched.join(",")}]`);
+    return Response.json({ error: `Log not found: ${fileName}`, code: "NOT_FOUND" }, { status: 404 });
   }
   const seen = /* @__PURE__ */ new Set();
   const logs = {};
@@ -31221,7 +31396,9 @@ async function GET9(request) {
     let files;
     try {
       files = readdirSync5(dir).filter((f) => f.endsWith(".log"));
-    } catch {
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      console.warn(`[admin/logs] readdir-fail dir=${dir} reason=${reason}`);
       continue;
     }
     files.filter((f) => !seen.has(f)).map((f) => ({ name: f, mtime: statSync7(resolve19(dir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime).forEach(({ name }) => {
@@ -31230,8 +31407,10 @@ async function GET9(request) {
         const content = readFileSync20(resolve19(dir, name));
         const tail = content.length > TAIL_BYTES ? content.subarray(content.length - TAIL_BYTES).toString("utf-8") : content.toString("utf-8");
         logs[name] = tail.trim() || "(empty)";
-      } catch {
-        logs[name] = "(unreadable)";
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        console.debug(`[admin/logs] read-fail name=${name} reason=${reason}`);
+        logs[name] = `(unreadable: ${reason})`;
       }
     });
   }