harnery 0.38.0 → 0.40.0

package/src/commands/diagnostics.ts

@@ -13,6 +13,7 @@ import {
   replayDiagnosticBundle,
   showDiagnosticBundle,
 } from "../core/diagnostics/index.ts";
+import { readPublishedPressure } from "../core/resources/status.ts";
 import {
   buildSupervisorTimeline,
   explainSupervisorFinding,
@@ -112,14 +113,16 @@ export function registerDiagnosticsCommand(
         }
         const report = readSupervisorFindings(repoRoot);
         const findings = mergeFindings(report?.active ?? [], report?.transitions ?? []);
-        const sourceCapability = liveFindingsCapability(repoRoot, report !== undefined);
+        const published = readPublishedPressure(repoRoot);
         emit.data({
           schema_version: DIAGNOSTIC_COMMAND_SCHEMA_VERSION,
           kind: "diagnostic_advice",
           source: { mode: "live" },
           advice: buildDiagnosticAdvice({
-            findings,
-            sourceCapability,
+            assessment: published.assessment,
+            priorHysteresis: published.prior_hysteresis,
+            sourceCapability: published.capability,
+            activeFindingCount: findings.filter((finding) => finding.state === "opened").length,
             evaluatedAt: new Date().toISOString(),
           }),
         });

package/src/commands/ledger-v3.ts

@@ -15,6 +15,7 @@ import {
   cleanEventV3Archives,
   initializeEventLedgerV3,
   inventoryEventV3Archives,
+  listHookProducerStateRecordsV3,
   readEventV3ControlState,
   recoverInvalidEventLedgerV3,
   sha256V3,
@@ -54,9 +55,24 @@ export function registerLedgerV3Command(
   command
     .command("status")
     .description("Read the V3 control boundary without changing it")
-    .action(() => {
+    .option("--root <path>", "Explicit coordination root")
+    .action((options: { root?: string }) => {
       try {
-        emit.data(readEventV3ControlState(coordRoot(context)));
+        const root = resolve(options.root ?? coordRoot(context));
+        const control = readEventV3ControlState(root);
+        const producers = listHookProducerStateRecordsV3(root, { includeTerminal: true });
+        const counts = producers.reduce<Record<string, number>>((summary, record) => {
+          summary[record.state.adapter] = (summary[record.state.adapter] ?? 0) + 1;
+          return summary;
+        }, {});
+        emit.data({
+          ...control,
+          summary: {
+            adapters: Object.keys(counts).sort(),
+            producer_states: producers.length,
+            producer_states_by_adapter: counts,
+          },
+        });
       } catch (error) {
         emitFailure(emit, "ledger_v3_status_failed", error);
       }
@@ -467,7 +483,8 @@ export function registerLedgerV3Command(
 
 function coordRoot(context: HarneryProgramContext | undefined): string {
   return resolve(
-    context?.resolveCoordRoot?.() ??
+    process.env.HARNERY_COORD_ROOT_OVERRIDE ??
+      context?.resolveCoordRoot?.() ??
       context?.repoRoot ??
       process.env.HARNERY_COORD_ROOT ??
       process.cwd(),

package/src/commands/qa-run.ts

@@ -11,7 +11,11 @@ import type { EmitContext, HarneryProgramContext } from "../commander.ts";
 import { recordQaSignal } from "../core/agents/qa-signal.ts";
 import { artifactsRoot } from "../core/artifacts/index.ts";
 import { resolveBinName, reviewPackAutoCleanEnabled } from "../core/config.ts";
-import { createManagedQaOutParent, resolveQaRepoRoot } from "../core/qa-artifacts.ts";
+import {
+  createManagedQaOutParent,
+  managedQaReviewGuidance,
+  resolveQaRepoRoot,
+} from "../core/qa-artifacts.ts";
 import { acquireAdmission, admissionBaseDir, admissionStatus } from "../lib/admission.ts";
 import {
   deleteExpiredPacks,
@@ -44,6 +48,8 @@ interface QaRunOpts {
   mode: string;
   concurrency?: string;
   pool?: string;
+  tileBudget?: string;
+  acceptDispositions?: boolean;
   allowMetered?: boolean;
   retain?: string;
   outDir?: string;
@@ -91,6 +97,14 @@ export function registerQaRunCommand(
       "Vision calls in flight during the judge stage, across every context (1-16; default: " +
         "the provider's own concurrency). Sets policy.critique_pool.",
     )
+    .option(
+      "--tile-budget <n>",
+      "Maximum native tiles across the complete review pack (8-400; default 96).",
+    )
+    .option(
+      "--accept-dispositions",
+      "Apply fully reviewed prior decisions only to identical findings on identical native tiles.",
+    )
     .option(
       "--allow-metered",
       "Permit the critique provider's metered-API fallback. Default: subscription-backed " +
@@ -208,6 +222,19 @@ export function registerQaRunCommand(
       }
 
       const policy = { ...validation.job.policy };
+      if (opts.tileBudget !== undefined) {
+        const n = Number(opts.tileBudget);
+        if (!Number.isInteger(n) || n < 8 || n > 400) {
+          emit.error({
+            code: "qa_run_invalid_tile_budget",
+            message: "--tile-budget must be an integer between 8 and 400",
+          });
+          process.exitCode = 1;
+          return;
+        }
+        policy.critique_tile_budget = n;
+      }
+      if (opts.acceptDispositions) policy.accept_dispositions = true;
       if (opts.concurrency !== undefined) {
         const n = Number.parseInt(opts.concurrency, 10);
         if (!Number.isInteger(n) || n < 1 || n > 8) {
@@ -272,7 +299,9 @@ export function registerQaRunCommand(
         outParent =
           opts.outDir !== undefined
             ? resolve(opts.outDir)
-            : createManagedQaOutParent(repoRoot, "qa-run");
+            : createManagedQaOutParent(repoRoot, "qa-run", {
+                onCleanupWarning: (message) => emit.log(message, "warn"),
+              });
       } catch (err: unknown) {
         emit.error({
           code: "qa_run_output_unavailable",
@@ -347,6 +376,8 @@ export function registerQaRunCommand(
           job.mode,
           ...(opts.concurrency !== undefined ? ["--concurrency", opts.concurrency] : []),
           ...(opts.pool !== undefined ? ["--pool", opts.pool] : []),
+          ...(opts.tileBudget !== undefined ? ["--tile-budget", opts.tileBudget] : []),
+          ...(opts.acceptDispositions ? ["--accept-dispositions"] : []),
           ...(opts.allowMetered ? ["--allow-metered"] : []),
           ...(opts.retain !== undefined ? ["--retain", opts.retain] : []),
           "--out-dir",
@@ -473,7 +504,10 @@ export function registerQaRunCommand(
       // session age. Best-effort by contract: never throws.
       recordQaSignal(result);
 
-      if (opts.json) emit.data(result);
+      const afterReview = managedQaReviewGuidance(repoRoot, outParent);
+      if (opts.json)
+        emit.data({ ...result, ...(afterReview ? { after_review: afterReview } : {}) });
+      if (afterReview) emit.log(afterReview, "info");
       const resultPath = join(result.run.out_dir, QA_RUN_RESULT_FILENAME);
       for (const blocker of result.blockers) {
         emit.log(

package/src/commands/qa-status.ts

@@ -11,7 +11,11 @@ import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import type { Command } from "commander";
 import type { EmitContext, HarneryProgramContext } from "../commander.ts";
-import { latestManagedQaRun, resolveQaRepoRoot } from "../core/qa-artifacts.ts";
+import {
+  latestManagedQaRun,
+  managedQaReviewGuidance,
+  resolveQaRepoRoot,
+} from "../core/qa-artifacts.ts";
 import {
   type AdmissionEntry,
   admissionBaseDir,
@@ -578,8 +582,13 @@ export function registerQaStatusCommand(
         const report = outcome.report;
         const settled = report.terminal || report.state === "dead";
         if (settled || !opts.wait) {
-          if (opts.json) emit.data(report);
+          const afterReview = report.terminal
+            ? managedQaReviewGuidance(resolveQaRepoRoot(context), dirname(runDir))
+            : undefined;
+          if (opts.json)
+            emit.data({ ...report, ...(afterReview ? { after_review: afterReview } : {}) });
           renderReport(emit, report);
+          if (afterReview) emit.log(afterReview, "info");
           if (!settled && !opts.wait) {
             emit.log("still in progress; rerun with --wait to block until the run settles", "info");
           }

package/src/commands/resources.ts

@@ -1,7 +1,7 @@
 import { resolve } from "node:path";
 import type { Command } from "commander";
 import type { EmitContext, HarneryProgramContext } from "../commander.ts";
-import { sampleResources } from "../core/resources/index.ts";
+import { formatResourceStatus, readResourceStatus } from "../core/resources/status.ts";
 
 export function registerResourcesCommand(
   program: Command,
@@ -10,14 +10,34 @@ export function registerResourcesCommand(
 ): void {
   const resources = program
     .command("resources")
-    .description("Observe local CPU and memory pressure by agent and process tree");
+    .description("Observe local CPU, memory, disk capacity, and resource pressure");
+
+  resources
+    .command("status")
+    .description("Read the supervisor's cached resource measurements without sampling")
+    .option("--root <path>", "Explicit coordination root")
+    .option("--json", "Bounded structured output")
+    .option("--processes", "Include up to 20 processes, largest memory first")
+    .action((options: { root?: string; json?: boolean; processes?: boolean }) => {
+      const status = readResourceStatus(resolve(options.root ?? coordRoot(context)), {
+        includeProcesses: options.processes,
+      });
+      if (options.json) {
+        emit.config({ format: "json" });
+        emit.data(status);
+      } else {
+        emit.config({ format: "text" });
+        emit.text(formatResourceStatus(status, program.name()));
+      }
+    });
 
   resources
     .command("snapshot")
     .description("Capture one machine and process-resource snapshot")
     .option("--root <path>", "Explicit coordination root")
-    .action((options: { root?: string }) => {
+    .action(async (options: { root?: string }) => {
       try {
+        const { sampleResources } = await import("../core/resources/sampler.ts");
         emit.data(sampleResources(resolve(options.root ?? coordRoot(context))).snapshot);
       } catch (error) {
         fail(emit, "resource_snapshot_failed", error);

package/src/commands/review-pack.ts

@@ -4,14 +4,18 @@
 // composes the same two library halves; this command exposes them directly
 // so an agent can prepare a page for review, or review a pack, on its own.
 
-import { mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { userInfo } from "node:os";
 import { resolve } from "node:path";
 import type { Command } from "commander";
 import type { EmitContext, HarneryProgramContext } from "../commander.ts";
+import { resolveOwner } from "../core/agents/index.ts";
+import { readLiveCoordinationRow } from "../core/agents/state/live-coordination-view.ts";
 import { artifactsRoot } from "../core/artifacts/index.ts";
 import { resolveBinName, reviewPackAutoCleanEnabled } from "../core/config.ts";
 import { createManagedQaOutParent, resolveQaRepoRoot } from "../core/qa-artifacts.ts";
 import { DEFAULT_CRITIQUE_RUBRIC } from "../lib/browser/critique.ts";
+import { persistPackReviewDecisions } from "../lib/browser/page-review-evidence.ts";
 import { judgePageReviewPack, toCritiqueRecords } from "../lib/browser/page-review-judge.ts";
 import {
   aggregateMachineOutcome,
@@ -55,7 +59,6 @@ interface CreateOpts {
   out?: string;
   context?: string[];
   scope?: string[];
-  noBands?: boolean;
   maxTiles?: string;
   concurrency?: string;
   timeout?: string;
@@ -167,6 +170,9 @@ interface ReviewAddOpts {
 }
 
 interface DispositionOpts {
+  target?: string[];
+  allHigh?: boolean;
+  context?: string;
   note?: string;
   by?: string;
   json?: boolean;
@@ -174,6 +180,7 @@ interface DispositionOpts {
 
 interface VerdictOpts {
   json?: boolean;
+  snapshotStore?: string;
 }
 
 /** Next free review-subagent finding id in the `F001` series. */
@@ -373,10 +380,9 @@ export function registerReviewPackCommand(
       (value: string, previous: string[] = []) => [...previous, value],
       [] as string[],
     )
-    .option("--no-bands", "Keep only --scope tiles; skip full-page bands.")
     .option(
       "--max-tiles <n>",
-      "Full-page band cap per context (browse --check-critique-max-tiles).",
+      "Native tile cap per context, including required top and bottom bands.",
     )
     .option("--concurrency <n>", "Concurrent capture browsers (1-8; default 2).", "2")
     .option("--timeout <ms>", "Per-capture timeout in milliseconds (default 120000).", "120000")
@@ -465,7 +471,6 @@ export function registerReviewPackCommand(
             ctx.theme,
             "--qa-state",
             ctx.state,
-            ...(opts.noBands ? ["--no-review-pack-bands"] : []),
             ...(opts.scope ?? []).flatMap((selector) => ["--review-pack-scope", selector]),
             ...(opts.maxTiles !== undefined ? ["--check-critique-max-tiles", opts.maxTiles] : []),
           ];
@@ -637,13 +642,14 @@ export function registerReviewPackCommand(
 
       const merged = new Map((manifest.critique ?? []).map((row) => [row.context_id, row]));
       for (const row of toCritiqueRecords(result)) merged.set(row.context_id, row);
+      const judgedRecords = new Map(result.contexts.map((row) => [row.context_id, row.record]));
       finalizePageReviewPack({
         packDir,
         target: manifest.target,
         ...(manifest.tested_revision !== undefined
           ? { tested_revision: manifest.tested_revision }
           : {}),
-        contexts: manifest.contexts,
+        contexts: manifest.contexts.map((record) => judgedRecords.get(record.id) ?? record),
         gates: manifest.gates,
         critique: [...merged.values()],
         pool: result.pool,
@@ -931,6 +937,24 @@ export function registerReviewPackCommand(
     .option("--json", "Print the summary as JSON.")
     .action((dir: string, opts: { json?: boolean }) => {
       const packDir = resolve(dir);
+      const stubPath = resolve(packDir, "pack-expired.json");
+      if (existsSync(stubPath)) {
+        try {
+          const stub = JSON.parse(readFileSync(stubPath, "utf8"));
+          if (stub.schema !== "harnery-page-review-expired/v1")
+            throw new Error("Unknown expired pack schema");
+          if (opts.json) emit.data(stub);
+          else
+            emit.log(
+              `expired pack: ${stub.target}; machine ${stub.machine_outcome ?? "not judged"}; reviewed ${stub.result?.reviewed_outcome ?? "no verdict"}`,
+              "info",
+            );
+        } catch (error) {
+          emit.error({ code: "review_pack_invalid_stub", message: String(error) });
+          process.exitCode = 1;
+        }
+        return;
+      }
       let manifest: ReturnType<typeof readPackManifest>;
       try {
         manifest = readPackManifest(packDir);
@@ -1165,7 +1189,7 @@ export function registerReviewPackCommand(
     });
 
   root
-    .command("disposition <dir> <target> <disposition>")
+    .command("disposition <dir> <target-or-disposition> [disposition]")
     .description(
       "Record the reviewer's verdict on one machine finding. <target> is " +
         "<context-id>/<tile-id>#<n>, n the finding's 0-based position among that tile's " +
@@ -1174,62 +1198,117 @@ export function registerReviewPackCommand(
         "target is replaced. evidence/critique.json itself is never rewritten.",
     )
     .option("--note <text>", "Why; what the tile actually shows.")
-    .option("--by <name>", "Who dispositioned it.")
+    .option("--by <name>", "Who dispositioned it (default: current agent or local account).")
+    .option(
+      "--target <target>",
+      "Explicit target (repeatable); use disposition as the first positional argument.",
+      (value: string, previous: string[] = []) => [...previous, value],
+      [] as string[],
+    )
+    .option("--all-high", "Disposition every high finding in --context.")
+    .option("--context <id>", "Required with --all-high.")
     .option("--json", "Print the written disposition as JSON.")
-    .action((dir: string, target: string, disposition: string, opts: DispositionOpts) => {
-      const pack = readReviewerPack(dir, emit);
-      if (!pack) return;
-      const { packDir, manifest, findings: doc } = pack;
-      if (!(PAGE_REVIEW_DISPOSITIONS as readonly string[]).includes(disposition)) {
-        emit.error({
-          code: "review_pack_invalid_disposition",
-          message: `disposition must be one of ${PAGE_REVIEW_DISPOSITIONS.join(", ")} (got ${JSON.stringify(disposition)})`,
-        });
-        process.exitCode = 1;
-        return;
-      }
-      if (manifest.critique === null) {
-        emit.error({
-          code: "review_pack_not_judged",
-          message: `the judge has not run for this pack, so there is no machine finding to disposition; run: ${judgeCommandFor(packDir)}`,
-        });
-        process.exitCode = 1;
-        return;
-      }
-      const targets = machineFindingTargets(manifest.critique);
-      const machine = targets.get(target.trim());
-      if (!machine) {
-        const sample = [...targets.keys()].slice(0, 8).join(", ");
-        emit.error({
-          code: "review_pack_unknown_finding",
-          message:
-            `${JSON.stringify(target)} names no machine finding in evidence/critique.json` +
-            (sample ? ` (known targets include: ${sample})` : " (the critique holds no findings)"),
-        });
-        process.exitCode = 1;
-        return;
-      }
-      const entry = {
-        target: target.trim(),
-        disposition: disposition as PageReviewDisposition,
-        ...(opts.note !== undefined ? { note: opts.note } : {}),
-        ...(opts.by !== undefined ? { by: opts.by } : {}),
-        at: new Date().toISOString(),
-      };
-      const kept = (doc.dispositions ?? []).filter((d) => d.target !== entry.target);
-      const next: PageReviewFindingsDocument = {
-        ...doc,
-        reviewed_at: new Date().toISOString(),
-        dispositions: [...kept, entry],
-      };
-      if (!commitFindings(packDir, next, emit)) return;
-      emit.log(
-        `${entry.target} · ${machine.severity} · ${machine.category} → ${entry.disposition}` +
-          (kept.length < (doc.dispositions ?? []).length ? " (replaced)" : ""),
-        "info",
-      );
-      if (opts.json) emit.data(entry as unknown as Record<string, unknown>);
-    });
+    .action(
+      (
+        dir: string,
+        targetOrDisposition: string,
+        positionalDisposition: string | undefined,
+        opts: DispositionOpts,
+      ) => {
+        const disposition = positionalDisposition ?? targetOrDisposition;
+        const pack = readReviewerPack(dir, emit);
+        if (!pack) return;
+        const { packDir, manifest, findings: doc } = pack;
+        if (!(PAGE_REVIEW_DISPOSITIONS as readonly string[]).includes(disposition)) {
+          emit.error({
+            code: "review_pack_invalid_disposition",
+            message: `disposition must be one of ${PAGE_REVIEW_DISPOSITIONS.join(", ")} (got ${JSON.stringify(disposition)})`,
+          });
+          process.exitCode = 1;
+          return;
+        }
+        if (manifest.critique === null) {
+          emit.error({
+            code: "review_pack_not_judged",
+            message: `the judge has not run for this pack, so there is no machine finding to disposition; run: ${judgeCommandFor(packDir)}`,
+          });
+          process.exitCode = 1;
+          return;
+        }
+        const targets = machineFindingTargets(manifest.critique);
+        if (opts.allHigh && (!opts.context || positionalDisposition || opts.target?.length)) {
+          emit.error({
+            code: "review_pack_invalid_selection",
+            message: "--all-high requires --context and cannot be combined with explicit targets",
+          });
+          process.exitCode = 1;
+          return;
+        }
+        if (opts.context && !manifest.contexts.some((ctx) => ctx.id === opts.context)) {
+          emit.error({
+            code: "review_pack_unknown_context",
+            message: "Unknown disposition context",
+          });
+          process.exitCode = 1;
+          return;
+        }
+        const selected = [
+          ...new Set(
+            opts.allHigh
+              ? [...targets]
+                  .filter(([, f]) => f.context_id === opts.context && f.severity === "high")
+                  .map(([key]) => key)
+              : [
+                  ...(positionalDisposition ? targetOrDisposition.split(",") : []),
+                  ...(opts.target ?? []),
+                ]
+                  .map((t) => t.trim())
+                  .filter(Boolean),
+          ),
+        ];
+        const invalid = selected.filter((target) => !targets.has(target));
+        if (!selected.length || invalid.length) {
+          emit.error({
+            code: "review_pack_unknown_finding",
+            message: `No valid selection, or unknown target(s): ${invalid.join(", ")} (known targets include: ${[...targets.keys()].slice(0, 8).join(", ")})`,
+          });
+          process.exitCode = 1;
+          return;
+        }
+        const owner = resolveOwner();
+        const by =
+          opts.by?.trim() ||
+          (owner
+            ? readLiveCoordinationRow(resolveQaRepoRoot(context), owner)?.name || owner
+            : userInfo().username);
+        const entries = selected.map((target) => ({
+          target,
+          disposition: disposition as PageReviewDisposition,
+          ...(opts.note === undefined ? {} : { note: opts.note }),
+          by,
+          at: new Date().toISOString(),
+        }));
+        const next: PageReviewFindingsDocument = {
+          ...doc,
+          reviewed_at: new Date().toISOString(),
+          dispositions: [
+            ...(doc.dispositions ?? []).filter((d) => !selected.includes(d.target)),
+            ...entries,
+          ],
+        };
+        if (!commitFindings(packDir, next, emit)) return;
+        emit.log(
+          `${entries.length} finding(s) dispositioned ${disposition} by ${by}${(doc.dispositions ?? []).some((d) => selected.includes(d.target)) ? " (replaced)" : ""}`,
+          "info",
+        );
+        if (opts.json)
+          emit.data(
+            entries.length === 1
+              ? (entries[0] as unknown as Record<string, unknown>)
+              : { dispositions: entries },
+          );
+      },
+    );
 
   root
     .command("verdict <dir>")
@@ -1241,6 +1320,10 @@ export function registerReviewPackCommand(
         "and refreshes review.md. Exit 2 on fail, 4 when critique or delegated coverage is " +
         "skipped or incomplete, 1 on a findings.json validation error.",
     )
+    .option(
+      "--snapshot-store <dir>",
+      "Native baseline and durable decision store (default: local QA cache).",
+    )
     .option("--json", "Print the verdict as JSON.")
     .action((dir: string, opts: VerdictOpts) => {
       const pack = readReviewerPack(dir, emit);
@@ -1261,6 +1344,26 @@ export function registerReviewPackCommand(
         ...resolvePackVerdict(manifest, readPackInspectionPlan(packDir), doc),
         reviewed_at: new Date().toISOString(),
       };
+      try {
+        // Incomplete submissions may report their outcome, but cannot publish decisions.
+        if (
+          verdict.uncovered_primary_tiles.length === 0 &&
+          verdict.machine_outcome !== "skipped" &&
+          verdict.machine_outcome !== "incomplete"
+        ) {
+          persistPackReviewDecisions(
+            packDir,
+            opts.snapshotStore ? { root: resolve(opts.snapshotStore) } : {},
+          );
+        }
+      } catch (error) {
+        emit.error({
+          code: "review_pack_decisions_not_saved",
+          message: error instanceof Error ? error.message : String(error),
+        });
+        process.exitCode = 1;
+        return;
+      }
       const paths = packPaths(packDir);
       mkdirSync(paths.evidenceDir, { recursive: true });
       writeFileSync(paths.verdict, `${JSON.stringify(verdict, null, 2)}\n`);

package/src/commands/tunnel.ts

@@ -16,6 +16,7 @@ import {
   ensureCloudflared,
   gateLogFile,
   isProcessAlive,
+  isTunnelStateLive,
   listStates,
   providerLogFile,
   readConfig,
@@ -433,7 +434,7 @@ function providerIsAlive(state: TunnelState): boolean {
 }
 
 function tunnelIsAlive(state: TunnelState): boolean {
-  return isProcessAlive(state.gate_pid) && providerIsAlive(state);
+  return isTunnelStateLive(state);
 }
 
 interface GateSpawnOpts {

package/src/core/agents/canonical-emit.ts

@@ -11,6 +11,7 @@
  */
 
 import { spawnSync } from "node:child_process";
+import type { EventAdapterIdV3 } from "../events/v3/adapter-id.ts";
 import type { LiveCoordinationObservationV3 } from "../events/v3/live-observation.ts";
 import { coordBinPath } from "./coord-bin.ts";
 import { resolveCoordRoot } from "./coord-client.ts";
@@ -28,7 +29,7 @@ export type EventV3EmitObservation =
 export interface EventV3EmitInput {
   owner: string;
   session: string;
-  adapter: "claude-code" | "cursor" | "codex";
+  adapter: EventAdapterIdV3;
   observation: EventV3EmitObservation;
 }
 
@@ -92,9 +93,10 @@ export function emitEventV3(input: EventV3EmitInput): boolean {
 /**
  * Normalize the heartbeat's `platform` field to the canonical Adapter type.
  */
-export function normalizeAdapter(platform: string | undefined): "claude-code" | "cursor" | "codex" {
+export function normalizeAdapter(platform: string | undefined): EventAdapterIdV3 {
   if (platform === "cursor") return "cursor";
   if (platform === "codex") return "codex";
+  if (platform === "openclaw") return "openclaw";
   return "claude-code";
 }