warpmetal 0.8.13 → 0.9.1

package/src/contracts/insights.js

@@ -0,0 +1,133 @@
+// Generated from worker/account/insights.ts; SHA-256 826eb08f9496415b408fe943d9eec33a6c8480a52474df76c118f471f6d42d1f.
+/** Sanitized owner Insights projection and explicit metadata-only mutations. */
+import { isPlainObject } from "./http.js";
+export const FINDING_ID = /^finding_[A-Za-z0-9_-]{4,96}$/;
+export const INSIGHTS_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const RULES = ["repeated_identical_failure@1", "repeated_identical_call@1", "empty_result_loop@1", "suspected_stall@1"];
+const GAPS = ["monitor_gap", "journal_generation_changed", "cursor_ahead", "source_unavailable", "unsupported_agent_version", "monitor_disabled", "export_unavailable", "capacity_exceeded"];
+const PHASES = ["unknown", "idle", "running_model", "running_tool", "running_background", "waiting_permission", "waiting_input", "waiting_retry", "compacting"];
+const SUGGESTIONS = ["inspect_first_failure", "check_repeated_operation", "refine_query", "inspect_active_phase"];
+const RECOVERY = ["matching_operation_succeeded", "qualified_progress_resumed", "nonempty_refined_query", "qualified_progress_resumed"];
+const id = (value, pattern = INSIGHTS_ID) => typeof value === "string" && pattern.test(value);
+const positive = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+const date = (value) => typeof value === "string" && value.length <= 40 && Number.isFinite(Date.parse(value));
+const oneOf = (value, options) => typeof value === "string" && options.includes(value);
+const pick = (value, keys) => Object.fromEntries(keys.map(key => [key, value[key]]));
+const exact = (value, keys) => isPlainObject(value) && Object.keys(value).length === keys.length && keys.every(key => key in value);
+export function insightsMutation(value, action = false) {
+    const keys = ["version", "requestId", "expectedRevision", ...(action ? ["action", "snoozeSeconds"] : ["enabled"])];
+    if (!exact(value, keys) || value.version !== 1 || !id(value.requestId) || !positive(value.expectedRevision))
+        return null;
+    if (!action)
+        return typeof value.enabled === "boolean" ? value : null;
+    if (value.action === "snooze")
+        return positive(value.snoozeSeconds) && value.snoozeSeconds >= 60 && value.snoozeSeconds <= 86400 ? value : null;
+    return oneOf(value.action, ["acknowledge", "dismiss"]) && value.snoozeSeconds === null ? value : null;
+}
+export function insightsQuery(params) {
+    const result = new URLSearchParams();
+    for (const key of params.keys()) {
+        if (!["limit", "cursor", "state", "session", "severity", "attention", "rule", "recentHours"].includes(key) || params.getAll(key).length !== 1)
+            return null;
+        const value = params.get(key);
+        if (key === "limit" ? !/^[1-9][0-9]{0,2}$/.test(value) || Number(value) > 100
+            : key === "cursor" ? !id(value, FINDING_ID) : key === "session" ? !id(value)
+                : key === "state" ? !["open", "resolved"].includes(value)
+                    : key === "attention" ? !["unacknowledged", "acknowledged", "snoozed", "dismissed"].includes(value)
+                        : key === "rule" ? !RULES.includes(value) : key === "recentHours" ? !["1", "24", "168", "720"].includes(value) : value !== "warning")
+            return null;
+        result.set(key, value);
+    }
+    return result.size ? `?${result}` : "";
+}
+export function projectInsightsSettings(value) {
+    if (!isPlainObject(value) || !isPlainObject(value.settings))
+        return null;
+    const s = value.settings;
+    if (s.version !== 1 || !positive(s.revision) || typeof s.enabled !== "boolean" ||
+        !(s.observedRevision === null || positive(s.observedRevision) && s.observedRevision <= s.revision) ||
+        !oneOf(s.status, ["pending", "ready", "degraded", "unsupported", "disabled", "unavailable"]) ||
+        !(s.lastObservedAt === null || date(s.lastObservedAt)) || !(s.gapReason === null || oneOf(s.gapReason, GAPS)) || s.retentionDays !== 30)
+        return null;
+    return { settings: pick(s, ["version", "revision", "enabled", "observedRevision", "status", "lastObservedAt", "gapReason", "retentionDays"]) };
+}
+export function projectInsight(value, findingId) {
+    if (!isPlainObject(value) || !id(value.findingId, FINDING_ID) || findingId !== undefined && value.findingId !== findingId ||
+        !oneOf(value.ruleId, RULES) || !oneOf(value.state, ["open", "resolved"]) || !positive(value.revision) ||
+        !positive(value.firstSequence) || !positive(value.lastSequence) || value.lastSequence < value.firstSequence ||
+        !positive(value.count) || !positive(value.threshold) || value.count < value.threshold || !date(value.firstObservedAt) ||
+        !date(value.lastObservedAt) || Date.parse(value.lastObservedAt) < Date.parse(value.firstObservedAt) ||
+        !oneOf(value.coverage, ["complete", "partial"]) || !oneOf(value.toolCategory, ["shell", "search", "file", "network", "other", "unknown"]) ||
+        !oneOf(value.phase, PHASES) || !positive(value.serviceGeneration) || !date(value.expiresAt) || value.severity !== "warning" ||
+        value.templateId !== value.ruleId || value.suggestionId !== SUGGESTIONS[RULES.indexOf(value.ruleId)] ||
+        !oneOf(value.sourceAvailability, ["available", "unavailable"]) ||
+        !(value.role === null || oneOf(value.role, ["manager", "worker", "reviewer"])) || !isPlainObject(value.attention))
+        return null;
+    for (const key of ["registeredSourceId", "workspaceEpoch", "nativeSessionId", "journalGeneration"])
+        if (!id(value[key]))
+            return null;
+    for (const key of ["phaseStartedAt", "lastProgressAt", "healthObservedAt"])
+        if (!(value[key] === null || date(value[key])))
+            return null;
+    if (!(value.stallThresholdMs === null || positive(value.stallThresholdMs)) || !Array.isArray(value.matchedCallIds) || value.matchedCallIds.length > 16 ||
+        value.matchedCallIds.some(ref => !id(ref)) || new Set(value.matchedCallIds).size !== value.matchedCallIds.length)
+        return null;
+    const a = value.attention;
+    if (!oneOf(a.state, ["unacknowledged", "acknowledged", "snoozed", "dismissed"]) || !positive(a.revision) || !(a.snoozedUntil === null || date(a.snoozedUntil)))
+        return null;
+    let recovery = null;
+    if (value.state === "resolved") {
+        const r = value.recovery;
+        if (!isPlainObject(r) || r.predicate !== RECOVERY[RULES.indexOf(value.ruleId)] || !positive(r.sequence) || r.sequence <= value.lastSequence || !id(r.referenceId))
+            return null;
+        recovery = pick(r, ["predicate", "sequence", "referenceId"]);
+    }
+    else if (value.recovery !== null)
+        return null;
+    return { ...pick(value, ["findingId", "ruleId", "state", "revision", "firstSequence", "lastSequence", "count", "threshold", "firstObservedAt", "lastObservedAt",
+            "coverage", "toolCategory", "phase", "phaseStartedAt", "lastProgressAt", "healthObservedAt", "stallThresholdMs", "registeredSourceId", "workspaceEpoch", "nativeSessionId",
+            "serviceGeneration", "journalGeneration", "severity", "templateId", "suggestionId", "sourceAvailability", "role", "expiresAt"]),
+        matchedCallIds: [...value.matchedCallIds], recovery, attention: pick(a, ["state", "revision", "snoozedUntil"]) };
+}
+export function projectInsightDetail(value, findingId) {
+    if (!isPlainObject(value))
+        return null;
+    const finding = projectInsight(value.finding, findingId);
+    return finding ? { finding } : null;
+}
+export function projectInsightsList(value) {
+    const settings = projectInsightsSettings(value);
+    if (!settings || !isPlainObject(value) || !Array.isArray(value.findings) || value.findings.length > 100 || !(value.nextCursor === null || id(value.nextCursor, FINDING_ID)))
+        return null;
+    const findings = value.findings.map(finding => projectInsight(finding));
+    if (findings.some(finding => finding === null) || new Set(findings.map(finding => finding.findingId)).size !== findings.length)
+        return null;
+    return { ...settings, findings, nextCursor: value.nextCursor };
+}
+export function projectInsightsSummary(value, serverId) {
+    if (!isPlainObject(value) || value.serverId !== serverId || !Array.isArray(value.boxes) || value.boxes.length > 100 ||
+        !(value.nextCursor === null || id(value.nextCursor, /^sbx_[A-Za-z0-9_-]{4,72}$/)))
+        return null;
+    const boxes = [];
+    for (const box of value.boxes) {
+        if (!isPlainObject(box) || !id(box.sandboxId, /^sbx_[A-Za-z0-9_-]{4,72}$/) ||
+            !Number.isSafeInteger(box.openFindings) || Number(box.openFindings) < 0 || Number(box.openFindings) > 1000 ||
+            !Number.isSafeInteger(box.attentionNeeded) || Number(box.attentionNeeded) < 0 || Number(box.attentionNeeded) > Number(box.openFindings))
+            return null;
+        const monitor = projectInsightsSettings({ settings: box.monitor });
+        if (!monitor)
+            return null;
+        let latest = null;
+        if (box.latestFinding !== null) {
+            const f = box.latestFinding;
+            if (!isPlainObject(f) || !id(f.findingId, FINDING_ID) || !oneOf(f.ruleId, RULES) || !positive(f.count) || !date(f.lastObservedAt) ||
+                !(f.role === null || oneOf(f.role, ["manager", "worker", "reviewer"])))
+                return null;
+            latest = pick(f, ["findingId", "ruleId", "count", "lastObservedAt", "role"]);
+        }
+        boxes.push({ sandboxId: box.sandboxId, monitor: monitor.settings, openFindings: box.openFindings, attentionNeeded: box.attentionNeeded, latestFinding: latest });
+    }
+    if (new Set(boxes.map(box => box.sandboxId)).size !== boxes.length)
+        return null;
+    return { serverId, boxes, nextCursor: value.nextCursor };
+}

