harnery 0.38.0 → 0.40.0

package/dist/core/diagnostics/replay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../../src/core/diagnostics/replay.ts"],"names":[],"mappings":"AA0BA,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAE3B,KAAK,oBAAoB,EAC1B,MAAM,eAAe,CAAC;AAEvB,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEpD;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAErD;AAED,kFAAkF;AAClF,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,sBAAsB,EACpC,UAAU,EAAE,oBAAoB,GAC/B,kBAAkB,CAkBpB;AAED,qEAAqE;AACrE,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,sBAAsB,EACpC,UAAU,EAAE,oBAAoB,GAC/B,kBAAkB,CAiDpB"}
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../../src/core/diagnostics/replay.ts"],"names":[],"mappings":"AAgCA,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAE3B,KAAK,oBAAoB,EAC1B,MAAM,eAAe,CAAC;AAOvB,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEpD;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAErD;AAED,kFAAkF;AAClF,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,sBAAsB,EACpC,UAAU,EAAE,oBAAoB,GAC/B,kBAAkB,CAkBpB;AAED,qEAAqE;AACrE,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,sBAAsB,EACpC,UAAU,EAAE,oBAAoB,GAC/B,kBAAkB,CAwDpB"}

package/dist/core/diagnostics/replay.js

@@ -5,8 +5,11 @@ import { explainSupervisorFinding } from "../supervisor/explanations.js";
 import { updateSupervisorFindings } from "../supervisor/findings.js";
 import { projectHookHealth } from "../supervisor/hook-health.js";
 import { buildSupervisorTimeline } from "../supervisor/timeline.js";
-import { buildDiagnosticAdvice } from "./advice.js";
+import { buildDiagnosticAdvice, pressureHistoryFromSupervisor, unknownPressureAssessment, } from "./advice.js";
 import { DIAGNOSTIC_EXPECTED_SCHEMA_VERSION, } from "./contract.js";
+import { assessPressure } from "./pressure.js";
+const PRESSURE_SOURCE = "supervisor.pressure";
+const FINDINGS_SOURCE = "supervisor.findings";
 export function canonicalJson(value) {
     return JSON.stringify(sortValue(value));
 }
