harnery 0.34.1 → 0.36.0

package/src/core/events/v3/producers/hook-base.ts

@@ -3,8 +3,16 @@ import type { ParsedPayload } from "../../../hooks/adapter/parse.ts";
 import { buildEventV3Base } from "../base-builder.ts";
 import type { EventV3Base, RuntimeAttestationV3Base } from "../base-contract.ts";
 import { type FingerprintContextV3, fingerprintV3, normalizeNativeIdV3 } from "../canonical.ts";
-import { adapterSignalSupportV3, adapterTurnWaitCountSupportV3 } from "../capabilities.ts";
+import {
+  adapterSignalSupportV3,
+  adapterTurnWaitCountSupportV3,
+  type CursorExecutionModeV3,
+} from "../capabilities.ts";
 import { eventIdV3 } from "../ids.ts";
+import {
+  effectiveRuntimeTelemetryCapabilitiesV3,
+  type RuntimeTelemetryCapabilitiesV3,
+} from "../runtime-telemetry-capabilities.ts";
 import { exactToolInputFingerprintV3, extractTargetsV3 } from "../targets.ts";
 
 export type HookSignalV3Base =
@@ -41,6 +49,7 @@ export interface HookProducerContextV3Base {
   platform: "linux" | "windows" | "macos" | "unknown";
   bridge?: "codex-wsl";
   capability_profile: `cap_${string}`;
+  cursor_mode?: CursorExecutionModeV3;
   fingerprintContext: FingerprintContextV3;
   turn_native_id?: string;
   turn_id?: `tid_${string}`;
@@ -61,6 +70,12 @@ export interface HookProducerContextV3Base {
   agent_role?: string;
   stop_remediation?: boolean;
   turn_ritual?: TurnRitualEvidenceV3;
+  /** Tuning read from a local runtime transcript by the recorder; hook-base
+   * itself performs no I/O. */
+  runtime_tuning?: RuntimeTuningContextV3;
+  /** Effective telemetry evidence resolved by the recorder. When absent, the
+   * session-start attestation records only what hook delivery can prove. */
+  runtime_telemetry?: RuntimeTelemetryCapabilitiesV3;
 }
 
 export interface TurnRitualEvidenceV3 {
@@ -176,6 +191,8 @@ export function normalizeHookEventV3Base(
               confidence: "exact",
             }
           : { state: "expected_but_missing", capability: "model_identity", reason: "not_reported" },
+        tuning: tuningObservation(context, payload),
+        telemetry: context.runtime_telemetry ?? initialTelemetryCapabilities(context),
         capability_profile: context.capability_profile,
         declared_by_event_id: eventId,
       };
@@ -455,7 +472,7 @@ function inputContextMeasurement(payload: ParsedPayload, phase: "before" | "afte
   const metadata = plainRecord(payload.raw.compact_metadata);
   const usedKeys =
     phase === "before"
-      ? ["pre_tokens", "pre_compact_tokens", "used_tokens"]
+      ? ["pre_tokens", "pre_compact_tokens", "used_tokens", "context_tokens"]
       : ["post_tokens", "post_compact_tokens", "used_tokens"];
   const limitKeys = [
     "context_window_size",
@@ -520,6 +537,103 @@ function plainRecord(value: unknown): Record<string, unknown> | undefined {
     : undefined;
 }
 
+/** Cursor encodes tuning in its parameterized model ids (…-high-fast). Other
+ * adapters do not, so absent tuning stays honest instead of being guessed. */
+const MODEL_ID_EFFORT_TOKENS = new Set([
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "ultra",
+]);
+
+export type RuntimeTuningObservationV3 = RuntimeAttestationV3Base["tuning"];
+
+function initialTelemetryCapabilities(
+  context: HookProducerContextV3Base,
+): RuntimeTelemetryCapabilitiesV3 {
+  return effectiveRuntimeTelemetryCapabilitiesV3({
+    adapter: context.adapter,
+    ...(context.cursor_mode ? { cursor_mode: context.cursor_mode } : {}),
+    context:
+      context.adapter === "cursor"
+        ? { state: "unsupported" }
+        : { state: "partial", reason: "context_source_not_ready" },
+    canonical_turn_boundaries:
+      adapterSignalSupportV3(context.adapter, "turn_completion") !== "unsupported",
+  });
+}
+
+/** Recorder-supplied tuning read from a local runtime transcript. */
+export interface RuntimeTuningContextV3 {
+  effort?: string;
+  speed?: string;
+  attestation: "native" | "derived";
+}
+
+/**
+ * Attest the runtime's tuning identity for one generation.
+ *
+ * Precedence: a recorder-read transcript observation, then the native payload
+ * field (CC stamps `effort.level` on tool hooks and Stop, never on
+ * SessionStart), then Cursor's model-id tokens. A payload/transcript source
+ * that was READ but carried no effort is proof the model has no dial —
+ * `unsupported` with capability `effort_selection` — while nothing-read-yet
+ * stays `expected_but_missing` so a later attestation can still land.
+ */
+function tuningObservation(
+  context: HookProducerContextV3Base,
+  payload: ParsedPayload,
+): RuntimeTuningObservationV3 {
+  const read = context.runtime_tuning;
+  if (read) {
+    if (read.effort || read.speed) {
+      return {
+        state: "observed",
+        value: {
+          ...(read.effort ? { effort: safeToken(read.effort, "unknown-effort") } : {}),
+          ...(read.speed ? { speed: safeToken(read.speed, "unknown-speed") } : {}),
+        },
+        attestation: read.attestation,
+        confidence: "exact",
+      };
+    }
+    return { state: "unsupported", capability: "effort_selection" };
+  }
+  if (payload.effort) {
+    return {
+      state: "observed",
+      value: { effort: safeToken(payload.effort, "unknown-effort") },
+      attestation: "native",
+      confidence: "exact",
+    };
+  }
+  if (context.adapter === "cursor" && payload.model) {
+    const tokens = payload.model.toLowerCase().split("-");
+    let effort: string | undefined;
+    for (let index = tokens.length - 1; index >= 0; index -= 1) {
+      const token = tokens[index];
+      if (token && MODEL_ID_EFFORT_TOKENS.has(token)) {
+        effort = token;
+        break;
+      }
+    }
+    const speed = tokens.includes("fast") ? "fast" : undefined;
+    if (effort || speed) {
+      return {
+        state: "observed",
+        value: { ...(effort ? { effort } : {}), ...(speed ? { speed } : {}) },
+        attestation: "derived",
+        confidence: "high",
+      };
+    }
+  }
+  return { state: "expected_but_missing", capability: "effort_selection", reason: "not_reported" };
+}
+
 function observedIdentity(id: string, version: string | undefined) {
   return {
     state: "observed" as const,

package/src/core/events/v3/producers/intake.ts

@@ -18,6 +18,10 @@ import type { ParsedPayload } from "../../../hooks/adapter/parse.ts";
 import { fsyncParentDirectory } from "../../../workflow/durable-record.ts";
 import type { EventV3WriteMode } from "../control.ts";
 import { EVENT_V3_LEDGER_RELATIVE_ROOT } from "../writer.ts";
+import {
+  type DiagnosticContentFingerprint,
+  gateProducerDiagnosticV3,
+} from "./diagnostic-summaries.ts";
 import type { HookSignalV3 } from "./hook.ts";
 import type { TurnRitualEvidenceV3 } from "./hook-base.ts";
 
@@ -73,6 +77,10 @@ const DIAGNOSTIC_METADATA_KEYS = new Set([
   "sequence",
   "expected",
   "actual",
+  "thread_id_present",
+  "wslenv_present",
+  "wslenv_names",
+  "identity_recovery_source",
 ]);
 
 export interface HookIntakeRecordV3 {
@@ -95,6 +103,12 @@ export interface HookIntakeRecordV3 {
   hook_duration_ms?: number;
   stop_remediation?: boolean;
   turn_ritual?: TurnRitualEvidenceV3;
+  delegated_child?: {
+    generation_id: `gen_${string}`;
+    parent_generation_id: `gen_${string}`;
+    delegation_id: `del_${string}`;
+    caused_by_event_id: `evt_${string}`;
+  };
 }
 
 export interface HookIntakeGroupV3 {
@@ -245,6 +259,7 @@ function readIntakeRecord(path: string): HookIntakeRecordV3 | undefined {
     (record.hook_duration_ms !== undefined &&
       (!Number.isSafeInteger(record.hook_duration_ms) || record.hook_duration_ms < 0)) ||
     (record.stop_remediation !== undefined && typeof record.stop_remediation !== "boolean") ||
+    !validDelegatedChild(record.delegated_child) ||
     !validTurnRitual(record.turn_ritual)
   ) {
     return undefined;
@@ -252,6 +267,17 @@ function readIntakeRecord(path: string): HookIntakeRecordV3 | undefined {
   return record;
 }
 
+function validDelegatedChild(value: HookIntakeRecordV3["delegated_child"]): boolean {
+  if (value === undefined) return true;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  return (
+    /^gen_[0-9a-f-]{36}$/.test(value.generation_id) &&
+    /^gen_[0-9a-f-]{36}$/.test(value.parent_generation_id) &&
+    /^del_[0-9a-f-]{36}$/.test(value.delegation_id) &&
+    /^evt_[0-9a-f-]{36}$/.test(value.caused_by_event_id)
+  );
+}
+
 function validTurnRitual(value: TurnRitualEvidenceV3 | undefined): boolean {
   if (value === undefined) return true;
   if (!value || typeof value !== "object" || Array.isArray(value)) return false;
@@ -270,6 +296,13 @@ function validTurnRitual(value: TurnRitualEvidenceV3 | undefined): boolean {
  * are reduced to byte counts and digests so the diagnostics spool never holds
  * prompt, tool input, or tool output bodies (invariant: delivered evidence is
  * never silently destroyed, and never re-exposed either).
+ *
+ * Identical emissions are bounded per (category, reason, instance) key and
+ * UTC day: past the loose-exemplar limit the emission is coalesced into the
+ * key's summary file. Returns the path of the durable record either way (the
+ * loose file when admitted, the summary file when coalesced); `undefined`
+ * means nothing durable was written. The gate is fail-open, so a mitigation
+ * failure still produces the loose file.
  */
 export function writeProducerDiagnosticV3(
   coordRoot: string,
@@ -278,13 +311,26 @@ export function writeProducerDiagnosticV3(
 ): string | undefined {
   try {
     const safeCategory = category.replace(/[^a-z0-9_-]/gi, "_").slice(0, 64);
+    const redacted = redactDiagnosticRecord(record);
+    const { content_fingerprint: fingerprint, ...metadata } = redacted;
+    const decision = gateProducerDiagnosticV3(coordRoot, {
+      category: safeCategory,
+      reason: typeof record.reason === "string" ? record.reason : undefined,
+      instanceId: typeof record.instance_id === "string" ? record.instance_id : undefined,
+      fingerprint: fingerprint as DiagnosticContentFingerprint,
+      metadata: metadata as Record<string, string | number | boolean | null>,
+    });
+    if (!decision.admit) return decision.summary_path;
     const root = diagnosticsRoot(coordRoot);
     ensureOwnerOnlyDirectory(root);
-    const path = join(root, `${safeCategory}-${intakeOrderKey()}.json`);
+    const path = join(
+      root,
+      `${safeCategory}-${intakeOrderKey()}${decision.loose_name_suffix}.json`,
+    );
     const contents = `${JSON.stringify({
       recorded_at: new Date().toISOString(),
       category: safeCategory,
-      ...redactDiagnosticRecord(record),
+      ...redacted,
     })}\n`;
     writeOwnerOnlyFileDurably(path, contents);
     return path;

package/src/core/events/v3/producers/producer-state-observer.ts

@@ -0,0 +1,52 @@
+import { existsSync, lstatSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { readEventV3ControlState } from "../control.ts";
+import { EVENT_V3_LEDGER_RELATIVE_ROOT } from "../reader.ts";
+
+export interface HookProducerStateSummaryV3 {
+  generation_id: `gen_${string}`;
+  open_span_count: number;
+  turn_open: boolean;
+}
+
+/** Read the narrow producer-state facts needed by passive coordination views. */
+export function listHookProducerStateSummariesV3(coordRoot: string): HookProducerStateSummaryV3[] {
+  const control = readEventV3ControlState(coordRoot);
+  if (control.state !== "candidate" && control.state !== "active") return [];
+  const producerRoot = join(resolve(coordRoot), EVENT_V3_LEDGER_RELATIVE_ROOT, "private-producers");
+  if (!existsSync(producerRoot)) return [];
+  const summaries: HookProducerStateSummaryV3[] = [];
+  for (const adapter of ["claude-code", "codex", "cursor"] as const) {
+    const directory = join(producerRoot, adapter);
+    if (!existsSync(directory)) continue;
+    const directoryMetadata = lstatSync(directory);
+    if (!directoryMetadata.isDirectory() || directoryMetadata.isSymbolicLink()) {
+      throw new Error("V3 producer state directory is unsafe");
+    }
+    for (const name of readdirSync(directory).filter((entry) =>
+      /^hid_[a-f0-9]{64}\.json$/.test(entry),
+    )) {
+      const file = join(directory, name);
+      const metadata = lstatSync(file);
+      if (!metadata.isFile() || metadata.isSymbolicLink()) continue;
+      const value = JSON.parse(readFileSync(file, "utf8")) as Record<string, unknown>;
+      if (
+        value.format !== "harnery-v3-hook-producer" ||
+        value.format_version !== 3 ||
+        value.adapter !== adapter ||
+        value.terminal === true ||
+        typeof value.generation_id !== "string" ||
+        !/^gen_[a-zA-Z0-9._-]+$/.test(value.generation_id) ||
+        !Array.isArray(value.spans)
+      ) {
+        continue;
+      }
+      summaries.push({
+        generation_id: value.generation_id as `gen_${string}`,
+        open_span_count: value.spans.length,
+        turn_open: typeof value.current_turn_id === "string",
+      });
+    }
+  }
+  return summaries.sort((left, right) => left.generation_id.localeCompare(right.generation_id));
+}