@typedstandards/civic-typed-harness 0.7.0 → 0.9.0

package/CHANGELOG.md

@@ -3,6 +3,82 @@
 Factual record of what changed per published version. Section references are
 to the Typed Standards specification unless noted otherwise.
 
+## 0.9.0 — 2026-10-18
+
+The reader's states and the flows-statement reference (sprint R6, H2;
+[ADR-0033](../../docs/adr/0033-composed-harness-record-fields.md)'s
+2026-10-18 amendment, ruling D2 = A of
+[civic-ai-tools-website#632](https://github.com/npstorey/civic-ai-tools-website/issues/632)),
+and the evaluator prompt's aggregate sources
+([civic-ai-tools#265](https://github.com/npstorey/civic-ai-tools/issues/265)).
+Signed bytes move only on a new record that passes a new reason or a
+`flowsStatement`; a record packaged without them has the same bytes, and no
+golden fixture moves.
+
+- **Two `sourcesOffered` reasons.** `SourceOfferedReason` and
+  `SOURCE_OFFERED_REASONS` gain `reader-off` (the source was configured, and
+  the reader turned it off) and `not-consented` (the source was configured,
+  and the reader has given no consent for it), after the four of ADR-0033 §E
+  in §E's order. A source was offered exactly when its reason is `configured`
+  or `selected`, as before. The derivation's refusal message lists the six.
+- **`flowsStatement` in the composition block.** `CompositionInput`,
+  `DatHerePolicyInput` and `ExtractedRunAttributes` gain an optional
+  `flowsStatement: { url, hash, date }`, typed as the new
+  `FlowsStatementInput` on the two inputs. `extractRunAttributes` reads it
+  from the root-span attribute `analysis.flows_statement`, JSON text of one
+  object whose fields are exactly the three strings, and refuses anything
+  else with `RunAttributeError`. The derivation states it as the block's last
+  key, keys in the order `url`, `hash`, `date`, and refuses with
+  `RecordFieldError` a `url` that is not an absolute `http:` or `https:` URL
+  without credentials or whitespace, a `hash` that is not lowercase hex
+  SHA-256, a `date` that is not a calendar date, and any other key. The
+  record refers to the statement by address, hash and date, never by content
+  (ADR-0036 §D). Absent, the key is absent.
+- **The evaluator prompt names an aggregate source.** `buildEvaluationPrompt`
+  rendered every `dataSources` entry by its `datasetUrl`, and an aggregate
+  entry (Data Commons, Boston, a hosted source) carries none, so the
+  evaluator read `- undefined (accessed …)` for it. An entry without a
+  `datasetUrl` now reads `- <sourceId> (<catalogType>, <portalUrl>) (accessed
+  <time>)`, with `dataset <datasetId>` added when it carries one; a missing
+  field is left out or stated in fixed words, so no line reads `undefined`.
+  An entry with a `datasetUrl` reads exactly as before. Measured across the
+  release boundary, as 0.4.1 was: the published 0.8.0 and this build render
+  a dataset-only package and an empty one byte-identically, and render a
+  package with two aggregate entries differently.
+- **`RUBRIC_VERSION_SHA256` does not move:**
+  `b62b193c992fd430cc82dff9a80a057bbe0b2b656fbdace450ca1a5d99fffa02` in the
+  published 0.8.0 and in this build. It is the SHA-256 of the rubric text
+  alone, and the prompt template is outside it, so an evaluation either side
+  of this release carries the same `promptSetVersion` while the evaluator of
+  a record with an aggregate entry is shown different input.
+  [civic-ai-tools#207](https://github.com/npstorey/civic-ai-tools/issues/207),
+  that gap, stays open.
+- No dependency changes.
+
+## 0.8.0 — 2026-10-16
+
+The dependency floor (sprint LAYOUT-WEB, F0).
+
+- **Dependency floor raised:** `@typedstandards/produce-core` `^0.8.0` →
+  `^0.9.0`, and the `@typedstandards/verify-core` devDependency `^0.13.0` →
+  `^0.14.0`, the version produce-core 0.9.0 resolves. Under 0.x semver
+  `^0.8.0` excludes 0.9.0, so a consumer that pins produce-core `^0.9.0`
+  would install a second copy of each core beside this package's.
+- **What the two releases bring.** produce-core 0.9.0 adds `buildLayoutNode`,
+  which builds a `content/layout/v1` node, with `CONTENT_LAYOUT` and five
+  types, and an optional `layoutNodeId` on `attestation/publishes/v1`,
+  emitted only when supplied; an attestation built without it has the same
+  bytes as one built by 0.8.0. verify-core 0.14.0 registers
+  `content/layout/v1` (check #12 reads `ok` for a layout node) and adds
+  `parseStrictJson` and `RepeatedMemberNameError`. The harness reads none of
+  these.
+- The lockfile resolves produce-core 0.9.0 and verify-core 0.14.0, one copy
+  each, and no other entry moves. The golden byte-compat suite passes
+  unchanged.
+- A consumer that pins produce-core 0.8.x no longer shares its copy with this
+  package.
+- **README:** the runtime-dependency line names `^0.9.0`.
+
 ## 0.7.0 — 2026-10-15
 
 - **The seam inside the harness** ([civic-ai-tools#244](https://github.com/npstorey/civic-ai-tools/issues/244) P2).

package/README.md

@@ -46,7 +46,7 @@ const graph = buildProvenanceGraph(trace, input, CIVICAITOOLS_PROVENANCE_CONFIG)
 
 Likewise: `buildDatHereEnvironment` / `deriveDatHereEnvelopeFields` take `CIVICAITOOLS_ENVIRONMENT_CONFIG`, `new TraceBuilder(...)` takes `CIVICAITOOLS_TRACE_CONFIG`, and `isDatasetKeyedSource` / `displayNameForSource` / `formatDataSourcesSummary` take `CIVIC_SOURCE_REGISTRY`. The acceptance condition is encoded in `src/required-config.assert.ts`: reintroducing any of the removed defaults fails `npm run typecheck`.
 
-## What a record states about its run (0.7.0, [ADR-0033](../../docs/adr/0033-composed-harness-record-fields.md))
+## What a record states about its run (0.7.0 and 0.9.0, [ADR-0033](../../docs/adr/0033-composed-harness-record-fields.md))
 
 **Every call is attributed to its own source.** A tool span's source is its `mcp.source` tag; an untagged span resolves by its tool name through the resolver (`ProvenanceConfig.resolver`, default `civicToolSourceResolver`); a span neither identifies is attributed to `UNKNOWN_SOURCE_ID` (`'unknown'`), never to Socrata. The same order holds in `dataSources[]`, where an unknown call mints no entry. A caller may still pass `fallbackSourceId` explicitly, for example `'socrata'` to reproduce an earlier record of an untagged span.
 
@@ -63,6 +63,7 @@ Likewise: `buildDatHereEnvironment` / `deriveDatHereEnvelopeFields` take `CIVICA
 | `analysis.tool_definitions` | `toolDefinitions` | `org.civicaitools.environment.toolDefinitions` |
 | `analysis.sources_offered` | `sourcesOffered` | `org.civicaitools.composition.sourcesOffered` |
 | `analysis.components` | `components` | `org.civicaitools.composition.components` |
+| `analysis.flows_statement` (one object, `{ url, hash, date }`) | `flowsStatement` | `org.civicaitools.composition.flowsStatement`, the block's last key |
 
 ```ts
 const fields = deriveDatHereEnvelopeFields(
@@ -71,13 +72,17 @@ const fields = deriveDatHereEnvelopeFields(
 );
 ```
 
-An absent attribute is an absent field. A present attribute that does not parse is refused (`RunAttributeError`), and a value outside the record's form — a date that is not a calendar date, a reason outside `configured` / `not-configured` / `selected` / `not-selected`, a guidance hash that is not lowercase hex SHA-256, an origin outside `endpoint` / `inline` / `fallback` — is refused by the derivation (`RecordFieldError`), never dropped. The `org.civicaitools.composition` block is emitted under every content profile, appended after the other extensions, and only when one of its fields is passed: a package built with none of these inputs has 0.6.0's extensions bytes, except that a datHere environment block no longer states the two placeholders.
+An absent attribute is an absent field. A present attribute that does not parse is refused (`RunAttributeError`), and a value outside the record's form — a date that is not a calendar date, a reason outside `configured` / `not-configured` / `selected` / `not-selected` / `reader-off` / `not-consented`, a guidance hash that is not lowercase hex SHA-256, an origin outside `endpoint` / `inline` / `fallback`, a flows statement that is not exactly an absolute `http:` or `https:` `url` with no credentials, a lowercase hex SHA-256 `hash` and a calendar `date` — is refused by the derivation (`RecordFieldError`), never dropped. The `org.civicaitools.composition` block is emitted under every content profile, appended after the other extensions, and only when one of its fields is passed: a package built with none of these inputs has 0.6.0's extensions bytes, except that a datHere environment block no longer states the two placeholders.
+
+**The reader's states and the flows statement (0.9.0, ADR-0033's 2026-10-18 amendment).** Two reasons follow the four: `reader-off` (the source was configured, and the reader turned it off) and `not-consented` (the source was configured, and the reader has given no consent for it). A source was offered exactly when its reason is `configured` or `selected`. `flowsStatement` refers to the instance's flows statement by address, hash and date, and the record never carries the statement itself. A record packaged without either has the same bytes.
+
+**The evaluator prompt (0.9.0, [civic-ai-tools#265](https://github.com/npstorey/civic-ai-tools/issues/265)).** `buildEvaluationPrompt` lists each `dataSources` entry by what it carries. An entry with a `datasetUrl` reads as before; an aggregate entry, which has none, reads `- <sourceId> (<catalogType>, <portalUrl>) (accessed <time>)`, where 0.8.0 printed `undefined`. `RUBRIC_VERSION_SHA256` does not move: it is the SHA-256 of the rubric text alone, and the prompt template is outside it ([civic-ai-tools#207](https://github.com/npstorey/civic-ai-tools/issues/207), open).
 
 ## Purity contract (harness-grade)
 
 No I/O, no network, no environment reads, no Node built-ins, browser-safe — anywhere in the package. Clock and RNG are permitted **in capture modules only** (span timestamps and ids are what capture *is*) and are injectable for deterministic tests. Enforced mechanically twice: `eslint.config.mjs` (`no-restricted-imports` / `-globals` / `-properties` / `-syntax`) and `src/purity.test.ts` (browser-safety + determinism + module-boundary checks under `node --test`).
 
-Runtime dependency: **`@typedstandards/produce-core` (`^0.8.0`) only.** The verify-core primitives the harness consumes (`sha256Hex`, `isBlobRef`, the canonicalization-rule URIs, the Q32 vocabulary table, the `CaptureMethod` type) are reached through produce-core's 0.2.0 re-exports rather than imported from `@typedstandards/verify-core` directly — one declared dependency, no phantom, and still one hashing implementation across producer, harness, and verifier by construction (produce-core re-exports the same bindings verify-core defines, verified by reference identity).
+Runtime dependency: **`@typedstandards/produce-core` (`^0.9.0`) only.** The verify-core primitives the harness consumes (`sha256Hex`, `isBlobRef`, the canonicalization-rule URIs, the Q32 vocabulary table, the `CaptureMethod` type) are reached through produce-core's 0.2.0 re-exports rather than imported from `@typedstandards/verify-core` directly — one declared dependency, no phantom, and still one hashing implementation across producer, harness, and verifier by construction (produce-core re-exports the same bindings verify-core defines, verified by reference identity).
 
 > **Q32 adjacency** (open-questions registry): the captureMethod vocabulary re-exported from `src/format/profiles.ts` is verify-core's hardcoded fallback table, pending versioned, content-addressed guidance bundles. Flagged, not solved, here.
 

package/dist/capture/run-attributes.d.ts

@@ -20,6 +20,11 @@ export interface ExtractedRunAttributes {
         guidanceHash?: string;
         guidanceOrigin?: string;
     }>;
+    flowsStatement?: {
+        url: string;
+        hash: string;
+        date: string;
+    };
 }
 /** A root-span attribute that is present but not the shape ADR-0033 names. */
 export declare class RunAttributeError extends Error {

package/dist/capture/run-attributes.js

@@ -1,7 +1,8 @@
 // Run-attribute extraction (CAPTURE group) — reads the facts the producer
 // recorded on the trace's ROOT span at run time (ADR-0033 §D, §E): the date
 // the prompt asserted, the servers the run had, the tools it offered, the
-// sources it was offered and the components that composed its prompt.
+// sources it was offered, the components that composed its prompt, and the
+// flows statement in force (by reference: address, hash and date).
 //
 // WHY THE TRACE (civic-ai-tools-website#495). A record is packaged after the
 // run, sometimes much later; a fact read at packaging is packaging-time state.
@@ -10,9 +11,11 @@
 //
 // SHAPE, NOT POLICY. This module checks that each attribute parses as the
 // shape ADR-0033 names (JSON text of an array of objects whose named fields
-// are strings) and returns it under the derivation's input names. The values
-// — the date form, the reason set, the hash form, the origin set — are policy,
-// checked by the format group's derivation, which refuses a bad one by name.
+// are strings; for `analysis.flows_statement`, of one object of exactly three
+// strings) and returns it under the derivation's input names. The values —
+// the date form, the reason set, the hash form, the origin set, the address
+// form — are policy, checked by the format group's derivation, which refuses
+// a bad one by name.
 //
 // An ABSENT attribute is an absent field. A PRESENT attribute that does not
 // parse is refused with `RunAttributeError`, never read as absent: absence
@@ -72,6 +75,34 @@ function objectArray(attribute, text, required, optional = []) {
     });
     return parsed;
 }
+/** Parse an attribute as JSON text of ONE plain object whose fields are
+ *  exactly `fields`, each a string: a missing field, a non-string field and
+ *  an extra field are each refused. The field set is closed because the
+ *  object lands in the record whole; an extra field would otherwise either
+ *  reach signed bytes unchecked or be dropped silently. */
+function exactStringObject(attribute, text, fields) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new RunAttributeError(attribute, 'is not JSON text');
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new RunAttributeError(attribute, 'is not a JSON object');
+    }
+    const entry = parsed;
+    for (const field of fields) {
+        if (typeof entry[field] !== 'string') {
+            throw new RunAttributeError(attribute, `has no string ${field}`);
+        }
+    }
+    const extra = Object.keys(entry).filter((k) => !fields.includes(k));
+    if (extra.length > 0) {
+        throw new RunAttributeError(attribute, `has a field outside ${fields.join(', ')}: ${extra.map((k) => JSON.stringify(k)).join(', ')}`);
+    }
+    return entry;
+}
 /**
  * Read the run attributes from a trace's root span. Returns `{}` for a trace
  * with no root span — including a BlobRef trace's inspection view
@@ -101,5 +132,10 @@ export function extractRunAttributes(trace) {
     if (components !== undefined) {
         out.components = objectArray('analysis.components', components, ['id'], ['version', 'guidanceHash', 'guidanceOrigin']);
     }
+    const flows = stringAttr(root, 'analysis.flows_statement');
+    if (flows !== undefined) {
+        const { url, hash, date } = exactStringObject('analysis.flows_statement', flows, ['url', 'hash', 'date']);
+        out.flowsStatement = { url, hash, date };
+    }
     return out;
 }

package/dist/format/dathere.d.ts

@@ -134,13 +134,19 @@ export interface DatHerePolicyInput {
     sourcesOffered?: readonly SourceOfferedInput[];
     /** What composed the prompt (composition block). */
     components?: readonly CompositionComponentInput[];
+    /** The instance's flows statement in force for the run, by reference
+     *  (composition block; ADR-0033 §E as amended 2026-10-18). */
+    flowsStatement?: FlowsStatementInput;
     /** Caller-supplied extensions to layer the environment extension onto. */
     extensions?: Record<string, unknown>;
 }
-/** Why a source was or was not offered to the model (ADR-0033 §E). A source
- *  was offered exactly when its reason is `configured` or `selected`. */
-export type SourceOfferedReason = 'configured' | 'not-configured' | 'selected' | 'not-selected';
-/** The four reasons, in the order ADR-0033 §E states them. */
+/** Why a source was or was not offered to the model (ADR-0033 §E, amended
+ *  2026-10-18). A source was offered exactly when its reason is `configured`
+ *  or `selected`; `reader-off` and `not-consented` are the reader's states
+ *  for a configured source that was not offered. */
+export type SourceOfferedReason = 'configured' | 'not-configured' | 'selected' | 'not-selected' | 'reader-off' | 'not-consented';
+/** The six reasons: the four in the order ADR-0033 §E states them, then the
+ *  two its 2026-10-18 amendment adds. */
 export declare const SOURCE_OFFERED_REASONS: readonly SourceOfferedReason[];
 /** One `sourcesOffered` entry as a caller passes it. `reason` is a string so
  *  the trace extractor's output is accepted as is; the derivation refuses a
@@ -167,11 +173,21 @@ export interface CompositionComponentInput {
     guidanceHash?: string;
     guidanceOrigin?: string;
 }
+/** The instance's flows statement, by reference (ADR-0033 §E as amended
+ *  2026-10-18; ADR-0036 §D): the address it is served at, the lowercase hex
+ *  SHA-256 that is its version, and its `YYYY-MM-DD` date. The record states
+ *  these three and never the statement's content. */
+export interface FlowsStatementInput {
+    url: string;
+    hash: string;
+    date: string;
+}
 /** The composition block's inputs (ADR-0033 §E). */
 export interface CompositionInput {
     assertedDate?: string;
     sourcesOffered?: readonly SourceOfferedInput[];
     components?: readonly CompositionComponentInput[];
+    flowsStatement?: FlowsStatementInput;
 }
 /**
  * Build the `org.civicaitools.composition` extension content (ADR-0033 §E),

package/dist/format/dathere.js

@@ -149,12 +149,15 @@ function checkRunSettings(run) {
     }
     return run;
 }
-/** The four reasons, in the order ADR-0033 §E states them. */
+/** The six reasons: the four in the order ADR-0033 §E states them, then the
+ *  two its 2026-10-18 amendment adds. */
 export const SOURCE_OFFERED_REASONS = [
     'configured',
     'not-configured',
     'selected',
     'not-selected',
+    'reader-off',
+    'not-consented',
 ];
 /** The three origins. */
 export const GUIDANCE_ORIGINS = ['endpoint', 'inline', 'fallback'];
@@ -178,6 +181,30 @@ function isCalendarDate(value) {
 function nonEmptyString(value) {
     return typeof value === 'string' && value.length > 0;
 }
+/** The flows statement's keys, in the record's order. */
+const FLOWS_STATEMENT_KEYS = ['url', 'hash', 'date'];
+/** Any whitespace or control character: a URL parser strips or drops these,
+ *  so a string carrying one is not the address it parses to. */
+const WHITESPACE_OR_CONTROL = /[\s\u0000-\u001f\u007f]/;
+/** An absolute `http:` or `https:` URL, as written (the scheme followed by
+ *  `//`), with no credentials and no whitespace or control character. `http:`
+ *  is accepted because a local instance serves its statement from
+ *  `http://localhost`. */
+function isStatementUrl(value) {
+    if (typeof value !== 'string' || !/^https?:\/\//i.test(value) || WHITESPACE_OR_CONTROL.test(value)) {
+        return false;
+    }
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        return false;
+    }
+    return (parsed.protocol === 'https:' || parsed.protocol === 'http:')
+        && parsed.username === ''
+        && parsed.password === '';
+}
 /**
  * Build the `org.civicaitools.composition` extension content (ADR-0033 §E),
  * or `undefined` when no field is passed (the block is then not emitted, and
@@ -244,6 +271,28 @@ export function buildCompositionExtension(input) {
             };
         });
     }
+    // The block's last key, so a block built without it keeps its bytes.
+    if (input.flowsStatement !== undefined) {
+        const statement = input.flowsStatement;
+        if (statement === null || typeof statement !== 'object' || Array.isArray(statement)) {
+            throw new RecordFieldError('flowsStatement', 'must be an object { url, hash, date }');
+        }
+        const extra = Object.keys(statement).filter((k) => !FLOWS_STATEMENT_KEYS.includes(k));
+        if (extra.length > 0) {
+            throw new RecordFieldError('flowsStatement', `carries url, hash and date only, never the statement itself; got ${extra.map((k) => JSON.stringify(k)).join(', ')}`);
+        }
+        const { url, hash, date } = statement;
+        if (!isStatementUrl(url)) {
+            throw new RecordFieldError('flowsStatement', `url must be an absolute http: or https: URL with no credentials; got ${JSON.stringify(url)}`);
+        }
+        if (!(typeof hash === 'string' && SHA256_HEX_FORM.test(hash))) {
+            throw new RecordFieldError('flowsStatement', `hash must be a lowercase hex SHA-256; got ${JSON.stringify(hash)}`);
+        }
+        if (!(typeof date === 'string' && isCalendarDate(date))) {
+            throw new RecordFieldError('flowsStatement', `date must be a YYYY-MM-DD calendar date; got ${JSON.stringify(date)}`);
+        }
+        block.flowsStatement = { url, hash, date };
+    }
     return Object.keys(block).length > 0 ? block : undefined;
 }
 /**
@@ -272,6 +321,7 @@ export function deriveDatHereEnvelopeFields(input, config) {
         assertedDate: input.assertedDate,
         sourcesOffered: input.sourcesOffered,
         components: input.components,
+        flowsStatement: input.flowsStatement,
     });
     if (composition !== undefined) {
         extensions[COMPOSITION_EXTENSION_KEY] = composition;

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

@@ -81,6 +81,40 @@ function wasRecordedRejected(query) {
  *  reading `→ ? rows` invited it to treat absent data as merely unrecorded
  *  (civic-ai-tools#203). */
 const REJECTED_CALL_RENDERING = 'REJECTED by the source — no data was returned, and no row count is claimed';
+/** A non-empty string field of a `dataSources` entry, or `undefined`. The
+ *  entry is read as stored: a package from an older producer may lack a
+ *  field the current type requires (the first packager wrote no `sourceId`). */
+function entryText(entry, field) {
+    const value = entry[field];
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+/** One `## Data Sources` line (civic-ai-tools#265). An entry carrying a
+ *  `datasetUrl` renders exactly as before 0.9.0. An entry without one (an
+ *  aggregate source: its registry row names a portal, not a dataset) renders
+ *  by what it carries: `sourceId`, then `catalogType`, `portalUrl` and any
+ *  `datasetId` in parentheses. Every value comes from the entry's own signed
+ *  fields, and no other producer text is interpolated; a missing one is
+ *  either left out or stated in this module's fixed words, so no line reads
+ *  `undefined`. */
+function renderDataSource(ds) {
+    const entry = ds;
+    // Both interpolations of the 0.8.0 line keep their test (a string, of any
+    // length), so every line 0.8.0 rendered from two strings is byte-identical.
+    const accessed = typeof entry.accessTimestamp === 'string'
+        ? `(accessed ${entry.accessTimestamp})`
+        : '(access time not recorded)';
+    if (typeof entry.datasetUrl === 'string') {
+        return `  - ${entry.datasetUrl} ${accessed}`;
+    }
+    const sourceId = entryText(entry, 'sourceId') ?? 'source not recorded';
+    const datasetId = entryText(entry, 'datasetId');
+    const where = [
+        entryText(entry, 'catalogType'),
+        entryText(entry, 'portalUrl'),
+        datasetId !== undefined ? `dataset ${datasetId}` : undefined,
+    ].filter((part) => part !== undefined);
+    return `  - ${sourceId}${where.length > 0 ? ` (${where.join(', ')})` : ''} ${accessed}`;
+}
 /** 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
@@ -99,7 +133,7 @@ export function buildEvaluationPrompt(pkg) {
     })
         .join('\n');
     const dataSources = pkg.dataSources
-        .map(ds => `  - ${ds.datasetUrl} (accessed ${ds.accessTimestamp})`)
+        .map(renderDataSource)
         .join('\n');
     return `## Original Prompt
 ${pkg.prompt.text || '[prompt text not available]'}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typedstandards/civic-typed-harness",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "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.8.0"
+    "@typedstandards/produce-core": "^0.9.0"
   },
   "devDependencies": {
-    "@typedstandards/verify-core": "^0.13.0",
+    "@typedstandards/verify-core": "^0.14.0",
     "@types/node": "^22.20.2",
     "@typescript-eslint/parser": "^8",
     "eslint": "^9",