@@ -19,7 +22,7 @@ export function deriveCapturedExpected(observations, thresholds) {
     const findings = filterFindings(findingsProjection(sourceValue(observations, "supervisor.findings")), selection);
     const coordination = sourceValue(observations, "coordination.health");
     const relatedSources = coordination?.recent_events ?? [];
-    return expected(thresholds, selection, findings, findings.map((finding) => diagnosticTimeline(finding, relatedSources)), findings.map(explainSupervisorFinding), observations);
+    return expected(thresholds, selection, findings, findings.map((finding) => diagnosticTimeline(finding, relatedSources)), findings.map(explainSupervisorFinding), capturedAdvice(observations, findings));
 }
 /** Re-run the pure finding engine from frozen source inputs only. */
 export function replayDiagnosticInputs(observations, thresholds) {
@@ -27,7 +30,14 @@ export function replayDiagnosticInputs(observations, thresholds) {
         neutralResource(observations.captured_at);
     const supervisor = optionalSource(observations, "supervisor.snapshot") ??
         neutralSupervisor(observations.captured_at);
-    const history = optionalSource(observations, "supervisor.history") ?? neutralHistory();
+    // A captured history is untrusted JSON from a bundle that may predate the
+    // current point shape. Reading it unchecked would let an older capture reach
+    // the trend projection with no pressure readings on its points. The live
+    // observer and the dashboard validate the same way.
+    const capturedHistory = optionalSource(observations, "supervisor.history");
+    const history = capturedHistory?.schema_version === SUPERVISOR_HISTORY_SCHEMA_VERSION
+        ? capturedHistory
+        : neutralHistory();
     const logFeed = optionalSource(observations, "supervisor.log-feed") ??
         neutralLogFeed(observations.captured_at);
     const hookHealth = projectHookHealth(logFeed, new Date(observations.captured_at));
@@ -55,7 +65,81 @@ export function replayDiagnosticInputs(observations, thresholds) {
     });
     const findings = filterFindings(findingsProjection(evaluated), observations.selection);
     const relatedSources = coordination?.recent_events ?? [];
-    return expected(thresholds, observations.selection, findings, findings.map((finding) => diagnosticTimeline(finding, relatedSources)), findings.map(explainSupervisorFinding), observations);
+    return expected(thresholds, observations.selection, findings, findings.map((finding) => diagnosticTimeline(finding, relatedSources)), findings.map(explainSupervisorFinding), replayedAdvice(observations, resource, history, evaluated));
+}
+/**
+ * The live assessment, exactly as the observer published it. Nothing is
+ * recomputed here, because `expected.json` freezes what the machine actually
+ * reported at capture time.
+ */
+function capturedAdvice(observations, findings) {
+    const record = optionalSource(observations, PRESSURE_SOURCE);
+    const capability = capturedSourceCapability(observations, PRESSURE_SOURCE);
+    if (!record?.assessment) {
+        return unavailableAdvice(observations.captured_at, capability);
+    }
+    return buildDiagnosticAdvice({
+        assessment: record.assessment,
+        priorHysteresis: record.prior_hysteresis ?? null,
+        sourceCapability: capability,
+        activeFindingCount: openedCount(findings),
+        evaluatedAt: observations.captured_at,
+    });
+}
+/**
+ * Recompute the assessment from frozen inputs. `prior_hysteresis` comes from
+ * the captured record, so a transition that depended on the previous sample is
+ * reproduced instead of restarting from a cold state.
+ */
+function replayedAdvice(observations, resource, history, evaluated) {
+    const record = optionalSource(observations, PRESSURE_SOURCE);
+    const capability = capturedSourceCapability(observations, PRESSURE_SOURCE);
+    if (!record?.assessment) {
+        return unavailableAdvice(observations.captured_at, capability);
+    }
+    const snapshotAvailable = optionalSource(observations, "resources.snapshot");
+    const findingsCapability = capturedSourceCapability(observations, FINDINGS_SOURCE);
+    const active = [...evaluated.active, ...evaluated.transitions].filter((finding) => finding.state === "opened");
+    const assessment = assessPressure({
+        snapshot: snapshotAvailable ? resource : null,
+        snapshot_reason: snapshotAvailable ? null : "captured_source_unavailable",
+        history: pressureHistoryFromSupervisor(history.points),
+        findings: active,
+        findings_capability: {
+            source_kind: findingsCapability.source_kind,
+            state: findingsCapability.state,
+            ...(findingsCapability.reason_code ? { reason_code: findingsCapability.reason_code } : {}),
+        },
+        prior: record.prior_hysteresis ?? null,
+        observer_generation: record.observer_generation,
+        // Recover the observer's exact clock. `observed_at` is the sample instant
+        // and `sample_age_ms` is how far past it the observer read, so the sum is
+        // the original `now`, which staleness and the OOM hold both depend on.
+        now_ms: Date.parse(record.assessment.observed_at) + (record.assessment.sample_age_ms ?? 0),
+    });
+    return buildDiagnosticAdvice({
+        assessment,
+        priorHysteresis: record.prior_hysteresis ?? null,
+        sourceCapability: capability,
+        activeFindingCount: openedCount(filterFindings(findingsProjection(evaluated), observations.selection)),
+        evaluatedAt: observations.captured_at,
+    });
+}
+function unavailableAdvice(capturedAt, capability) {
+    return buildDiagnosticAdvice({
+        assessment: unknownPressureAssessment({
+            observedAt: capturedAt,
+            reasonCode: "evidence_unavailable",
+            summary: `Local resource pressure cannot be determined because the published assessment is ${capability.state}${capability.reason_code ? ` (${capability.reason_code})` : ""}.`,
+        }),
+        priorHysteresis: null,
+        sourceCapability: capability,
+        activeFindingCount: 0,
+        evaluatedAt: capturedAt,
+    });
+}
+function openedCount(findings) {
+    return findings.filter((finding) => finding.state === "opened").length;
 }
 function diagnosticTimeline(finding, relatedSources) {
     return buildSupervisorTimeline(finding, relatedSources.filter((source) => {
@@ -63,7 +147,7 @@ function diagnosticTimeline(finding, relatedSources) {
         return Number.isFinite(delta) && delta <= 5 * 60_000;
     }));
 }
-function expected(thresholds, selection, findings, timelines, explanations, observations) {
+function expected(thresholds, selection, findings, timelines, explanations, advice) {
     return {
         schema_version: DIAGNOSTIC_EXPECTED_SCHEMA_VERSION,
         threshold_digest: sha256(canonicalJson(thresholds)),
@@ -71,11 +155,7 @@ function expected(thresholds, selection, findings, timelines, explanations, obse
         findings,
         timelines: [...timelines].sort((left, right) => left.finding_id.localeCompare(right.finding_id)),
         explanations: [...explanations].sort((left, right) => left.finding_id.localeCompare(right.finding_id)),
-        advice: buildDiagnosticAdvice({
-            findings,
-            sourceCapability: capturedSourceCapability(observations, "supervisor.findings"),
-            evaluatedAt: observations.captured_at,
-        }),
+        advice,
     };
 }
 function capturedSourceCapability(observations, sourceKind) {

package/dist/core/events/v3/adapter-id.d.ts

@@ -0,0 +1,6 @@
+import type { Adapter } from "../../adapter.js";
+/** Harness identities that may produce or describe Event Ledger V3 evidence. */
+export type EventAdapterIdV3 = Adapter | "openclaw";
+/** Canonical event-adapter census. Workflow launch adapters remain in core/adapter.ts. */
+export declare const EVENT_ADAPTER_IDS_V3: readonly ["claude-code", "codex", "cursor", "openclaw"];
+//# sourceMappingURL=adapter-id.d.ts.map

package/dist/core/events/v3/adapter-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-id.d.ts","sourceRoot":"","sources":["../../../../src/core/events/v3/adapter-id.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEhD,gFAAgF;AAChF,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,UAAU,CAAC;AAEpD,0FAA0F;AAC1F,eAAO,MAAM,oBAAoB,yDAKe,CAAC"}

package/dist/core/events/v3/adapter-id.js

@@ -0,0 +1,7 @@
+/** Canonical event-adapter census. Workflow launch adapters remain in core/adapter.ts. */
+export const EVENT_ADAPTER_IDS_V3 = [
+    "claude-code",
+    "codex",
+    "cursor",
+    "openclaw",
+];

package/dist/core/events/v3/archive-retention.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-retention.d.ts","sourceRoot":"","sources":["../../../../src/core/events/v3/archive-retention.ts"],"names":[],"mappings":"AAAA,qEAAqE;AAYrE,OAAO,EAEL,KAAK,wBAAwB,EAE9B,MAAM,iBAAiB,CAAC;AAEzB,MAAM,MAAM,4BAA4B,GACpC,UAAU,GACV,SAAS,GACT,aAAa,GACb,mBAAmB,GACnB,WAAW,GACX,SAAS,GACT,SAAS,CAAC;AAEd,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,4BAA4B,CAAC;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAAC;IAC5C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,6BAA6B;IAC5C,GAAG,EAAE,OAAO,CAAC;IACb,MAAM,EAAE,OAAO,GAAG,UAAU,GAAG,OAAO,GAAG,SAAS,CAAC;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAKD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,IAAI,CAAC;IAAC,MAAM,CAAC,EAAE,wBAAwB,CAAA;CAAO,GAC3D,mBAAmB,EAAE,CA4CvB;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,IAAI,CAAC;IAAC,MAAM,CAAC,EAAE,wBAAwB,CAAA;CAAO,GAC1E,mBAAmB,EAAE,CAqCvB;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,IAAI,CAAA;CAAO,GACxB,6BAA6B,CAgC/B"}
+{"version":3,"file":"archive-retention.d.ts","sourceRoot":"","sources":["../../../../src/core/events/v3/archive-retention.ts"],"names":[],"mappings":"AAAA,qEAAqE;AAYrE,OAAO,EAAE,KAAK,wBAAwB,EAA4B,MAAM,iBAAiB,CAAC;AAE1F,MAAM,MAAM,4BAA4B,GACpC,UAAU,GACV,SAAS,GACT,aAAa,GACb,mBAAmB,GACnB,WAAW,GACX,SAAS,GACT,SAAS,CAAC;AAEd,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,4BAA4B,CAAC;IAC7C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAAC;IAC5C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,6BAA6B;IAC5C,GAAG,EAAE,OAAO,CAAC;IACb,MAAM,EAAE,OAAO,GAAG,UAAU,GAAG,OAAO,GAAG,SAAS,CAAC;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAKD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,IAAI,CAAC;IAAC,MAAM,CAAC,EAAE,wBAAwB,CAAA;CAAO,GAC3D,mBAAmB,EAAE,CA4CvB;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,OAAO,CAAC;IAAC,GAAG,CAAC,EAAE,IAAI,CAAC;IAAC,MAAM,CAAC,EAAE,wBAAwB,CAAA;CAAO,GAC1E,mBAAmB,EAAE,CAqCvB;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,IAAI,CAAA;CAAO,GACxB,6BAA6B,CAiC/B"}

package/dist/core/events/v3/archive-retention.js

@@ -1,7 +1,7 @@
 /** Bounded retention for complete, closed Event Ledger V3 epochs. */
 import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
 import { basename, join, relative, resolve } from "node:path";
-import { artifactAutoCleanIntervalHours, eventLedgerArchivePolicy, } from "../../config.js";
+import { eventLedgerArchivePolicy } from "../../config.js";
 const ARCHIVE_PATTERN = /^epoch-[0-9]+(?:-[0-9]+)?$/;
 const AUTO_CLEAN_STAMP = ".harnery/event-v3-archive-auto-clean.json";
 export function eventV3ArchivesRoot(repoRoot) {
@@ -95,7 +95,8 @@ export function autoCleanEventV3Archives(repoRoot, opts = {}) {
     if (!policy.autoClean)
         return { ran: false, reason: "disabled", deleted: 0, bytes: 0 };
     const stampPath = join(resolve(repoRoot), AUTO_CLEAN_STAMP);
-    const intervalMs = artifactAutoCleanIntervalHours() * 60 * 60 * 1000;
+    // Archive cleanup remains daily, independent of short-lived working files.
+    const intervalMs = 24 * 60 * 60 * 1000;
     try {
         const stamp = JSON.parse(readFileSync(stampPath, "utf8"));
         const last = Date.parse(stamp.last_run_at ?? "");

package/dist/core/events/v3/bootstrap.d.ts

@@ -6,6 +6,16 @@ export interface InitializeEventLedgerV3Input {
     configDigest: `sha256:${string}`;
     approvalRecordId: string;
     forceNewEpoch?: boolean;
+    /**
+     * Activate a candidate epoch that was already created for this root.
+     *
+     * Unset, this activates a candidate that carries this initializer's producer
+     * identity and refuses every other one. Creation and activation are one
+     * locked step here, so such a candidate is the residue of a crash or a
+     * failed activation, never work in progress; a candidate from another
+     * producer is a deliberate cutover state. Set it explicitly to force either
+     * answer.
+     */
     resumeCandidate?: boolean;
     now?: () => Date;
 }
@@ -44,6 +54,30 @@ export declare function initializeEventLedgerV3(input: InitializeEventLedgerV3In
  * explicit recovery command.
  */
 export declare function refreshIncompatibleEventLedgerV3(coordRoot: string): RefreshIncompatibleEventLedgerV3Result;
+export interface RepairStrandedEventLedgerV3CandidateResult {
+    state: "repaired" | "not_stranded" | "unavailable";
+    reason?: string;
+    control: EventV3ControlState;
+}
+/** The approval record every automatic stranded-candidate repair is bound to. */
+export declare const EVENT_V3_STRANDED_CANDIDATE_APPROVAL_RECORD_ID: "harnery-runtime-v3-stranded-candidate";
+/**
+ * Complete an epoch that was created but never activated.
+ *
+ * This initializer creates a candidate and activates it inside one lease, so a
+ * candidate carrying its producer identity is residue: some process published
+ * the genesis and died or failed before publishing the activation, and every
+ * hook afterwards served that half-built epoch with a candidate-only write
+ * gate. Finishing it is a repair, not a decision, and it is exactly as safe as
+ * the creation it completes: the same lease serializes it, the activation is
+ * derived from the immutable candidate packet, and no ledger row is edited or
+ * synthesized.
+ *
+ * A candidate from any other producer is a deliberate cutover state and is
+ * left untouched. A live bootstrap lease makes this a no-op rather than a
+ * failure, so the next boundary retries.
+ */
+export declare function repairStrandedEventLedgerV3Candidate(coordRoot: string): RepairStrandedEventLedgerV3CandidateResult;
 export interface RotateOversizedEventLedgerV3Result {
     state: "rotated" | "not_oversized" | "not_active" | "disabled";
     active_bytes: number;
@@ -62,10 +96,13 @@ export interface RotateOversizedEventLedgerV3Result {
  * (events, spool, producer states, manifests) moves whole into the V3
  * archive, live sessions re-onboard into the new epoch on their next signal,
  * and the writer's epoch fence keeps in-flight producers of the old epoch
- * from ever committing into the new one. Only a currently valid, active
- * ledger rotates; integrity failures stay closed for the explicit recovery
- * command. The threshold comes from the isolated Event V3 config resolver
- * unless the caller pins one; a non-positive threshold disables rotation.
+ * from ever committing into the new one. A candidate epoch rotates on the same
+ * terms as an active one: its control pair is valid, every reader still
+ * validates all of its history, and refusing to bound it is how a stranded
+ * epoch grew to 100 MB. Integrity failures stay closed for the explicit
+ * recovery command. The threshold comes from the isolated Event V3 config
+ * resolver unless the caller pins one; a non-positive threshold disables
+ * rotation.
  */
 export declare function rotateOversizedEventLedgerV3(coordRoot: string, options?: {
     thresholdBytes?: number;

package/dist/core/events/v3/bootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../../src/core/events/v3/bootstrap.ts"],"names":[],"mappings":"AAoBA,OAAO,EAML,KAAK,mBAAmB,EAEzB,MAAM,cAAc,CAAC;AAStB,MAAM,WAAW,4BAA4B;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,UAAU,MAAM,EAAE,CAAC;IACjC,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,6BAA6B;IAC5C,KAAK,EAAE,QAAQ,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC,mBAAmB,EAAE;QAAE,KAAK,EAAE,QAAQ,CAAA;KAAE,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,sCAAsC;IACrD,KAAK,EAAE,SAAS,GAAG,WAAW,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC,mBAAmB,EAAE;QAAE,KAAK,EAAE,QAAQ,CAAA;KAAE,CAAC,CAAC;CAC5D;AAOD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,gBAAgB,SAAiC,GAChD,OAAO,CAAC,mBAAmB,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAA;CAAE,CAAC,CAenD;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,4BAA4B,GAClC,6BAA6B,CAE/B;AAED;;;;GAIG;AACH,wBAAgB,gCAAgC,CAC9C,SAAS,EAAE,MAAM,GAChB,sCAAsC,CAgCxC;AAED,MAAM,WAAW,kCAAkC;IACjD,KAAK,EAAE,SAAS,GAAG,eAAe,GAAG,YAAY,GAAG,UAAU,CAAC;IAC/D,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC,mBAAmB,EAAE;QAAE,KAAK,EAAE,QAAQ,CAAA;KAAE,CAAC,CAAC;CAC7D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,cAAc,CAAC,EAAE,MAAM,CAAA;CAAO,GACxC,kCAAkC,CA8DpC"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../../src/core/events/v3/bootstrap.ts"],"names":[],"mappings":"AAsBA,OAAO,EAOL,KAAK,mBAAmB,EAEzB,MAAM,cAAc,CAAC;AAStB,MAAM,WAAW,4BAA4B;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,UAAU,MAAM,EAAE,CAAC;IACjC,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;;OASG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,6BAA6B;IAC5C,KAAK,EAAE,QAAQ,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC,mBAAmB,EAAE;QAAE,KAAK,EAAE,QAAQ,CAAA;KAAE,CAAC,CAAC;CAC5D;AAED,MAAM,WAAW,sCAAsC;IACrD,KAAK,EAAE,SAAS,GAAG,WAAW,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC,mBAAmB,EAAE;QAAE,KAAK,EAAE,QAAQ,CAAA;KAAE,CAAC,CAAC;CAC5D;AAkBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,gBAAgB,SAAiC,GAChD,OAAO,CAAC,mBAAmB,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAA;CAAE,CAAC,CAenD;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,4BAA4B,GAClC,6BAA6B,CAE/B;AAED;;;;GAIG;AACH,wBAAgB,gCAAgC,CAC9C,SAAS,EAAE,MAAM,GAChB,sCAAsC,CAgCxC;AAED,MAAM,WAAW,0CAA0C;IACzD,KAAK,EAAE,UAAU,GAAG,cAAc,GAAG,aAAa,CAAC;IACnD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,mBAAmB,CAAC;CAC9B;AAED,iFAAiF;AACjF,eAAO,MAAM,8CAA8C,EACzD,uCAAgD,CAAC;AAEnD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oCAAoC,CAClD,SAAS,EAAE,MAAM,GAChB,0CAA0C,CA6B5C;AAWD,MAAM,WAAW,kCAAkC;IACjD,KAAK,EAAE,SAAS,GAAG,eAAe,GAAG,YAAY,GAAG,UAAU,CAAC;IAC/D,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC,mBAAmB,EAAE;QAAE,KAAK,EAAE,QAAQ,CAAA;KAAE,CAAC,CAAC;CAC7D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,cAAc,CAAC,EAAE,MAAM,CAAA;CAAO,GACxC,kCAAkC,CA8DpC"}

package/dist/core/events/v3/bootstrap.js

@@ -1,8 +1,9 @@
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, statSync, writeFileSync, } from "node:fs";
+import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
 import { hostname } from "node:os";
 import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { fsyncParentDirectory } from "../../workflow/durable-record.js";
 import { acquireNoClobberLease } from "../../workflow/workspaces/leases.js";
 import { canonicalJsonV3, sha256V3 } from "./canonical.js";
@@ -15,6 +16,16 @@ import { reanchorArchivedHookProducersV3 } from "./producers/recorder.js";
 import { resolveEventLedgerRotateActiveBytesV3 } from "./rotation-config.js";
 import { currentHarneryRuntimeBuild, liveEventV3BuildId, livePlatformV3 } from "./runtime-build.js";
 import { drainReadyEventsV3 } from "./writer.js";
+/**
+ * The control producer every epoch created by this initializer carries.
+ *
+ * It separates a stranded epoch from a deliberate one. A candidate minted here
+ * was always meant to be activated in the same locked step, so finishing it is
+ * a repair. A candidate published by any other producer (an operator cutover or
+ * rollback rehearsal) is a state someone chose, and automatic activation would
+ * overrule them.
+ */
+const BOOTSTRAP_CONTROL_PRODUCER_ID = "prd_harnery-init";
 const BOOTSTRAP_LEASE_RETRIES = 12;
 const BOOTSTRAP_LEASE_RETRY_MS = 25;
 const BOOTSTRAP_LEASE_STALE_MS = 10_000;
@@ -84,6 +95,56 @@ export function refreshIncompatibleEventLedgerV3(coordRoot) {
         };
     });
 }
+/** The approval record every automatic stranded-candidate repair is bound to. */
+export const EVENT_V3_STRANDED_CANDIDATE_APPROVAL_RECORD_ID = "harnery-runtime-v3-stranded-candidate";
+/**
+ * Complete an epoch that was created but never activated.
+ *
+ * This initializer creates a candidate and activates it inside one lease, so a
+ * candidate carrying its producer identity is residue: some process published
+ * the genesis and died or failed before publishing the activation, and every
+ * hook afterwards served that half-built epoch with a candidate-only write
+ * gate. Finishing it is a repair, not a decision, and it is exactly as safe as
+ * the creation it completes: the same lease serializes it, the activation is
+ * derived from the immutable candidate packet, and no ledger row is edited or
+ * synthesized.
+ *
+ * A candidate from any other producer is a deliberate cutover state and is
+ * left untouched. A live bootstrap lease makes this a no-op rather than a
+ * failure, so the next boundary retries.
+ */
+export function repairStrandedEventLedgerV3Candidate(coordRoot) {
+    const root = resolve(coordRoot);
+    const observed = readEventV3ControlState(root);
+    const deliberateCandidate = observed.state === "candidate";
+    if (!strandedBootstrapCandidate(observed)) {
+        return {
+            state: "not_stranded",
+            control: observed,
+            ...(deliberateCandidate ? { reason: "candidate_not_bootstrap_created" } : {}),
+        };
+    }
+    try {
+        return withBootstrapLease(root, () => {
+            const current = readEventV3ControlState(root);
+            if (!strandedBootstrapCandidate(current))
+                return { state: "not_stranded", control: current };
+            const activated = activateCandidateEpoch(root, current.genesis, EVENT_V3_STRANDED_CANDIDATE_APPROVAL_RECORD_ID);
+            return { state: "repaired", control: activated.control };
+        });
+    }
+    catch (error) {
+        return {
+            state: "unavailable",
+            reason: error instanceof Error ? error.message : String(error),
+            control: observed,
+        };
+    }
+}
+function strandedBootstrapCandidate(control) {
+    return (control.state === "candidate" &&
+        control.genesis.event.producer.producer_id === BOOTSTRAP_CONTROL_PRODUCER_ID);
+}
 /**
  * Archive a valid oversized epoch intact and start a fresh one.
  *
@@ -93,10 +154,13 @@ export function refreshIncompatibleEventLedgerV3(coordRoot) {
  * (events, spool, producer states, manifests) moves whole into the V3
  * archive, live sessions re-onboard into the new epoch on their next signal,
  * and the writer's epoch fence keeps in-flight producers of the old epoch
- * from ever committing into the new one. Only a currently valid, active
- * ledger rotates; integrity failures stay closed for the explicit recovery
- * command. The threshold comes from the isolated Event V3 config resolver
- * unless the caller pins one; a non-positive threshold disables rotation.
+ * from ever committing into the new one. A candidate epoch rotates on the same
+ * terms as an active one: its control pair is valid, every reader still
+ * validates all of its history, and refusing to bound it is how a stranded
+ * epoch grew to 100 MB. Integrity failures stay closed for the explicit
+ * recovery command. The threshold comes from the isolated Event V3 config
+ * resolver unless the caller pins one; a non-positive threshold disables
+ * rotation.
  */
 export function rotateOversizedEventLedgerV3(coordRoot, options = {}) {
     const root = resolve(coordRoot);
@@ -122,7 +186,7 @@ export function rotateOversizedEventLedgerV3(coordRoot, options = {}) {
             return { state: "not_oversized", active_bytes: activeBytes, threshold_bytes: threshold };
         }
         const current = readEventV3ControlState(root);
-        if (current.state !== "active") {
+        if (current.state !== "active" && current.state !== "candidate") {
             return { state: "not_active", active_bytes: activeBytes, threshold_bytes: threshold };
         }
         // Flush durable ready rows into the epoch they were produced for, so the
@@ -164,13 +228,14 @@ export function rotateOversizedEventLedgerV3(coordRoot, options = {}) {
 function initializeEventLedgerV3Locked(input) {
     const root = resolve(input.coordRoot);
     let current = readEventV3ControlState(root);
-    if (input.resumeCandidate && current.state === "repairable") {
+    const resumeCandidate = input.resumeCandidate ?? strandedBootstrapCandidate(current);
+    if (resumeCandidate && current.state === "repairable") {
         current = repairEventV3ControlPair(root);
     }
     if (!input.forceNewEpoch && current.state === "active") {
         return { state: "active", initialized: false, control: current };
     }
-    if (!input.forceNewEpoch && input.resumeCandidate && current.state === "candidate") {
+    if (!input.forceNewEpoch && resumeCandidate && current.state === "candidate") {
         return activateCandidateEpoch(root, current.genesis, input.approvalRecordId);
     }
     if (!input.forceNewEpoch && current.state === "candidate") {
@@ -178,11 +243,10 @@ function initializeEventLedgerV3Locked(input) {
     }
     const now = input.now ?? (() => new Date());
     const createdAt = now().toISOString();
-    const archivedEpoch = archiveCurrentEpoch(root, createdAt);
     const keys = loadOrCreateFingerprintKeyStoreV3(root, now);
     const harneryBuild = safeBuild(input.harneryBuild);
     const hostBuild = safeBuild(input.hostBuild);
-    const producerId = "prd_harnery-init";
+    const producerId = BOOTSTRAP_CONTROL_PRODUCER_ID;
     const bootId = `boot_${createHash("sha256").update(`${root}\0${createdAt}`).digest("hex")}`;
     const buildId = liveEventV3BuildId(harneryBuild);
     const rootId = `root_${createHash("sha256").update(root).digest("hex")}`;
@@ -214,17 +278,35 @@ function initializeEventLedgerV3Locked(input) {
             platform: livePlatformV3(),
         },
     });
+    // Mint the complete control pair before any epoch bytes move. Every approval
+    // and validation failure then happens while the current epoch is still
+    // whole, so it can never leave a replaced epoch stranded in candidate state.
+    const activation = buildActivationManifestV3(activationInput(candidate, input.approvalRecordId));
+    const archivedEpoch = archiveCurrentEpoch(root, createdAt);
     publishControlFile(join(root, EVENT_V3_GENESIS_MANIFEST), candidate);
-    const candidateState = repairEventV3ControlPair(root);
-    if (candidateState.state !== "candidate") {
-        throw new Error(`event_v3_candidate_initialization_failed:${candidateState.state}`);
+    let activated;
+    try {
+        activated = completeCandidateActivation(root, activation);
+    }
+    catch (error) {
+        // The epoch has already been replaced, so returning here would strand it.
+        // Retry the completion inside the same lease and, failing that, name the
+        // stranded epoch rather than reporting a successful initialization.
+        activated = completeStrandedCandidateActivation(root, activation, error);
     }
-    const activated = activateCandidateEpoch(root, candidate, input.approvalRecordId);
     return {
         ...activated,
         ...(archivedEpoch ? { archived_epoch: archivedEpoch } : {}),
     };
 }
+function completeStrandedCandidateActivation(root, activation, cause) {
+    try {
+        return completeCandidateActivation(root, activation);
+    }
+    catch {
+        throw new Error(`event_v3_epoch_stranded_before_activation:${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+}
 function runtimeCapabilityProfileCurrent(control) {
     const expected = Object.values(ADAPTER_CAPABILITY_PROFILES_V3).map((profile) => sha256V3(canonicalJsonV3(profile)));
     const approved = control.genesis.profile.adapter_capability_profile_digests;
@@ -275,8 +357,12 @@ function pidIsAlive(pid) {
     }
 }
 function activateCandidateEpoch(root, candidate, approvalRecordId) {
+    return completeCandidateActivation(root, buildActivationManifestV3(activationInput(candidate, approvalRecordId)));
+}
+/** The activation packet one exact candidate deserves, derived and pure. */
+function activationInput(candidate, approvalRecordId) {
     const producer = candidate.event.producer;
-    const activation = buildActivationManifestV3({
+    return {
         candidate,
         approval_record_id: approvalRecordId,
         activation_approved_at: candidate.profile.candidate_created_at,
@@ -288,7 +374,19 @@ function activateCandidateEpoch(root, candidate, approvalRecordId) {
             platform: producer.platform,
             ...(producer.bridge ? { bridge: producer.bridge } : {}),
         },
-    });
+    };
+}
+/**
+ * Bring a published candidate to active: append the pre-minted genesis event
+ * if a crash left it missing, publish the activation manifest, then append its
+ * pre-minted event. Every step is idempotent, so the caller may retry it, and
+ * anything short of `active` throws with the state that blocked it.
+ */
+function completeCandidateActivation(root, activation) {
+    const candidateState = repairEventV3ControlPair(root);
+    if (candidateState.state !== "candidate") {
+        throw new Error(`event_v3_candidate_initialization_failed:${candidateState.state}`);
+    }
     publishControlFile(join(root, EVENT_V3_ACTIVATION_MANIFEST), activation);
     const active = repairEventV3ControlPair(root);
     if (active.state !== "active") {
@@ -314,6 +412,11 @@ function archiveCurrentEpoch(root, createdAt) {
 function publishControlFile(path, value) {
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
     const temp = `${path}.tmp.${process.pid}`;
+    // A prior failed publish by this same pid would otherwise make every retry
+    // fail on the exclusive create, which is exactly how one transient error
+    // turns into a permanently stranded epoch.
+    if (existsSync(temp))
+        unlinkSync(temp);
     const fd = openSync(temp, "wx", 0o600);
     try {
         writeFileSync(fd, `${canonicalJsonV3(value)}\n`, "utf8");
@@ -335,7 +438,7 @@ function safeBuild(value) {
         .digest("hex");
 }
 function rootOfHarnery() {
-    return resolve(import.meta.dir, "../../../..");
+    return resolve(dirname(fileURLToPath(import.meta.url)), "../../../..");
 }
 function repositoryBuild(root) {
     const result = spawnSync("git", ["-C", root, "rev-parse", "HEAD"], {

package/dist/core/events/v3/capabilities.d.ts

@@ -1,5 +1,6 @@
-import type { Adapter } from "../../adapter.js";
+import type { EventAdapterIdV3 } from "./adapter-id.js";
 export type CapabilitySupportV3 = "native" | "derived" | "conditional" | "unsupported";
+export type AdapterDurationCapabilityV3 = "turn_duration" | "tool_duration";
 export type CursorExecutionModeV3 = "local" | "cloud" | "unknown";
 export type AdapterWaitKindV3 = "permission" | "needs_input" | "decision" | "approval" | "scheduled" | "rate_limit" | "unknown";
 export declare const ADAPTER_WAIT_KINDS_V3: readonly AdapterWaitKindV3[];
@@ -12,27 +13,33 @@ export type AdapterSignalV3 = BaseAdapterSignalV3 | "model_usage" | "inference_t
 export interface AdapterCapabilityProfileV3 {
     format: "harnery-v3-adapter-capabilities";
     format_version: 1;
-    adapter: Adapter;
+    adapter: EventAdapterIdV3;
     signals: Record<AdapterSignalV3, CapabilitySupportV3>;
 }
-export declare const ADAPTER_CAPABILITY_PROFILES_V3: Record<Adapter, AdapterCapabilityProfileV3>;
-export declare function adapterCapabilityProfileV3(adapter: Adapter): AdapterCapabilityProfileV3;
-export declare function adapterCapabilityProfileDigestV3(adapter: Adapter): `cap_${string}`;
-export declare function adapterSignalSupportV3(adapter: Adapter, signal: AdapterSignalV3): CapabilitySupportV3;
+export declare const ADAPTER_CAPABILITY_PROFILES_V3: Record<EventAdapterIdV3, AdapterCapabilityProfileV3>;
+export declare function adapterCapabilityProfileV3(adapter: EventAdapterIdV3): AdapterCapabilityProfileV3;
+export declare function adapterCapabilityProfileDigestV3(adapter: EventAdapterIdV3): `cap_${string}`;
+export declare function adapterSignalSupportV3(adapter: EventAdapterIdV3, signal: AdapterSignalV3): CapabilitySupportV3;
+/**
+ * Duration support for terminal spans. Tool duration is part of the digested
+ * adapter profile. Turn duration predates that profile dimension, so keep its
+ * compatibility-preserving classification here until the next contract major.
+ */
+export declare function adapterDurationSupportV3(adapter: EventAdapterIdV3, capability: AdapterDurationCapabilityV3): CapabilitySupportV3;
 /**
  * Adapter hooks only expose permission waits today. Other wait kinds can be
  * authored by coordination producers, but they are not observable from an
  * adapter's native turn channel.
  */
-export declare function adapterWaitKindSupportV3(adapter: Adapter, kind: AdapterWaitKindV3): CapabilitySupportV3;
+export declare function adapterWaitKindSupportV3(adapter: EventAdapterIdV3, kind: AdapterWaitKindV3): CapabilitySupportV3;
 /** No current adapter supplies an independent completed-turn wait aggregate. */
-export declare function adapterTurnWaitCountSupportV3(_adapter: Adapter): CapabilitySupportV3;
+export declare function adapterTurnWaitCountSupportV3(_adapter: EventAdapterIdV3): CapabilitySupportV3;
 /**
  * Per-kind wait matrix for native adapter turns. Span delivery and independent
  * completed-turn completeness are deliberately separate: observing a span
  * never proves that an absent span means zero.
  */
-export declare function adapterWaitCoverageMatrixV3(adapter: Adapter): Record<AdapterWaitKindV3, WaitKindCapabilityV3>;
+export declare function adapterWaitCoverageMatrixV3(adapter: EventAdapterIdV3): Record<AdapterWaitKindV3, WaitKindCapabilityV3>;
 /**
  * Local Cursor sessions expose the generic tool channel. Cloud/private-worker
  * sessions cannot guarantee whole-turn delivery because hooks may start only

package/dist/core/events/v3/capabilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../../src/core/events/v3/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAGhD,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,SAAS,GAAG,aAAa,GAAG,aAAa,CAAC;AAEvF,MAAM,MAAM,qBAAqB,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;AAElE,MAAM,MAAM,iBAAiB,GACzB,YAAY,GACZ,aAAa,GACb,UAAU,GACV,UAAU,GACV,WAAW,GACX,YAAY,GACZ,SAAS,CAAC;AAEd,eAAO,MAAM,qBAAqB,EAAE,SAAS,iBAAiB,EAQpD,CAAC;AAEX,MAAM,WAAW,oBAAoB;IACnC,aAAa,EAAE,mBAAmB,CAAC;IACnC,iBAAiB,EAAE,mBAAmB,CAAC;CACxC;AAED,MAAM,MAAM,mBAAmB,GAC3B,eAAe,GACf,aAAa,GACb,QAAQ,GACR,SAAS,GACT,iBAAiB,GACjB,sBAAsB,GACtB,cAAc,GACd,aAAa,GACb,cAAc,GACd,cAAc,GACd,eAAe,GACf,YAAY,GACZ,UAAU,GACV,OAAO,GACP,gBAAgB,GAChB,iBAAiB,GACjB,eAAe,GACf,gBAAgB,CAAC;AAErB,MAAM,MAAM,eAAe,GACvB,mBAAmB,GACnB,aAAa,GACb,kBAAkB,GAClB,gBAAgB,GAChB,kBAAkB,CAAC;AAEvB,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,iCAAiC,CAAC;IAC1C,cAAc,EAAE,CAAC,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC,eAAe,EAAE,mBAAmB,CAAC,CAAC;CACvD;AAoED,eAAO,MAAM,8BAA8B,EAAE,MAAM,CAAC,OAAO,EAAE,0BAA0B,CAatF,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,0BAA0B,CAEvF;AAED,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,MAAM,EAAE,CAElF;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,eAAe,GACtB,mBAAmB,CAErB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,iBAAiB,GACtB,mBAAmB,CAErB;AAED,gFAAgF;AAChF,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,OAAO,GAAG,mBAAmB,CAEpF;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,OAAO,GACf,MAAM,CAAC,iBAAiB,EAAE,oBAAoB,CAAC,CAUjD;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,qBAAqB,GAAG,mBAAmB,CAI3F"}
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../../src/core/events/v3/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGxD,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,SAAS,GAAG,aAAa,GAAG,aAAa,CAAC;AAEvF,MAAM,MAAM,2BAA2B,GAAG,eAAe,GAAG,eAAe,CAAC;AAE5E,MAAM,MAAM,qBAAqB,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;AAElE,MAAM,MAAM,iBAAiB,GACzB,YAAY,GACZ,aAAa,GACb,UAAU,GACV,UAAU,GACV,WAAW,GACX,YAAY,GACZ,SAAS,CAAC;AAEd,eAAO,MAAM,qBAAqB,EAAE,SAAS,iBAAiB,EAQpD,CAAC;AAEX,MAAM,WAAW,oBAAoB;IACnC,aAAa,EAAE,mBAAmB,CAAC;IACnC,iBAAiB,EAAE,mBAAmB,CAAC;CACxC;AAED,MAAM,MAAM,mBAAmB,GAC3B,eAAe,GACf,aAAa,GACb,QAAQ,GACR,SAAS,GACT,iBAAiB,GACjB,sBAAsB,GACtB,cAAc,GACd,aAAa,GACb,cAAc,GACd,cAAc,GACd,eAAe,GACf,YAAY,GACZ,UAAU,GACV,OAAO,GACP,gBAAgB,GAChB,iBAAiB,GACjB,eAAe,GACf,gBAAgB,CAAC;AAErB,MAAM,MAAM,eAAe,GACvB,mBAAmB,GACnB,aAAa,GACb,kBAAkB,GAClB,gBAAgB,GAChB,kBAAkB,CAAC;AAEvB,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,iCAAiC,CAAC;IAC1C,cAAc,EAAE,CAAC,CAAC;IAClB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC,eAAe,EAAE,mBAAmB,CAAC,CAAC;CACvD;AA4FD,eAAO,MAAM,8BAA8B,EAAE,MAAM,CAAC,gBAAgB,EAAE,0BAA0B,CAsB7F,CAAC;AAEJ,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,gBAAgB,GAAG,0BAA0B,CAEhG;AAED,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,MAAM,EAAE,CAE3F;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,eAAe,GACtB,mBAAmB,CAErB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,gBAAgB,EACzB,UAAU,EAAE,2BAA2B,GACtC,mBAAmB,CAKrB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,gBAAgB,EACzB,IAAI,EAAE,iBAAiB,GACtB,mBAAmB,CAErB;AAED,gFAAgF;AAChF,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,gBAAgB,GAAG,mBAAmB,CAE7F;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,gBAAgB,GACxB,MAAM,CAAC,iBAAiB,EAAE,oBAAoB,CAAC,CAUjD;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,qBAAqB,GAAG,mBAAmB,CAI3F"}

package/dist/core/events/v3/capabilities.js

@@ -54,8 +54,28 @@ const BASE_SIGNAL_SUPPORT = {
         post_compaction: "unsupported",
         context_usage: "conditional",
     },
+    openclaw: {
+        session_start: "conditional",
+        session_end: "native",
+        prompt: "native",
+        turn_id: "native",
+        turn_completion: "native",
+        assistant_reply_text: "unsupported",
+        tool_request: "native",
+        tool_result: "native",
+        tool_failure: "conditional",
+        tool_call_id: "native",
+        tool_duration: "unsupported",
+        permission: "unsupported",
+        subagent: "unsupported",
+        shell: "native",
+        pre_compaction: "unsupported",
+        post_compaction: "unsupported",
+        context_usage: "unsupported",
+        model_identity: "unsupported",
+    },
 };
-function profile(adapter, economics) {
+function profile(adapter, economics, harnessTiming = "derived") {
     return {
         format: "harnery-v3-adapter-capabilities",
         format_version: 1,
@@ -63,7 +83,7 @@ function profile(adapter, economics) {
         signals: {
             ...BASE_SIGNAL_SUPPORT[adapter],
             ...economics,
-            harness_timing: "derived",
+            harness_timing: harnessTiming,
             capability_drift: "derived",
         },
     };
@@ -81,6 +101,10 @@ export const ADAPTER_CAPABILITY_PROFILES_V3 = {
         model_usage: "unsupported",
         inference_timing: "unsupported",
     }),
+    openclaw: profile("openclaw", {
+        model_usage: "unsupported",
+        inference_timing: "unsupported",
+    }, "unsupported"),
 };
 export function adapterCapabilityProfileV3(adapter) {
     return ADAPTER_CAPABILITY_PROFILES_V3[adapter];
@@ -91,6 +115,17 @@ export function adapterCapabilityProfileDigestV3(adapter) {
 export function adapterSignalSupportV3(adapter, signal) {
     return adapterCapabilityProfileV3(adapter).signals[signal];
 }
+/**
+ * Duration support for terminal spans. Tool duration is part of the digested
+ * adapter profile. Turn duration predates that profile dimension, so keep its
+ * compatibility-preserving classification here until the next contract major.
+ */
+export function adapterDurationSupportV3(adapter, capability) {
+    if (capability === "tool_duration") {
+        return adapterSignalSupportV3(adapter, "tool_duration");
+    }
+    return adapter === "openclaw" ? "unsupported" : "derived";
+}
 /**
  * Adapter hooks only expose permission waits today. Other wait kinds can be
  * authored by coordination producers, but they are not observable from an