package/src/contracts/manager.js

@@ -0,0 +1,86 @@
+// Generated from worker/account/manager.ts; SHA-256 2f97f5d43411ef68208cd0a9b001416d535ae51e6b14cfd0a3164eb39d72a787.
+/** The owner boundary accepts only the canonical closed, metadata-only schema. */
+import { readFileSync } from "node:fs";
+const contract = JSON.parse(readFileSync(new URL("./agent-manager-control-v1.schema.json", import.meta.url), "utf8"));
+import { isPlainObject } from "./http.js";
+export const MANAGER_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{3,159}$/;
+const definitions = contract.$defs;
+// This small interpreter is deliberately limited to the vocabulary in this
+// versioned contract. Unsupported schema additions fail closed at the boundary.
+const vocabulary = new Set(["$ref", "type", "const", "enum", "oneOf", "allOf", "properties", "required", "additionalProperties", "items", "maximum", "minimum", "maxItems", "minItems", "uniqueItems", "pattern", "format"]);
+function matches(value, rule, depth = 0) {
+    if (!rule || depth > 32 || Object.keys(rule).some(key => !vocabulary.has(key)))
+        return false;
+    if (rule.$ref)
+        return rule.$ref.startsWith("#/$defs/") && matches(value, definitions[rule.$ref.slice(8)], depth + 1);
+    if ("const" in rule && value !== rule.const || rule.enum && !rule.enum.includes(value))
+        return false;
+    if (rule.oneOf && rule.oneOf.filter(r => matches(value, r, depth + 1)).length !== 1 || rule.allOf && !rule.allOf.every(r => matches(value, r, depth + 1)))
+        return false;
+    if (rule.type) {
+        const types = Array.isArray(rule.type) ? rule.type : [rule.type];
+        const type = value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
+        if (!types.includes(type) && !(types.includes("integer") && typeof value === "number" && Number.isSafeInteger(value)))
+            return false;
+        if (type === "object" && !isPlainObject(value))
+            return false;
+    }
+    if (typeof value === "number" && (!Number.isSafeInteger(value) || rule.minimum !== undefined && value < rule.minimum || rule.maximum !== undefined && value > rule.maximum))
+        return false;
+    if (typeof value === "string" && (rule.pattern && !new RegExp(rule.pattern).test(value) || rule.format && (rule.format !== "date-time" || value.length > 40 || !/T.*(?:Z|[+-]\d\d:\d\d)$/.test(value) || !Number.isFinite(Date.parse(value)))))
+        return false;
+    if (Array.isArray(value)) {
+        if (rule.maxItems !== undefined && value.length > rule.maxItems || rule.minItems !== undefined && value.length < rule.minItems ||
+            rule.uniqueItems && new Set(value.map(v => JSON.stringify(v))).size !== value.length || rule.items && !value.every(v => matches(v, rule.items, depth + 1)))
+            return false;
+    }
+    if (isPlainObject(value)) {
+        if (rule.required?.some(key => !Object.hasOwn(value, key)) || rule.additionalProperties === false && Object.keys(value).some(key => !rule.properties || !Object.hasOwn(rule.properties, key)))
+            return false;
+        if (rule.properties && Object.entries(rule.properties).some(([key, child]) => Object.hasOwn(value, key) && !matches(value[key], child, depth + 1)))
+            return false;
+    }
+    return true;
+}
+export function projectManager(value, shape, scope = {}) {
+    if (!matches(value, definitions[shape]) || !isPlainObject(value))
+        return null;
+    if (shape === "activityList" || shape === "takeoverList") {
+        const rows = value[shape === "activityList" ? "runs" : "takeovers"];
+        const field = shape === "activityList" ? "runId" : "operationId";
+        if (new Set(rows.map(row => row[field])).size !== rows.length || rows.some(row => !projectManager(row, shape === "activityList" ? "activity" : "takeover", scope)))
+            return null;
+    }
+    else
+        for (const [key, wanted] of Object.entries(scope))
+            if (wanted !== undefined && value[key] !== wanted)
+                return null;
+    if (shape === "policy" && value.appliedRevision !== null && Number(value.appliedRevision) > Number(value.revision))
+        return null;
+    if (shape === "takeover") {
+        const receipt = value;
+        const policy = receipt.monitorPolicy, hold = receipt.memberHold;
+        if (policy.appliedRevision !== null && policy.appliedRevision > policy.desiredRevision ||
+            hold.nodeAppliedRevision !== null && hold.nodeAppliedRevision > hold.desiredRevision)
+            return null;
+        if (["ready", "resumed"].includes(receipt.state) && (policy.appliedRevision !== policy.desiredRevision ||
+            hold.nodeAppliedRevision !== hold.desiredRevision || !hold.brokerApplied ||
+            !["none_pending", "canceled", "already_available_to_worker"].includes(receipt.pendingInput.state) ||
+            (receipt.state === "ready" ? receipt.action !== "pause_manager_and_hold_member" || hold.desiredState !== "active"
+                : receipt.action !== "resume_manager_and_release_member" || hold.desiredState !== "released")))
+            return null;
+    }
+    return structuredClone(value);
+}
+export function managerMutation(value, shape) {
+    return matches(value, definitions[shape]) && isPlainObject(value) ? value : null;
+}
+export function managerListQuery(params, allowFinding = false) {
+    for (const key of params.keys()) {
+        const value = params.get(key);
+        if (!(allowFinding ? ["limit", "cursor", "findingId"] : ["limit", "cursor"]).includes(key) || params.getAll(key).length !== 1 ||
+            (key === "limit" ? !/^[1-9][0-9]{0,2}$/.test(value) || Number(value) > 100 : !MANAGER_ID.test(value)))
+            return null;
+    }
+    return params.size ? `?${params}` : "";
+}

