harnery 0.32.0 → 0.34.0

package/dist/core/agents/canonical-emit.js

@@ -1,12 +1,13 @@
 /**
- * Emit canonical events by spawning `agent-coord emit-event`. Used by every
- * `agents …` / `journal` / `presence` write that has a canonical state event.
+ * Emit canonical V3 observations by spawning `agent-coord emit-event`. Used by
+ * coordination commands whose durable state change also has a V3 audit event.
  *
  * Soft-fails: never throws into the caller. A failed emit logs to stderr
  * (visible to operators in their terminal) but never breaks the CLI flow.
  *
- * Synchronous spawn: the projector runs before the CLI returns. ~20ms
- * latency budget per call.
+ * Synchronous spawn: the projector runs before the CLI returns. The child has
+ * a 15-second safety budget; loaded-host checks normally finish in a few
+ * seconds and record the observation before the parent command exits.
  */
 import { spawnSync } from "node:child_process";
 import { coordBinPath } from "./coord-bin.js";
@@ -15,57 +16,58 @@ import { resolveCoordRoot } from "./coord-client.js";
  * Resolve the coord root for a canonical emit.
  *
  * Delegates to `resolveCoordRoot()`, the single resolution the hooks and the
- * CLI's reads also use. An emit resolved any other way is an emit the Stop hook
- * cannot see: the hook reads `state.status_checked` from the stream under ITS
- * root, so a divergent emit root blocks rule 1/3 on a turn that did run
- * `agents status`, and no sequence of CLI commands can satisfy it.
+ * CLI's reads also use. An observation resolved any other way can disappear
+ * from the live V3 generation even though the command itself succeeded.
  */
 export function resolveEmitRoot(start = process.cwd()) {
     return resolveCoordRoot(start);
 }
-export function emitCanonical(input) {
+export function emitEventV3(input) {
     const root = resolveEmitRoot();
     if (!root)
-        return;
+        return false;
     const binary = coordBinPath("agent-coord", root);
     if (!binary)
-        return;
+        return false;
     try {
         const args = [
             "emit-event",
             "--type",
-            input.type,
+            input.observation.event_type,
             "--owner",
             input.owner,
             "--session",
             input.session,
             "--adapter",
             input.adapter,
-            "--data-json",
-            JSON.stringify(input.data),
+            "--data-stdin",
         ];
-        if (input.turnId)
-            args.push("--turn-id", input.turnId);
-        if (input.parentSessionId)
-            args.push("--parent-session-id", input.parentSessionId);
-        if (input.parentTurnId)
-            args.push("--parent-turn-id", input.parentTurnId);
         // Pin cwd + HARNERY_COORD_ROOT_OVERRIDE so the child writes to the SAME
         // stream we resolved, regardless of where the caller's shell is cd'd.
         const result = spawnSync(binary, args, {
             encoding: "utf8",
-            stdio: "ignore",
-            timeout: 3000,
+            stdio: ["pipe", "ignore", "pipe"],
+            input: JSON.stringify(input.observation),
+            // Budget the append generously. Under multi-agent contention a single
+            // `agent-coord emit-event` has been measured at 3.4-4.1s on a loaded
+            // host, so a 3s cap timed out every emit and blocked end-of-turn checks
+            // -- exactly the failure this module's doc warns about.
+            timeout: 15000,
             cwd: root,
             env: { ...process.env, HARNERY_COORD_ROOT_OVERRIDE: root },
         });
         if (result.error || result.status !== 0) {
-            const why = result.error ? result.error.message : `exit ${result.status}`;
-            process.stderr.write(`emitCanonical: ${input.type} emit failed (${why})\n`); // lint-ok-emission: soft-fail diagnostic promised by the module doc; silent drops cost blocked turns
+            const detail = typeof result.stderr === "string" ? result.stderr.trim() : "";
+            const why = result.error
+                ? result.error.message
+                : `exit ${result.status}${detail ? `: ${detail}` : ""}`;
+            process.stderr.write(`emitEventV3: ${input.observation.event_type} emit failed (${why})\n`); // lint-ok-emission: soft-fail diagnostic promised by the module doc; silent drops cost blocked turns
+            return false;
         }
+        return true;
     }
     catch {
-        /* never break the caller */
+        return false;
     }
 }
 /**