@oscharko-dev/keiko-contracts 0.2.0

package/dist/workflow-handoff.js

@@ -0,0 +1,381 @@
+// Public type contracts for the governed workflow-handoff surface (Epic #177, Issue #186).
+// All string content here is already redacted upstream; nothing performs IO, crypto, clock
+// reads, or randomness. Pure data + pure validators only. The schemaVersion discriminant
+// follows the same evolution rule as CONNECTED_CONTEXT_SCHEMA_VERSION (ADR-0010 D2): a
+// breaking change introduces a NEW literal member rather than mutating "1". Leaf-package
+// rule (ADR-0019 direction 1) means no `@oscharko-dev/keiko-*` imports may appear in this
+// module — including this package's own siblings; intra-package imports use relative paths.
+import { isValidScopePath } from "./connected-context.js";
+// ─── Schema version ───────────────────────────────────────────────────────────
+export const WORKFLOW_HANDOFF_SCHEMA_VERSION = "1";
+export const DEFAULT_PATCH_SCOPE_LIMITS = {
+    maxFileCount: 16,
+    maxPatchBytes: 65_536,
+    maxNewFiles: 4,
+    elapsedMsMax: 60_000,
+};
+export const EXPECTED_CHECKS = [
+    "verify",
+    "lint",
+    "typecheck",
+    "tests",
+    "manual",
+];
+export const WORKFLOW_KINDS = [
+    "unit-test-generation",
+    "bug-investigation",
+    "verification",
+];
+// ─── Internal helpers ─────────────────────────────────────────────────────────
+const APPROVAL_TOKEN_RE = /^[0-9a-f]{64}$/;
+const CONTEXT_PACK_ID_RE = /^(pl-[0-9a-f]{16}|p-[0-9a-f]{64})$/;
+// The schema discriminant comparisons below are statically true at the type level (the
+// constant equals the literal field type), so we widen to `string` before comparing. This
+// keeps the validator honest against runtime inputs that bypass the type system — e.g.,
+// objects materialized from JSON.parse or cross-version manifests. Same posture as
+// connected-context.ts schemaMismatch.
+function schemaMismatch(actual, expected) {
+    return actual !== expected;
+}
+function isFiniteNonNegativeInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isNonEmptyTrimmed(value) {
+    return value.trim().length > 0;
+}
+function hasDuplicates(values) {
+    return new Set(values).size !== values.length;
+}
+function hasIntersection(a, b) {
+    if (a.length === 0 || b.length === 0) {
+        return false;
+    }
+    const set = new Set(a);
+    for (const value of b) {
+        if (set.has(value)) {
+            return true;
+        }
+    }
+    return false;
+}
+function pushIf(reasons, condition, reason) {
+    if (condition) {
+        reasons.push(reason);
+    }
+}
+function buildResult(reasons) {
+    return reasons.length === 0 ? { ok: true } : { ok: false, reasons };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readArrayField(source, field, reasons) {
+    const value = source[field];
+    if (!Array.isArray(value)) {
+        reasons.push(`patchScope.${field} must be an array`);
+        return undefined;
+    }
+    return value;
+}
+function isExpectedCheck(value) {
+    return typeof value === "string" && EXPECTED_CHECKS.includes(value);
+}
+function isWorkflowKind(value) {
+    return typeof value === "string" && WORKFLOW_KINDS.includes(value);
+}
+// ─── Approval-token shape ─────────────────────────────────────────────────────
+export function isApprovalTokenShape(token) {
+    return APPROVAL_TOKEN_RE.test(token);
+}
+// ─── PatchScope validation ────────────────────────────────────────────────────
+function validateScopePathArray(values, field, reasons) {
+    const parsed = [];
+    for (const value of values) {
+        if (typeof value !== "string" || !isNonEmptyTrimmed(value)) {
+            reasons.push(`patchScope.${field} contains empty entry`);
+            return undefined;
+        }
+        if (!isValidScopePath(value, { mustBeRelative: true })) {
+            reasons.push(`patchScope.${field} contains invalid path`);
+            return undefined;
+        }
+        parsed.push(value);
+    }
+    return parsed;
+}
+function validatePatchScopeLimits(limits, reasons) {
+    if (!isRecord(limits)) {
+        reasons.push("patchScope.limits must be an object");
+        return;
+    }
+    pushIf(reasons, !isFiniteNonNegativeInteger(limits.maxFileCount), "patchScope.limits.maxFileCount invalid");
+    pushIf(reasons, !isFiniteNonNegativeInteger(limits.maxPatchBytes), "patchScope.limits.maxPatchBytes invalid");
+    pushIf(reasons, !isFiniteNonNegativeInteger(limits.maxNewFiles), "patchScope.limits.maxNewFiles invalid");
+    pushIf(reasons, !isFiniteNonNegativeInteger(limits.elapsedMsMax), "patchScope.limits.elapsedMsMax invalid");
+}
+function validateExpectedChecks(checks, reasons) {
+    if (checks.length === 0) {
+        reasons.push("patchScope.expectedChecks empty");
+        return;
+    }
+    for (const check of checks) {
+        if (!isExpectedCheck(check)) {
+            reasons.push("patchScope.expectedChecks contains invalid value");
+            return;
+        }
+    }
+}
+function validateEvidenceAtomIds(ids, reasons) {
+    if (ids.length === 0) {
+        reasons.push("patchScope.evidenceAtomIds empty");
+        return undefined;
+    }
+    const parsed = [];
+    for (const id of ids) {
+        if (typeof id !== "string" || !isNonEmptyTrimmed(id)) {
+            reasons.push("patchScope.evidenceAtomIds contains empty entry");
+            return undefined;
+        }
+        parsed.push(id);
+    }
+    if (hasDuplicates(parsed)) {
+        reasons.push("patchScope.evidenceAtomIds contains duplicates");
+    }
+    return parsed;
+}
+function validateUnknowns(unknowns, reasons) {
+    for (const entry of unknowns) {
+        if (typeof entry !== "string") {
+            reasons.push("patchScope.unknowns contains non-string entry");
+            return;
+        }
+        if (!isNonEmptyTrimmed(entry)) {
+            reasons.push("patchScope.unknowns contains empty entry");
+            return;
+        }
+    }
+}
+function readPatchScopeArrays(scope, reasons) {
+    return {
+        editablePaths: readArrayField(scope, "editablePaths", reasons),
+        readOnlyPaths: readArrayField(scope, "readOnlyPaths", reasons),
+        evidenceAtomIds: readArrayField(scope, "evidenceAtomIds", reasons),
+        expectedChecks: readArrayField(scope, "expectedChecks", reasons),
+        unknowns: readArrayField(scope, "unknowns", reasons),
+    };
+}
+function validatePatchScopePaths(arrays, reasons) {
+    const editablePaths = arrays.editablePaths
+        ? validateScopePathArray(arrays.editablePaths, "editablePaths", reasons)
+        : undefined;
+    const readOnlyPaths = arrays.readOnlyPaths
+        ? validateScopePathArray(arrays.readOnlyPaths, "readOnlyPaths", reasons)
+        : undefined;
+    if (editablePaths) {
+        pushIf(reasons, hasDuplicates(editablePaths), "patchScope.editablePaths contains duplicates");
+    }
+    if (readOnlyPaths) {
+        pushIf(reasons, hasDuplicates(readOnlyPaths), "patchScope.readOnlyPaths contains duplicates");
+    }
+    if (editablePaths && readOnlyPaths) {
+        pushIf(reasons, hasIntersection(editablePaths, readOnlyPaths), "patchScope.editablePaths overlaps readOnlyPaths");
+    }
+}
+function validatePatchScopeArrays(arrays, reasons) {
+    validatePatchScopePaths(arrays, reasons);
+    if (arrays.evidenceAtomIds) {
+        validateEvidenceAtomIds(arrays.evidenceAtomIds, reasons);
+    }
+    if (arrays.expectedChecks) {
+        validateExpectedChecks(arrays.expectedChecks, reasons);
+    }
+    if (arrays.unknowns) {
+        validateUnknowns(arrays.unknowns, reasons);
+    }
+}
+export function validatePatchScope(scope) {
+    const reasons = [];
+    if (!isRecord(scope)) {
+        return { ok: false, reasons: ["patchScope must be an object"] };
+    }
+    pushIf(reasons, schemaMismatch(scope.schemaVersion, WORKFLOW_HANDOFF_SCHEMA_VERSION), "patchScope.schemaVersion mismatch");
+    validatePatchScopeArrays(readPatchScopeArrays(scope, reasons), reasons);
+    validatePatchScopeLimits(scope.limits, reasons);
+    return buildResult(reasons);
+}
+// ─── WorkflowHandoffRequest validation ────────────────────────────────────────
+export function validateWorkflowHandoffRequest(request) {
+    const reasons = [];
+    if (!isRecord(request)) {
+        return { ok: false, reasons: ["request must be an object"] };
+    }
+    pushIf(reasons, schemaMismatch(request.schemaVersion, WORKFLOW_HANDOFF_SCHEMA_VERSION), "request.schemaVersion mismatch");
+    if (typeof request.contextPackStableId !== "string" ||
+        !isNonEmptyTrimmed(request.contextPackStableId)) {
+        reasons.push("request.contextPackStableId empty");
+    }
+    else if (!CONTEXT_PACK_ID_RE.test(request.contextPackStableId)) {
+        reasons.push("request.contextPackStableId malformed");
+    }
+    pushIf(reasons, !isWorkflowKind(request.workflowKind), "request.workflowKind invalid");
+    pushIf(reasons, !isFiniteNonNegativeInteger(request.requestedAtMs), "request.requestedAtMs invalid");
+    pushIf(reasons, typeof request.userApprovalToken !== "string" ||
+        !isApprovalTokenShape(request.userApprovalToken), "request.userApprovalToken malformed");
+    const scopeResult = validatePatchScope(request.patchScope);
+    if (!scopeResult.ok) {
+        for (const reason of scopeResult.reasons) {
+            reasons.push(`request.${reason}`);
+        }
+    }
+    return buildResult(reasons);
+}
+// ─── checkPatchAgainstScope ───────────────────────────────────────────────────
+function violationOutsideSet(path) {
+    return {
+        kind: "outside-editable-set",
+        path,
+        observed: undefined,
+        limit: undefined,
+        message: `path "${path}" is not in patchScope.editablePaths`,
+    };
+}
+function violationBound(kind, observed, limit, field) {
+    return {
+        kind,
+        path: undefined,
+        observed,
+        limit,
+        message: `${field}: observed ${observed.toString()} exceeds limit ${limit.toString()}`,
+    };
+}
+function violationNoChecks() {
+    return {
+        kind: "no-expected-checks",
+        path: undefined,
+        observed: undefined,
+        limit: undefined,
+        message: "patchScope.expectedChecks is empty",
+    };
+}
+function violationInvalidScope(reason) {
+    return {
+        kind: "invalid-patch-scope",
+        path: undefined,
+        observed: undefined,
+        limit: undefined,
+        message: `patchScope invalid: ${reason}`,
+    };
+}
+function violationInvalidEntry(path, reason) {
+    return {
+        kind: "invalid-patch-entry",
+        path,
+        observed: undefined,
+        limit: undefined,
+        message: path === undefined ? `patch entry invalid: ${reason}` : `path "${path}" invalid: ${reason}`,
+    };
+}
+function readProposedPath(entry, violations) {
+    const path = typeof entry.path === "string" ? entry.path : undefined;
+    const valid = path !== undefined &&
+        isNonEmptyTrimmed(path) &&
+        isValidScopePath(path, { mustBeRelative: true });
+    if (!valid) {
+        violations.push(violationInvalidEntry(path, "path must be a valid relative scope path"));
+        return undefined;
+    }
+    return path;
+}
+function readProposedPatchBytes(entry, path, violations) {
+    const patchBytes = entry.patchBytes;
+    if (typeof patchBytes !== "number" || !Number.isFinite(patchBytes) || patchBytes < 0) {
+        violations.push(violationInvalidEntry(path, "patchBytes must be a finite non-negative number"));
+        return undefined;
+    }
+    return patchBytes;
+}
+function readProposedNewFile(entry, path, violations) {
+    const newFile = entry.newFile;
+    if (typeof newFile !== "boolean") {
+        violations.push(violationInvalidEntry(path, "newFile must be a boolean"));
+        return undefined;
+    }
+    return newFile;
+}
+function normalizeProposedEntry(entry, violations) {
+    if (!isRecord(entry)) {
+        violations.push(violationInvalidEntry(undefined, "entry must be an object"));
+        return undefined;
+    }
+    const path = readProposedPath(entry, violations);
+    const patchBytes = readProposedPatchBytes(entry, path, violations);
+    const newFile = readProposedNewFile(entry, path, violations);
+    if (path === undefined || patchBytes === undefined || newFile === undefined) {
+        return undefined;
+    }
+    return { path, patchBytes, newFile };
+}
+function collectProposedEntries(proposed, violations) {
+    const valid = [];
+    for (const entry of proposed) {
+        const normalized = normalizeProposedEntry(entry, violations);
+        if (normalized) {
+            valid.push(normalized);
+        }
+    }
+    return valid;
+}
+function collectOutsideSet(scope, proposed, violations) {
+    const editable = new Set(scope.editablePaths);
+    for (const entry of proposed) {
+        if (!editable.has(entry.path)) {
+            violations.push(violationOutsideSet(entry.path));
+        }
+    }
+}
+function collectAggregateBounds(scope, proposed, violations) {
+    if (proposed.length > scope.limits.maxFileCount) {
+        violations.push(violationBound("exceeds-max-file-count", proposed.length, scope.limits.maxFileCount, "fileCount"));
+    }
+    let totalBytes = 0;
+    let newFiles = 0;
+    for (const entry of proposed) {
+        totalBytes += entry.patchBytes;
+        if (entry.newFile) {
+            newFiles += 1;
+        }
+    }
+    if (totalBytes > scope.limits.maxPatchBytes) {
+        violations.push(violationBound("exceeds-max-patch-bytes", totalBytes, scope.limits.maxPatchBytes, "patchBytes"));
+    }
+    if (newFiles > scope.limits.maxNewFiles) {
+        violations.push(violationBound("exceeds-max-new-files", newFiles, scope.limits.maxNewFiles, "newFiles"));
+    }
+}
+export function checkPatchAgainstScope(scope, proposed) {
+    const violations = [];
+    const scopeResult = validatePatchScope(scope);
+    let hasBlockingScopeViolation = false;
+    if (!scopeResult.ok) {
+        for (const reason of scopeResult.reasons) {
+            if (reason === "patchScope.expectedChecks empty") {
+                violations.push(violationNoChecks());
+            }
+            else {
+                hasBlockingScopeViolation = true;
+                violations.push(violationInvalidScope(reason));
+            }
+        }
+    }
+    if (hasBlockingScopeViolation) {
+        return { ok: false, violations };
+    }
+    if (!Array.isArray(proposed)) {
+        violations.push(violationInvalidEntry(undefined, "proposed patch list must be an array"));
+        return { ok: false, violations };
+    }
+    const validProposed = collectProposedEntries(proposed, violations);
+    collectOutsideSet(scope, validProposed, violations);
+    collectAggregateBounds(scope, validProposed, violations);
+    return violations.length === 0 ? { ok: true } : { ok: false, violations };
+}

package/dist/workspace-descriptors.d.ts

@@ -0,0 +1,21 @@
+export type WorkspaceObjectLifecycleState = "idle" | "live" | "error" | "empty" | "focused" | "none" | "connecting" | "connected" | "degraded" | "disconnected" | "draft" | "streaming" | "final" | "archived" | "proposed" | "running" | "blocked" | "needs-review" | "verified" | "cancelled" | "applied" | "reverted" | "passed" | "failed" | "viewing" | "editing" | "unsaved" | "saved" | "unread" | "read" | "dismissed" | "paired" | "unpaired" | "searching" | "results" | "installed" | "disabled" | "enabled";
+export type WorkspaceObjectTrustBoundary = "ui" | "fs" | "tool" | "model" | "evidence" | "memory" | "network";
+export type WorkspaceObjectAuthority = "ui-only" | "user" | "user-confirm" | "read-only";
+export type WorkspaceObjectPersistence = "transient" | "durable.ui" | "durable.config" | "evidence-reference" | "fs-reference" | "memory-reference";
+export interface WorkspaceDescriptorMeta {
+    readonly lifecycle: readonly WorkspaceObjectLifecycleState[];
+    readonly trustBoundary: readonly WorkspaceObjectTrustBoundary[];
+    readonly authority: WorkspaceObjectAuthority;
+    readonly persistence: WorkspaceObjectPersistence;
+}
+export declare const WORKSPACE_LIFECYCLE_STATES: readonly WorkspaceObjectLifecycleState[];
+export declare const WORKSPACE_TRUST_BOUNDARIES: readonly WorkspaceObjectTrustBoundary[];
+export declare const WORKSPACE_AUTHORITY_REQUIREMENTS: readonly WorkspaceObjectAuthority[];
+export declare const WORKSPACE_PERSISTENCE_EXPECTATIONS: readonly WorkspaceObjectPersistence[];
+export interface WorkspaceDescriptorValidationError {
+    readonly objectType: string;
+    readonly field: "lifecycle" | "trustBoundary" | "authority" | "persistence" | "consistency";
+    readonly message: string;
+}
+export declare function validateWorkspaceDescriptorMeta(objectType: string, meta: WorkspaceDescriptorMeta): readonly WorkspaceDescriptorValidationError[];
+//# sourceMappingURL=workspace-descriptors.d.ts.map

package/dist/workspace-descriptors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-descriptors.d.ts","sourceRoot":"","sources":["../src/workspace-descriptors.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,6BAA6B,GAErC,MAAM,GACN,MAAM,GACN,OAAO,GACP,OAAO,GACP,SAAS,GAET,MAAM,GACN,YAAY,GACZ,WAAW,GACX,UAAU,GACV,cAAc,GAEd,OAAO,GACP,WAAW,GACX,OAAO,GACP,UAAU,GAEV,UAAU,GACV,SAAS,GACT,SAAS,GACT,cAAc,GACd,UAAU,GACV,WAAW,GAEX,SAAS,GACT,UAAU,GAEV,QAAQ,GACR,QAAQ,GAER,SAAS,GACT,SAAS,GACT,SAAS,GACT,OAAO,GAEP,QAAQ,GACR,MAAM,GACN,WAAW,GAEX,QAAQ,GACR,UAAU,GAEV,WAAW,GACX,SAAS,GAET,WAAW,GACX,UAAU,GACV,SAAS,CAAC;AAId,MAAM,MAAM,4BAA4B,GACpC,IAAI,GACJ,IAAI,GACJ,MAAM,GACN,OAAO,GACP,UAAU,GACV,QAAQ,GACR,SAAS,CAAC;AAId,MAAM,MAAM,wBAAwB,GAChC,SAAS,GACT,MAAM,GACN,cAAc,GACd,WAAW,CAAC;AAIhB,MAAM,MAAM,0BAA0B,GAClC,WAAW,GACX,YAAY,GACZ,gBAAgB,GAChB,oBAAoB,GACpB,cAAc,GACd,kBAAkB,CAAC;AAIvB,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,SAAS,EAAE,SAAS,6BAA6B,EAAE,CAAC;IAC7D,QAAQ,CAAC,aAAa,EAAE,SAAS,4BAA4B,EAAE,CAAC;IAChE,QAAQ,CAAC,SAAS,EAAE,wBAAwB,CAAC;IAC7C,QAAQ,CAAC,WAAW,EAAE,0BAA0B,CAAC;CAClD;AAID,eAAO,MAAM,0BAA0B,EAAE,SAAS,6BAA6B,EAuC9E,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,SAAS,4BAA4B,EAQ7E,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,SAAS,wBAAwB,EAK/E,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,SAAS,0BAA0B,EAOnF,CAAC;AAIF,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,eAAe,GAAG,WAAW,GAAG,aAAa,GAAG,aAAa,CAAC;IAC5F,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AA4BD,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,uBAAuB,GAC5B,SAAS,kCAAkC,EAAE,CAsF/C"}

package/dist/workspace-descriptors.js

@@ -0,0 +1,180 @@
+// Epic #518 / Issue #528 — Workspace object descriptor metadata contracts.
+//
+// ADR-0029 extends the workspace object registry with four declarative
+// metadata fields per object type: lifecycle, trustBoundary, authority,
+// persistence. The enums below are the closed sets the registration-time
+// validator (in `@oscharko-dev/keiko-ui`) checks against.
+//
+// These types are kept side-table-friendly so the existing
+// WindowsRegistry.ts in keiko-ui does not need invasive edits. The UI
+// package exposes a parallel `WIN_META: Record<WindowType, WorkspaceDescriptorMeta>`
+// table consumed by the validator and any object-aware UI surface.
+// ─── Closed-set membership (for the validator) ────────────────────────────
+export const WORKSPACE_LIFECYCLE_STATES = [
+    "idle",
+    "live",
+    "error",
+    "empty",
+    "focused",
+    "none",
+    "connecting",
+    "connected",
+    "degraded",
+    "disconnected",
+    "draft",
+    "streaming",
+    "final",
+    "archived",
+    "proposed",
+    "running",
+    "blocked",
+    "needs-review",
+    "verified",
+    "cancelled",
+    "applied",
+    "reverted",
+    "passed",
+    "failed",
+    "viewing",
+    "editing",
+    "unsaved",
+    "saved",
+    "unread",
+    "read",
+    "dismissed",
+    "paired",
+    "unpaired",
+    "searching",
+    "results",
+    "installed",
+    "disabled",
+    "enabled",
+];
+export const WORKSPACE_TRUST_BOUNDARIES = [
+    "ui",
+    "fs",
+    "tool",
+    "model",
+    "evidence",
+    "memory",
+    "network",
+];
+export const WORKSPACE_AUTHORITY_REQUIREMENTS = [
+    "ui-only",
+    "user",
+    "user-confirm",
+    "read-only",
+];
+export const WORKSPACE_PERSISTENCE_EXPECTATIONS = [
+    "transient",
+    "durable.ui",
+    "durable.config",
+    "evidence-reference",
+    "fs-reference",
+    "memory-reference",
+];
+// ─── Pure validator ──────────────────────────────────────────────────────
+//
+// Validates a single descriptor meta record against the closed sets and
+// the ADR-0029 / ADR-0030 consistency rules:
+//
+// R1 unknown enum: every member of lifecycle / trustBoundary, and the
+//   authority / persistence value, must belong to its closed set.
+// R2 trust-vs-authority: authority="ui-only" requires trustBoundary be
+//   ["ui"] only; any other trust class implies the user originates the
+//   action.
+// R3 evidence-persistence: persistence="evidence-reference" requires the
+//   trustBoundary set to include "evidence".
+// R4 fs-persistence: persistence="fs-reference" requires the
+//   trustBoundary set to include "fs".
+// R5 memory-persistence: persistence="memory-reference" requires the
+//   trustBoundary set to include "memory".
+// R6 durable.ui-readonly: persistence="durable.ui" with authority="read-only"
+//   is allowed but trustBoundary must include "ui" (the durable record
+//   itself is a UI surface).
+//
+// The validator is pure; the failing entries are returned as a list so the
+// caller decides how to surface them (dev: throw, prod: assert in test).
+// The rules above are individually simple; keeping them in one function
+// keeps the entire contract reviewable in one place.
+// eslint-disable-next-line complexity, max-lines-per-function
+export function validateWorkspaceDescriptorMeta(objectType, meta) {
+    const errors = [];
+    // R1 — closed-set membership
+    for (const state of meta.lifecycle) {
+        if (!WORKSPACE_LIFECYCLE_STATES.includes(state)) {
+            errors.push({
+                objectType,
+                field: "lifecycle",
+                message: `unknown lifecycle state '${state}'`,
+            });
+        }
+    }
+    for (const tb of meta.trustBoundary) {
+        if (!WORKSPACE_TRUST_BOUNDARIES.includes(tb)) {
+            errors.push({
+                objectType,
+                field: "trustBoundary",
+                message: `unknown trust boundary '${tb}'`,
+            });
+        }
+    }
+    if (!WORKSPACE_AUTHORITY_REQUIREMENTS.includes(meta.authority)) {
+        errors.push({
+            objectType,
+            field: "authority",
+            message: `unknown authority requirement '${meta.authority}'`,
+        });
+    }
+    if (!WORKSPACE_PERSISTENCE_EXPECTATIONS.includes(meta.persistence)) {
+        errors.push({
+            objectType,
+            field: "persistence",
+            message: `unknown persistence expectation '${meta.persistence}'`,
+        });
+    }
+    // R2 — ui-only authority must not cross any boundary other than ui
+    if (meta.authority === "ui-only") {
+        const nonUi = meta.trustBoundary.filter((tb) => tb !== "ui");
+        if (nonUi.length > 0) {
+            errors.push({
+                objectType,
+                field: "consistency",
+                message: `authority 'ui-only' is inconsistent with trust boundary [${nonUi.join(", ")}]`,
+            });
+        }
+    }
+    // R3 — evidence-reference requires the evidence trust boundary
+    if (meta.persistence === "evidence-reference" && !meta.trustBoundary.includes("evidence")) {
+        errors.push({
+            objectType,
+            field: "consistency",
+            message: `persistence 'evidence-reference' requires trustBoundary to include 'evidence'`,
+        });
+    }
+    // R4 — fs-reference requires the fs trust boundary
+    if (meta.persistence === "fs-reference" && !meta.trustBoundary.includes("fs")) {
+        errors.push({
+            objectType,
+            field: "consistency",
+            message: `persistence 'fs-reference' requires trustBoundary to include 'fs'`,
+        });
+    }
+    // R5 — memory-reference requires the memory trust boundary
+    if (meta.persistence === "memory-reference" && !meta.trustBoundary.includes("memory")) {
+        errors.push({
+            objectType,
+            field: "consistency",
+            message: `persistence 'memory-reference' requires trustBoundary to include 'memory'`,
+        });
+    }
+    // R6 — durable.ui requires the ui trust boundary
+    if (meta.persistence === "durable.ui" && !meta.trustBoundary.includes("ui")) {
+        errors.push({
+            objectType,
+            field: "consistency",
+            message: `persistence 'durable.ui' requires trustBoundary to include 'ui'`,
+        });
+    }
+    return errors;
+}