package/src/contracts/session-handoff.js

@@ -0,0 +1,49 @@
+// Generated from worker/account/session-handoff.ts; SHA-256 d2bc3e8fc85cc686e4eba1fe539e18d5f1c8c2c832667b321b305fa0c8421396.
+/** Closed safe metadata for the existing grant-bound managed bridge. */
+import { isPlainObject } from "./http.js";
+import { WORK_ID, WORK_BOX_ID } from "./work.js";
+const ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const DIGEST = /^sha256:[a-f0-9]{64}$/;
+const positive = (v) => Number.isSafeInteger(v) && Number(v) > 0;
+const id = (v, re = ID) => typeof v === "string" && re.test(v);
+const closed = (v, keys) => isPlainObject(v) && Object.keys(v).length === keys.length && keys.every(k => k in v);
+export function projectSessionHandoff(value, serverId, sandboxId, workId) {
+    if (!closed(value, ["formatVersion", "capability", "reason", "handoff", "access"]) || value.formatVersion !== 1 ||
+        !closed(value.access, ["transport", "requiresLocalOwnerCredential", "requiresSandboxGrant", "requiresPinnedHostKey"]) ||
+        value.access.transport !== "wm-team-control/1" || value.access.requiresLocalOwnerCredential !== true ||
+        value.access.requiresSandboxGrant !== true || value.access.requiresPinnedHostKey !== true)
+        return null;
+    if (value.capability === "unavailable")
+        return value.handoff === null && ["source_unavailable", "target_changed", "binding_not_verified", "managed_service_not_ready"].includes(String(value.reason)) ? value : null;
+    if (value.capability !== "exact_session" || value.reason !== null || !closed(value.handoff, ["formatVersion", "action", "handoffId", "issuedAt", "expiresAt", "identity", "source", "task", "work"]))
+        return null;
+    const h = value.handoff;
+    if (h.formatVersion !== 1 || h.action !== "open_session" || !id(h.handoffId) || typeof h.issuedAt !== "string" || typeof h.expiresAt !== "string")
+        return null;
+    const duration = Date.parse(h.expiresAt) - Date.parse(h.issuedAt);
+    if (!Number.isFinite(duration) || duration <= 0 || duration > 120000)
+        return null;
+    const i = h.identity, s = h.source;
+    if (!closed(i, ["serverId", "teamId", "memberId", "sandboxId", "sandboxGeneration", "serviceRegistrationId", "serviceGeneration", "instance", "role", "projectId", "workspaceEpoch", "profileId", "profileRevision", "profileDigest", "instructionRevision", "instructionDigest"]) ||
+        i.serverId !== serverId || i.sandboxId !== sandboxId || !WORK_BOX_ID.test(sandboxId) ||
+        !["worker", "reviewer", "manager"].includes(String(i.role)) || i.profileId !== "opencode" ||
+        !id(i.instance, /^[a-z0-9][a-z0-9_-]{0,31}$/) || !id(i.profileDigest, DIGEST) || !id(i.instructionDigest, DIGEST))
+        return null;
+    for (const field of ["serverId", "teamId", "memberId", "serviceRegistrationId", "projectId", "workspaceEpoch"])
+        if (!id(i[field]))
+            return null;
+    for (const field of ["sandboxGeneration", "serviceGeneration", "profileRevision", "instructionRevision"])
+        if (!positive(i[field]))
+            return null;
+    if (!closed(s, ["registeredSourceId", "nativeSessionId", "nativeProjectId", "nativeLocationDigest"]) || !id(s.registeredSourceId) ||
+        !id(s.nativeSessionId, /^ses_[A-Za-z0-9_-]{4,64}$/) || !id(s.nativeProjectId, /^(global|[a-f0-9]{40})$/) || !id(s.nativeLocationDigest, DIGEST))
+        return null;
+    if (h.task !== null && (!closed(h.task, ["taskId", "taskAttempt"]) || !id(h.task.taskId, /^task_[A-Za-z0-9_-]{4,75}$/) || !positive(h.task.taskAttempt)))
+        return null;
+    if (h.work !== null && (!closed(h.work, ["workId", "expectedRevision", "bindingId", "bindingRevision"]) || !id(h.work.workId, WORK_ID) ||
+        !id(h.work.bindingId, /^binding_[A-Za-z0-9_-]{4,72}$/) || !positive(h.work.expectedRevision) || !positive(h.work.bindingRevision)))
+        return null;
+    if (workId !== undefined && (!isPlainObject(h.work) || h.work.workId !== workId))
+        return null;
+    return value;
+}

