@typedstandards/civic-typed-harness 0.2.0 → 0.3.1

package/CHANGELOG.md

@@ -3,6 +3,115 @@
 Factual record of what changed per published version. Section references are
 to the Typed Standards specification unless noted otherwise.
 
+## 0.3.1 — 2026-09-02
+
+**The graph states what the span carried, and states absence as absence**
+([civic-ai-tools-website#384](https://github.com/npstorey/civic-ai-tools-website/issues/384),
+Wave N9 P-H1). Patch, not breaking: no existing export is removed or
+retyped, and every golden byte — both vocabulary eras, all eight
+golden-reproduction cases — is unchanged.
+
+- **`buildProvenanceGraph` no longer invents a tool name.** An
+  `mcp_tool_call` span with no `tool.name` yields a query entity with no
+  `civic:toolName` key (omitted, not placeholdered) and a tool-call activity
+  described as `MCP tool call (<operation type>)`. Previously the builder
+  substituted `get_data`.
+- **`buildProvenanceGraph` no longer attributes a data response to the run's
+  portal.** `civic:portalDomain` and `civic:datasetUrl` are emitted only when
+  the span carried both `tool.portal_domain` and `tool.dataset_id`. A
+  dataset-keyed span with no portal is described by its source agent's
+  registry title (`Data response from Socrata MCP Server`), the form
+  aggregate and unknown sources already took; a span with a dataset id and
+  no portal states `civic:datasetId` and mints no URL. Previously the builder
+  substituted `ProvenanceInput.portal` — the run's selected portal — which
+  attributed every `search` and `fetch` response to a portal the call never
+  addressed (the Socrata server's `search` and `fetch` take no portal and
+  answer from the portal that server is configured for). The graph does not
+  parse tool arguments: a portal embedded in a `fetch` id is not a portal the
+  span carried.
+- **`buildDataSources` no longer mints an entry on `fallbackPortal`.** A
+  dataset-keyed call whose arguments carry `dataset_id` but no `portal`
+  contributes no `dataSources` entry — `DataSourceEntry.portalUrl` is a
+  required string in produce-core, so an entry with no portal is not a shape
+  this package can emit — and the call remains on the graph's tool-call
+  activities. Calls that carry a portal (every `get_data` call from the
+  reference producer, whose loop injects the run portal before the record is
+  built) are unchanged.
+- **Unchanged signatures, two inputs now unused.** `ProvenanceInput.portal`
+  and the `fallbackPortal` parameter of `buildDataSources` keep their exact
+  types and positions, are accepted, and are not consulted; both say so at
+  the declaration.
+- **Byte consequence.** A package produced by this version from a trace
+  whose tool spans all carry `tool.name`, and carry `tool.portal_domain`
+  wherever they carry a response hash, is byte-identical to one produced by
+  0.3.0. Where a span carried less, the 0.3.0 output asserted a value the
+  span did not, and this version's output differs from it by exactly that
+  assertion. Packages already signed under 0.3.0 are untouched and remain
+  verifiable exactly as published.
+- **Dependency range widened, nothing resolved differently.**
+  `@typedstandards/produce-core` is accepted at `^0.3.0 || ^0.4.0` so a
+  consumer that takes produce-core 0.4.0 (an additive minor) resolves one
+  copy rather than nesting a second under this package. The lockfile here
+  still resolves 0.3.0.
+
+## 0.3.0 — 2026-08-20
+
+**Settlement-era civic vocabulary + produce-core 0.3.0**
+([civic-ai-tools#160](https://github.com/npstorey/civic-ai-tools/issues/160) —
+the 2026-08-19 vocabulary settlement, [ADR-0025](../../docs/adr/0025-vocabulary-settlement-evidence-excision.md);
+canonical mapping in the specification's **Appendix J**, migration class
+*frozen-in-signed-artifacts*). Minor, not breaking: no existing export is
+removed or retyped, and no already-published package changes.
+
+- **New emissions mint the settlement-era vocabulary.** `CIVIC_NS` becomes
+  `https://civicaitools.org/ns/civic/` (was
+  `https://civicaitools.org/ns/evidence/`) and `CIVIC_URN_PREFIX` becomes
+  `urn:civic-record` (was `urn:civic-evidence`). Every id emitted by
+  `buildProvenanceGraph` and every `civic:` `@context` entry moves with them.
+  **A package produced by this version is not byte-identical to one produced
+  by 0.2.0 from the same inputs** — the graph is inside the hashed envelope,
+  so its envelope hash differs. Packages already signed under 0.2.0 are
+  untouched and remain verifiable exactly as published.
+- **The prior era stays available, exported, and reproducible.** New:
+  `PRIOR_ERA_CIVIC_NS`, `PRIOR_ERA_CIVIC_URN_PREFIX`, the `CivicVocabulary`
+  type, `makeCivicVocabulary(ns, urnPrefix)`, and the two bound eras
+  `CIVIC_VOCABULARY` / `PRIOR_ERA_CIVIC_VOCABULARY`. `ProvenanceConfig` gains
+  an optional `vocabulary` field defaulting to `CIVIC_VOCABULARY`. Supplying
+  `PRIOR_ERA_CIVIC_VOCABULARY` reproduces a pre-settlement record
+  byte-for-byte — the only sanctioned use; it is never for new emissions.
+  Unlike the other `ProvenanceConfig` fields this one is defaulted rather than
+  required: emitting the current vocabulary is not the silent-attribution
+  hazard ADR-0024 guards against.
+- **Unchanged signatures.** `civicUrn`, `civicModelUrn`, `civicSourceAgentUrn`,
+  `civicPlatformUrn`, and `makeCivicProvContext` keep their exact signatures
+  and now delegate to `CIVIC_VOCABULARY`, so callers of the settlement era need
+  no edits.
+- **`buildEvaluationPrompt` takes `RecordPackage`** — produce-core 0.3.0's
+  settlement-era name for the same object (Appendix J, *alias-and-deprecate*).
+  `EvidencePackage` remains a deprecated upstream alias of that exact type, so
+  existing callers still compile; the rubric test suite deliberately stays on
+  the prior name as the executable alias proof.
+- **Dependency floor raised:** `@typedstandards/produce-core` `^0.2.0` →
+  `^0.3.0`, and the `@typedstandards/verify-core` devDependency `^0.8.0` →
+  `^0.9.0` to match the version produce-core 0.3.0 resolves (same-commit
+  manifest bump across a minor boundary). No behavior-affecting patch bumps
+  ride along.
+- **Both eras are under test.** The two captured fixtures
+  (`reference-golden.json`, `website-golden.json`) predate the settlement and
+  are not edited: their byte- and hash-parity legs now run with the prior-era
+  vocabulary injected, and a settlement-era leg asserts the same reference
+  bytes with exactly the two Appendix J literals substituted, with the hashes
+  recomputed from those substituted bytes by verify-core's shared chain. The
+  per-canonicalization-rule consequence is pinned explicitly: under
+  `legacy-json/v1` the era flip moves `contentHash` (the whole package is
+  fingerprinted, provenance included); under `dathere-ag-jupyter/v1` it does
+  not (only the executed notebook is). The envelope hash moves under both.
+- **Purity guard widened:** the capture/format boundary test now bars
+  vocabulary literals of **both** eras from `src/capture/**`. The invariant is
+  "vocabulary lives only in `format/vocabulary.ts`", not "the prior-era strings
+  are gone" — both eras are real vocabulary now, and either could be redefined
+  in the wrong module.
+
 ## 0.2.0 — 2026-08-17
 
 **Breaking: identity-bearing config is now required**

package/README.md

@@ -1,6 +1,6 @@
 # @typedstandards/civic-typed-harness
 
-The civic **domain harness** for [Typed Standards](../../docs/architecture/typed-standards-specification.md) evidence packages — the DOMAIN side of the format/domain line drawn in [ADR-0021](../../docs/adr/0021-produce-core-extraction.md), relocated from the reference app as an installable package ([ADR-0022](../../docs/adr/0022-civic-typed-harness-packaging.md)). The operating rule: **the harness derives, the core assembles** — everything here produces domain-derived values (civic vocabulary terms, datHere policy fields, provenance graphs, capture artifacts) that feed [`@typedstandards/produce-core`](https://www.npmjs.com/package/@typedstandards/produce-core)'s neutral envelope assembly.
+The civic **domain harness** for [Typed Standards](../../docs/architecture/typed-standards-specification.md) record packages — the DOMAIN side of the format/domain line drawn in [ADR-0021](../../docs/adr/0021-produce-core-extraction.md), relocated from the reference app as an installable package ([ADR-0022](../../docs/adr/0022-civic-typed-harness-packaging.md)). The operating rule: **the harness derives, the core assembles** — everything here produces domain-derived values (civic vocabulary terms, datHere policy fields, provenance graphs, capture artifacts) that feed [`@typedstandards/produce-core`](https://www.npmjs.com/package/@typedstandards/produce-core)'s neutral envelope assembly.
 
 > **Name.** The package landed in-repo under the working name `civic-typed-harness` with the final npm name deferred (ADR-0022 §B). It publishes as **`@typedstandards/civic-typed-harness`** — the standard's scope with the full layer-3 basename; the rationale, the alternatives scored, and the named reversal condition are recorded in the planning-side naming memo and summarized in the [ADR-0022 addendum](../../docs/adr/0022-civic-typed-harness-packaging.md#addendum-2026-08-02--final-npm-name).
 
@@ -8,7 +8,7 @@ The civic **domain harness** for [Typed Standards](../../docs/architecture/typed
 
 | Module group | Modules | What it is |
 |---|---|---|
-| **`src/format/`** — the civic format-extension | `vocabulary.ts`, `sources.ts`, `dathere.ts`, `profiles.ts` | What extends the *standard*: the `civic:` JSON-LD namespace and `urn:civic-evidence:` id scheme, the civic source registry, the datHere envelope-policy derivations (producerProfile, canonicalization rule, summary emission, environment extension), and the captureMethod vocabulary surface. |
+| **`src/format/`** — the civic format-extension | `vocabulary.ts`, `sources.ts`, `dathere.ts`, `profiles.ts` | What extends the *standard*: the `civic:` JSON-LD namespace and `urn:civic-record:` id scheme (both in two eras — new emissions mint the settlement-era terms, the prior-era terms stay exported and reproducible because they are frozen inside already-signed records; spec Appendix J), the civic source registry, the datHere envelope-policy derivations (producerProfile, canonicalization rule, summary emission, environment extension), and the captureMethod vocabulary surface. |
 | **`src/capture/`** — the capture machinery | `trace.ts`, `skill-metadata.ts`, `data-sources.ts`, `provenance.ts` | What *produces* under it: the OTel `TraceBuilder`, skill-metadata extraction, data-source population, and the provenance **builder** — which imports its vocabulary from the format group and walks the trace. |
 | **`src/rubric/`** — the adversarial rubric | `adversarial-eval-core.ts` | The civic six-criterion evaluation rubric (pure core: rubric text, pinned version hash, prompt builder, response parser). The model runner and result emission stay implementation-side. |
 
@@ -55,7 +55,7 @@ Runtime dependency: **`@typedstandards/produce-core` (`^0.2.0`) only.** The veri
 
 ## Byte-compatibility
 
-The port is tested for **byte parity** against golden outputs captured from the reference implementation (`src/__fixtures__/website-golden.json`): with the reference config passed explicitly, `buildProvenanceGraph` and `buildDataSources` reproduce the app's output byte-for-byte, and `RUBRIC_VERSION_SHA256` is asserted against the exact reference digest (moving the rubric changes no hashes). Fixture-level byte-compat against produce-core's `reference-golden.json` (`src/golden-reproduction.test.ts`) and the produce→verify composition round-trip (`src/composition-roundtrip.test.ts`) landed in S2 P2 and run with the suite.
+The port is tested for **byte parity** against golden outputs captured from the reference implementation (`src/__fixtures__/website-golden.json`): with the reference config passed explicitly, `buildProvenanceGraph` and `buildDataSources` reproduce the app's output byte-for-byte, and `RUBRIC_VERSION_SHA256` is asserted against the exact reference digest (moving the rubric changes no hashes). Both captured fixtures predate the 2026-08-19 vocabulary settlement, so their byte-parity legs run with `PRIOR_ERA_CIVIC_VOCABULARY` injected — the fixtures are never rewritten — beside a settlement-era leg asserting the same bytes with exactly the two Appendix J literals substituted. Fixture-level byte-compat against produce-core's `reference-golden.json` (`src/golden-reproduction.test.ts`) and the produce→verify composition round-trip (`src/composition-roundtrip.test.ts`) landed in S2 P2 and run with the suite.
 
 ## Develop
 

package/dist/capture/data-sources.d.ts

@@ -47,12 +47,18 @@ export declare function resolveToolSource(toolCall: ToolCallSummary, span: Trace
  * Build the per-source evidence-package `dataSources` array.
  *
  * Dataset-keyed sources (Socrata) contribute one entry per unique
- * `dataset_id` observed across tool calls. Aggregate sources (Data Commons,
+ * `dataset_id` observed across tool calls that also carried a `portal`
+ * argument; a dataset-keyed call that carried no portal contributes NO
+ * entry (the loop body says why). Aggregate sources (Data Commons,
  * Boston OpenContext — registry entries carrying `aggregatePortalUrl`)
  * contribute a single entry when any of their tool calls was made. Unknown
  * source ids contribute no entry. Each entry is tagged with `sourceId` so
  * downstream consumers can distinguish provenance. Emission order: the
  * dataset-keyed entries (first-seen order), then aggregate sources in
  * registry insertion order — matching the reference implementation.
+ *
+ * `fallbackPortal` is accepted and NOT consulted since 0.3.1: an entry
+ * states the portal the call carried, never the run's. The parameter stays
+ * in the signature so existing callers keep compiling.
  */
 export declare function buildDataSources(toolCalls: ToolCallSummary[], trace: Record<string, unknown>, fallbackPortal: string, now: string, options?: DataSourceOptions): DataSourceEntry[];

package/dist/capture/data-sources.js

@@ -51,13 +51,19 @@ export function resolveToolSource(toolCall, span, resolver = civicToolSourceReso
  * Build the per-source evidence-package `dataSources` array.
  *
  * Dataset-keyed sources (Socrata) contribute one entry per unique
- * `dataset_id` observed across tool calls. Aggregate sources (Data Commons,
+ * `dataset_id` observed across tool calls that also carried a `portal`
+ * argument; a dataset-keyed call that carried no portal contributes NO
+ * entry (the loop body says why). Aggregate sources (Data Commons,
  * Boston OpenContext — registry entries carrying `aggregatePortalUrl`)
  * contribute a single entry when any of their tool calls was made. Unknown
  * source ids contribute no entry. Each entry is tagged with `sourceId` so
  * downstream consumers can distinguish provenance. Emission order: the
  * dataset-keyed entries (first-seen order), then aggregate sources in
  * registry insertion order — matching the reference implementation.
+ *
+ * `fallbackPortal` is accepted and NOT consulted since 0.3.1: an entry
+ * states the portal the call carried, never the run's. The parameter stays
+ * in the signature so existing callers keep compiling.
  */
 export function buildDataSources(toolCalls, trace, fallbackPortal, now, options = {}) {
     const resolver = options.resolver ?? civicToolSourceResolver;
@@ -71,8 +77,20 @@ export function buildDataSources(toolCalls, trace, fallbackPortal, now, options
         const source = resolveToolSource(tc, toolSpans[i], resolver, fallbackSourceId);
         if (isDatasetKeyedSource(source, registry)) {
             const datasetId = tc.args.dataset_id;
-            const portal = tc.args.portal || fallbackPortal;
-            if (datasetId) {
+            const portal = tc.args.portal;
+            // An entry is minted only from what the call carried: a dataset id AND
+            // a portal. A dataset-keyed call with a dataset id and no portal
+            // contributes no entry. `DataSourceEntry.portalUrl` is a required
+            // string (produce-core), so "an entry with no portal" is not a shape
+            // this package can emit; and substituting the run's portal
+            // (`fallbackPortal`, before 0.3.1) attributed the call to a portal it
+            // never addressed. Omission is the honest shape — the call is still on
+            // the PROV-O graph's tool-call activities, stated without a portal.
+            // The branch is latent for the reference producer, whose loop injects
+            // the run portal into `get_data` arguments before the record is built
+            // (run-tool-loop.ts:799 at the time of writing); any caller whose
+            // summary carries `dataset_id` without `portal` reaches it.
+            if (datasetId && portal) {
                 let byDataset = datasetKeyed.get(source);
                 if (!byDataset) {
                     byDataset = new Map();

package/dist/capture/provenance.d.ts

@@ -1,5 +1,5 @@
 import { type ProvGraph, type ProvNode } from '@typedstandards/produce-core';
-import { type PlatformAgentConfig } from '../format/vocabulary.ts';
+import { type CivicVocabulary, type PlatformAgentConfig } from '../format/vocabulary.ts';
 import { type CivicSourceRegistry } from '../format/sources.ts';
 export type { ProvGraph, ProvNode };
 /** Package-level inputs to the graph build. */
@@ -15,11 +15,17 @@ export interface ProvenanceInput {
      *  itself is exactly this value by construction. */
     outputHash?: string;
     model: string;
+    /** The run's selected portal. Accepted and NOT consulted by the graph
+     *  builder since 0.3.1: the graph states the portal a tool span carried
+     *  (`tool.portal_domain`) and states absence as absence — it never
+     *  substitutes the run's portal for one the call did not address. The
+     *  field stays in the type so callers that pass it (the reference app
+     *  does, as an object literal) keep compiling. */
     portal: string;
 }
 /** Instance configuration for the graph build (config-not-constants). */
 export interface ProvenanceConfig {
-    /** Platform-agent identity — the deployment publishing the evidence. */
+    /** Platform-agent identity — the deployment publishing the record. */
     platformAgent: PlatformAgentConfig;
     /** Source registry supplying agent titles and MCP server URLs. */
     sourceRegistry: CivicSourceRegistry;
@@ -34,9 +40,20 @@ export interface ProvenanceConfig {
      *  carries no `dcterms:description` at all — the field is omitted from the
      *  graph (honest omission), never filled with a fallback. */
     modelAgentDescription?: string;
+    /** Vocabulary era to emit (spec Appendix J). Defaults to the settlement-era
+     *  `CIVIC_VOCABULARY` — the only value a new emission may use. Supply
+     *  `PRIOR_ERA_CIVIC_VOCABULARY` ONLY to reproduce or verify a record signed
+     *  before the 2026-08-19 settlement, whose identifiers are frozen under the
+     *  hash it was signed with. Unlike the other fields here this is not
+     *  deployment identity, so it is defaulted rather than required: emitting
+     *  the current vocabulary is never the silent-attribution hazard ADR-0024
+     *  guards against. */
+    vocabulary?: CivicVocabulary;
 }
 /** The civicaitools.org reference deployment's values. Passed explicitly by
- *  the reference app — never applied as a default. */
+ *  the reference app — never applied as a default, and never spread into
+ *  another instance's config, which would assert infrastructure that
+ *  instance doesn't run. */
 export declare const CIVICAITOOLS_PROVENANCE_CONFIG: ProvenanceConfig;
 /**
  * Build a W3C PROV-O JSON-LD graph from an OTel trace and package metadata.

package/dist/capture/provenance.js

@@ -17,10 +17,12 @@
 // order is preserved throughout — the legacy hash chain's byte contract).
 import { makeProvGraph, makeEntityNode, makeActivityNode, makeAgentNode, provRef, provUsed, provWasGeneratedBy, provWasDerivedFrom, provWasAssociatedWith, xsdDateTime, } from '@typedstandards/produce-core';
 import { hash } from "./trace.js";
-import { makeCivicProvContext, civicUrn, civicModelUrn, civicSourceAgentUrn, civicPlatformUrn, CIVICAITOOLS_PLATFORM_AGENT, } from "../format/vocabulary.js";
+import { CIVIC_VOCABULARY, CIVICAITOOLS_PLATFORM_AGENT, } from "../format/vocabulary.js";
 import { CIVIC_SOURCE_REGISTRY, FALLBACK_SOURCE_ID, isDatasetKeyedSource, } from "../format/sources.js";
 /** The civicaitools.org reference deployment's values. Passed explicitly by
- *  the reference app — never applied as a default. */
+ *  the reference app — never applied as a default, and never spread into
+ *  another instance's config, which would assert infrastructure that
+ *  instance doesn't run. */
 export const CIVICAITOOLS_PROVENANCE_CONFIG = {
     platformAgent: CIVICAITOOLS_PLATFORM_AGENT,
     sourceRegistry: CIVIC_SOURCE_REGISTRY,
@@ -48,15 +50,20 @@ function nanoToIso(nano) {
 export function buildProvenanceGraph(trace, input, config) {
     const otel = trace;
     const spans = otel?.resourceSpans?.[0]?.scopeSpans?.[0]?.spans || [];
-    const { packageId, promptHash, promptText, outputText, model, portal } = input;
+    // `input.portal` is deliberately not read — see `ProvenanceInput.portal`.
+    const { packageId, promptHash, promptText, outputText, model } = input;
     const outputHash = input.outputHash ?? hash(outputText ?? '');
     const registry = config.sourceRegistry;
     const fallbackSourceId = config.fallbackSourceId ?? FALLBACK_SOURCE_ID;
     const skillSourceId = config.skillSourceId ?? FALLBACK_SOURCE_ID;
+    // Vocabulary era — settlement-era unless a prior-era reproduction asks
+    // otherwise. Every id and the `@context` below route through it, so a graph
+    // never mixes eras.
+    const vocab = config.vocabulary ?? CIVIC_VOCABULARY;
     const graph = [];
     // --- Entities ---
     // User prompt
-    graph.push(makeEntityNode(civicUrn(packageId, 'prompt', promptHash), {
+    graph.push(makeEntityNode(vocab.urn(packageId, 'prompt', promptHash), {
         'civic:contentHash': `sha256:${promptHash}`,
         'dcterms:description': 'User query prompt',
         ...(promptText ? { 'prov:value': promptText } : {}),
@@ -69,13 +76,13 @@ export function buildProvenanceGraph(trace, input, config) {
     const skillHash = skillSpan ? getAttr(skillSpan.attributes, 'skill.text_hash') : undefined;
     const skillServerUrl = skillSpan ? getAttr(skillSpan.attributes, 'skill.mcp_server_url') : undefined;
     if (skillHash) {
-        graph.push(makeEntityNode(civicUrn(packageId, 'skill', skillHash), {
+        graph.push(makeEntityNode(vocab.urn(packageId, 'skill', skillHash), {
             'civic:contentHash': `sha256:${skillHash}`,
             'dcterms:description': 'Composed MCP skill guidance (system prompt)',
         }, ['prov:Plan']));
     }
     // Final output
-    graph.push(makeEntityNode(civicUrn(packageId, 'output', outputHash), {
+    graph.push(makeEntityNode(vocab.urn(packageId, 'output', outputHash), {
         'civic:contentHash': `sha256:${outputHash}`,
         'dcterms:description': 'AI-generated analysis output',
     }));
@@ -83,7 +90,7 @@ export function buildProvenanceGraph(trace, input, config) {
     // LLM model. The description is emitted only when the config supplies one —
     // absent otherwise (honest omission, same idiom as deriveProducerProfile /
     // deriveSummaryEmission in ../format/dathere.ts).
-    const modelUrn = civicModelUrn(model);
+    const modelUrn = vocab.modelUrn(model);
     graph.push(makeAgentNode(modelUrn, {
         'dcterms:title': model,
         ...(config.modelAgentDescription
@@ -91,7 +98,7 @@ export function buildProvenanceGraph(trace, input, config) {
             : {}),
     }, ['prov:SoftwareAgent']));
     // MCP server agents — one per distinct data source that appears in the
-    // trace. Tool spans carry `mcp.source`; evidence records captured before
+    // trace. Tool spans carry `mcp.source`; records captured before
     // source tagging have no source attribute, so they fall back to the
     // configured fallback source (socrata — the only source at the time) for
     // backwards compatibility. Agent coordinates come from the source registry;
@@ -100,7 +107,7 @@ export function buildProvenanceGraph(trace, input, config) {
     const sourceAgentMap = {};
     for (const [id, info] of Object.entries(registry)) {
         sourceAgentMap[id] = {
-            urn: civicSourceAgentUrn(id),
+            urn: vocab.sourceAgentUrn(id),
             title: info.agentTitle,
             serverUrl: id === skillSourceId ? skillServerUrl || info.serverUrl : info.serverUrl,
         };
@@ -112,7 +119,7 @@ export function buildProvenanceGraph(trace, input, config) {
     }
     for (const sourceId of sourcesInTrace) {
         const meta = sourceAgentMap[sourceId] ?? {
-            urn: civicSourceAgentUrn(encodeURIComponent(sourceId)),
+            urn: vocab.sourceAgentUrn(encodeURIComponent(sourceId)),
             title: `${sourceId} MCP Server`,
             serverUrl: sourceId,
         };
@@ -129,10 +136,10 @@ export function buildProvenanceGraph(trace, input, config) {
         const id = sourceId || fallbackSourceId;
         return (sourceAgentMap[id]?.urn
             ?? sourceAgentMap[fallbackSourceId]?.urn
-            ?? civicSourceAgentUrn(encodeURIComponent(id)));
+            ?? vocab.sourceAgentUrn(encodeURIComponent(id)));
     }
     // Platform
-    graph.push(makeAgentNode(civicPlatformUrn(config.platformAgent.id), {
+    graph.push(makeAgentNode(vocab.platformUrn(config.platformAgent.id), {
         'dcterms:title': config.platformAgent.title,
         'civic:url': config.platformAgent.url,
     }, ['prov:SoftwareAgent']));
@@ -141,11 +148,11 @@ export function buildProvenanceGraph(trace, input, config) {
     const inferenceSpans = spans.filter(s => s.name === 'llm_inference');
     const inferenceUrns = [];
     for (const span of inferenceSpans) {
-        const spanUrn = civicUrn(packageId, 'inference', span.spanId);
+        const spanUrn = vocab.urn(packageId, 'inference', span.spanId);
         inferenceUrns.push(spanUrn);
-        const used = [provRef(civicUrn(packageId, 'prompt', promptHash))];
+        const used = [provRef(vocab.urn(packageId, 'prompt', promptHash))];
         if (skillHash) {
-            used.push(provRef(civicUrn(packageId, 'skill', skillHash)));
+            used.push(provRef(vocab.urn(packageId, 'skill', skillHash)));
         }
         const promptTokens = getAttr(span.attributes, 'gen_ai.response.prompt_tokens');
         const completionTokens = getAttr(span.attributes, 'gen_ai.response.completion_tokens');
@@ -163,17 +170,34 @@ export function buildProvenanceGraph(trace, input, config) {
             ...(completionTokens ? { 'civic:completionTokens': Number(completionTokens) } : {}),
         }));
     }
-    // MCP tool call spans
+    // MCP tool call spans.
+    //
+    // Every node derived from a span states what the span carried, and states
+    // absence as absence: a span with no `tool.name` yields nodes that name no
+    // tool, and a span with no `tool.portal_domain` yields a data response
+    // attributed to no portal. Nothing here substitutes the run's selected
+    // portal (`input.portal`, accepted and unused since 0.3.1) or a default
+    // tool name for a value the producer did not write. The reference
+    // producer's loop always writes `tool.name`, and writes
+    // `tool.portal_domain` only when the call's arguments carried a portal —
+    // which its portal injection does for `get_data` and for no other tool.
+    // The Socrata server's `search` (one argument, `query`) and `fetch` (one
+    // argument, `id`) address the portal that server is configured for, which
+    // the producer does not know. A `fetch` id may embed a portal, but that
+    // grammar belongs to the server: the graph does not parse arguments, so an
+    // id is never a portal the span carried.
     const dataResponseUrns = [];
     for (const span of toolSpans) {
-        const toolCallUrn = civicUrn(packageId, 'tool-call', span.spanId);
+        const toolCallUrn = vocab.urn(packageId, 'tool-call', span.spanId);
         const argsStr = getAttr(span.attributes, 'tool.arguments') || '{}';
         const queryHash = hash(argsStr);
         const responseHash = getAttr(span.attributes, 'tool.response_hash');
-        const toolName = getAttr(span.attributes, 'tool.name') || 'get_data';
+        // Absent when the span carried none — never defaulted.
+        const toolName = getAttr(span.attributes, 'tool.name');
         const opType = getAttr(span.attributes, 'tool.operation_type') || 'unknown';
         const datasetId = getAttr(span.attributes, 'tool.dataset_id');
-        const portalDomain = getAttr(span.attributes, 'tool.portal_domain') || portal;
+        // Absent when the span carried none — never the run's portal.
+        const portalDomain = getAttr(span.attributes, 'tool.portal_domain');
         const toolSource = getAttr(span.attributes, 'mcp.source') || fallbackSourceId;
         const toolAgentUrn = agentUrnForSource(toolSource);
         const toolSourceDatasetKeyed = isDatasetKeyedSource(toolSource, registry);
@@ -183,24 +207,35 @@ export function buildProvenanceGraph(trace, input, config) {
         const precedingInference = inferenceSpans
             .filter(is => Number(is.endTimeUnixNano || '0') <= toolStart)
             .sort((a, b) => Number(b.endTimeUnixNano || '0') - Number(a.endTimeUnixNano || '0'))[0];
-        const queryUrn = civicUrn(packageId, 'query', queryHash);
+        const queryUrn = vocab.urn(packageId, 'query', queryHash);
         graph.push(makeEntityNode(queryUrn, {
             'civic:contentHash': `sha256:${queryHash}`,
-            'civic:toolName': toolName,
+            // Omitted — not placeholdered — when the span named no tool.
+            ...(toolName ? { 'civic:toolName': toolName } : {}),
             'civic:operationType': opType,
             'dcterms:description': `MCP tool arguments (${opType})`,
             ...(precedingInference
-                ? provWasGeneratedBy(civicUrn(packageId, 'inference', precedingInference.spanId))
+                ? provWasGeneratedBy(vocab.urn(packageId, 'inference', precedingInference.spanId))
                 : {}),
         }));
         // Data response entity
         if (responseHash) {
-            const dataUrn = civicUrn(packageId, 'data', responseHash);
+            const dataUrn = vocab.urn(packageId, 'data', responseHash);
             dataResponseUrns.push(dataUrn);
-            // Description varies by source — dataset-keyed sources (Socrata) have
-            // a portal domain; aggregate/unknown sources are described by their
-            // agent title.
-            const description = toolSourceDatasetKeyed
+            // Description: the portal the span carried, when it carried one;
+            // otherwise the agent that answered the call, by its registry title —
+            // the form aggregate and unknown sources already take. A dataset-keyed
+            // source whose span carried a dataset id but no portal takes the
+            // agent-title form too, with the dataset id stated below as
+            // `civic:datasetId` and no URL minted (a dataset URL needs a host the
+            // span did not carry). That branch is latent by construction for the
+            // reference producer — its loop injects the run portal into `get_data`
+            // arguments before the span opens (run-tool-loop.ts:799 at the time of
+            // writing), and `get_data` is the only tool whose arguments carry a
+            // dataset id — but any producer that writes `tool.dataset_id` without
+            // `tool.portal_domain` reaches it, so it is stated honestly rather
+            // than left dead.
+            const description = toolSourceDatasetKeyed && portalDomain
                 ? `Data response from ${portalDomain}`
                 : `Data response from ${sourceAgentMap[toolSource]?.title || toolSource}`;
             const responseRows = getAttr(span.attributes, 'tool.response_rows');
@@ -210,12 +245,18 @@ export function buildProvenanceGraph(trace, input, config) {
                 'civic:sourceId': toolSource,
                 ...provWasGeneratedBy(toolCallUrn),
                 // Croissant 1.1 placeholder — only meaningful for dataset-keyed
-                // sources today.
+                // sources today. The dataset id is stated whenever the span carried
+                // one; the portal and the dataset URL only when the span carried
+                // the portal as well. Key order is the byte contract.
                 ...(toolSourceDatasetKeyed && datasetId
                     ? {
                         'civic:datasetId': datasetId,
-                        'civic:portalDomain': portalDomain,
-                        'civic:datasetUrl': `https://${portalDomain}/d/${datasetId}`,
+                        ...(portalDomain
+                            ? {
+                                'civic:portalDomain': portalDomain,
+                                'civic:datasetUrl': `https://${portalDomain}/d/${datasetId}`,
+                            }
+                            : {}),
                         'civic:croissantMetadataUrl': null, // hook for future Croissant integration
                     }
                     : {}),
@@ -227,7 +268,10 @@ export function buildProvenanceGraph(trace, input, config) {
         // agent (e.g. socrata for `get_data`, data-commons for `get_observations`).
         const durationMs = getAttr(span.attributes, 'tool.duration_ms');
         graph.push(makeActivityNode(toolCallUrn, {
-            'dcterms:description': `MCP tool call: ${toolName} (${opType})`,
+            // Names the tool only when the span did.
+            'dcterms:description': toolName
+                ? `MCP tool call: ${toolName} (${opType})`
+                : `MCP tool call (${opType})`,
             'civic:sourceId': toolSource,
             ...provUsed([queryUrn]),
             ...provWasAssociatedWith(toolAgentUrn),
@@ -249,8 +293,8 @@ export function buildProvenanceGraph(trace, input, config) {
     const generatorSpan = synthesisSpan || lastInference;
     if (generatorSpan) {
         const generatorUrn = synthesisSpan
-            ? civicUrn(packageId, 'synthesis', synthesisSpan.spanId)
-            : civicUrn(packageId, 'inference', generatorSpan.spanId);
+            ? vocab.urn(packageId, 'synthesis', synthesisSpan.spanId)
+            : vocab.urn(packageId, 'inference', generatorSpan.spanId);
         // Add synthesis activity if it exists
         if (synthesisSpan) {
             graph.push(makeActivityNode(generatorUrn, {
@@ -265,7 +309,7 @@ export function buildProvenanceGraph(trace, input, config) {
             }));
         }
         // Output wasGeneratedBy
-        graph.push(makeEntityNode(civicUrn(packageId, 'output', outputHash), {
+        graph.push(makeEntityNode(vocab.urn(packageId, 'output', outputHash), {
             ...provWasGeneratedBy(generatorUrn),
             ...(dataResponseUrns.length > 0
                 ? provWasDerivedFrom(dataResponseUrns)
@@ -288,9 +332,9 @@ export function buildProvenanceGraph(trace, input, config) {
             'prov:qualifiedAssociation': {
                 '@type': 'prov:Association',
                 'prov:agent': provRef(modelUrn),
-                'prov:hadPlan': provRef(civicUrn(packageId, 'skill', skillHash)),
+                'prov:hadPlan': provRef(vocab.urn(packageId, 'skill', skillHash)),
             },
         }));
     }
-    return makeProvGraph(makeCivicProvContext(), graph);
+    return makeProvGraph(vocab.context(), graph);
 }

package/dist/format/vocabulary.d.ts

@@ -1,24 +1,68 @@
 /** The `civic:` JSON-LD namespace URI. Part of the civic vocabulary itself
  *  (it names the term set, not a deployment), so it is a constant, not a
- *  config input. */
-export declare const CIVIC_NS = "https://civicaitools.org/ns/evidence/";
-/** The civic evidence-package JSON-LD `@context`: prov / xsd / civic /
+ *  config input. Settlement-era value (Appendix J). */
+export declare const CIVIC_NS = "https://civicaitools.org/ns/civic/";
+/** Root of the `urn:civic-record:` id scheme. Settlement-era value
+ *  (Appendix J). */
+export declare const CIVIC_URN_PREFIX = "urn:civic-record";
+/** The prior-era `civic:` namespace URI, frozen inside records signed before
+ *  the 2026-08-19 settlement. Never emitted for new packages. */
+export declare const PRIOR_ERA_CIVIC_NS = "https://civicaitools.org/ns/evidence/";
+/** The prior-era id-scheme root, frozen inside records signed before the
+ *  2026-08-19 settlement. Never emitted for new packages. */
+export declare const PRIOR_ERA_CIVIC_URN_PREFIX = "urn:civic-evidence";
+/**
+ * One era of the civic vocabulary: the two literals plus the emitters bound
+ * to them. The vocabulary is not deployment configuration (a deployment does
+ * not choose its own term set); this seam exists only so a prior-era package
+ * can be reproduced with the exact vocabulary it was signed under.
+ */
+export interface CivicVocabulary {
+    /** The `civic:` JSON-LD namespace URI for this era. */
+    readonly ns: string;
+    /** The id-scheme root for this era. */
+    readonly urnPrefix: string;
+    /** The civic record-package JSON-LD `@context`: prov / xsd / civic /
+     *  dcterms, in the reference emission order (legacy-chain byte discipline —
+     *  insertion order is the byte contract). */
+    context(): Record<string, string>;
+    /** Package-scoped node id: `<prefix>:<packageId>:<type>:<id>`. */
+    urn(packageId: string, type: string, id: string): string;
+    /** Model-agent id: `<prefix>:model:<modelId>` (slashes in the model
+     *  identifier collapse to dashes). */
+    modelUrn(model: string): string;
+    /** MCP source-agent id: `<prefix>:mcp-server:<sourceId>`. Known source ids
+     *  are emitted raw (they are already URN-safe by construction); callers
+     *  emitting an UNKNOWN id must encode it first (the capture-side builder
+     *  uses `encodeURIComponent`, matching the reference behavior). */
+    sourceAgentUrn(sourceId: string): string;
+    /** Platform-agent id: `<prefix>:platform:<platformId>`. */
+    platformUrn(platformId: string): string;
+}
+/** Bind the emitters to one era's two literals. */
+export declare function makeCivicVocabulary(ns: string, urnPrefix: string): CivicVocabulary;
+/** The settlement-era vocabulary — what every new emission uses. */
+export declare const CIVIC_VOCABULARY: CivicVocabulary;
+/** The prior-era vocabulary, valid forever inside records signed before the
+ *  settlement. Supply it to reproduce or verify such a record byte-for-byte;
+ *  never to mint a new package. */
+export declare const PRIOR_ERA_CIVIC_VOCABULARY: CivicVocabulary;
+/** The civic record-package JSON-LD `@context`: prov / xsd / civic /
  *  dcterms, in the reference emission order (legacy-chain byte discipline —
- *  insertion order is the byte contract). */
+ *  insertion order is the byte contract). Settlement era; for a prior-era
+ *  graph use `PRIOR_ERA_CIVIC_VOCABULARY.context()`. */
 export declare function makeCivicProvContext(): Record<string, string>;
-/** Root of the `urn:civic-evidence:` id scheme. */
-export declare const CIVIC_URN_PREFIX = "urn:civic-evidence";
-/** Package-scoped node id: `urn:civic-evidence:<packageId>:<type>:<id>`. */
+/** Package-scoped node id: `urn:civic-record:<packageId>:<type>:<id>`. */
 export declare function civicUrn(packageId: string, type: string, id: string): string;
-/** Model-agent id: `urn:civic-evidence:model:<modelId>` (slashes in the
+/** Model-agent id: `urn:civic-record:model:<modelId>` (slashes in the
  *  model identifier collapse to dashes). */
 export declare function civicModelUrn(model: string): string;
-/** MCP source-agent id: `urn:civic-evidence:mcp-server:<sourceId>`. Known
+/** MCP source-agent id: `urn:civic-record:mcp-server:<sourceId>`. Known
  *  source ids are emitted raw (they are already URN-safe by construction);
  *  callers emitting an UNKNOWN id must encode it first (the capture-side
  *  builder uses `encodeURIComponent`, matching the reference behavior). */
 export declare function civicSourceAgentUrn(sourceId: string): string;
-/** Platform-agent id: `urn:civic-evidence:platform:<platformId>`. */
+/** Platform-agent id: `urn:civic-record:platform:<platformId>`. */
 export declare function civicPlatformUrn(platformId: string): string;
 /**
  * Platform-agent identity — WHO published, as a PROV agent. A typed config
@@ -26,7 +70,8 @@ export declare function civicPlatformUrn(platformId: string): string;
  * the civicaitools.org demo values are the exported default below.
  */
 export interface PlatformAgentConfig {
-    /** Stable platform id — becomes `urn:civic-evidence:platform:<id>`. */
+    /** Stable platform id — becomes `urn:civic-record:platform:<id>` (prior-era
+     *  graphs carry the same id under the prior-era prefix). */
     id: string;
     /** Human-readable platform title (`dcterms:title`). */
     title: string;

package/dist/format/vocabulary.js

@@ -1,5 +1,5 @@
 // Civic PROV-O vocabulary (FORMAT-EXTENSION group) — the `civic:` JSON-LD
-// namespace, the `urn:civic-evidence:` id scheme, and the platform-agent
+// namespace, the `urn:civic-record:` id scheme, and the platform-agent
 // identity shape. Relocated from civic-ai-tools-website
 // `src/lib/evidence/provenance.ts` (`:51` urn scheme, `:179–184` platform
 // agent, `:384–391` context) per the S2 brief §1.
@@ -7,43 +7,81 @@
 // This module defines vocabulary; it never walks a trace. The capture-side
 // provenance BUILDER (src/capture/provenance.ts) imports its terms from here —
 // that direction is the package's internal module boundary.
+//
+// TWO ERAS (spec Appendix J — the 2026-08-19 vocabulary settlement, migration
+// class "frozen-in-signed-artifacts"). New emissions mint the SETTLEMENT-era
+// terms (`CIVIC_NS` / `CIVIC_URN_PREFIX` below, the module's canonical
+// values). The PRIOR-era terms are frozen inside every already-signed record —
+// rewriting them would change the envelope hash and invalidate the signature —
+// so they remain valid forever and are exported here too: reproducing or
+// verifying a prior-era package byte-for-byte requires emitting its vocabulary
+// exactly as it was signed. Era is not a trust signal (Appendix J §J.4 rule 2);
+// prior-era injection exists for reproduction and verification, never for new
+// emissions.
 import { makeProvContext, PROV_NS, XSD_NS, DCTERMS_NS } from '@typedstandards/produce-core';
 /** The `civic:` JSON-LD namespace URI. Part of the civic vocabulary itself
  *  (it names the term set, not a deployment), so it is a constant, not a
- *  config input. */
-export const CIVIC_NS = 'https://civicaitools.org/ns/evidence/';
-/** The civic evidence-package JSON-LD `@context`: prov / xsd / civic /
+ *  config input. Settlement-era value (Appendix J). */
+export const CIVIC_NS = 'https://civicaitools.org/ns/civic/';
+/** Root of the `urn:civic-record:` id scheme. Settlement-era value
+ *  (Appendix J). */
+export const CIVIC_URN_PREFIX = 'urn:civic-record';
+/** The prior-era `civic:` namespace URI, frozen inside records signed before
+ *  the 2026-08-19 settlement. Never emitted for new packages. */
+export const PRIOR_ERA_CIVIC_NS = 'https://civicaitools.org/ns/evidence/';
+/** The prior-era id-scheme root, frozen inside records signed before the
+ *  2026-08-19 settlement. Never emitted for new packages. */
+export const PRIOR_ERA_CIVIC_URN_PREFIX = 'urn:civic-evidence';
+/** Bind the emitters to one era's two literals. */
+export function makeCivicVocabulary(ns, urnPrefix) {
+    return {
+        ns,
+        urnPrefix,
+        context: () => makeProvContext({
+            prov: PROV_NS,
+            xsd: XSD_NS,
+            civic: ns,
+            dcterms: DCTERMS_NS,
+        }),
+        urn: (packageId, type, id) => `${urnPrefix}:${packageId}:${type}:${id}`,
+        modelUrn: (model) => `${urnPrefix}:model:${model.replace(/\//g, '-')}`,
+        sourceAgentUrn: (sourceId) => `${urnPrefix}:mcp-server:${sourceId}`,
+        platformUrn: (platformId) => `${urnPrefix}:platform:${platformId}`,
+    };
+}
+/** The settlement-era vocabulary — what every new emission uses. */
+export const CIVIC_VOCABULARY = makeCivicVocabulary(CIVIC_NS, CIVIC_URN_PREFIX);
+/** The prior-era vocabulary, valid forever inside records signed before the
+ *  settlement. Supply it to reproduce or verify such a record byte-for-byte;
+ *  never to mint a new package. */
+export const PRIOR_ERA_CIVIC_VOCABULARY = makeCivicVocabulary(PRIOR_ERA_CIVIC_NS, PRIOR_ERA_CIVIC_URN_PREFIX);
+// --- Settlement-era convenience bindings (unchanged signatures) ---
+/** The civic record-package JSON-LD `@context`: prov / xsd / civic /
  *  dcterms, in the reference emission order (legacy-chain byte discipline —
- *  insertion order is the byte contract). */
+ *  insertion order is the byte contract). Settlement era; for a prior-era
+ *  graph use `PRIOR_ERA_CIVIC_VOCABULARY.context()`. */
 export function makeCivicProvContext() {
-    return makeProvContext({
-        prov: PROV_NS,
-        xsd: XSD_NS,
-        civic: CIVIC_NS,
-        dcterms: DCTERMS_NS,
-    });
+    return CIVIC_VOCABULARY.context();
 }
-/** Root of the `urn:civic-evidence:` id scheme. */
-export const CIVIC_URN_PREFIX = 'urn:civic-evidence';
-/** Package-scoped node id: `urn:civic-evidence:<packageId>:<type>:<id>`. */
+/** Package-scoped node id: `urn:civic-record:<packageId>:<type>:<id>`. */
 export function civicUrn(packageId, type, id) {
-    return `${CIVIC_URN_PREFIX}:${packageId}:${type}:${id}`;
+    return CIVIC_VOCABULARY.urn(packageId, type, id);
 }
-/** Model-agent id: `urn:civic-evidence:model:<modelId>` (slashes in the
+/** Model-agent id: `urn:civic-record:model:<modelId>` (slashes in the
  *  model identifier collapse to dashes). */
 export function civicModelUrn(model) {
-    return `${CIVIC_URN_PREFIX}:model:${model.replace(/\//g, '-')}`;
+    return CIVIC_VOCABULARY.modelUrn(model);
 }
-/** MCP source-agent id: `urn:civic-evidence:mcp-server:<sourceId>`. Known
+/** MCP source-agent id: `urn:civic-record:mcp-server:<sourceId>`. Known
  *  source ids are emitted raw (they are already URN-safe by construction);
  *  callers emitting an UNKNOWN id must encode it first (the capture-side
  *  builder uses `encodeURIComponent`, matching the reference behavior). */
 export function civicSourceAgentUrn(sourceId) {
-    return `${CIVIC_URN_PREFIX}:mcp-server:${sourceId}`;
+    return CIVIC_VOCABULARY.sourceAgentUrn(sourceId);
 }
-/** Platform-agent id: `urn:civic-evidence:platform:<platformId>`. */
+/** Platform-agent id: `urn:civic-record:platform:<platformId>`. */
 export function civicPlatformUrn(platformId) {
-    return `${CIVIC_URN_PREFIX}:platform:${platformId}`;
+    return CIVIC_VOCABULARY.platformUrn(platformId);
 }
 /** Demo default: the civicaitools.org reference deployment's identity. */
 export const CIVICAITOOLS_PLATFORM_AGENT = {

package/dist/rubric/adversarial-eval-core.d.ts

@@ -1,4 +1,4 @@
-import { type EvidencePackage, type EvaluationResults } from '@typedstandards/produce-core';
+import { type RecordPackage, type EvaluationResults } from '@typedstandards/produce-core';
 /** Rubric identifier carried as the `scoringRubric` payload field and the
  *  methodology `testSet`. Six criteria, 1-10 each, plus aggregate. */
 export declare const RUBRIC_ID = "civicaitools-adversarial-rubric/six-criterion-v1";
@@ -8,8 +8,12 @@ export declare const EVALUATION_RUBRIC = "You are an independent evaluator asses
  *  once at module load. Any wording change to the rubric produces a new
  *  version, so an attestation pins the exact prompt set that scored it. */
 export declare const RUBRIC_VERSION_SHA256: string;
-/** Build the user-turn evaluation content from a package's signed fields. */
-export declare function buildEvaluationPrompt(pkg: EvidencePackage): string;
+/** Build the user-turn evaluation content from a package's signed fields.
+ *  Takes `RecordPackage` — produce-core 0.3.0's settlement-era name for the
+ *  same object (spec Appendix J, migration class alias-and-deprecate). The
+ *  prior name is a deprecated alias of this exact type upstream, so existing
+ *  callers still compile unchanged. */
+export declare function buildEvaluationPrompt(pkg: RecordPackage): string;
 export type ParsedEvaluation = {
     ok: true;
     results: EvaluationResults;

package/dist/rubric/adversarial-eval-core.js

@@ -59,7 +59,11 @@ Respond in this exact JSON format (no markdown fences, just raw JSON):
  *  once at module load. Any wording change to the rubric produces a new
  *  version, so an attestation pins the exact prompt set that scored it. */
 export const RUBRIC_VERSION_SHA256 = sha256Hex(EVALUATION_RUBRIC);
-/** Build the user-turn evaluation content from a package's signed fields. */
+/** Build the user-turn evaluation content from a package's signed fields.
+ *  Takes `RecordPackage` — produce-core 0.3.0's settlement-era name for the
+ *  same object (spec Appendix J, migration class alias-and-deprecate). The
+ *  prior name is a deprecated alias of this exact type upstream, so existing
+ *  callers still compile unchanged. */
 export function buildEvaluationPrompt(pkg) {
     const toolCallSummary = pkg.queries
         .map((q, i) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typedstandards/civic-typed-harness",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Civic-domain harness for Typed Standards evidence packages — the DOMAIN layer of the ADR-0021 format/domain line: civic PROV-O vocabulary and provenance builder, datHere envelope-policy derivations, and the capture machinery (trace builder, skill-metadata extraction, data-source population, adversarial rubric core). Derives; @typedstandards/produce-core assembles.",
   "license": "MIT",
   "author": "Nathan Storey",
@@ -33,10 +33,10 @@
     "prepublishOnly": "npm run clean && npm run build"
   },
   "dependencies": {
-    "@typedstandards/produce-core": "^0.2.0"
+    "@typedstandards/produce-core": "^0.3.0 || ^0.4.0"
   },
   "devDependencies": {
-    "@typedstandards/verify-core": "^0.8.0",
+    "@typedstandards/verify-core": "^0.9.0",
     "@typescript-eslint/parser": "^8",
     "eslint": "^9",
     "typescript": "^5.9.3"