harnery 0.34.0 → 0.35.0

package/src/core/events/v3/producers/coordination-recorder.ts

@@ -38,7 +38,7 @@ import {
   type CoordinationObservationBySignalV3,
   normalizeCoordinationAuthorityV3,
 } from "./coordination.ts";
-import { readHookProducerStateV3 } from "./recorder.ts";
+import { readJoinableHookProducerStateV3 } from "./recorder.ts";
 
 const COORDINATION_STATE_FORMAT = "harnery-v3-coordination-producer" as const;
 const COORDINATION_STATE_VERSION = 2 as const;
@@ -124,10 +124,11 @@ export function recordCoordinationAuthorityV3<S extends CoordinationAuthoritySig
 ): RecordCoordinationAuthorityV3Result {
   const control = readEventV3ControlState(input.coordRoot);
   if (control.state !== input.mode) return { state: "gate_closed", reason: control.state };
-  const hook = readHookProducerStateV3(
+  const hook = readJoinableHookProducerStateV3(
     input.coordRoot,
     input.adapter,
     input.native_actor_session_id,
+    input.actor_instance_id,
   );
   if (
     !hook ||
@@ -158,6 +159,16 @@ export function recordCoordinationAuthorityV3<S extends CoordinationAuthoritySig
     if (state && !matchesHookState(state, hook, input, epochId)) {
       throw new Error("V3 coordination producer state does not match the joined hook generation");
     }
+    if (state && state.attestation_id !== hook.attestation_id) {
+      // A mid-generation re-attestation (session.attestation_changed) moves
+      // the hook's attestation id without opening a new generation. The
+      // producer keeps its one continuous sequence, clock, and observation
+      // dedupe for the generation and stamps later events with the live
+      // attestation — the same in-place adoption the hook producer performs.
+      // Refusing here would wedge the producer forever, since its state path
+      // is derived from the generation alone and can never be superseded.
+      state.attestation_id = hook.attestation_id;
+    }
     if (state?.pending) {
       if (state.pending.source_id !== sourceId) {
         // A writer that died mid-commit leaves `pending` owned by an
@@ -313,7 +324,7 @@ export function recordCoordinationAuthorityV3<S extends CoordinationAuthoritySig
 
 function newCoordinationState<S extends CoordinationAuthoritySignalV3>(
   input: RecordCoordinationAuthorityV3Input<S>,
-  hook: NonNullable<ReturnType<typeof readHookProducerStateV3>>,
+  hook: NonNullable<ReturnType<typeof readJoinableHookProducerStateV3>>,
   epochId: `pep_${string}`,
 ): CoordinationRecorderStateV3 {
   return {
@@ -340,7 +351,7 @@ function newCoordinationState<S extends CoordinationAuthoritySignalV3>(
 
 function matchesHookState<S extends CoordinationAuthoritySignalV3>(
   state: CoordinationRecorderStateV3,
-  hook: NonNullable<ReturnType<typeof readHookProducerStateV3>>,
+  hook: NonNullable<ReturnType<typeof readJoinableHookProducerStateV3>>,
   input: RecordCoordinationAuthorityV3Input<S>,
   epochId: string,
 ): boolean {
@@ -349,7 +360,8 @@ function matchesHookState<S extends CoordinationAuthoritySignalV3>(
     state.actor_instance_id === input.actor_instance_id &&
     state.session_id === hook.session_id &&
     state.generation_id === hook.generation_id &&
-    state.attestation_id === hook.attestation_id &&
+    // attestation_id is deliberately absent: a re-attestation within the
+    // generation is a continuation, adopted by the caller, not a mismatch.
     state.privacy_epoch_id === epochId &&
     state.producer_id === input.producer_id &&
     state.build_id === input.build_id &&

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,
       };
@@ -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

@@ -95,6 +95,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 +251,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 +259,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;