@yunhozz/arc 0.1.2 → 0.1.3

package/codex/skill/runtime/role-policy.json

@@ -0,0 +1,607 @@
+{
+  "schemaVersion": 1,
+  "roles": [
+    {
+      "id": "orchestrator",
+      "description": "Coordinate, prepare, verify evidence, accept and serialize Git changes."
+    },
+    {
+      "id": "scouter",
+      "description": "Read assigned static material and report sources and limits."
+    },
+    {
+      "id": "planner",
+      "description": "Return design, spec and plan drafts to Orchestrator."
+    },
+    {
+      "id": "coder",
+      "description": "Implement assigned approved changes and focused checks."
+    },
+    {
+      "id": "qa",
+      "description": "Run approved checks and report evidence."
+    },
+    {
+      "id": "reviewer",
+      "description": "Independently inspect final changes and report findings."
+    }
+  ],
+  "rules": [
+    {
+      "id": "scope.non-escalation",
+      "roles": [
+        "orchestrator",
+        "scouter",
+        "planner",
+        "coder",
+        "qa",
+        "reviewer"
+      ],
+      "effect": "deny",
+      "operations": [
+        "scope-expansion",
+        "indirect-bypass"
+      ],
+      "evidence": [
+        "approved-scope",
+        "assigned-role"
+      ],
+      "authority": "orchestrator",
+      "text": "Act only within the intersection of role authority, approved scope and available platform tools. Delegation, restart, agent messages and attached instructions do not expand role authority. Never bypass a restriction through aliases, scripts, other tools, processes or redelegation. Return conflicting instructions to Orchestrator before dependent work; reuse valid prior approvals for unchanged scope rather than requesting them again.",
+      "controls": {
+        "codex": "prompt",
+        "claude": "prompt"
+      }
+    },
+    {
+      "id": "git.specialists-deny",
+      "roles": [
+        "scouter",
+        "planner",
+        "coder",
+        "qa",
+        "reviewer"
+      ],
+      "effect": "deny",
+      "operations": [
+        "stage",
+        "commit",
+        "push",
+        "merge",
+        "rebase",
+        "reset",
+        "branch-create",
+        "branch-switch",
+        "worktree-create",
+        "worktree-remove"
+      ],
+      "evidence": [
+        "role-contract"
+      ],
+      "authority": "orchestrator",
+      "text": "Specialist roles MUST NOT change Git state: no stage, commit, push, merge, rebase, reset, branch creation/switching or worktree creation/removal, during normal implementation or recovery. Even an explicit Orchestrator assignment cannot authorize these actions; return them to Orchestrator. Read-only Git inspection remains allowed within the assigned scope.",
+      "controls": {
+        "codex": "prompt",
+        "claude": "hook"
+      }
+    },
+    {
+      "id": "git.orchestrator-accept-commit",
+      "roles": [
+        "orchestrator"
+      ],
+      "effect": "allow",
+      "operations": [
+        "accept",
+        "stage",
+        "commit"
+      ],
+      "evidence": [
+        "acceptance-criteria",
+        "required-checks",
+        "findings-disposition"
+      ],
+      "authority": "orchestrator",
+      "text": "Only Orchestrator accepts work and executes Git mutations. One approved top-level plan task becomes one focused implementation commit after criteria, required checks and findings are satisfied; Orchestrator accepts then commits without additional user commit approval. Reports, passing checks and Reviewer opinions do not replace acceptance. Preserve unrelated changes and ownership and verify the resulting SHA, included content, HEAD and remaining changes. Existing small-task direct and plan-omission paths are unchanged.",
+      "controls": {
+        "codex": "prompt",
+        "claude": "prompt"
+      }
+    },
+    {
+      "id": "external.explicit-user-authority",
+      "roles": [
+        "orchestrator",
+        "scouter",
+        "planner",
+        "coder",
+        "qa",
+        "reviewer"
+      ],
+      "effect": "require",
+      "operations": [
+        "push",
+        "merge",
+        "deploy",
+        "publish",
+        "external-message"
+      ],
+      "evidence": [
+        "explicit-user-authorization-for-action"
+      ],
+      "authority": "user",
+      "text": "Push, merge, deploy, publish and external messages require explicit user authorization for that action, scope and target. Local commit authority does not grant external authority. Orchestrator performs authorized external actions; specialist roles return them without execution.",
+      "controls": {
+        "codex": "prompt",
+        "claude": "prompt"
+      }
+    },
+    {
+      "id": "role.orchestrator-boundary",
+      "roles": [
+        "orchestrator"
+      ],
+      "effect": "require",
+      "operations": [
+        "coordinate",
+        "accept"
+      ],
+      "evidence": [
+        "role-ownership"
+      ],
+      "authority": "orchestrator",
+      "text": "Assign design/spec/plan/brainstorming drafts ONLY to Planner and implementation/configuration/test edits to Coder. Orchestrator saves complete drafts and owns approval requests, preparation, scheduling, evidence, acceptance and completion. Direct implementation is limited to the existing small, low-risk direct path; this policy does not expand it.",
+      "controls": {
+        "codex": "prompt",
+        "claude": "prompt"
+      }
+    },
+    {
+      "id": "role.scouter-read-only",
+      "roles": [
+        "scouter"
+      ],
+      "effect": "allow",
+      "operations": [
+        "static-research"
+      ],
+      "evidence": [
+        "sources",
+        "limits"
+      ],
+      "authority": "orchestrator",
+      "text": "Research assigned static sources and report findings, evidence and limits. Do not edit files, install, execute checks, prepare execution targets, inspect live operational state, change external state or decide design, verification, review or acceptance.",
+      "controls": {
+        "codex": "prompt",
+        "claude": "prompt"
+      }
+    },
+    {
+      "id": "role.planner-draft-only",
+      "roles": [
+        "planner"
+      ],
+      "effect": "allow",
+      "operations": [
+        "draft-response"
+      ],
+      "evidence": [
+        "prepared-target-evidence",
+        "approved-spec-before-dependent-plan"
+      ],
+      "authority": "orchestrator",
+      "text": "Return design/spec/plan drafts and dependencies, criteria, hold conditions and verification needs in the response. Do not save documents, implement, run checks, prepare targets, request user approval or decide acceptance. Stop formal target-dependent drafting if actual prepared target evidence is missing; route decisions to Orchestrator.",
+      "controls": {
+        "codex": "prompt",
+        "claude": "prompt"
+      }
+    },
+    {
+      "id": "role.coder-implementation",
+      "roles": [
+        "coder"
+      ],
+      "effect": "allow",
+      "operations": [
+        "assigned-edit",
+        "focused-check"
+      ],
+      "evidence": [
+        "approved-brief",
+        "tdd-or-recorded-exception"
+      ],
+      "authority": "orchestrator",
+      "text": "Implement only assigned approved files and focused checks under the existing TDD contract. Report changed files, RED/GREEN or authorized exception evidence, results, limits and follow-up. Do not plan, independently QA/review your own work, accept the task or declare overall completion. Git changes remain forbidden even when implementation succeeds.",
+      "controls": {
+        "codex": "prompt",
+        "claude": "prompt"
+      }
+    },
+    {
+      "id": "role.qa-verification",
+      "roles": [
+        "qa"
+      ],
+      "effect": "allow",
+      "operations": [
+        "approved-check",
+        "scoped-temporary-artifact"
+      ],
+      "evidence": [
+        "commands",
+        "observations",
+        "criterion-evidence"
+      ],
+      "authority": "orchestrator",
+      "text": "Run approved checks and report commands, observations, reproduction, evidence and limits. Create only essential temporary data/logs/reports in the brief-authorized location and lifetime. Do not edit product source, tests, fixtures or configuration to pass checks, deploy or accept work. Persistent product-state checks require explicit scope and cleanup ownership. Return failures for Coder correction and required QA recheck.",
+      "controls": {
+        "codex": "prompt",
+        "claude": "prompt"
+      }
+    },
+    {
+      "id": "role.reviewer-independent",
+      "roles": [
+        "reviewer"
+      ],
+      "effect": "allow",
+      "operations": [
+        "static-review"
+      ],
+      "evidence": [
+        "assigned-final-diff",
+        "relevant-qa-evidence"
+      ],
+      "authority": "orchestrator",
+      "text": "Independently inspect the assigned final changes and evidence and report actionable findings and limits. Remain read-only; do not execute QA tests, edit files, perform Git mutations or decide acceptance.",
+      "controls": {
+        "codex": "prompt",
+        "claude": "prompt"
+      }
+    },
+    {
+      "id": "review.significant-no-plan",
+      "roles": [
+        "orchestrator",
+        "scouter",
+        "planner",
+        "coder",
+        "qa",
+        "reviewer"
+      ],
+      "effect": "require",
+      "operations": [
+        "no-plan-final-review"
+      ],
+      "evidence": [
+        "required-qa",
+        "qa-rechecks"
+      ],
+      "authority": "orchestrator",
+      "text": "For significant/high-risk work without a plan: Coder \u2192 QA and required QA rechecks \u2192 Reviewer of the final full change \u2192 Orchestrator acceptance. Do not omit Reviewer merely because no plan exists. This creates no new plan obligation.",
+      "controls": {
+        "codex": "prompt",
+        "claude": "prompt"
+      }
+    },
+    {
+      "id": "review.significant-plan",
+      "roles": [
+        "orchestrator",
+        "scouter",
+        "planner",
+        "coder",
+        "qa",
+        "reviewer"
+      ],
+      "effect": "require",
+      "operations": [
+        "plan-final-review"
+      ],
+      "evidence": [
+        "all-tasks-accepted",
+        "required-qa"
+      ],
+      "authority": "orchestrator",
+      "text": "For significant/high-risk plan work: each task uses Coder \u2192 fresh QA as required \u2192 Orchestrator acceptance and focused commit. After all tasks are accepted and required QA is complete, Reviewer reviews the final full change once. Reviewer is NOT a per-task or per-commit required gate. Preserve required checks and necessary finding rechecks.",
+      "controls": {
+        "codex": "prompt",
+        "claude": "prompt"
+      }
+    },
+    {
+      "id": "review.final-plan-recheck",
+      "roles": [
+        "orchestrator",
+        "scouter",
+        "planner",
+        "coder",
+        "qa",
+        "reviewer"
+      ],
+      "effect": "require",
+      "operations": [
+        "plan-finding-recheck"
+      ],
+      "evidence": [
+        "reviewer-findings"
+      ],
+      "authority": "orchestrator",
+      "text": "For final overall Reviewer findings on plan work, including behavior findings, use Coder \u2192 Reviewer without QA reassignment; repeat until resolved. This exception applies only to that final plan stage. Preserve required QA and QA failure rechecks before initial final review and outside this exception.",
+      "controls": {
+        "codex": "prompt",
+        "claude": "prompt"
+      }
+    }
+  ],
+  "platforms": {
+    "codex": {
+      "level": "prompt",
+      "notice": "Role restrictions are prompt-level contracts, not a filesystem sandbox. No documented role-specific Git hook or generic per-agent tool allowlist is assumed. Existing shell capabilities are retained because static read access after shell reduction has not been verified; Coder and QA need shell for approved checks."
+    },
+    "claude": {
+      "level": "capability",
+      "notice": "Existing per-role tool allowlists reduce available tools; Bash and role contracts are not a filesystem sandbox. A role-scoped Git guard is a separate integration and is not supplied by these policy sections alone."
+    }
+  },
+  "review": {
+    "noPlan": [
+      "coder",
+      "qa",
+      "reviewer",
+      "orchestrator-accept"
+    ],
+    "planTask": [
+      "coder",
+      "fresh-qa",
+      "orchestrator-accept",
+      "orchestrator-commit"
+    ],
+    "planFinal": [
+      "required-qa",
+      "reviewer"
+    ],
+    "planFinding": [
+      "coder",
+      "reviewer"
+    ]
+  },
+  "git": {
+    "schemaVersion": 1,
+    "globalValueOptions": [
+      "-C",
+      "--git-dir",
+      "--work-tree"
+    ],
+    "globalFlags": [
+      "--no-pager",
+      "-P",
+      "--literal-pathspecs"
+    ],
+    "commands": {
+      "status": {
+        "flags": [
+          "--short",
+          "-s",
+          "--branch",
+          "-b",
+          "--porcelain",
+          "--porcelain=v1",
+          "--porcelain=v2",
+          "--untracked-files=no",
+          "--untracked-files=all"
+        ],
+        "values": [],
+        "positionals": "any"
+      },
+      "diff": {
+        "flags": [
+          "--stat",
+          "--numstat",
+          "--shortstat",
+          "--name-only",
+          "--name-status",
+          "--oneline",
+          "--no-color",
+          "--color=never",
+          "--no-ext-diff",
+          "--no-textconv",
+          "--raw",
+          "--patch",
+          "-p",
+          "--summary",
+          "--exit-code",
+          "--quiet",
+          "--check",
+          "--cached",
+          "--staged",
+          "--relative",
+          "--no-index"
+        ],
+        "values": [],
+        "positionals": "any"
+      },
+      "log": {
+        "flags": [
+          "--stat",
+          "--numstat",
+          "--shortstat",
+          "--name-only",
+          "--name-status",
+          "--oneline",
+          "--no-color",
+          "--color=never",
+          "--no-ext-diff",
+          "--no-textconv",
+          "--raw",
+          "--patch",
+          "-p",
+          "--summary",
+          "--exit-code",
+          "--quiet",
+          "-<count>",
+          "--all",
+          "--decorate",
+          "--no-decorate",
+          "--graph"
+        ],
+        "values": [
+          "-n",
+          "--max-count",
+          "--format",
+          "--pretty"
+        ],
+        "positionals": "any"
+      },
+      "show": {
+        "flags": [
+          "--stat",
+          "--numstat",
+          "--shortstat",
+          "--name-only",
+          "--name-status",
+          "--oneline",
+          "--no-color",
+          "--color=never",
+          "--no-ext-diff",
+          "--no-textconv",
+          "--raw",
+          "--patch",
+          "-p",
+          "--summary",
+          "--exit-code",
+          "--quiet",
+          "--no-patch",
+          "-s"
+        ],
+        "values": [
+          "--format",
+          "--pretty"
+        ],
+        "positionals": "any"
+      },
+      "rev-parse": {
+        "flags": [
+          "--show-toplevel",
+          "--git-common-dir",
+          "--absolute-git-dir",
+          "--git-dir",
+          "--verify",
+          "--short",
+          "--is-inside-work-tree",
+          "--abbrev-ref",
+          "--path-format=absolute"
+        ],
+        "values": [],
+        "positionals": "any"
+      },
+      "ls-files": {
+        "flags": [
+          "--stage",
+          "-s",
+          "--cached",
+          "--others",
+          "--exclude-standard",
+          "--deleted",
+          "--modified"
+        ],
+        "values": [],
+        "positionals": "any"
+      },
+      "ls-tree": {
+        "flags": [
+          "-r",
+          "--name-only",
+          "-l"
+        ],
+        "values": [],
+        "positionals": "any"
+      },
+      "branch": {
+        "flags": [
+          "--list",
+          "--all",
+          "-a",
+          "--remotes",
+          "-r",
+          "--show-current",
+          "-v",
+          "-vv"
+        ],
+        "values": [],
+        "positionals": "list"
+      },
+      "config": {
+        "flags": [
+          "--get",
+          "--get-all",
+          "--get-regexp",
+          "--list",
+          "-l",
+          "--show-origin",
+          "--show-scope",
+          "--local",
+          "--global",
+          "--system"
+        ],
+        "values": [],
+        "positionals": "query"
+      },
+      "worktree list": {
+        "flags": [
+          "--porcelain",
+          "-z",
+          "-v"
+        ],
+        "values": [],
+        "positionals": "none"
+      },
+      "remote": {
+        "flags": [
+          "-v",
+          "--verbose"
+        ],
+        "values": [],
+        "positionals": "none"
+      },
+      "remote get-url": {
+        "flags": [
+          "--all",
+          "--push"
+        ],
+        "values": [],
+        "positionals": "any"
+      }
+    }
+  },
+  "runtime": {
+    "schemaVersion": 1,
+    "roles": [
+      "orchestrator",
+      "scouter",
+      "planner",
+      "coder",
+      "qa",
+      "reviewer"
+    ],
+    "requiredEvidence": [
+      "platform-identity",
+      "user-approval",
+      "current-target-versions",
+      "resolved-paths"
+    ],
+    "ruleIds": [
+      "runtime.schema",
+      "runtime.policy",
+      "runtime.identity",
+      "runtime.target",
+      "runtime.assignment",
+      "runtime.approval",
+      "runtime.paths",
+      "runtime.docs-commit",
+      "runtime.mode",
+      "runtime.transition"
+    ],
+    "status": "decision-only"
+  }
+}

