Proposal 100: Text Origin Labels and Propagation¶
Status: Proposed (Draft). Date: 2026-11-09.
Based on:
- Vision, "Culture as a Low-Pass Filter" (synthetic content displacing human content)
- P004: Human-Origin
Flags
and
doc/project/50-requirements/requirements-005-transcript-segments.md(today'sorigin_classvocabulary) - P047: Classification Label
Propagation
(label as data, join, edge-first staging, deferred
Tainted<T>) - P090: Inference Execution Provenance (a separate axis that must compose with origin)
- P013: Whisper (declared material origin and the "AI-assisted" label)
- P064: Inquirium Implementation Recommendations (observation transport and prompt-injection boundaries)
Executive Summary¶
Text loses its origin as soon as it becomes a plain string. Today only
answer-room transcripts record where text came from, using one of three values,
and node-generated does not distinguish model output from static software
text. Other carriers declare origin by hand or not at all.
This proposal defines a small, set-valued text origin label that travels
with text segments across Node and middleware. A label records who produced the
words (origin/classes) and which origins could have shaped them
(origin/influence). It reuses P013's origin/processing for what was done to
the text and P090's evidence vocabulary for how the label was established, so
each fact keeps one spelling. Labels combine only by union, so no ordinary
operation can remove a name. An absent or lost label means unknown, which
every consumer treats as the worst case.
The label is deliberately sticky, in the spirit of taint flags in kernels and templating systems. It is a provenance record: it grants nothing and proves no authorship.
On the wire a label is a group of sorted name lists beside the text. In Rust it
is a small Copy value held beside existing text fields. A text type with no
implicit exit to str is reserved for paths where an audit shows label loss.
In Python it is a str subclass whose loss is detected at egress. Enforcement
starts at the edges, following P047; the interior is labeled only where text is
actually composed.
This proposal does not:
- prove that a human or a model wrote a given text;
- define confidentiality (P047), execution locality (P090) or material source (P013);
- change participation modes or room policy in P004;
- replace
Stringacross the codebase; - enforce a gate on
origin/influencein its first slice (section 14 starts in observe-only mode).
Context and Problem Statement¶
| Existing carrier | Owner | Meaning | Gap |
|---|---|---|---|
origin_class on transcript segments |
P004, requirements-005 | One of node-generated, node-mediated-human, human-live |
Transcripts only; model and software text are one value |
provenance/origin-classes on response envelopes |
response-envelope.v1 |
Classes materially present in an answer path | The settlement host derives it from one human-linked boolean |
origin/processing with model-assisted |
P013 | Publisher's declaration on a signed signal | Declared per publication, not tracked with the text |
classification.v1 |
P047 | Who may see the data | Different axis |
| Inference execution provenance | P090 | Where inference ran | Different axis; P090 rejected merging it with origin |
PromptLayerOrigin |
Inquirium | Which host layer contributed a prompt layer | Host assembly fact, not text authorship |
Without a shared label, several questions have no answer once text has passed through a few components: whether a summary rests on model output, whether a corpus entry contains synthetic text, and whether a static host message is being presented as an answer.
A search of Node on 2026-11-09 found no consumer of P047's Classified<T>
envelope outside its own crate, while classification travels as a sibling
field in 16 files. That is evidence for sibling fields on the wire, and against
assuming that a wrapper type will spread by itself.
Proposed Model¶
1. A label is four small sets of named values¶
| Field | Question | Names | Vocabulary owner |
|---|---|---|---|
origin/classes |
Who produced these words? | Producer names | This proposal |
origin/influence |
What could have shaped them? | Producer names | This proposal |
origin/processing |
What was done to the text? | extracted, grouped, human-edited, model-assisted, redacted, software-edited, summarized |
P013; human-edited and software-edited are added by P100-010 |
origin/evidence |
How was origin/classes established? |
Evidence names | P090, plus host-observed and module-declared |
| Producer name | Meaning |
|---|---|
human |
Entered through an ordinary human-composition surface. Not proof of human composition: unmarked pasted output may be indistinguishable. A host-owned specialized import profile uses its declared semantics instead (see manual inference exchange below) |
model |
Produced by an inference runtime |
software |
Produced by deterministic code: static templates, host messages, generated reports |
external |
Obtained from outside the node's own actors (web page, mail, document, sensor text); author not established |
unknown |
Label absent, lost or unrecognized |
| Evidence name | Meaning |
|---|---|
host-observed |
This host saw the text enter through the named surface or leave the named runtime |
module-declared |
A local module or connector declared the label |
peer-attested |
A peer declared the label. A signature authenticates the claim, not its truth |
derived |
Computed from another carrier, such as a legacy field |
unknown |
No basis is recorded |
Laws:
origin/classes,origin/influenceandorigin/evidenceeach hold at least one name. An empty set is invalid; it is not a way to say that nothing is known.origin/processingmay be empty, which means that no step is recorded, not that none occurred.model-assistedrequiresmodelinorigin/classes,human-editedrequireshuman, andsoftware-editedrequiressoftware.- Join is field-wise set union: idempotent, commutative, associative and monotone. Valid labels stay valid under union.
- No ordinary operation removes a name (see section 4).
{human, model} alone also arises from concatenating human text with model
text. model-assisted says that a model reworked supplied words,
human-edited that a human changed them, and software-edited that
deterministic code replaced or inserted words. None of them measures how much
changed, and a set does not record which came first.
| Situation | origin/classes |
origin/processing |
origin/evidence |
|---|---|---|---|
| Model answer | {model} |
none | {host-observed} |
| Text typed by the operator | {human} |
none | {host-observed} |
| Operator's text summarized by a model | {human, model} |
{model-assisted, summarized} |
{host-observed} |
| Model draft corrected by the operator on an edit surface | {human, model} |
{human-edited} |
{host-observed} |
| Operator's text changed by a host spelling corrector | {human, software} |
{software-edited} |
{host-observed} |
| Static host error message | {software} |
none | {host-observed} |
| Web page quoted verbatim | {external} |
none | {host-observed} |
| Text a peer labeled as human | {human} |
none | {peer-attested} |
| Text a module returned as its own output | {software} |
none | {module-declared} |
| Record that predates this proposal | {unknown} |
none | {unknown} |
2. Two axes: who wrote it and what shaped it¶
A hostile web page can steer a model into writing text. The model authored those words, yet the page influenced them. Prompt injection concerns influence, so a single mask would hide the fact that matters most.
origin/classesanswers who produced these words.origin/influenceanswers which origins could have shaped them.
Both use the producer names. Text first admitted outside inference starts with influence equal to its classes.
origin/influence is an upper bound only when every contributing segment is
labeled. Any unlabeled segment adds unknown, so during migration the field is
recorded and not used for decisions.
| Axis | Question | Owner | Join |
|---|---|---|---|
origin/classes |
Who produced these words? | P100 | Union |
origin/influence |
What could have shaped them? | P100 | Union |
origin/processing |
What was done to the text? | P013 vocabulary | Union |
origin/evidence |
How was origin/classes established? |
P090 vocabulary | Union |
| Classification | Who may see this? | P047 | Most restrictive |
| Execution provenance | Where did inference run? | P090 | Conservative provenance join |
| Material origin | What source was it drawn from, as declared at publication? | P013 | Per publication |
Classification and execution provenance stay separate carriers. They are larger values with their own join rules and cannot be reduced to bits.
3. An absent label means unknown¶
Templating systems mark text as safe, so a lost mark falls back to escaping. A mark meaning "from a model" has the opposite polarity: once lost, the text looks clean. This proposal therefore fixes the meaning of absence:
- a carrier with no label is read as
{unknown}on both producer axes and for evidence, with no recorded processing; - a name outside the closed vocabulary is refused by the schema on local carriers;
- carriers explicitly selecting the
ingressprofile in section 8 permit bounded unrecognized names in any facet; interpretation is facet-specific; unknownnever projects tohuman,softwareor a legacy value that names an author (section 12);- a consumer treats
unknownas the worst case for its own decision.
This matches P013, where legacy records render origin as unknown, and P047, where unlabeled ingress receives the highest restriction.
After a peer carrier passes its explicitly selected ingress schema and its
owner's applicable authentication checks, interpretation follows these rules:
| Facet | Unrecognized token |
|---|---|
origin/classes, origin/influence |
In the local interpretation, replace the token with unknown, keep all recognized names, then sort and deduplicate. Do not infer a missing producer from a processing token |
origin/evidence |
Ignore the incoming evidence claim whether recognized or not; the host stamps peer-attested. A bounded unknown evidence token does not invalidate interpretation. Outside the unchanged original carrier, it appears only in bounded diagnostics, never as interpreted evidence |
origin/processing |
Return the typed interpretation result unsupported-processing-token. The processing vocabulary has no unknown token; do not drop the operation or substitute an empty processing list |
The resulting producer interpretation still has to satisfy the laws in section
1.
For example, mapping an unrecognized producer to unknown does not satisfy
human-edited's requirement for human. Such a label has a typed validity
refusal; interpretation must not invent the missing name.
An unsupported or invalid label is not a valid TextOrigin or a successful
empty-processing result. Consumers that require an interpreted label must not
automatically approve the operation from it. They expose the interpretation
failure and use their existing refusal or review path. This does not bypass
any existing publication or authority requirement.
Interpretation never rewrites signed arrays or reserializes a signed record as its replacement. The original bytes remain the input to the carrier owner's signature, schema and admission checks. Interpreting an unfamiliar label grants no permission to admit a record rejected by those checks. A local interpretation or diagnostic is a separate read model, not a repaired signed fact.
Required boundary vectors cover each facet, mixed recognized/unrecognized
processing tokens, preservation of recognized producer names, the cross-facet
validity refusal above, and unchanged signed bytes. Local closed-schema refusal
remains unchanged; a valid signature does not make an unsupported label known.
A strictly versioned signed carrier that rejects the token at Schema Gate never
enters this interpretation path. Being received from a peer does not select the
ingress profile. Module ingress retains section 5's module-declared
stamping.
Unknown processing remains a safe refusal to interpret in mixed-version federations. The host provenance-ingress adapter owns the local diagnostic store under S028; the pure codec returns diagnostics but performs no I/O. The store is operator-only and uses a rolling seven-day retention window. Reads and writes prune expired entries; restart does not restart retention.
A diagnostic key binds the admitted peer, carrier/schema version, receiver's
vocabulary version and sender's declared vocabulary version or not-declared.
Keep at most 256 keys and eight token samples per key, with one bounded overflow
aggregate for excess keys and counts. Samples retain the ingress token bound of
32 ASCII characters; counters saturate rather than creating more records.
The overflow aggregate follows the same seven-day retention. Samples expire
according to capture time, even if the same key receives later observations.
Peer-chosen samples are escaped at display and never exported, published, sent to models or copied into notification payloads. Counts identify mismatch for operator action without guessing an undeclared sender version. Repeated failures update these counters rather than creating a review request each time. The store grants no authority to relax interpretation or publication checks.
4. Labels grow; only an act replaces them¶
As with kernel taint flags, names accumulate. Producing a different label requires a new artifact and a recorded act.
An operator approving a model draft does not change its label. Approval is a separate fact owned by the surface that records it, such as a P066 consent or a P013 publication review.
Editing is different, because the words change. When a surface holds the label
of the text it opens and receives changed text, the host keeps every existing
name, adds human to origin/classes and origin/influence, and adds
human-edited to origin/processing. One changed comma is enough, so
human-edited does not say that a human read or endorsed the whole text, and
it never removes model.
Deterministic code can also change words. A step that replaces or inserts words
in supplied text, such as a spelling corrector, keeps every existing name, adds
software to origin/classes and origin/influence, and adds
software-edited to origin/processing. A step that only trims, truncates,
normalizes or changes layout keeps the label unchanged (section 9). Composing
separately labeled segments stays a plain union.
Retyping text by hand, or pasting it into a surface with no link to its source,
yields a new {human} text. That cannot be prevented, and it is one reason
labels are not proof.
5. Who may assign which name¶
| Name | Assigned by |
|---|---|
human |
Host, on operator-facing input surfaces |
model, model-assisted |
Host, at the inference boundary. A module or peer may only relay them |
software |
Host or module, for its own static or generated text |
external |
Host or connector, at ingress of fetched, harvested or sensed text |
human-edited |
Host, on operator-facing edit surfaces that hold the source label. A module or peer may only relay it |
extracted, grouped, redacted, software-edited, summarized |
The party that performed the step |
All of origin/evidence |
Host only |
A module or peer cannot make a label more trustworthy. The host discards any
evidence that arrives with a label and writes its own: module-declared for a
module or connector, peer-attested for a peer. As in P090, a signature
authenticates a claim and does not promote it to host-observed.
A claimed origin/influence can only understate what shaped the text, so the
host adds unknown to it.
6. The inference boundary¶
No string operation crosses a model, because the output is new text. The host therefore assigns the label when it receives a result:
origin/classesis{model};origin/influenceis the union oforigin/classesandorigin/influenceof every segment in the assembled context;origin/evidenceis{host-observed}for a runtime that the host selected and dispatched, and{peer-attested}for a result returned by a peer.
An operation may be declared to rework supplied text:
InquiriumOperation::Summarize, InquiriumOperation::Transform, or a
host-selected flow that names its source segments. The host then also:
- adds the classes, processing and evidence of the source segments;
- records
model-assistedinorigin/processing, andsummarizedforSummarize.
The host never infers this from the content of the output.
Host prompt layers count as context, so influence on inference output almost
always contains software. Consumers test for the names relevant to them, such
as external, unknown or model.
Stamping is the first production source of model-assisted. A label containing
it does not by itself satisfy MaterialLineage, which still requires verified
inference lineage.
7. Granularity: segments, not characters¶
Union over a whole prompt quickly produces a label that names everything. Labels
therefore attach to segments that already exist: InquiryContent, prompt
layers,
GenerateOutput and transcript segments. Flattening segments into one string
joins their labels, so flattening should happen as late as possible. The
assembly trace keeps per-segment labels without content.
For GenerateOutput::Structured, the label covers the whole value. Strings
extracted from it inherit that label. Per-character spans are out of scope.
8. Wire form¶
A label is a group of sibling fields beside the text, never a wrapped string:
{
"type": "text",
"text": "A short summary of the note.",
"origin/classes": ["human", "model"],
"origin/influence": ["external", "human", "software"],
"origin/processing": ["model-assisted", "summarized"],
"origin/evidence": ["host-observed"]
}
- Arrays are sorted and unique, and hold at most 16 names.
origin/classes,origin/influenceandorigin/evidenceappear together. Local writers omitorigin/processingwhen empty; ingress may also carry an empty processing array. A partial label is invalid.text-origin.v1defines two explicit sub-schema profiles,localandingress. The containing carrier selects one by$ref; a payload cannot select or override its profile. No schema failure triggers a profile fallback.localuses closed producer/evidence enums and references the processing definition inwhisper-origin.v2(P100-010). It governs host authorship and local carriers.ingressbounds every token in all four facets to 1–32 ASCII characters, matching^[a-z][a-z0-9-]{0,31}$over the entire token, with an explicit length bound. Implementations match the entire token, for example withre.fullmatchin Python; trailing newlines are refused by the shared vectors. Every array has at most 16 tokens, is unique and sorted in ASCII byte order; the three required facets are nonempty. Processing may be omitted or empty. It permits unfamiliar names, not malformed structure or unbounded input. Schema acceptance precedes the separate semantic interpretation in section 3.- The profiles share known spellings and interpreted validity laws. An ingress
wire value is not deserialized directly into the closed
Processingenum or treated as a validatedTextOrigin. - Labels on signed records are covered by the signature as canonical arrays.
- Numeric bit values never appear on the wire, in facts or in signatures. A rebuildable projection (S028) may store them only if positions are append-only.
The initial carrier disposition is:
| Carrier / boundary | Planned disposition |
|---|---|
Local InquiryContent, prompt layers, normalized GenerateOutput, Whisper drafts and Python module output |
local in their P100 carrier revisions; adapters cannot supply trusted labels |
Proposed response-envelope.v2 |
One wire schema referencing ingress; P100-001 owns the schema and vectors. Host-authored output uses the typed emitter plus the local label check at Boundary::Egress |
Proposed transcript-segment.v2 authored by the local transcript owner |
local; interpretation of peer source envelopes happens before transcript construction |
Existing response-envelope.v1 and transcript-segment.v1 |
Existing schemas and legacy projection only; no new ingress profile inferred |
Peer import of transcript-bundle.v1 |
Strict import through its existing transcript-segment.v1 reference; no ingress fallback |
Proposed bundle version carrying transcript-segment.v2 |
P100-001 freezes its version and strict local-profile segment reference; peer import deterministically refuses vocabulary mismatch |
whisper-signal.v3 and its whisper-origin.v1 dependency |
Existing strict schemas; unknown processing is rejected before interpretation |
| Future signed records with a full text-origin label | No implicit adoption; a new carrier version must explicitly choose its profile |
P100-001 owns the new carrier schemas and their positive/refusal vectors,
including response-envelope.v2, transcript-segment.v2 and the corresponding
bundle revision. It freezes the exhaustive carrier/version/profile inventory
with each owner. Schema Gate vectors establish that a bounded unfamiliar token
can reach interpretation through the peer envelope, while strict transcript
imports and existing signed carriers refuse mismatches. Expected interpretation
outcomes are vector data here; interpreter execution belongs to P100-002/003.
P100-005 implements carriers and projections against those frozen schemas.
There is exactly one wire schema for response-envelope.v2, referencing
ingress. Its host emitter accepts only validated TextOrigin values and
checks the label against local using the existing Schema Gate
Boundary::Egress, in addition to validating the full wire envelope. This is a
boundary check of the label, not a second envelope schema. Peer receipt uses
Boundary::Ingress, then the separate interpreter. Both checks keep the same
wire bytes; no profile is selected from untrusted payload data.
Until those new versions exist, this is a proposed contract, not runtime compatibility. Signatures bind the original carrier, including unfamiliar but schema-valid tokens; interpretation never changes those bytes.
9. Rust representation¶
/// Copy set of one facet's tokens. Union is the only combinator.
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct TokenSet<T> {
bits: u16,
facet: PhantomData<T>,
}
/// A validated label. `classes`, `influence` and `evidence` are never empty.
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct TextOrigin {
classes: TokenSet<Producer>,
influence: TokenSet<Producer>,
processing: TokenSet<Processing>,
evidence: TokenSet<Evidence>,
}
/// No `Deref`, `Display`, `AsRef<str>`, `From<String>` or direct serde impl.
pub struct AttributedText {
text: String,
origin: TextOrigin,
}
Peer wire input has a separate structural type in text-origin-core:
/// Private, bounded token vectors; structural validity only.
pub struct IngressOriginLabel {
classes: Vec<IngressToken>,
influence: Vec<IngressToken>,
processing: Vec<IngressToken>,
evidence: Vec<IngressToken>,
}
pub struct OriginInterpretation {
pub result: Result<TextOrigin, OriginRefusal>,
pub diagnostics: Vec<OriginDiagnostic>,
}
pub fn interpret(label: &IngressOriginLabel) -> OriginInterpretation;
IngressToken and the label have checked constructors/deserialization enforcing
section 8 before unbounded allocation. They validate structure, token limits,
ASCII ordering and uniqueness without requiring names to be known. The result
is never implicitly convertible into TextOrigin. interpret is pure and
specifically implements the peer-label rules in section 3; module and host
stamping remain distinct boundaries. It neither authenticates a peer nor admits
a carrier. Diagnostics are bounded by the input (at most 64 token entries);
the host attaches authenticated peer/version context and applies the store's
stricter sample/retention limits. No raw input is emitted as a valid label after
an interpretation refusal.
The bitset is chosen for its algebra rather than for memory: union is a single
OR, and the laws are trivial to property-test. Each facet has room for 16 tokens
and at most seven are in use. A TextOrigin is eight bytes, so AttributedText
is 32 bytes on 64-bit targets against 24 for String.
Local and interpreted carriers hold an optional TextOrigin beside their text.
Peer wire carriers hold IngressOriginLabel until interpretation (section 8).
AttributedText is introduced only on composition paths where an audit shows
that sibling fields lose labels (P100-008).
Where it exists, AttributedText deliberately does not behave like a string.
Deref<Target = str> would provide every string method, but each would return
an unlabeled &str or String, which is exactly how a label gets lost. P047
reached the same conclusion for Tainted<T>.
| Operation | Effect on the label |
|---|---|
as_text() |
Read-only, explicit and easy to search for; the result is unlabeled |
concat, join |
Union of all parts |
map_same_origin(f) |
Label kept; the caller states that f adds no new origin (trim, truncate, normalize). Never for a step that replaces or inserts words (section 4) |
into_parts() |
Explicit exit at an egress boundary |
Debug prints the labels and the byte length, never the text. Serialization
goes through the segment carriers in section 8. Union is an inherent const fn.
It obeys the same join laws as classification::Join, and the leaf crate
text-origin-core does not depend on that crate.
10. Python representation¶
Python exposes corresponding IngressOriginLabel, OriginInterpretation
and interpret contracts with the same structural checks, typed refusal codes
and bounded diagnostics. They use the shared vectors, including full-token
matching. The helper does not silently construct a trusted LabeledStr from
raw ingress tokens or from a failed interpretation.
The host delivers labels as JSON fields. A middleware helper,
middleware-modules/lib/text_origin.py, wraps the text in a LabeledStr
subclass of str, so existing code keeps working.
A probe on CPython 3.12.2 (2026-11-09) showed that a plain subclass loses its
label in all 15 operations tried, including +, slicing, strip, f-strings,
join and a JSON round trip. Overriding methods restores "x" + t and a lone
f"{t}", but f"{t}x" and "".join(...) still return a plain str, and a
subclass cannot intercept them.
Propagation in Python therefore cannot be guaranteed, so loss must be safe:
- a plain
strreaching an egress helper is labeled{unknown}; LabeledStroverrides the common operations and propagates by union;join_labeledandformat_labeledcover what a subclass cannot intercept;- a module's claim of
humanormodelstays a declaration: the host writesmodule-declaredas the evidence of anything a module returns (section 5).
11. Consumers at the edges¶
| Consumer | Rule |
|---|---|
| Whisper publication (P013) | Text whose origin/classes contains model must not be published without model-assisted. The label does not replace the verified inference lineage that model-assisted already requires. Text containing unknown cannot pass this check automatically and needs publication review. Drafts carry no label today, so this consumer includes that plumbing |
| Corpus | Keep the presence of human-origin material, promotion as human-origin material and training eligibility separate. Apply the criteria below; no origin label grants consent or training approval |
| Node UI | Shows the label as a badge; unknown is displayed as unknown, never hidden |
| Inquirium traces | Record per-segment labels and influence, without content |
| Future discussion artifacts (P026) | Reuse the label instead of a local flag |
Corpus presence, promotion and training¶
contains-human-origin describes the presence of human-originated source
material, not its eligibility. A recognized human contribution with an
evidence
basis accepted by the Corpus owner remains present in mixed material such as
{human, model}. A refusal to promote that mixture must not erase the human
contribution or bypass the consent rules that protect it. Lack of knowledge does
not establish false; when the source does not support a boolean assertion,
omit the optional field and preserve uncertainty in the label and provenance.
Use the same evidence-acceptance policy as promotion, defaulting to exactly
{host-observed}. For a valid, supported label with accepted evidence, set
true when human is present. Set false only when none of human, unknown
or external is present. Otherwise omit the field. Invalid/unsupported labels
or unaccepted evidence also yield omission, not false; thus a peer's claimed
human with peer-attested is omitted by default.
Automatic human-origin promotion requires all of:
- A valid, supported label with
humaninorigin/classes. - Neither
modelnorunknowninorigin/classes. - No
externalcontribution with unestablished authorship. Mixed{human, external}material requires explicit Corpus review rather than automatic promotion; review does not remove names from the label. origin/evidenceexactly{host-observed}, unless the Corpus owner's explicit policy accepts another basis. The original evidence basis remains visible; accepting it does not promote it tohost-observed.
For {human, software}, composition facts mean the retained per-segment
labels in section 7's host assembly trace, bound to the exact candidate text.
No new peer assertion or separate composition artifact is introduced. Automatic
promotion requires all ordinary origin/evidence conditions and a complete trace:
no contributing segment is purely {software}, and every segment containing
software also contains human and records software-edited.
These conditions apply to retained source segments before concatenation. A
segment that has already flattened an unknown composition cannot establish them;
its source segments must still be available in the assembly trace, otherwise
review is required. This prevents a template and an edited human sentence from
being flattened into a single apparently eligible {human, software} segment.
An aggregate label alone requires review. A segment-level decision covers only
the selected eligible segments, not an aggregate containing an excluded
template.
No ratio of human to software words is inferred.
These are origin conditions only. training/eligibility remains a separate
curation decision (blocked, needs-review or approved) governed by consent,
the training profile and P004. Passing the origin conditions never sets it to
approved. The label still records observed entry or declared provenance, not
proof of human composition.
Required consumer vectors, with an otherwise accepted evidence basis:
origin/classes |
contains-human-origin |
Automatic human-origin promotion |
|---|---|---|
{human} |
true |
Origin conditions met; independent consent and curation still apply |
{human, software} |
true |
Only with the composition/segment evidence above; otherwise review |
{software} |
false |
Refused: no human contribution |
{model} |
false |
Refused: model contribution |
{external} |
Omitted | Refused: no established human contribution |
{human, model} |
true |
Refused; the accepted human contribution remains recorded |
{human, unknown} |
true |
Refused; uncertainty remains visible |
{human, external} |
true |
Requires explicit Corpus review |
{unknown} |
Omitted | Refused; absence of knowledge does not establish false |
The suite also covers default refusal of peer-attested and module-declared
for promotion, an explicit policy accepting another evidence basis without
rewriting it, default omission of presence for {human} with peer-attested,
and consent refusal after all origin conditions pass. Composition vectors
include
human text edited by software, human text concatenated with a software template,
and that same concatenation also carrying software-edited: the token must not
bypass aggregate review. Invalid/unsupported labels never produce a presence
assertion or automatic promotion.
Publication projection¶
A publication is a broader projection than a segment. Any segment with model
in origin/classes makes the publication declare model-assisted, even when
no segment carries that value, because origin/processing on a publication
summarizes the whole material. human-edited and software-edited reach a
publication only on a contract version that defines them. Projecting to
whisper-origin.v1 withholds them.
Effect gating on origin/influence is limited to the surfaces in section 14
and starts in observe-only mode.
12. Migration from origin_class¶
New labels project onto the existing closed enum in room contexts:
New origin/classes |
Legacy origin_class |
|---|---|
Only human, and operator-presence/mode is direct-live |
human-live |
Contains human in any other case |
node-mediated-human |
Contains neither human nor unknown |
node-generated |
Contains unknown and no human |
Omitted |
Reading old records must not invent facts the old value does not hold:
Legacy origin_class |
New origin/classes |
|---|---|
node-generated |
{unknown}: the old value cannot separate model from software |
node-mediated-human |
{human, unknown} |
human-live |
{human} |
Labels read this way carry origin/evidence {derived} and origin/influence
{unknown}.
A label with unknown and no human has no faithful legacy value. Writing
node-generated would turn absence into a declaration, which ProjectionLaw
forbids. transcript-segment.v1 and response-envelope.v1 require legacy
values and cannot express that case, so new versions make origin/classes the
required field and the legacy fields optional. No Rust or Python code implements
the transcript fields yet, so they need no data migration. Middleware binds
provenance/origin-classes, which keeps its current derivation until the new
envelope version exists.
New eligibility decisions must read the new label and must not use a legacy projection as input.
13. Digests, adapters and export¶
- Digests. An unlabeled segment serializes without label fields, so its
historical bytes do not change.
instruction/hashidentifies instructions given to the model, and labels never reach the model, so it is computed from a text-only projection. Every other commitment over a carrier decides inclusion explicitly. - Adapters. Labels are never sent to a provider or written into prompt text. The host ignores any label in an adapter response and stamps the result itself.
- Export.
humancan reveal that an operator took part. Labels leaving the node follow P004 visibility and selective disclosure: a projection may withhold a label but cannot strengthen it.
14. Effect gating on origin/influence¶
origin/influence may gate only irreversible or outgoing effects, on four
surfaces. No other surface reads it for a decision.
| Surface | Effect | Entry point on 2026-11-09 |
|---|---|---|
| Whisper publication | A signal leaves the node | Publication review in daemon/src/weak_signal_harvester/review |
| Message sending | A message leaves the node | enqueue_outbound in messaging-service |
| Actuation | A directive changes the world | sensorium-actuation-core |
| Settlement | Value moves | daemon/src/settlement_host.rs |
Gating starts in observe-only mode, which is the default on every surface.
The gate evaluates its rules and writes an audit-only record of what it would
decide. The effect proceeds exactly as it would without the gate, even if
evaluation fails.
- Rules are data. A versioned table yields
allow,askordenyfor each surface and producer name, and each surface's owner owns its rows. Rules do not testsoftware, because host prompt layers are almost always in context. allowmeans only that no rule fired. Pasted attack text ishuman(section 4), sohumanproves nothing about safety.- Influence travels with the request. An effect request carries the
origin/influenceof the text that caused it. A request without it reads as{unknown}, and the record shows a coverage gap. - Approval is a separate fact.
askmaps to a P066 consent bound to the surface and a digest of the effect's arguments. It never removes a name. - Records hold no content. They hold the surface, rule-table version, would-be decision, triggering names, contributing segment references and whether a fresh human act already covers the effect. They never reach a model or a peer.
An alarm means that text could have been shaped, not that an attack happened. Real attacks are rare, so counting every alarm without an attack as false would report nearly 100% and decide nothing. Observe-only mode therefore reports four measures per surface:
| Measure | Definition | What it decides |
|---|---|---|
| Added interruptions | Share of effects with a would-be ask or deny and no fresh human act |
Operator burden |
| Cause split | Whether the trigger is only unknown, a name from the current turn or a name inherited from an earlier turn |
Whether to fix coverage, rules or inheritance between turns |
| Reviewed false alarms | Share of a reviewed sample in which a reviewer judges that no human look was needed | Precision of the rules |
| Threat-case detection | Share of replayed injection cases that the rules catch | Whether the gate earns its cost |
Each surface's owner records acceptance thresholds before collection starts. A surface moves to enforcement through an explicit host-owned setting, which a module or model cannot request, and only when its thresholds are met and path coverage is proven. Under enforcement, a failed evaluation fails closed.
If inherited names dominate, looser rules are the wrong remedy. The candidate fix is quarantined reading: a separate inference without tool access returns narrowly typed values. That is an Inquirium architecture decision outside this proposal.
Scenario: a note rewritten and published¶
- The operator types a note in Node UI. The segment has
origin/classes{human}andorigin/evidence{host-observed}. - Harvester attaches a web excerpt, labeled
{external}. - A
Transformrequest supplies both as source text, with a host prompt layer labeled{software}. The output hasorigin/classes{external, human, model},origin/processing{model-assisted},origin/influence{external, human, software}andorigin/evidence{host-observed}. - A Python module trims the result with
LabeledStr.strip(). The names survive. When the text returns, the host writes{module-declared}as the evidence and addsunknownto the influence. - The Whisper draft carries a label containing
model, so publication must declaremodel-assisted. Public views render "AI-assisted". - The signed signal carries only P013's origin summary in the first slice. The full label stays local.
If step 4 had used f"{text}\n", the host would receive a plain str and label
it {unknown}. Publication would then require review instead of silently
passing as clean text.
Trade-offs¶
| Decision | Benefit | Cost |
|---|---|---|
| Set of names instead of one enum | Mixtures stay expressible; union is trivial | Consumers test membership instead of matching one value |
No implicit exit from AttributedText |
Loss is visible in code review | Less convenient than a string |
| Sibling fields on the wire | Existing carriers evolve additively | Text and label can be separated by a careless reader |
| Closed names on local carriers | Typos and drift are refused at the schema gate | A new name needs a schema version and a release |
| Reusing the P013 and P090 vocabularies | Each fact keeps one spelling | A label has four fields and two upstream vocabulary owners |
| Observe-only before enforcement | Rules are tuned on real traffic without blocking anyone | Attacks are not stopped during measurement |
| Segment granularity | Reuses existing structure | Flattened text has only a coarse label |
Failure Modes and Mitigations¶
| Failure | Mitigation |
|---|---|
| A label is dropped in an interior path | Absence reads as unknown, which is the worst case |
| Unbounded tokens enter through the open ingress profile | Enforce the ASCII token pattern, 32-character limit, 16 tokens per facet and structural rules before interpretation; test exact bounds and one beyond |
| Mixed-version peers repeatedly send unsupported processing | Bounded per-peer/version diagnostics expose incompatibility without relaxing refusal or flooding review |
| An unfamiliar processing token is silently erased | Return unsupported-processing-token; no valid empty-processing fallback and no automatic approval |
| Ingress normalization changes a signed fact | Interpret separately from original signed bytes; the carrier owner retains signature, schema and admission authority |
| Non-human material meets only the negative Corpus checks | Require positive human membership as well as the exclusion and evidence conditions |
| Mixed material loses its human contribution when promotion is refused | Keep contains-human-origin separate from promotion and training eligibility; preserve consent requirements and uncertainty |
| Python operations lose the label | Egress labels plain str as {unknown} |
human is claimed for pasted model text |
human is defined as surface entry, and labels are documented as non-proof |
A peer or module claims human falsely |
The host writes the evidence itself, and human-origin promotion refuses peer-attested and module-declared by default |
human-edited is read as review or as removal of model |
Section 4 defines it as a change only; approval stays a separate fact and model stays in the label |
software-edited spreads to every deterministic step |
Section 4 limits it to steps that replace or insert words in supplied text |
| A label changes a digest | Unlabeled segments keep their bytes, and instruction/hash uses a text-only projection |
| An adapter sets its own label | The host ignores labels in adapter responses and stamps the result |
| A legacy projection invents an author | Section 12 omits the legacy value when the label holds unknown and no human |
origin/influence is trusted before coverage is complete |
Enforcement is enabled per surface and only with proven coverage; any unlabeled segment adds unknown |
| Injected content floods the operator with approval requests | Only four surfaces can ask, and added interruptions are measured before enforcement |
| Union makes labels uninformative | Segments keep separate labels, and consumers test specific names |
| Labels are mistaken for authority | The label grants nothing; existing owners keep admission and consent |
| A consumer reuses the legacy projection for eligibility | Section 12 forbids it; the P100-006 consumers read the new label |
Alternatives Considered¶
Give the type every string capability through Deref¶
Rejected. Every method would return unlabeled text, so the label would disappear at the first ordinary operation and no one would notice.
Extend P047¶
Rejected. P047 governs confidentiality, with an ordered lattice, egress refusal and declassification. Origin has no "more restrictive" order and cannot be declassified.
Extend P004 alone¶
Rejected. P004 is scoped to answer rooms and operator participation. This label also concerns Inquirium, Whisper, Corpus and middleware.
New modifiers for rewriting and assertion¶
Rejected. origin/processing already records that a model reworked material,
and P090 already names evidence bases. A second spelling would let them drift,
and one assertion flag would conflate a supervised local module with a remote
peer.
Reuse adapter-declared for module labels¶
Rejected. P100 ignores labels from inference adapters (section 13), and P090 uses that name for reports about execution. The token would only ever describe components that are not adapters.
Record a human edit as a plain union¶
Rejected. {human, model} alone cannot be told apart from concatenated text.
A separate value for shallow model edits¶
Rejected. The host cannot verify depth without reading the content, so a module could declare the lighter value for a full rewrite.
An enum listing every combination¶
Rejected. The number of combinations grows quickly, and union becomes a table that has to be maintained.
A numeric mask on the wire¶
Rejected. A number is opaque in JSON and would freeze bit positions across Rust, Python and versions.
One mask for all axes¶
Rejected. Authorship, influence, classification and locality have different meanings and different join rules.
Per-character spans¶
Rejected for now. The cost is high, and existing segments already cover the known consumers.
Open Questions¶
- Should the name be
humanorhuman-entered? Recommended default:human, with the definition in section 1.human-enteredis more accurate but more awkward. - How does a host-selected flow declare its source segments for
model-assisted? Assumption: a field in the flow's host-owned definition, to be frozen with P100-004. - When should
origin/classesenter signed records such as a future Whisper signal? Recommended default: after the local consumers have shown value. This does not defer the explicitly planned peerresponse-envelope.v2ingress profile in section 8; existing signed Whisper schemas remain strict. - Should an extensible peer carrier explicitly declare its
whisper-originvocabulary version? Freeze any such field with the carrier owner, including binding it to the signed carrier where applicable. Unsupported declared versions should produce a deterministic version/schema refusal rather than repeated content review. Until that contract exists, diagnostics use the known carrier version andnot-declared, without guessing compatibility.
Resolved 2026-11-09:
TextOriginlives in the leaf cratetext-origin-core, licensedApache-2.0.origin/influencemay gate only irreversible or outgoing effects: Whisper publication, message sending, actuation and settlement. Gating starts in observe-only mode and measures false alarms first (section 14).- Module and connector labels use
module-declared. - A human edit is recorded as
human-edited, and a deterministic step that replaces or inserts words assoftware-edited, symmetric tomodel-assisted.
Next Actions¶
- Review the vocabulary, laws and axes in this draft.
- Change the
origin/processingcontract (P100-010). - Freeze
text-origin.v1with positive and refusal vectors.
Implementation Recommendations¶
These recommendations come from a convergence review against Node 989c84a31
and the Orbidocs schema catalogue on 2026-11-09, following the "Reusable Data
Abstractions" and "Retrospective Convergence Review" rules in
node/DEV-GUIDELINES.md. They are planning input.
Layers¶
| Layer | Owner | Holds | Must not hold |
|---|---|---|---|
| Contract | text-origin.v1 sub-schema and golden vectors |
Token spellings, validity laws, refusal cases | Consumer policy |
| Algebra and codec | New leaf crate text-origin-core |
Closed token enums, token sets, TextOrigin, wire codec |
Transports, carriers, policy |
| Carriers | Owner of each carrier, such as inquirium-core |
An optional label beside existing text | A private copy of names or union |
| Stamping | inquirium-host and host ingress surfaces |
Assignment of names at trust boundaries | What a label permits |
| Projections | Owner of each legacy field | Typed one-way derivations | New facts |
| Consumers | Whisper, Corpus, Node UI | Decisions | Label construction |
text-origin-core depends only on serde and thiserror. Existing owners
were checked first:
| Candidate owner | Why not |
|---|---|
whisper-core |
Owns publication semantics and sits too high for Inquirium and middleware |
inference-provenance-core |
Owns the execution axis, which P090 keeps separate from origin |
classification |
Owns confidentiality; whisper-core, middleware, room-core and control do not depend on it |
workflow-vocabulary |
Owns workflow status tokens |
The closest precedents are workflow-vocabulary, which owns wire tokens but no
policy, and relative-path-core, which owns one law with golden vectors.
One source of truth per concept¶
| Concept | Source of truth | Action |
|---|---|---|
| Who produced the words | origin/classes in text-origin.v1 |
New. provenance/origin-classes becomes its derived projection on response envelopes |
| How the text was processed | origin/processing in whisper-origin; whisper-core::Processing |
Reuse at segment level. Move the Rust enum to text-origin-core and re-export it from whisper-core. The local sub-schema $refs the contract definition; the bounded ingress profile uses those known spellings during interpretation. human-edited and software-edited need a new contract version (see below) |
| How well a label is established | evidence-basis in inference-provenance-common.v1 |
Reuse peer-attested, derived and unknown. P090's host tokens describe egress and its adapter-declared describes execution reports, so origin adds host-observed and module-declared |
| What source the material came from | origin/source-kinds in P013 |
Keep at publication level and bridge it (table below) |
origin/source-kinds |
origin/classes |
|---|---|
web, mail, document, sensorium |
external |
personal-report |
human |
unknown |
unknown |
These concepts stay separate:
| Field or type | Reason | Link to this label |
|---|---|---|
gossip/source-kind (machine-assisted) |
Legacy disclosure aid, schema-only today | Derive machine-assisted from a label containing model |
Whisper source/class |
Signed authorship and preparation posture | Consistency check only |
corpus/model-class, hybrid |
Service posture mixing locality and authorship (P090 Decision 8) | None |
origin/collection-method, origin/coverage, origin/lineage |
Publication-level facts with different joins | None |
PromptLayerOrigin, configuration source/class, origin/actor-ref, CausalContext |
Similar words, different authority and lifecycle | None |
Shared mechanism¶
The types in section 9 follow these rules:
- The facets share one algorithm and differ only in tokens, so one
parameterized
TokenSet<T>serves all of them. Distinct facet types keep a processing token from being tested against a producer set. - A facet's capacity of 16 tokens matches the wire bound in section 8.
- Token enums come from a local macro in the style of
statuses!, so that each declaration owns its wire spelling once. A test comparesALLwith the schema enum, and the shared evidence names withevidence-basis. - Parse, do not validate: private fields,
serde(try_from)as inWireOrigin, and typed errors instead of panics. TextOrigin::UNKNOWNis the only representation of absence.- Property tests prove the join laws in the style of the
classificationcrate. Rust and Python run the same vectors fromprotocol/contracts/golden. - Names are ASCII, so byte order, Rust
sortand Pythonsorted()agree on the canonical array.
| Reuse candidate | Disposition | Revisit when |
|---|---|---|
classification::Join |
Do not implement it from the leaf: that inverts layering for one external user. Use an inherent const fn union |
A function generic over two lattices appears; then move the trait down |
ProjectionLaw |
Reuse for legacy projections. Implement on carriers in their owner crates | Not deferred |
| Closed-token macro | Local copy now; three variants already exist | A defect needs the same fix in two macros (owner: Node maintainers) |
Registry as data (vendor-media-types) |
Not needed for a small closed vocabulary | Names must ship without a Node release |
AttributedText |
Sibling fields first. Classified<T> has no consumer outside its crate, so a wrapper needs a demonstrated need |
An audit finds label loss at a composition site |
Carriers and digests¶
- Add optional fields with
#[serde(default, skip_serializing_if = ...)], so that unlabeled content keeps its historical bytes. - Label
GenerateOutput::Textfirst, thenInquiryContent::Text, prompt layers and transcripts.classificationstays request-wide beside per-segment labels. - Add constructors such as
InquiryContent::textbefore adding the field. About 95 construction sites exist, most of them in tests. - Do not use
#[serde(flatten)]on a type withdeny_unknown_fields, because serde does not support that combination. instruction_hashserializesInquiryTurnvalues directly. Compute it from a text-only projection, since labels never reach the model, and pin the result with a regression test. Decide inclusion for every other commitment per carrier.
Stamping¶
assembled_chat_messages(inquirium-host/src/lib.rs:2141) is the point where segments flatten for a provider, and it already emits only role and text. Keep it that way, and add a test that labels do not reach the adapter body.adapter_output_textreads onlytypeandtext, although the adapter response schema allows additional properties. Stamp after normalization, on the return path that buildsBoundInferenceResult, and test that an adapter-suppliedorigin/classesis ignored.- Output capping (
inquirium-host/src/lib.rs:3395) keeps the label unchanged. - Stamping becomes the first production producer of
Processing::ModelAssisted. It may feedMaterialLineageonly through verified inference lineage. - Before closing P100-004, list every other inference path with a disposition:
external-agent-runtime-*, Agent controllers, JSON-e flows,control[]and streaming. A path left out staysunknown, which is safe but must be recorded.
Legacy fields¶
origin_class,human_origin,contains_human_origin,contains-human-originandhuman-linked/inputhave no Rust or Python implementation yet. They can become derived fields in new schema versions without a data migration.provenance/origin-classesis bound inmiddleware/src/marketplace.rs:705asVec<String>without a vocabulary check, and produced indaemon/src/settlement_host.rs:1522andcontrol/src/lib.rs:1917. Parse it through the shared vocabulary.middleware/tests/middleware_contract.rs:1385uses values outside the schema enum, and that drift must be resolved first.
Contract change for the edit values¶
whisper-origin.v1 is closed, with maxItems 5, and whisper-signal.v3
references it inside signed content. Processing deserializes strictly, so an
older node refuses an unknown value. Editing v1 in place would break that
contract.
- Define
human-editedandsoftware-editedinwhisper-origin.v2, withmaxItems7, and update P013 in both languages. - The
localprofile oftext-origin.v1references v2;ingresspermits bounded wire tokens and interprets supported processing against that vocabulary. Existing schemas stay on v1 until their own next version, and projecting to v1 withholds both values, whichProjectionLawallows. - Record a disposition for each dependent:
whisper-signal.v3,whisper-origin-lineage.v1,public-gossip.v2,weak-signal-whisper-draft.local.v2andweak-signal-review.v1. whisper-signal-draft.local.v2holds an inline copy of the enum. Its next version replaces that copy with a$ref.- When
Processinggains the variants, a test proves that a v3 signal carrying either value is still refused. - The sync list in
scripts/sync-node-schemas.py, theContractFamilyentries inschema-gateand the literals intools/acceptance/sensorium-web-v3follow the new version.
Effect gate¶
| Reuse candidate | Disposition |
|---|---|
observe-only and resolve_corpus_experiment_executor |
Reuse the token and the rule that an absent setting selects the safest mode. Keep a separate type, because that enum names Corpus executors |
MiddlewareEffectClass, MiddlewareEffectScope |
Consistency check, not the key. They describe declared middleware effects, while the gate names host surfaces. A component declaring irreversible-external or an external or federated scope outside the four surfaces is a review finding |
operator-consent-core |
Reuse for ask; P066 remains the only durable consent owner |
sensorium-directive-outcome.v1 |
Precedent for an audit-only record |
The evaluator is a pure function of surface, influence and rule table. It does
not belong in text-origin-core, which holds no policy. Assumption: the four
surfaces meet in daemon, so it starts there and is extracted only if another
host needs it.
Delivery and obligations¶
whisper-origin.v2, thetext-origin.v1contract, vectors,text-origin-coreand theProcessingmove. This step changes no behavior.GenerateOutputstamping and trace fields, with the Node UI badge as the first consumer, because a badge needs no policy.- Whisper and Corpus checks. Whisper drafts carry no label today, so this step includes the plumbing.
- The Python helper and middleware ingress. Python has no existing binding.
- Room and transcript carriers.
- The observe-only gate on the four surfaces, then enforcement per surface.
A new crate also requires a workspace entry, rust-version.workspace, an SPDX
header, docs/development/source-headers.v1.json,
docs/implementation-ledger.toml with a regenerated
docs/IMPLEMENTATION-LEDGER.md, and docs/MVP.md. The schema requires
scripts/sync-node-schemas.py, a ContractFamily in schema-gate, negative
fixtures and regenerated doc/schemas-gen/**.
text-origin-core is licensed Apache-2.0 by owner decision on 2026-11-09.
Its Cargo manifest and SPDX headers declare that license, and
docs/development/source-headers.v1.json records the explicit grant, which
also covers Processing when it moves out of whisper-core. The Python helper
needs its own entry in that manifest.
Manual inference exchange ingress profile¶
Proposed extension, 2026-11-14, owned jointly with P101. A response imported through the dedicated manual-inference form is not ordinary human composition. The host chooses a versioned surface profile, bound to the pending request, before parsing the paste. The pasted payload cannot choose its profile or supply authoritative origin labels.
The proposed logical label is origin/classes: [model] with
origin/evidence: [asserted], not two producer classes named model and
asserted. asserted is a proposed evidence-vocabulary extension, not an
existing accepted schema value. P100-001 and P100-MEX-001 must freeze its wire
version and migration rules before use. Its meaning is "presented as model output
through this bound import surface"; it proves neither machine authorship, exact
model identity, nor absence of operator edits. Host observation proves the import,
not the remote production claim. Do not add human merely because a person pasted
or approved the response. Later edits on a linked, host-observed edit surface
follow the existing human/human-edited join rule; earlier external edits remain
unobserved. Influence preserves known input origins and unknown external chat
context; an imported answer must not acquire a clean lineage by losing its input
bindings.
Reuse the shared vocabulary, ingress interpreter and host return-path stamping. Do not loosen the ordinary form default, accept arbitrary label overrides, or rewrite historical/signed carriers. Consumers requiring positive human production or qualified model provenance must reject or review this asserted profile; a Corpus human-only path cannot accept it just because its transport was a form. V1 remains one text inference. This addition does not complete the existing P100 tracker or add a release/alpha prerequisite.
| ID | Work item | Depends on | Status | Done criteria / evidence |
|---|---|---|---|---|
| P100-MEX-001 | Freeze and implement host-selected manual-response origin stamping | P100-001, P100-002, P101-001 | todo | Versioned asserted evidence semantics and surface profile are frozen with compatibility vectors; dedicated manual paste stamps model/asserted while ordinary human composition retains its existing default. Payload label spoofing, unchanged approval, linked edits, unknown external influence, replay and Corpus human-only refusal are tested through the same shared interpreter. No observation is misrepresented as proof of external model execution. |
Implementation Tracker¶
Statuses: todo, partial, blocked, done. All entries are planned; done
requires the row's evidence and reconciliation with its implementation owner.
| ID | Task / owner | Depends on | Status | Completion gate |
|---|---|---|---|---|
| P100-001 | Freeze vocabulary, laws and wire form / Orbidocs + Node | P100-010 | todo | text-origin.v1 freezes local/ingress profiles and the exhaustive carrier/version/profile inventory; the local processing facet references whisper-origin.v2; P100-001 owns response-envelope.v2, transcript-segment.v2 and its bundle schema revision and all schema vectors; peer envelope vectors traverse Schema Gate with expected interpretation outcomes recorded as data, strict signed carriers refuse unknown tokens, and ingress bound/fallback tests (including trailing whitespace/newlines) pass; vectors and negative fixtures cover join laws, model-assisted without model, human-edited without human, software-edited without software, empty required sets, partial labels and names outside the closed vocabulary; section 3 vectors distinguish each facet, mixed known/unknown processing, cross-facet validity refusals and unchanged signed bytes |
| P100-002 | text-origin-core / Node |
P100-001 | todo | Property tests prove the join laws; bounded IngressOriginLabel and the pure interpret API execute the frozen vectors; ingress interpretation preserves known producer names, stamps peer evidence regardless of incoming token knowledge and returns typed unsupported/invalid results without an empty-processing fallback; bounded result diagnostics pass; Processing moves out of whisper-core and gains human-edited and software-edited, while whisper-signal.v3 still refuses both; bit positions stay out of facts and signatures; the crate declares Apache-2.0 and the grant is recorded in the source-header manifest |
| P100-003 | LabeledStr, ingress interpretation and the egress rule / middleware |
P100-001 | todo | Python IngressOriginLabel and interpret execute the same frozen vectors and refusal codes as Rust; tests pin the operations that lose a label and the {unknown} result at egress |
| P100-004 | Segment fields and inference stamping / Inquirium | P100-001, P100-002 | todo | Output labels follow section 6, including Summarize/Transform; labels leave instruction/hash unchanged; tests prove that labels do not reach the adapter body and that adapter-supplied labels are ignored; every other inference path has a recorded disposition; traces hold no content |
| P100-005 | Carrier implementation and legacy projections / Room and middleware owners | P100-001, P100-002 | todo | Implement the envelope, segment and bundle schemas frozen by P100-001; one envelope wire schema passes both boundary paths with the local label check at Egress; strict peer bundle import refuses mismatch; host-store checks cover seven-day expiry across restart, 256 keys plus overflow, eight samples per key and escaped operator-only display; both migration tables hold; new transcript and envelope versions require origin/classes; the legacy value is omitted where section 12 says so; provenance/origin-classes parses through the shared vocabulary |
| P100-006 | First consumers / Whisper, Corpus, Node UI | P100-004 | todo | Whisper drafts carry labels; the Whisper check refuses text labeled model without model-assisted and sends unknown to review; all section 11 Corpus vectors pass, including positive human membership, mixed external review, explicit true/false/omitted presence with the shared evidence policy, default evidence refusal, software-edit/concatenation/segment distinctions including a pre-flattened segment with missing ancestry, preservation of human contributions in mixtures and independent consent refusal; unsupported/invalid labels never authorize automatic approval; UI shows unknown |
| P100-007 | Observe-only gate on the four surfaces / Inquirium and surface owners | P100-004 | todo | All four surfaces evaluate the versioned rule table and write audit-only records without content; effects proceed unchanged, including when evaluation fails; thresholds are recorded before collection; the four measures in section 14 are reported per surface |
| P100-008 | Audit composition paths for AttributedText / Node |
P100-004 | todo | A recorded finding per composition site; the type is added only where the audit shows label loss; where it exists, no implicit conversion to str exists and Debug never prints text |
| P100-009 | Enable enforcement per surface / surface owners and P064 owners | P100-007 | todo | A recorded decision per surface against its threshold; path coverage is proven; threat cases are replayed; ask uses a P066 consent bound to the effect digest; a failed evaluation fails closed |
| P100-010 | Add human-edited and software-edited to the origin/processing contract / Orbidocs + Whisper owners |
— | todo | whisper-origin.v2 defines both values and passes Schema Gate with negative fixtures; P013 lists them in both languages; every schema depending on v1 has a recorded disposition; projection to v1 withholds them; schema sync and generated artifacts are current |
| P100-011 | Stamp the edit values / Node UI, Whisper and step owners | P100-002 | todo | A surface holding the source label keeps its names and adds human and human-edited only when the text changed; approval without a change leaves the label unchanged; a surface with no link yields {human}; a step that replaces or inserts words adds software and software-edited; map_same_origin operations leave the label unchanged |