harnery 0.35.0 → 0.37.0

package/src/core/governor/service.ts

@@ -1,7 +1,6 @@
 import { spawn } from "node:child_process";
 import { randomBytes, randomUUID } from "node:crypto";
 import {
-  appendFileSync,
   chmodSync,
   closeSync,
   existsSync,
@@ -16,7 +15,10 @@ import {
 } from "node:fs";
 import { hostname } from "node:os";
 import { dirname, join, resolve } from "node:path";
+import { coordEnv } from "../../lib/env.ts";
 import { type NormalizedPolicy, normalizePolicy, type PolicyIsolation } from "../policy/index.ts";
+import { closeProcessLoggers, legacyLogFields, processLogger } from "../storage/logger.ts";
+import { RotatingTextSink } from "../storage/process-log.ts";
 import type { RunWorkItemInput } from "../work/index.ts";
 import { type GovernorRunReport, type GovernorStopReason, runGovernor } from "./runner.ts";
 import { type GovernorRecord, readGovernor } from "./state.ts";
@@ -260,18 +262,19 @@ export async function spawnGovernorService(coordRootRaw: string): Promise<Govern
     throw new Error(`governor service is already running under pid ${current.record?.pid}`);
   }
   mkdirSync(serviceDir(coordRoot), { recursive: true, mode: 0o700 });