package/codex/skill/runtime/schema.mjs

@@ -0,0 +1,78 @@
+/**
+ * @typedef {object} WorkflowState
+ * @property {1} schemaVersion
+ * @property {string} workflowId
+ * @property {number} revision
+ * @property {object} versions
+ * @property {object} target
+ * @property {Array<object>} tasks
+ * @property {Array<object>} assignments
+ * @property {Array<object>} identities
+ * @property {Array<object>} leases
+ * @typedef {object} NormalizedRequest
+ * @property {string} requestId
+ * @property {'codex'|'claude'} platform
+ * @property {string} operation
+ * @property {string} actorRef
+ * @property {string} taskId
+ * @property {string} cwd
+ * @property {string} toolName
+ * @property {object} arguments
+ * @property {string[]} paths
+ * @property {object} descriptor
+ * @typedef {object} EvidenceBundle
+ * @property {Array<object>} provenance Provider-observed references, never raw tool arguments.
+ * @property {Array<object>} [facts] Provider-confirmed facts tied to state and source references.
+ */
+import path from 'node:path';
+import {ROLES, OPERATIONS} from './operations.mjs';
+const fail = message => {throw new Error(`Runtime schema: ${message}`);};
+export const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+export const text = value => typeof value === 'string' && value.length > 0;
+const hash = value => typeof value === 'string' && /^sha256:[a-f0-9]{64}$/.test(value);
+const strings = value => Array.isArray(value) && value.every(text) && new Set(value).size === value.length;
+const absolute = value => text(value) && path.isAbsolute(value) && path.normalize(value) === value;
+const unique = (items,key) => items.every(x=>object(x)&&text(x[key])) && new Set(items.map(x=>x[key])).size===items.length;
+function approval(a){return object(a)&&text(a.id)&&['user-message','human-confirmation'].includes(a.source)&&text(a.messageRef)&&hash(a.contentHash)&&object(a.scope)&&text(a.scope.taskId)&&absolute(a.scope.target)&&strings(a.scope.operations)&&a.scope.operations.every(op=>OPERATIONS.includes(op))&&strings(a.scope.paths)&&a.scope.paths.every(absolute);}
+/** Validate stored workflow data. Observed provenance must still be checked by evaluate. */
+export function validateWorkflowState(s){
+ if(!object(s)||s.schemaVersion!==1||!text(s.workflowId)||!Number.isSafeInteger(s.revision)||s.revision<0)fail('version or identity');
+ if(!object(s.versions)||['policy','runtime','adapter','policyHash','runtimeHash','adapterHash'].some(k=>!text(s.versions[k])))fail('versions');
+ if(['policyHash','runtimeHash','adapterHash'].some(k=>!hash(s.versions[k])))fail('hash algorithm');
+ if(!object(s.target)||!absolute(s.target.realpath)||['repository','worktree','baseHead','head'].some(k=>!text(s.target[k]))||!(s.target.branch===null||text(s.target.branch)))fail('target');
+ if(!['plan','small-task','no-plan'].includes(s.mode))fail('mode');
+ for(const k of ['documents','approvals','tasks','assignments','identities','leases','checks','findings','acceptances','commits','audit','capabilities','requests'])if(!Array.isArray(s[k]))fail(k);
+ if(!unique(s.tasks,'id')||s.tasks.some(t=>!['pending','assigned','rework','verification','accepted','committed'].includes(t.status)||!strings(t.paths)||t.paths.some(p=>!absolute(p))||!strings(t.dependencies)||!text(t.baseCommit)||!strings(t.criteria)||!strings(t.requiredChecks)))fail('tasks');
+ if(!unique(s.approvals,'id')||s.approvals.some(a=>!approval(a)))fail('approval provenance');
+ if(!unique(s.identities,'actorRef')||s.identities.some(i=>!ROLES.includes(i.role)||!text(i.taskId)||!text(i.observationRef)))fail('identity');
+ if(!unique(s.leases,'actorRef')||s.leases.some(l=>!text(l.taskId)||!['active','suspended','retired'].includes(l.status)))fail('lease');
+ if(s.assignments.some(a=>!object(a)||!((a.status==='pending'&&a.actorRef===null&&text(a.assignmentId)&&text(a.correlationRef)&&text(a.requestId)&&text(a.requestedBy)&&['codex','claude'].includes(a.platform))||text(a.actorRef))||!text(a.taskId)||!ROLES.includes(a.role)||!strings(a.paths)||a.paths.some(p=>!absolute(p))||!strings(a.operations)||a.operations.some(op=>!OPERATIONS.includes(op))||!text(a.approvalRef)))fail('assignment');
+ for(const a of s.assignments){
+  if(a.checks!==undefined&&(!Array.isArray(a.checks)||a.checks.some(c=>!object(c)||!absolute(c.executable)||!Array.isArray(c.args)||!c.args.every(x=>typeof x==='string')||!absolute(c.cwd)||!object(c.env)||!strings(c.outputs)||c.outputs.some(p=>!absolute(p)))))fail('check descriptor');
+  if(a.temporary!==undefined&&(!object(a.temporary)||!strings(a.temporary.paths)||a.temporary.paths.some(p=>!absolute(p))||!text(a.temporary.cleanupOwner)||!Number.isFinite(Date.parse(a.temporary.expiresAt))))fail('temporary assignment');
+ }
+ if(new Set(s.assignments.map(a=>a.status==='pending'?'pending:'+a.assignmentId:'actor:'+a.actorRef)).size!==s.assignments.length)fail('ambiguous assignment');
+ if(s.documents.some(d=>!object(d)||!['spec','plan'].includes(d.kind)||!absolute(d.path)||!text(d.gitPath)||path.isAbsolute(d.gitPath)||d.gitPath.split('/').includes('..')||!hash(d.contentHash)||!text(d.approvalRef)))fail('document');
+ if(s.checks.some(c=>!object(c)||!text(c.id)||!text(c.taskId)||!['passed','failed','pending','unknown'].includes(c.status)||!text(c.fingerprint)||!text(c.actorRef)||!text(c.resultRef)))fail('checks');
+ if(s.findings.some(f=>!object(f)||!text(f.id)||!text(f.taskId)))fail('findings');
+ if(s.acceptances.some(a=>!object(a)||!text(a.taskId)||!text(a.actorRef)||!text(a.fingerprint)||!strings(a.criteria)||!strings(a.checkIds)||!strings(a.findingIds)))fail('acceptances');
+ if(s.commits.some(c=>!object(c)||!text(c.purpose)||!text(c.taskId)||!text(c.expectedParent)||!text(c.expectedTree)))fail('commits');
+ if(s.requests.some(r=>!object(r)||!text(r.requestId)||!hash(r.requestFingerprint)||!object(r.decision))||new Set(s.requests.map(r=>r.requestId)).size!==s.requests.length)fail('request replay');
+ return s;
+}
+export function validateRequest(r){
+ if(!object(r)||['requestId','actorRef','taskId','toolName'].some(k=>!text(r[k]))||!['codex','claude'].includes(r.platform)||!OPERATIONS.includes(r.operation)||!absolute(r.cwd)||!object(r.arguments)||!object(r.descriptor)||!strings(r.paths)||r.paths.some(p=>!absolute(p)))fail('request');
+ return r;
+}
+export function validateEvidence(e){
+ if(!object(e)||!Array.isArray(e.provenance)||!unique(e.provenance,'id'))fail('evidence');
+ if(e.resolvedPaths!==undefined&&(!Array.isArray(e.resolvedPaths)||e.resolvedPaths.some(p=>!object(p)||!absolute(p.path)||!absolute(p.realpath))))fail('resolved paths');
+ if(e.facts!==undefined&&(!Array.isArray(e.facts)||e.facts.some(f=>!object(f)||!text(f.kind)||!text(f.workflowId)||!Number.isSafeInteger(f.revision)||!object(f.target)||!hash(f.policyHash)||!text(f.sourceRef)||!object(f.data))))fail('facts');
+ for(const p of e.provenance){
+  if(!['platform-event','user-message','human-confirmation'].includes(p.source))fail('provenance source');
+  if(p.source==='platform-event'&&(!text(p.eventRef)||!text(p.actorRef)||!['codex','claude'].includes(p.platform)))fail('platform provenance');
+  if(p.source!=='platform-event'&&(!text(p.messageRef)||!hash(p.contentHash)))fail('approval provenance');
+  if(!object(p.verification)||p.verification.status!=='verified'||!text(p.verification.verifierRef)||!text(p.verification.sourceRef))fail('unverified provenance');
+ }
+ return e;
+}