package/src/contracts/sources.json

@@ -0,0 +1,12 @@
+{
+  "description": "Reviewed owner boundary adapters; mechanical TypeScript transpilation only",
+  "sources": {
+    "worker/account/work.ts": "e4176707a30848118bd44d1c369fc4303a267300fc981560d58c618b279ce516",
+    "worker/account/work-handoff.ts": "d89273eeab925968f757e6458542681d88356a494e6fc7d7af800193c371fb3d",
+    "worker/account/insights.ts": "826eb08f9496415b408fe943d9eec33a6c8480a52474df76c118f471f6d42d1f",
+    "worker/account/manager.ts": "2f97f5d43411ef68208cd0a9b001416d535ae51e6b14cfd0a3164eb39d72a787",
+    "worker/account/session-handoff.ts": "d2bc3e8fc85cc686e4eba1fe539e18d5f1c8c2c832667b321b305fa0c8421396",
+    "worker/account/http.ts#isPlainObject": "45a498e37caa3c89d198945a127cf050b9c11712c0a1ca050fac83a9b60c34b2",
+    "backend/contracts/agent-manager-control-v1.schema.json": "58ccce9f3324c13fb6cfa0cfe6d73fbbdb9d7222892541dc00e45547904ab4fb"
+  }
+}

package/src/contracts/work-handoff.js