-  const logFd = openSync(serviceLogPath(coordRoot), "a", 0o600);
-  chmodSync(serviceLogPath(coordRoot), 0o600);
+  const sharedLogs = coordEnv("SHARED_LOGS") !== "0";
+  const logFd = sharedLogs ? undefined : openSync(serviceLogPath(coordRoot), "a", 0o600);
+  if (logFd !== undefined) chmodSync(serviceLogPath(coordRoot), 0o600);
   const harnBin = new URL("../../../bin/harn", import.meta.url).pathname;
   if (!existsSync(harnBin)) {
-    closeSync(logFd);
+    if (logFd !== undefined) closeSync(logFd);
     throw new Error(`cannot find harn executable at ${harnBin}`);
   }
   let spawnError: Error | undefined;
   const child = spawn(harnBin, ["governor", "service", "daemon"], {
     cwd: coordRoot,
     detached: true,
-    stdio: ["ignore", logFd, logFd],
+    stdio: logFd === undefined ? ["ignore", "ignore", "ignore"] : ["ignore", logFd, logFd],
     env: {
       ...process.env,
       HARNERY_COORD_ROOT_OVERRIDE: coordRoot,
@@ -281,7 +284,7 @@ export async function spawnGovernorService(coordRootRaw: string): Promise<Govern
   child.once("error", (error) => {
     spawnError = error;
   });
-  closeSync(logFd);
+  if (logFd !== undefined) closeSync(logFd);
   child.unref();
   const deadline = Date.now() + 5_000;
   while (Date.now() < deadline) {
@@ -291,7 +294,7 @@ export async function spawnGovernorService(coordRootRaw: string): Promise<Govern
     if (status.running && status.record?.pid === child.pid) return status;
     if (child.exitCode !== null) break;
   }
-  throw new Error(`governor service failed to start; inspect ${serviceLogPath(coordRoot)}`);
+  throw new Error(`governor service failed to start; inspect ${governorServiceLogPath(coordRoot)}`);
 }
 
 export function requestGovernorServiceStop(coordRootRaw: string): GovernorServiceStatus {
@@ -396,7 +399,7 @@ export async function runGovernorServiceSweep(
         stop_reason: report.stop_reason,
         next_wake_at: runtime.goals[goalId]?.next_wake_at,
       });
-      appendServiceEvent(coordRoot, {
+      appendGovernorServiceDiagnostic(coordRoot, {
         event: "goal.tick",
         goal_id: goalId,
         stop_reason: report.stop_reason,
@@ -437,7 +440,7 @@ export async function runGovernorServiceSweep(
         reason: message,
         next_wake_at: nextWakeAt,
       });
-      appendServiceEvent(coordRoot, {
+      appendGovernorServiceDiagnostic(coordRoot, {
         event: "goal.error",
         goal_id: goalId,
         error: message,
@@ -486,7 +489,7 @@ export async function runGovernorServiceDaemon(
   process.on("SIGTERM", requestStop);
   status.state = "running";
   writeStatus();
-  appendServiceEvent(coordRoot, {
+  appendGovernorServiceDiagnostic(coordRoot, {
     event: "service.started",
     pid: process.pid,
     goals: config.goal_ids,
@@ -528,7 +531,7 @@ export async function runGovernorServiceDaemon(
         status.last_error = boundedError((error as Error).message);
         status.next_wake_at = new Date(Date.now() + config.error_backoff_max_ms).toISOString();
         writeStatus();
-        appendServiceEvent(coordRoot, {
+        appendGovernorServiceDiagnostic(coordRoot, {
           event: "service.sweep_error",
           error: status.last_error,
         });
@@ -550,19 +553,26 @@ export async function runGovernorServiceDaemon(
     status.active_goal_id = undefined;
     status.stopped_at = new Date().toISOString();
     writeStatus();
-    appendServiceEvent(coordRoot, {
+    appendGovernorServiceDiagnostic(coordRoot, {
       event: "service.stopped",
       pid: process.pid,
       sweeps: status.sweep_count,
     });
     rmSync(serviceStopPath(coordRoot), { force: true });
-    release();
+    try {
+      await closeProcessLoggers();
+    } finally {
+      release();
+    }
   }
   return status;
 }
 
 export function governorServiceLogPath(coordRoot: string): string {
-  return serviceLogPath(resolve(coordRoot));
+  const root = resolve(coordRoot);
+  return coordEnv("SHARED_LOGS") === "0"
+    ? serviceLogPath(root)
+    : join(root, ".harnery", "logs", "governor-service", "active.jsonl");
 }
 
 function runtimeForConfig(
@@ -804,15 +814,32 @@ function pidAlive(pid: number): boolean {
   }
 }
 
-function appendServiceEvent(coordRoot: string, data: Record<string, unknown>): void {
+export function appendGovernorServiceDiagnostic(
+  coordRoot: string,
+  data: Record<string, unknown>,
+): "shared" | "legacy" {
+  if (coordEnv("SHARED_LOGS") !== "0") {
+    try {
+      const event = typeof data.event === "string" ? data.event : "service.event";
+      const fields = { ...data };
+      delete fields.event;
+      const logger = processLogger(coordRoot, "governor-service");
+      if (event.includes("error")) logger.error(event, legacyLogFields(fields));
+      else logger.info(event, legacyLogFields(fields));
+      return "shared";
+    } catch {
+      // Bootstrap failures retain the legacy service event stream as the fallback.
+    }
+  }
+  appendGovernorServiceLegacyEvent(coordRoot, data);
+  return "legacy";
+}
+
+function appendGovernorServiceLegacyEvent(coordRoot: string, data: Record<string, unknown>): void {
   const path = serviceEventsPath(coordRoot);
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-  appendFileSync(
-    path,
-    `${JSON.stringify({ schema_version: 1, ts: new Date().toISOString(), ...data })}\n`,
-    { encoding: "utf8", mode: 0o600 },
-  );
-  chmodSync(path, 0o600);
+  const sink = new RotatingTextSink({ path, max_bytes: MAX_FILE_BYTES });
+  sink.append(`${JSON.stringify({ schema_version: 1, ts: new Date().toISOString(), ...data })}\n`);
+  sink.close();
 }
 
 function renderSweepLog(report: GovernorServiceSweepReport): string | undefined {

package/src/core/guard/evidence-v3.ts

@@ -55,6 +55,7 @@ export function normalizeRunQualityEventV3(
     case "context.observed": {
       const measurement = event.payload.measurement;
       if (measurement.state !== "observed") return [];
+      if (!("used_tokens" in measurement.value)) return [];
       return [
         {
           ...base,

package/src/core/hooks/adapter/events.ts

@@ -86,6 +86,7 @@ export const CURSOR_EVENTS: HookEvent[] = [
   { settingsKey: "subagentStart", subcommand: "sub-agent-start" },
   { settingsKey: "subagentStop", subcommand: "sub-agent-stop" },
   { settingsKey: "beforeSubmitPrompt", subcommand: "user-prompt-submit" },
+  { settingsKey: "afterAgentResponse", subcommand: "after-agent-response" },
   { settingsKey: "preCompact", subcommand: "pre-compact" },
   { settingsKey: "stop", subcommand: "stop" },
 ];

package/src/core/hooks/adapter/output.ts

@@ -8,8 +8,10 @@
  * - **Claude Code**: `{hookSpecificOutput: {hookEventName, additionalContext}}`
  *   for SessionStart / UserPromptSubmit / SubagentStart; deny uses
  *   `{hookSpecificOutput: {hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason}}`.
- * - **Cursor**: `{additional_context, env?}` flat for sessionStart /
- *   beforeSubmitPrompt; deny uses `{permission: "deny", agent_message, user_message}`.
+ * - **Cursor**: `{additional_context, env?}` flat for sessionStart and other
+ *   context-capable events. Its current beforeSubmitPrompt schema can validate
+ *   or block but cannot inject context, so UserPromptSubmit output is skipped.
+ *   Deny uses `{permission: "deny", agent_message, user_message}`.
  * - **Codex**: structurally identical to Claude Code for context and tool
  *   denials. Stop blocks are deliberately suppressed because their automatic
  *   continuation can replace a completed user-facing answer.
@@ -29,9 +31,21 @@ export type SystemEvent =
   | "PreToolUse"
   | "PostToolUse";
 
+/**
+ * Whether this adapter can actually receive injected context for an event.
+ * Cursor's beforeSubmitPrompt hook can allow or block a turn but cannot inject
+ * model context, so anything rendered for that event is discarded. A caller
+ * that consumes state to build the text (draining a mailbox, for instance)
+ * must check this first, or the state is spent on output nobody reads.
+ */
+export function canReceiveContext(adapter: Adapter, event: SystemEvent): boolean {
+  return !(adapter === "cursor" && event === "UserPromptSubmit");
+}
+
 /** Emit a context-injection (peer table, wiring check, council pending, …). */
 export function emitContext(adapter: Adapter, event: SystemEvent, text: string): void {
   if (!text || text.length === 0) return;
+  if (!canReceiveContext(adapter, event)) return;
   const json = buildContextJson(adapter, event, text);
   process.stdout.write(`${JSON.stringify(json)}\n`);
 }
@@ -89,9 +103,13 @@ export function emitStopBlock(
     process.stdout.write(`${JSON.stringify({ followup_message: message })}\n`);
     return 0;
   }
-  // Claude Code continues the SAME turn on exit 2, so the single failing rule is
-  // both accurate and sufficient there. Left unchanged deliberately.
-  process.stderr.write(`${reason}\n[agent-hook stop]: rule=${verdict.rule}\n`);
+  // Claude Code re-prompts inside one native Stop remediation cycle, but tools
+  // run after the first terminal are recorded in recovered telemetry turns.
+  // Name the whole ritual so one continuation can repair every required signal.
+  const bin = resolveBinName(coordRoot);
+  const statusCommand = endOfTurnStatusCommand(coordRoot);
+  const remediation = `Repair the whole ritual in this continuation: if the original turn used a tool and task evidence is missing, run \`${bin} agents set-task "<short focus>"\`; then run \`${statusCommand}\` as your last tool call and paste its status box verbatim in your reply.`;
+  process.stderr.write(`${reason}\n${remediation}\n[agent-hook stop]: rule=${verdict.rule}\n`);
   return 2;
 }