@@ -0,0 +1,73 @@
+// Generated from worker/account/work-handoff.ts; SHA-256 d89273eeab925968f757e6458542681d88356a494e6fc7d7af800193c371fb3d.
+/** Explicit separate-session Work handoff; opaque owner receipts only. */
+import { isPlainObject } from "./http.js";
+import { WORK_ID, WORK_OPERATION_ID, WORK_REQUEST_ID, WORK_BOX_ID, workStateBody } from "./work.js";
+const ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const DIGEST = /^sha256:[a-f0-9]{64}$/;
+const id = (value, pattern = ID) => typeof value === "string" && pattern.test(value);
+const positive = (v) => Number.isSafeInteger(v) && Number(v) > 0;
+const date = (v) => typeof v === "string" && v.length <= 40 && Number.isFinite(Date.parse(v));
+const label = (v) => typeof v === "string" && v.trim() === v && v.length > 0 && new TextEncoder().encode(v).length <= 160 && !/[\x00-\x1f\x7f]/.test(v);
+const pick = (v, keys) => Object.fromEntries(keys.map(k => [k, v[k]]));
+export function workHandoffBody(value) {
+    if (!isPlainObject(value))
+        return null;
+    const extra = ["handoffKind", "restoreOperationId", "sessionChoice", "title"];
+    if (extra.some(k => !(k in value)) || value.sessionChoice !== "create_separate" || !label(value.title) ||
+        !(value.handoffKind === "reviewer" && value.restoreOperationId === null || value.handoffKind === "restored_target" && id(value.restoreOperationId, WORK_OPERATION_ID)))
+        return null;
+    const common = Object.fromEntries(Object.entries(value).filter(([k]) => !extra.includes(k)));
+    return workStateBody(common, "continue") ? value : null;
+}
+function member(value) {
+    if (!isPlainObject(value) || !id(value.memberId) || !label(value.label) || !["worker", "reviewer"].includes(String(value.role)) || !id(value.sandboxId, WORK_BOX_ID))
+        return null;
+    return pick(value, ["memberId", "label", "role", "sandboxId"]);
+}
+export function projectWorkHandoffTargets(value) {
+    if (!isPlainObject(value) || !Array.isArray(value.targets) || value.targets.length > 8 || value.nextCursor !== null || !Array.isArray(value.restores) || value.restores.length > 20 || typeof value.restoresTruncated !== "boolean")
+        return null;
+    const targets = value.targets.map(member);
+    if (targets.some(v => v === null) || new Set(targets.map(v => v.memberId)).size !== targets.length)
+        return null;
+    const restores = [];
+    for (const r of value.restores) {
+        if (!isPlainObject(r) || !id(r.operationId, WORK_OPERATION_ID) || !id(r.projectId) || !id(r.workspaceEpoch) || !id(r.sandboxId, WORK_BOX_ID))
+            return null;
+        restores.push(pick(r, ["operationId", "projectId", "workspaceEpoch", "sandboxId"]));
+    }
+    if (new Set(restores.map(r => r.operationId)).size !== restores.length)
+        return null;
+    return { targets: targets, nextCursor: null, restores, restoresTruncated: value.restoresTruncated };
+}
+export function projectWorkHandoff(value, workId, operationId, requestId) {
+    if (!isPlainObject(value) || !isPlainObject(value.operation))
+        return null;
+    const op = value.operation, target = member(op.targetMember);
+    if (!target || op.sourceWorkId !== workId || !id(op.operationId, WORK_OPERATION_ID) || !id(op.requestId, WORK_REQUEST_ID) ||
+        operationId !== undefined && op.operationId !== operationId || requestId !== undefined && op.requestId !== requestId ||
+        op.action !== "prepare_handoff" || op.sessionChoice !== "create_separate" || !["pending", "accepted", "failed", "superseded", "outcome_unknown"].includes(String(op.state)) ||
+        !positive(op.sourceRevision) || !id(op.targetWorkId, WORK_ID) || !id(op.checkpointOperationId, WORK_OPERATION_ID) ||
+        !(op.handoffKind === "reviewer" && op.restoreOperationId === null && target.role === "reviewer" || op.handoffKind === "restored_target" && id(op.restoreOperationId, WORK_OPERATION_ID)) ||
+        !date(op.createdAt) || !date(op.updatedAt) || ![op.baselineId, op.taskId, op.parentTaskId].every(v => v === null || id(v)) ||
+        !(op.errorCode === null || id(op.errorCode, /^[a-z][a-z0-9_]{0,79}$/)))
+        return null;
+    let workspace = null, session = null;
+    if (op.targetWorkspace !== null) {
+        const w = op.targetWorkspace;
+        if (!isPlainObject(w) || !id(w.selectionId) || !id(w.projectId) || !id(w.workspaceEpoch) || !positive(w.scopeRevision) || !id(w.rootAttestation, DIGEST))
+            return null;
+        workspace = pick(w, ["selectionId", "projectId", "workspaceEpoch", "scopeRevision", "rootAttestation"]);
+    }
+    if (op.session !== null) {
+        const s = op.session;
+        if (!isPlainObject(s) || !id(s.mappingId) || !id(s.registeredSourceId) || !id(s.nativeSessionId, /^ses_[A-Za-z0-9_-]{4,64}$/) ||
+            !id(s.nativeProjectId, /^(global|[a-f0-9]{40})$/) || !id(s.nativeLocationDigest, DIGEST))
+            return null;
+        session = pick(s, ["mappingId", "registeredSourceId", "nativeSessionId", "nativeProjectId", "nativeLocationDigest"]);
+    }
+    if (op.state === "accepted" && (!workspace || !session || !op.taskId || !op.baselineId))
+        return null;
+    return { operation: { ...pick(op, ["operationId", "requestId", "action", "handoffKind", "sessionChoice", "state", "sourceWorkId", "sourceRevision", "targetWorkId", "checkpointOperationId", "restoreOperationId", "baselineId", "taskId", "parentTaskId", "errorCode", "createdAt", "updatedAt"]),
+            targetMember: target, targetWorkspace: workspace, session } };
+}