GameCult/Huginn
Watch
9
0
Fork
You've already forked Huginn
 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions
Huginn/schemas/cultnet/huginn.mind_response.v1.schema.json

4982 lines
125 KiB
JSON
Raw Normal View History

Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"title": "HuginnMindResponse",
"description": "Every answer a mind gives. A refusal is data in the response, never a\ntransport failure: the read side carries `Refused`, the write side carries\nthe outcome's own `Refused`.",
"oneOf": [
{
"type": "object",
"properties": {
"Whoami": {
"$ref": "#/$defs/MindStatus"
}
},
"additionalProperties": false,
"required": [
"Whoami"
]
},
{
"type": "object",
"properties": {
"Admit": {
"$ref": "#/$defs/PipelineAdmissionOutcome"
}
},
"additionalProperties": false,
"required": [
"Admit"
]
},
{
"type": "object",
"properties": {
"View": {
"anyOf": [
{
"$ref": "#/$defs/PipelineDocumentView"
},
{
"type": "null"
}
]
}
},
"additionalProperties": false,
"required": [
"View"
]
},
{
"type": "object",
"properties": {
"Query": {
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"$ref": "#/$defs/PipelineSelectionPage"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
}
},
"additionalProperties": false,
"required": [
"Query"
]
},
{
"type": "object",
"properties": {
"Refused": {
"$ref": "#/$defs/MindRefusal"
}
},
"additionalProperties": false,
"required": [
"Refused"
]
BP-3 1: an oversize answer is deferred to the body plane deliver replaces within_window as the one owner of how an answer leaves: whole when the envelope fits the window, deferred when the payload is within MAX_DEFERRED_BODY_BYTES (64 MiB), refused by name past it. A deferred answer is HuginnMindResponse::Deferred(DeferredAnswer { manifest }), the reference's CultMeshCdnArtifactManifest; the chunks are asked for on the session the client holds and answered by cultnet-rs's answer_content_chunk_request. The body is held by DeferredBodies (256 MiB budget, sliding 60 s TTL, least-recently- touched eviction, shared chunks stored once), in memory only. The mind knows nothing of deferral. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 07:29:17 +02:00
},
Persona: compile fixes and the regenerated wire schemas The jsonschema error kind lives in jsonschema::error; the eureka-state tool closures own their input; huginn.mind_request/response.v1 carry the persona operations (derived by the existing published_wire_schemas test). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-10 05:47:00 +02:00
{
"type": "object",
"properties": {
"Persona": {
"anyOf": [
{
"$ref": "#/$defs/PersonaStateView"
},
{
"type": "null"
}
]
}
},
"additionalProperties": false,
"required": [
"Persona"
]
},
{
"type": "object",
"properties": {
"PersonaPut": {
"$ref": "#/$defs/PersonaPutOutcome"
}
},
"additionalProperties": false,
"required": [
"PersonaPut"
]
},
schemas: publish SearchSources and Sources (derived from the wire types) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 06:36:57 +01:00
{
"type": "object",
"properties": {
"Sources": {
"$ref": "#/$defs/SourceHits"
}
},
"additionalProperties": false,
"required": [
"Sources"
]
},
repo-activity: a Mind hears of changes in her stewarded repos, on her first line and by one organ notice on change; a repo the anonymous read cannot reach is named, never a failed read (squash of hands/eureka-body-repo-activity 5a294ed..eee0b14; Soul s1-s4) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 04:54:26 +01:00
{
"type": "object",
"properties": {
"Activity": {
"$ref": "#/$defs/RepoActivity"
}
},
"additionalProperties": false,
"required": [
"Activity"
]
},
wear-facts: a Mind's first line shows the wear her own mind holds, specs with no report, open Soul findings and quiet campaigns on what she stewards, each leading to a record she can open (squash of hands/eureka-body-wear-facts ab61a53..6014554; Soul s1-s2) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 07:06:16 +01:00
{
"type": "object",
"properties": {
"RootsTouched": {
"type": "array",
"items": {
"$ref": "#/$defs/RootTouched"
}
}
},
"additionalProperties": false,
"required": [
"RootsTouched"
]
},
BP-3 1: an oversize answer is deferred to the body plane deliver replaces within_window as the one owner of how an answer leaves: whole when the envelope fits the window, deferred when the payload is within MAX_DEFERRED_BODY_BYTES (64 MiB), refused by name past it. A deferred answer is HuginnMindResponse::Deferred(DeferredAnswer { manifest }), the reference's CultMeshCdnArtifactManifest; the chunks are asked for on the session the client holds and answered by cultnet-rs's answer_content_chunk_request. The body is held by DeferredBodies (256 MiB budget, sliding 60 s TTL, least-recently- touched eviction, shared chunks stored once), in memory only. The mind knows nothing of deferral. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 07:29:17 +02:00
{
"description": "The answer did not fit one send and is being held for the client to\nfetch. Nothing in a mind produces this: the daemon's serve module does,\nin place of an answer, and the answer it stands for is the named\nMessagePack of the `HuginnMindResponse` the mind gave.",
"type": "object",
"properties": {
"Deferred": {
"$ref": "#/$defs/DeferredAnswer"
}
},
"additionalProperties": false,
"required": [
"Deferred"
]
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
}
],
"$defs": {
"AdmissionFacts": {
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"description": "What admission recorded about a document when it landed: the receipt that\nwrote it, the `now` that receipt was taken at, who asked, and the\nreceipt's ordinal, which is the read side's order and its snapshot\nposition.",
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"type": "object",
"properties": {
"admitted_at": {
"type": "string"
},
Cut RS-1: the receipt ordinal, receipt v2, and the epoch-first opener Per eureka-read-side-cut.md. The receipt goes to v2 (type id and schema version both huginn.mind_commit_receipt.v2) and gains ordinal: u64 at key 7. candidate takes the ordinal; digest stays unchanged, so an exact replay keeps the ordinal its first admission assigned. validate refuses ordinal == 0. New receipt::head(mind) decodes the receipts and requires their ordinals to be exactly {1..=N}, refusing Unavailable otherwise; admission is the only caller, passing head(self)? + 1, and no other code computes an ordinal. AdmissionFacts gains ordinal, filled by AdmissionIndex::build; the order query.rs sorts by is unchanged (RS-3 deletes it, not this cut). mind.rs's opener now calls refuse_foreign_epoch before refuse_foreign_types, so a store written at a foreign epoch is refused as ForeignEpoch rather than ForeignStore: a real epoch bump always moves every type id, so the type gate would otherwise fire first and the epoch gate would never be reached for the one case it exists for. The doc comment is updated to match. Regenerated both published wire schemas. New tools/eureka-readside-mutations.psd1 (R1-R5, R1 and R3 with L variants, R1 also with an off-by-one-head R1L2; R2 and R5 documented as having no loosening, on the same grounds cut10's D9 and D12 give). Five new tests carry them: ordinals_are_admission_order_not_clock_or_id_order and an_exact_replay_keeps_its_ordinal in admission.rs, a_chain_that_is_not_dense_refuses_admission_and_reads_alike in receipt.rs, and a_v1_receipt_store_is_refused_at_open plus a_store_written_at_the_previous_epoch_is_refused_by_the_epoch_gate in mind.rs. cut8's H6 is re-anchored on the new gate order (its own rule, every gate before attach, is unchanged); cut8 (67), cut9 (27) and cut10 (65) all rerun clean, because candidate's signature and the opener's order both changed. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:56:04 +02:00
"ordinal": {
"type": "integer",
"format": "uint64",
RS fix batch: read-side density, the smallest seal, R5's two shapes, stale prose F1: AdmissionIndex::build now calls receipt::head before copying any ordinal, so query and view refuse a receipt chain that is not exactly {1..=N} (duplicate, gap, zero, or above-N) instead of trusting a stored ordinal unchecked. New test query::tests::query_and_view_refuse_a_receipt_chain_that_is_not_dense pins it behaviourally: it plants each broken chain directly (bypassing admission) and asserts query and view both refuse. The schema's ordinal gets minimum: 1 (was 0), matched by #[schemars(range(min = 1))] on AdmissionFacts::ordinal. head's doc now says AdmissionIndex::build asks it too. F2: Mind::open_with is renamed to an internal open_checked, and a test-only Mind::open_with is gated behind cfg(test) or the test-support feature, exactly like store_path_for. Production reaches open_checked only through Mind::open, which takes the store's per-path lock first. mind::tests::a_mind_has_one_owner_at_a_time (pre-existing) still pins that a second Mind::open on the same path is refused. The full store seal against a second in-process owner over an arbitrary MindStore stays a recorded follow-up. lib.rs's crate doc now names Mind::open as the owner of "may this store be this instance's mind". F3: R5 is not binary. Two loosenings are pinned as R5b and R5c in mind.rs, with behavioural fixtures: a foreign type with no epoch record at all still refuses MissingIdentity, not ForeignStore (R5b); an epoch record at the current key with a foreign value, beside a foreign type, still refuses ForeignEpoch, not ForeignStore (R5c). F5: gate step numbering in mind.rs's doc comment and its test comments now read 2 (epoch), 3 (type), matching the code's actual order. docs.rs no longer credits resolutions_of/assignments_of with reading history, which RS-2 deleted. The two-door test in query.rs is renamed from a_ref_whose_kind_and_id_disagree_is_refused_by_both_doors to ..._by_view, since view is the only door left. Per the operator's ruling retiring the anchor-based mutation harness, this batch carries no .psd1 changes; the cut9/cut10/readside mutation files have uncommitted edits from the earlier pass (stale references to the old test names, and R3L's target) left for a later pass to fold in or drop. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 18:34:47 +02:00
"minimum": 1
Cut RS-1: the receipt ordinal, receipt v2, and the epoch-first opener Per eureka-read-side-cut.md. The receipt goes to v2 (type id and schema version both huginn.mind_commit_receipt.v2) and gains ordinal: u64 at key 7. candidate takes the ordinal; digest stays unchanged, so an exact replay keeps the ordinal its first admission assigned. validate refuses ordinal == 0. New receipt::head(mind) decodes the receipts and requires their ordinals to be exactly {1..=N}, refusing Unavailable otherwise; admission is the only caller, passing head(self)? + 1, and no other code computes an ordinal. AdmissionFacts gains ordinal, filled by AdmissionIndex::build; the order query.rs sorts by is unchanged (RS-3 deletes it, not this cut). mind.rs's opener now calls refuse_foreign_epoch before refuse_foreign_types, so a store written at a foreign epoch is refused as ForeignEpoch rather than ForeignStore: a real epoch bump always moves every type id, so the type gate would otherwise fire first and the epoch gate would never be reached for the one case it exists for. The doc comment is updated to match. Regenerated both published wire schemas. New tools/eureka-readside-mutations.psd1 (R1-R5, R1 and R3 with L variants, R1 also with an off-by-one-head R1L2; R2 and R5 documented as having no loosening, on the same grounds cut10's D9 and D12 give). Five new tests carry them: ordinals_are_admission_order_not_clock_or_id_order and an_exact_replay_keeps_its_ordinal in admission.rs, a_chain_that_is_not_dense_refuses_admission_and_reads_alike in receipt.rs, and a_v1_receipt_store_is_refused_at_open plus a_store_written_at_the_previous_epoch_is_refused_by_the_epoch_gate in mind.rs. cut8's H6 is re-anchored on the new gate order (its own rule, every gate before attach, is unchanged); cut8 (67), cut9 (27) and cut10 (65) all rerun clean, because candidate's signature and the opener's order both changed. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:56:04 +02:00
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"provenance": {
"$ref": "#/$defs/PipelineProvenance"
},
"receipt_id": {
"type": "string"
}
},
"required": [
"receipt_id",
"admitted_at",
Cut RS-1: the receipt ordinal, receipt v2, and the epoch-first opener Per eureka-read-side-cut.md. The receipt goes to v2 (type id and schema version both huginn.mind_commit_receipt.v2) and gains ordinal: u64 at key 7. candidate takes the ordinal; digest stays unchanged, so an exact replay keeps the ordinal its first admission assigned. validate refuses ordinal == 0. New receipt::head(mind) decodes the receipts and requires their ordinals to be exactly {1..=N}, refusing Unavailable otherwise; admission is the only caller, passing head(self)? + 1, and no other code computes an ordinal. AdmissionFacts gains ordinal, filled by AdmissionIndex::build; the order query.rs sorts by is unchanged (RS-3 deletes it, not this cut). mind.rs's opener now calls refuse_foreign_epoch before refuse_foreign_types, so a store written at a foreign epoch is refused as ForeignEpoch rather than ForeignStore: a real epoch bump always moves every type id, so the type gate would otherwise fire first and the epoch gate would never be reached for the one case it exists for. The doc comment is updated to match. Regenerated both published wire schemas. New tools/eureka-readside-mutations.psd1 (R1-R5, R1 and R3 with L variants, R1 also with an off-by-one-head R1L2; R2 and R5 documented as having no loosening, on the same grounds cut10's D9 and D12 give). Five new tests carry them: ordinals_are_admission_order_not_clock_or_id_order and an_exact_replay_keeps_its_ordinal in admission.rs, a_chain_that_is_not_dense_refuses_admission_and_reads_alike in receipt.rs, and a_v1_receipt_store_is_refused_at_open plus a_store_written_at_the_previous_epoch_is_refused_by_the_epoch_gate in mind.rs. cut8's H6 is re-anchored on the new gate order (its own rule, every gate before attach, is unchanged); cut8 (67), cut9 (27) and cut10 (65) all rerun clean, because candidate's signature and the opener's order both changed. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 11:56:04 +02:00
"provenance",
"ordinal"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
]
},
"AuthorityMap": {
"type": "object",
"properties": {
"deletion_line": {
"$ref": "#/$defs/Line"
},
"derived_state": {
"type": "array",
"items": {
"$ref": "#/$defs/Line"
},
"maxItems": 16
},
"forbidden_writers": {
"type": "array",
"items": {
"$ref": "#/$defs/Line"
},
"maxItems": 16
},
"inputs": {
"type": "array",
"items": {
"$ref": "#/$defs/Line"
},
"maxItems": 16
},
"outputs": {
"type": "array",
"items": {
"$ref": "#/$defs/Line"
},
"maxItems": 16
},
"owner": {
"$ref": "#/$defs/Line"
},
"shared_paths": {
"type": "array",
"items": {
"$ref": "#/$defs/Line"
},
"maxItems": 16
}
},
"required": [
"owner",
"inputs",
"outputs",
"derived_state",
"forbidden_writers",
"shared_paths",
"deletion_line"
]
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"CitationRole": {
"description": "The referring field of a citation edge, one per leaf field that names\nanother document. The wire spelling is the field's own name, so a client\nreads an edge's role as the field it came from.",
"type": "string",
"enum": [
"raised_in",
"answers",
"rulings",
"questions",
"cut_spec",
"forks",
"cut_report",
"findings",
"verdict",
"source",
"subject",
"superseded_by",
"resolved_by",
"deferred_to",
Mind: run admission with AlreadyClaimed, the run resolution row, the claims edge A run's instance must be this mind. Every claim must name a document in force (MissingReference, CitesResolvedDocument); a claim held by another run in force is refused AlreadyClaimed { item, run }, so the claim is the one consumption fact. A byte-identical replay of an admitted run owes its claims no fresh freedom and answers AlreadyAdmitted. A run resolves Recorded or Withdrawn only. Runs cite their claims under role `claims`, so cites and cited selections reach them; the header facts carry label, operator, turn, start and claims. The published schemas that embed PipelineKind (finding, follow_up, question, resolution, ruling) and the two mind wire schemas are re-derived: the Run variant, PipelineFacts::Run, AlreadyClaimed and the claims role. The leaf commit before this one has those five stale. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 16:07:19 +02:00
"documents",
memory: a persistent kind for what a Mind keeps (eureka-pipeline, huginn-mind) epiphany.pipeline.memory.v2, instance-rooted `<instance>:memory:<label>`: PipelineMemory with seven sorts (Asked, Decided, Committed, Learned, Did, Idea, Rapport), her own text, who it is about, where it was learned, whether directly, what it rests on, a salience that only ranks, and the memories a consolidating one replaces. Admission refuses a foreign instance and resolves a memory only Deferred to a follow-up (an ask taken on), Recorded, Withdrawn or Superseded by a memory. Memories have their own lineage so supersession stays within one mind. The read side selects by sort, about (multi-valued) and direct; the index carries the text; `consolidates` is a citation role. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 15:15:40 +01:00
"claims",
"consolidates"
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"ClaimOutcome": {
"type": "string",
"enum": [
"Holds",
"Falsified",
"Unproven"
]
},
"CodeLocation": {
"type": "object",
"properties": {
"end_line": {
"type": [
"integer",
"null"
],
"format": "uint32",
"minimum": 0
},
"line": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"path": {
"$ref": "#/$defs/Short"
Golden lines and published schemas derived for CodeLocation.symbol and CutSpec.reads Two golden lines appended (dumped by golden_dump on Yggdrasil at 44c010c; numstat 3 added, 0 deleted against the base) and the six schemas regenerated from the types. Builds; with 44c010c the workspace tests are expected to pass. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 21:12:25 +02:00
},
"symbol": {
"anyOf": [
{
"$ref": "#/$defs/Symbol"
},
{
"type": "null"
}
]
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
}
},
"required": [
"path",
"line"
]
},
"CommitRange": {
"type": "object",
"properties": {
"base": {
"$ref": "#/$defs/Sha"
},
"head": {
"$ref": "#/$defs/Sha"
}
},
"required": [
"base",
"head"
]
},
"CutDelete": {
"type": "object",
"properties": {
"lines": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"note": {
"$ref": "#/$defs/Line"
},
"path": {
"$ref": "#/$defs/Short"
}
},
"required": [
"path",
"lines",
"note"
]
},
"CutVerification": {
"type": "object",
"properties": {
"builds": {
"type": "array",
"items": {
"$ref": "#/$defs/Line"
},
"maxItems": 64
},
"negative": {
"type": "array",
"items": {
"$ref": "#/$defs/NegativeCheck"
},
"maxItems": 64
},
"operator": {
"type": "array",
"items": {
"$ref": "#/$defs/Line"
},
"maxItems": 64
},
"tests": {
"type": "array",
"items": {
"$ref": "#/$defs/VerificationTest"
},
"maxItems": 64
}
},
"required": [
"builds",
"tests",
"negative",
"operator"
]
},
"Date": {
"description": "A calendar date, `YYYY-MM-DD`.",
"type": "string",
"maxLength": 10
},
BP-3 1: an oversize answer is deferred to the body plane deliver replaces within_window as the one owner of how an answer leaves: whole when the envelope fits the window, deferred when the payload is within MAX_DEFERRED_BODY_BYTES (64 MiB), refused by name past it. A deferred answer is HuginnMindResponse::Deferred(DeferredAnswer { manifest }), the reference's CultMeshCdnArtifactManifest; the chunks are asked for on the session the client holds and answered by cultnet-rs's answer_content_chunk_request. The body is held by DeferredBodies (256 MiB budget, sliding 60 s TTL, least-recently- touched eviction, shared chunks stored once), in memory only. The mind knows nothing of deferral. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 07:29:17 +02:00
"DeferredAnswer": {
"description": "Where the body of an answer that did not fit one send can be fetched: the\nreference's own manifest, whose `contentHash` is the SHA-256 of the answer's\nencoded bytes and whose chunks are asked for, one at a time, on the session\nthis arrived on. Row-level facts come from asking again with a header\nprojection; there is no summary.",
"type": "object",
"properties": {
"manifest": {
"description": "gamecult.mesh.cdn_artifact_manifest.v1, the C# reference's CultMeshCdnArtifactManifest as its positional array: [artifactId, kind, version, contentHash, sizeBytes, mimeType, createdAtUtc, chunks[[chunkHash, offset, sizeBytes, recordKey]], tags, metadata].",
"type": "array"
}
},
"required": [
"manifest"
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"Deviation": {
"type": "object",
"properties": {
"what": {
"$ref": "#/$defs/Line"
},
"why": {
"$ref": "#/$defs/Line"
}
},
"required": [
"what",
"why"
]
},
"DocRef": {
"type": "object",
"properties": {
"commit": {
"$ref": "#/$defs/Sha"
},
"end_line": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"path": {
"$ref": "#/$defs/Short"
},
"start_line": {
"type": "integer",
"format": "uint32",
"minimum": 0
}
},
"required": [
"path",
"start_line",
"end_line",
"commit"
]
},
"Evidence": {
"type": "object",
"properties": {
"kind": {
"$ref": "#/$defs/EvidenceKind"
},
"locator": {
"$ref": "#/$defs/Line"
},
"result": {
"$ref": "#/$defs/Line"
}
},
"required": [
"kind",
"locator",
"result"
]
},
"EvidenceKind": {
"type": "string",
"enum": [
"Command",
"Test",
"Mutation",
"Probe",
"SourceRead",
"Capture"
]
},
"Faculty": {
"description": "Which faculty a batch was admitted as. Attribution, not authority\n(ruling 18): no admission rule trusts it, and Cut 9's views read it back\nfrom the receipt.",
"type": "string",
"enum": [
"SelfFaculty",
"Imagination",
"Hands",
"Soul",
huginn-mind: published wire schemas follow the renames; the summary bound test uses real cuts Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-01 12:57:55 +02:00
"Life",
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"Eyes",
"Operator"
]
},
"FileChange": {
"type": "object",
"properties": {
"change": {
"$ref": "#/$defs/Line"
},
"location": {
"$ref": "#/$defs/CodeLocation"
}
},
"required": [
"location",
"change"
]
},
"FindingConfidence": {
"type": "string",
"enum": [
"Confirmed",
"Plausible"
]
},
"FindingOrigin": {
"type": "string",
"enum": [
"Introduced",
"PreExisting"
]
},
"FindingSeverity": {
"type": "string",
"enum": [
"Blocker",
"High",
"Medium",
"Low"
]
},
"ForeignRef": {
"description": "A citation of a document in another repo's pipeline store (D6).",
"type": "object",
"properties": {
"commit": {
"$ref": "#/$defs/FullSha"
},
"id": {
"$ref": "#/$defs/Short"
},
"kind": {
"$ref": "#/$defs/PipelineKind"
},
"payload_sha256": {
"$ref": "#/$defs/Sha256Hex"
},
"repo": {
"$ref": "#/$defs/OrgRepo"
}
},
"required": [
"repo",
"commit",
"kind",
"id",
"payload_sha256"
]
},
"FullSha": {
"description": "A full git commit id: exactly 40 lowercase hex characters.",
"type": "string",
"maxLength": 40
},
Cut 11a: the index write side huginn-mind::index owns what of a document is searchable: index_text is a pure function per kind, Mind::index_entries builds the entries with the writing receipt's ordinal, INDEX_TEXT_VERSION says when the rule changed. huginn-daemon::index owns the projection. A Projector reconciles the mind against the collection at startup (the only place a point is judged missing: set difference on point ids, rebuild when the model name, digest, dimensions or text version differ, refuse a collection that is not this instance's) and one worker thread embeds and upserts in batches of 32, retrying with a 30 s to 10 min backoff. IndexSink::committed builds entries and leaves them in an inbox; admission never waits on the embedder or on Qdrant. Whoami reports the worker's health as IndexStatus. The Ollama and Qdrant adapters are the only files holding HTTP or JSON (ureq 3, no TLS). The daemon now requires --qdrant-url, --ollama-url and --embedding-model; NoIndex leaves the binary. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 08:05:26 +02:00
"IndexStatus": {
"description": "How far the semantic index has caught up with the mind. The mind decides\nnone of it: the daemon's index worker reports it, in memory, and a restart\nrecomputes it. `pending` counts documents not yet known to be in the index.",
"oneOf": [
{
"description": "The worker has not yet compared the mind with the collection.",
"type": "object",
"properties": {
"Reconciling": {
"type": "object",
"properties": {
"pending": {
"type": "integer",
"format": "uint32",
"minimum": 0
}
},
"required": [
"pending"
]
}
},
"additionalProperties": false,
"required": [
"Reconciling"
]
},
{
"description": "Every indexable document is in the collection.",
"type": "string",
"const": "Current"
},
{
"description": "Reconciled, and indexing what is still pending.",
"type": "object",
"properties": {
"Behind": {
"type": "object",
"properties": {
"pending": {
"type": "integer",
"format": "uint32",
"minimum": 0
}
},
"required": [
"pending"
]
}
},
"additionalProperties": false,
"required": [
"Behind"
]
},
{
"description": "The last attempt failed (the embedder or the vector store is\nunreachable, or refused); it is retried with a backoff and nothing is\ndropped. `attempts` counts consecutive failures.",
"type": "object",
"properties": {
"Failing": {
"type": "object",
"properties": {
"attempts": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"error": {
"type": "string"
},
"pending": {
"type": "integer",
"format": "uint32",
"minimum": 0
}
},
"required": [
"pending",
"attempts",
"error"
]
}
},
"additionalProperties": false,
"required": [
"Failing"
]
},
{
"description": "The collection belongs to another writer. The worker never recreates\nit; it re-reads it on the same backoff.",
"type": "object",
"properties": {
"Refused": {
"type": "object",
"properties": {
"attempts": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"pending": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"reason": {
"type": "string"
}
},
"required": [
"pending",
"attempts",
"reason"
]
}
},
"additionalProperties": false,
"required": [
"Refused"
]
}
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"Label": {
"description": "A key label: `[A-Za-z0-9_-]{1,64}`.",
"type": "string",
"maxLength": 64
},
"LandedName": {
"description": "A name the cut landed, and where it lives.",
"type": "object",
"properties": {
"name": {
"$ref": "#/$defs/Short"
},
"path": {
"$ref": "#/$defs/Short"
}
},
"required": [
"name",
"path"
]
},
"Line": {
"description": "Text of at most 1,000 UTF-8 bytes.",
"type": "string",
"maxLength": 1000
},
memory: golden and schemas re-derived for origin Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 17:48:18 +01:00
"MemoryOrigin": {
"description": "Where a memory came from and whom she heard it from. The organ derives it\nfrom the batch of the turn that wrote the memory; the model never writes it.\n`about` names whom a memory concerns, this names the room and the voices.",
"oneOf": [
{
"description": "A turn in rooms: their aliases comma-joined, and the batch's other senders.",
"type": "object",
"properties": {
"Room": {
"type": "object",
"properties": {
"heard_from": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 8
},
"rooms": {
"$ref": "#/$defs/Short"
}
},
"required": [
"rooms",
"heard_from"
]
}
},
"additionalProperties": false,
"required": [
"Room"
]
},
{
"description": "A direct message: the DM's room id, and the others who spoke in it (whom\nshe heard it from in confidence).",
"type": "object",
"properties": {
"Direct": {
"type": "object",
"properties": {
"room": {
"$ref": "#/$defs/Short"
},
"with": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 8
}
},
"required": [
"room",
"with"
]
}
},
"additionalProperties": false,
"required": [
"Direct"
]
},
{
"description": "A wake: no one spoke.",
"type": "string",
"const": "Wake"
},
{
"description": "A Self run of hers, by its label.",
"type": "object",
"properties": {
"SelfRun": {
"type": "object",
"properties": {
"run": {
"$ref": "#/$defs/Short"
}
},
"required": [
"run"
]
}
},
"additionalProperties": false,
"required": [
"SelfRun"
]
}
]
},
memory: a persistent kind for what a Mind keeps (eureka-pipeline, huginn-mind) epiphany.pipeline.memory.v2, instance-rooted `<instance>:memory:<label>`: PipelineMemory with seven sorts (Asked, Decided, Committed, Learned, Did, Idea, Rapport), her own text, who it is about, where it was learned, whether directly, what it rests on, a salience that only ranks, and the memories a consolidating one replaces. Admission refuses a foreign instance and resolves a memory only Deferred to a follow-up (an ask taken on), Recorded, Withdrawn or Superseded by a memory. Memories have their own lineage so supersession stays within one mind. The read side selects by sort, about (multi-valued) and direct; the index carries the text; `consolidates` is a citation role. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 15:15:40 +01:00
"MemorySort": {
"type": "string",
"enum": [
"Asked",
"Decided",
"Committed",
"Learned",
"Did",
"Idea",
"Rapport"
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"MindRefusal": {
"description": "Every way a mind refuses. `Document` wraps the leaf's four (bounds,\nformats, key identity, foreign type); the rest are the organ's: store\nidentity, epoch, ownership, batch shape, references, and every cross-field\nand cross-document rule of admission.\n\nThe two sequenced kinds refuse in the same pair of shapes: an\n`OutOfSequence` when the writer's `sequence` is not the previous plus one,\nand `AlreadyResolved`/`AlreadyStewarded` when a record of that scope is\nstill in force.",
"oneOf": [
{
"type": "string",
"enum": [
"MissingIdentity",
"EmptySupersession",
"FindingWithoutRange",
"FindingWithoutEvidence"
]
},
{
"type": "object",
"properties": {
"Document": {
"$ref": "#/$defs/PipelineRefusal"
}
},
"additionalProperties": false,
"required": [
"Document"
]
},
{
"type": "object",
"properties": {
"ForeignInstance": {
"type": "object",
"properties": {
"declared": {
"type": "string"
},
"mind": {
"type": "string"
}
},
"required": [
"declared",
"mind"
]
}
},
"additionalProperties": false,
"required": [
"ForeignInstance"
]
},
{
"type": "object",
"properties": {
"ForeignEpoch": {
"type": "object",
"properties": {
"expected": {
"type": "string"
},
"found": {
"type": "string"
}
},
"required": [
"found",
"expected"
]
}
},
"additionalProperties": false,
"required": [
"ForeignEpoch"
]
},
{
"type": "object",
"properties": {
"ForeignStore": {
"type": "object",
"properties": {
"type": {
"type": "string"
}
},
"required": [
"type"
]
}
},
"additionalProperties": false,
"required": [
"ForeignStore"
]
},
{
"type": "object",
"properties": {
"MindAlreadyOwned": {
"type": "object",
"properties": {
"path": {
"type": "string"
}
},
"required": [
"path"
]
}
},
"additionalProperties": false,
"required": [
"MindAlreadyOwned"
]
},
{
"type": "object",
"properties": {
"BatchSize": {
"type": "object",
"properties": {
"actual": {
"type": "integer",
"format": "uint32",
"minimum": 0
}
},
"required": [
"actual"
]
}
},
"additionalProperties": false,
"required": [
"BatchSize"
]
},
{
"type": "object",
"properties": {
"IdentityCollision": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"kind": {
"$ref": "#/$defs/PipelineKind"
}
},
"required": [
"kind",
"id"
]
}
},
"additionalProperties": false,
"required": [
"IdentityCollision"
]
},
{
"type": "object",
"properties": {
"MissingReference": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"kind": {
"$ref": "#/$defs/PipelineKind"
}
},
"required": [
"kind",
"id"
]
}
},
"additionalProperties": false,
"required": [
"MissingReference"
]
},
{
"type": "object",
"properties": {
"AlreadyResolved": {
"type": "object",
"properties": {
"subject": {
"type": "string"
}
},
"required": [
"subject"
]
}
},
"additionalProperties": false,
"required": [
"AlreadyResolved"
]
},
{
"type": "object",
"properties": {
"ResolutionOutOfSequence": {
"type": "object",
"properties": {
"actual": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"expected": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"subject": {
"type": "string"
}
},
"required": [
"subject",
"expected",
"actual"
]
}
},
"additionalProperties": false,
"required": [
"ResolutionOutOfSequence"
]
},
{
"type": "object",
"properties": {
"AlreadyStewarded": {
"type": "object",
"properties": {
"repo": {
"type": "string"
}
},
"required": [
"repo"
]
}
},
"additionalProperties": false,
"required": [
"AlreadyStewarded"
]
},
{
"type": "object",
"properties": {
"StewardshipOutOfSequence": {
"type": "object",
"properties": {
"actual": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"expected": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"repo": {
"type": "string"
}
},
"required": [
"repo",
"expected",
"actual"
]
}
},
"additionalProperties": false,
"required": [
"StewardshipOutOfSequence"
]
},
{
"type": "object",
"properties": {
"IncompatibleResolution": {
"type": "object",
"properties": {
"outcome": {
"type": "string"
},
"subject_kind": {
"$ref": "#/$defs/PipelineKind"
}
},
"required": [
"subject_kind",
"outcome"
]
}
},
"additionalProperties": false,
"required": [
"IncompatibleResolution"
]
},
{
"type": "object",
"properties": {
"WouldReinstateOverLater": {
"type": "object",
"properties": {
"later": {
"type": "string"
},
"subject": {
"type": "string"
}
},
"required": [
"subject",
"later"
]
}
},
"additionalProperties": false,
"required": [
"WouldReinstateOverLater"
]
},
{
"type": "object",
"properties": {
"CitesResolvedDocument": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"kind": {
"$ref": "#/$defs/PipelineKind"
}
},
"required": [
"kind",
"id"
]
}
},
"additionalProperties": false,
"required": [
"CitesResolvedDocument"
]
},
{
"type": "object",
"properties": {
"UnknownSupersessor": {
"type": "object",
"properties": {
"id": {
"type": "string"
}
},
"required": [
"id"
]
}
},
"additionalProperties": false,
"required": [
"UnknownSupersessor"
]
},
{
"type": "object",
"properties": {
"RevisionWithoutSupersession": {
"type": "object",
"properties": {
"kind": {
"$ref": "#/$defs/PipelineKind"
},
"revision": {
"type": "integer",
"format": "uint32",
"minimum": 0
}
},
"required": [
"kind",
"revision"
]
}
},
"additionalProperties": false,
"required": [
"RevisionWithoutSupersession"
]
},
{
"type": "object",
"properties": {
"DuplicateLabel": {
"type": "object",
"properties": {
"field": {
"type": "string"
},
"label": {
"type": "string"
}
},
"required": [
"field",
"label"
]
}
},
"additionalProperties": false,
"required": [
"DuplicateLabel"
]
},
{
"type": "object",
"properties": {
"InvalidOptions": {
"type": "object",
"properties": {
"question": {
"type": "string"
}
},
"required": [
"question"
]
}
},
"additionalProperties": false,
"required": [
"InvalidOptions"
]
},
{
"type": "object",
"properties": {
"InvalidChoice": {
"type": "object",
"properties": {
"choice": {
"type": "string"
},
"ruling": {
"type": "string"
}
},
"required": [
"ruling",
"choice"
]
}
},
"additionalProperties": false,
"required": [
"InvalidChoice"
]
},
{
"type": "object",
"properties": {
"QuoteWithoutOperator": {
"type": "object",
"properties": {
"ruling": {
"type": "string"
}
},
"required": [
"ruling"
]
}
},
"additionalProperties": false,
"required": [
"QuoteWithoutOperator"
]
},
{
campaign-repos: a campaign's repo set changes by target revision; one line_of decides supersession lineage (squash of eureka-substrate/campaign-repos c0a1f2c..4442e1a) target.repos additive at epoch v2; Docs::repos_in_force owns membership; line_of owns lineage (targets per campaign, cut_specs per campaign+cut, stewardships per instance+repo, rulings and follow_ups global); rival_in_force owns one-assignment-in-force. Soul s5 holds (eureka-substrate:verdict:cut-campaign-repos.s5). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 23:38:20 +02:00
"description": "`campaign` names the refused document: a campaign, or a target revision that empties its predecessor's repos.",
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"type": "object",
"properties": {
"EmptyRepos": {
"type": "object",
"properties": {
"campaign": {
"type": "string"
}
},
"required": [
"campaign"
]
}
},
"additionalProperties": false,
"required": [
"EmptyRepos"
]
},
{
"type": "object",
"properties": {
huginn-mind: published wire schemas follow the renames; the summary bound test uses real cuts Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-01 12:57:55 +02:00
"RepoNotInCampaign": {
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"type": "object",
"properties": {
"repo": {
"type": "string"
}
},
"required": [
"repo"
]
}
},
"additionalProperties": false,
"required": [
huginn-mind: published wire schemas follow the renames; the summary bound test uses real cuts Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-01 12:57:55 +02:00
"RepoNotInCampaign"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
]
},
{
"type": "object",
"properties": {
huginn-mind: published wire schemas follow the renames; the summary bound test uses real cuts Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-01 12:57:55 +02:00
"UnknownDependency": {
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"type": "object",
"properties": {
huginn-mind: published wire schemas follow the renames; the summary bound test uses real cuts Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-01 12:57:55 +02:00
"cut": {
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"type": "string"
}
},
"required": [
huginn-mind: published wire schemas follow the renames; the summary bound test uses real cuts Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-01 12:57:55 +02:00
"cut"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
]
}
},
"additionalProperties": false,
"required": [
huginn-mind: published wire schemas follow the renames; the summary bound test uses real cuts Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-01 12:57:55 +02:00
"UnknownDependency"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
]
},
{
"type": "object",
"properties": {
"CutReportWithoutSpec": {
"type": "object",
"properties": {
"report": {
"type": "string"
}
},
"required": [
"report"
]
}
},
"additionalProperties": false,
"required": [
"CutReportWithoutSpec"
]
},
{
"type": "object",
"properties": {
"SpecMismatch": {
"type": "object",
"properties": {
"field": {
"type": "string"
}
},
"required": [
"field"
]
}
},
"additionalProperties": false,
"required": [
"SpecMismatch"
]
},
{
"type": "object",
"properties": {
"RangeOutsideCommits": {
"type": "object",
"properties": {
"head": {
"type": "string"
}
},
"required": [
"head"
]
}
},
"additionalProperties": false,
"required": [
"RangeOutsideCommits"
]
},
{
"type": "object",
"properties": {
"FalsifiedClaimWithoutConfirmedFinding": {
"type": "object",
"properties": {
"claim": {
"type": "string"
}
},
"required": [
"claim"
]
}
},
"additionalProperties": false,
"required": [
"FalsifiedClaimWithoutConfirmedFinding"
]
},
{
"type": "object",
"properties": {
"UnprovenClaimWithConfirmedFinding": {
"type": "object",
"properties": {
"claim": {
"type": "string"
}
},
"required": [
"claim"
]
}
},
"additionalProperties": false,
"required": [
"UnprovenClaimWithConfirmedFinding"
]
},
{
"type": "object",
"properties": {
"PromiseWithoutVerdict": {
"type": "object",
"properties": {
"promise": {
"type": "string"
}
},
"required": [
"promise"
]
}
},
"additionalProperties": false,
"required": [
"PromiseWithoutVerdict"
]
},
{
"type": "object",
"properties": {
"UnknownMutationLabel": {
"type": "object",
"properties": {
"label": {
"type": "string"
}
},
"required": [
"label"
]
}
},
"additionalProperties": false,
"required": [
"UnknownMutationLabel"
]
},
{
"type": "object",
"properties": {
"UnknownInvariant": {
"type": "object",
"properties": {
"label": {
"type": "string"
}
},
"required": [
"label"
]
}
},
"additionalProperties": false,
"required": [
"UnknownInvariant"
]
},
{
"type": "object",
"properties": {
"NotStewarded": {
"type": "object",
"properties": {
"repo": {
"type": "string"
}
},
"required": [
"repo"
]
}
},
"additionalProperties": false,
"required": [
"NotStewarded"
]
},
Persona: compile fixes and the regenerated wire schemas The jsonschema error kind lives in jsonschema::error; the eureka-state tool closures own their input; huginn.mind_request/response.v1 carry the persona operations (derived by the existing published_wire_schemas test). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-10 05:47:00 +02:00
{
"description": "The persona document fails the published schema: `path` is the\ndocument location (a key the schema does not declare is `*`) and\n`message` the schema keyword that failed. Never the offending value.",
"type": "object",
"properties": {
"PersonaInvalid": {
"type": "object",
"properties": {
"message": {
"type": "string"
},
"path": {
"type": "string"
}
},
"required": [
"path",
"message"
]
}
},
"additionalProperties": false,
"required": [
"PersonaInvalid"
]
},
{
"description": "The document's `personaId` is not this mind's instance, which is\n`instance`.",
"type": "object",
"properties": {
"PersonaForeign": {
"type": "object",
"properties": {
"instance": {
"type": "string"
}
},
"required": [
"instance"
]
}
},
"additionalProperties": false,
"required": [
"PersonaForeign"
]
},
{
"description": "The put's `expected_updated_at` is not the stored document's\n`updatedAt`, which is `stored` (none when no persona is stored).",
"type": "object",
"properties": {
"PersonaStale": {
"type": "object",
"properties": {
"stored": {
"type": [
"string",
"null"
]
}
}
}
},
"additionalProperties": false,
"required": [
"PersonaStale"
]
},
{
"description": "The document's `provenance.authority` is not `canonical`: a projection\nor an import is not the mind's persona.",
"type": "string",
"const": "PersonaNotCanonical"
},
Mind: run admission with AlreadyClaimed, the run resolution row, the claims edge A run's instance must be this mind. Every claim must name a document in force (MissingReference, CitesResolvedDocument); a claim held by another run in force is refused AlreadyClaimed { item, run }, so the claim is the one consumption fact. A byte-identical replay of an admitted run owes its claims no fresh freedom and answers AlreadyAdmitted. A run resolves Recorded or Withdrawn only. Runs cite their claims under role `claims`, so cites and cited selections reach them; the header facts carry label, operator, turn, start and claims. The published schemas that embed PipelineKind (finding, follow_up, question, resolution, ruling) and the two mind wire schemas are re-derived: the Run variant, PipelineFacts::Run, AlreadyClaimed and the claims role. The leaf commit before this one has those five stale. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 16:07:19 +02:00
{
"description": "A run claims work another run in force already holds: `item` is the\nclaimed document's id and `run` the id of the run that holds it.",
"type": "object",
"properties": {
"AlreadyClaimed": {
"type": "object",
"properties": {
"item": {
"type": "string"
},
"run": {
huginn-mind: published response schema carries RunId Regenerated from schema_for!(HuginnMindResponse) as the wire test derives it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-10 05:18:38 +02:00
"$ref": "#/$defs/RunId"
Mind: run admission with AlreadyClaimed, the run resolution row, the claims edge A run's instance must be this mind. Every claim must name a document in force (MissingReference, CitesResolvedDocument); a claim held by another run in force is refused AlreadyClaimed { item, run }, so the claim is the one consumption fact. A byte-identical replay of an admitted run owes its claims no fresh freedom and answers AlreadyAdmitted. A run resolves Recorded or Withdrawn only. Runs cite their claims under role `claims`, so cites and cited selections reach them; the header facts carry label, operator, turn, start and claims. The published schemas that embed PipelineKind (finding, follow_up, question, resolution, ruling) and the two mind wire schemas are re-derived: the Run variant, PipelineFacts::Run, AlreadyClaimed and the claims role. The leaf commit before this one has those five stale. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 16:07:19 +02:00
}
},
"required": [
"item",
"run"
]
}
},
"additionalProperties": false,
"required": [
"AlreadyClaimed"
]
},
huginn-mind: published response schema indents AlreadyLive like its siblings ff259a1 and 11af610 carry the schema block one indent level too deep, so published_wire_schemas_match_derivation fails on them; this commit fixes it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 23:01:30 +02:00
{
"description": "A run of hers opens, or is reinstated, while another in-force run of\nhers of the same instance and turn is live: `run` is the holder's id\n(ruling one-live-self-run).",
"type": "object",
"properties": {
"AlreadyLive": {
"type": "object",
"properties": {
"run": {
huginn-mind: published response schema carries RunId Regenerated from schema_for!(HuginnMindResponse) as the wire test derives it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-10 05:18:38 +02:00
"$ref": "#/$defs/RunId"
huginn-mind: published response schema indents AlreadyLive like its siblings ff259a1 and 11af610 carry the schema block one indent level too deep, so published_wire_schemas_match_derivation fails on them; this commit fixes it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 23:01:30 +02:00
}
},
"required": [
"run"
]
}
huginn-mind: admission refuses a second live run of hers of one turn (AlreadyLive) Ruling one-live-self-run, decided where batches are serialized: run_rule (was run_claims_rule) now also refuses an opening or reinstated run whose instance and turn already have an in-force operated_by Mind run. The fixture run() is an operator's run; mind_run() is hers. Unverified: this commit has not been built when written; verification follows. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 22:48:01 +02:00
},
huginn-mind: published response schema indents AlreadyLive like its siblings ff259a1 and 11af610 carry the schema block one indent level too deep, so published_wire_schemas_match_derivation fails on them; this commit fixes it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 23:01:30 +02:00
"additionalProperties": false,
"required": [
"AlreadyLive"
]
},
Refuse an answer that will not fit, by name A reply larger than one send could carry was handed to the hub anyway. The hub refused it, the loop printed the error and served past, and the client waited for an answer nothing would ever send. A real-sized read was lost in silence, which is the one thing this surface promises not to do: a refusal is typed, and that has to hold at every size. `within_window` now encodes the reply and measures it against the window this module configures, before a send it can already see will fail. Over the limit, the answer becomes `MindRefusal::ResponseTooLarge { bytes, limit }` on the response schema, reaching the client exactly as every other refusal does, with the encoded size and the limit so a caller can narrow its own request. Nothing is truncated, paginated or retried. The arithmetic, measured rather than estimated. One `PipelineCutSpec` with every list at the leaf's bound -- 256 file changes, 64 deletes, keeps, adds, builds, tests, negative checks and operator checks, a full authority map and structural delta -- is about 980,000 bytes of field content. As a `View` response, base64 in the operation envelope and MessagePack around that, it encodes to 1,315,551 bytes. The window is `MAX_PENDING_RELIABLE_PACKETS` (1024) times `MAX_FRAGMENT_BYTES` (1200), so 1,228,800. A single document at the leaf's own bounds therefore does not fit, by 86,751 bytes. The window's values are unchanged by ruling: what a list read should return is an open question, and raising the window would bake multi-megabyte answers in as ordinary traffic before that question is answered. The module documentation states 1,228,800 as the current bound rather than as a design target. The test admits two cut specs into a real mind: one at 256 file changes and one narrowed to 180, whose view encodes to 1,189,495 bytes. Over one loopback session the query, the wide view and the open items are each refused by name, and the narrow view is then delivered whole. Both halves are load-bearing: the delivered answer sits 39,305 bytes under the limit, so `D22` and `D22L`, which shrink the configured window, break it. `D20` removes the gate, `D20L` measures against a larger number than the hub carries, `D20L2` and `D20L3` collapse the two fields the refusal reports, `D21` sends it as a failure envelope instead, and `D22`, `D22L` and `D22L2` shrink each half of the window the gate trusts. All eight die. The whole suite, 51 entries and M0, is green. Two reads pipelined on one session are still not both answered, and the module documentation says so: the window is per session and counts what is unacknowledged, so a second large reply sent before the first is acknowledged fails to send even though each passes the gate alone. The gate measures one answer against the window, not against what the session still has room for. That is not fixed here. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-17 00:08:10 +02:00
{
BP-3 1: an oversize answer is deferred to the body plane deliver replaces within_window as the one owner of how an answer leaves: whole when the envelope fits the window, deferred when the payload is within MAX_DEFERRED_BODY_BYTES (64 MiB), refused by name past it. A deferred answer is HuginnMindResponse::Deferred(DeferredAnswer { manifest }), the reference's CultMeshCdnArtifactManifest; the chunks are asked for on the session the client holds and answered by cultnet-rs's answer_content_chunk_request. The body is held by DeferredBodies (256 MiB budget, sliding 60 s TTL, least-recently- touched eviction, shared chunks stored once), in memory only. The mind knows nothing of deferral. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 07:29:17 +02:00
"description": "The one refusal a mind never raises: the answer exceeds the largest\nbody the organ will deliver by any plane, one send or a deferred body.\nIt lives here because a refusal rides the response schema and there is\none of those, so a client reads it the way it reads every other refusal\nrather than parsing a second vocabulary. `bytes` is the encoded answer\n(the payload, not its envelope) and `limit` is the largest body the\ndaemon defers, both so a caller can narrow its own request; nothing is\ntruncated or paginated on its behalf. The daemon owns it and its\ndeferral bound decides it; no rule of the mind is involved.",
Refuse an answer that will not fit, by name A reply larger than one send could carry was handed to the hub anyway. The hub refused it, the loop printed the error and served past, and the client waited for an answer nothing would ever send. A real-sized read was lost in silence, which is the one thing this surface promises not to do: a refusal is typed, and that has to hold at every size. `within_window` now encodes the reply and measures it against the window this module configures, before a send it can already see will fail. Over the limit, the answer becomes `MindRefusal::ResponseTooLarge { bytes, limit }` on the response schema, reaching the client exactly as every other refusal does, with the encoded size and the limit so a caller can narrow its own request. Nothing is truncated, paginated or retried. The arithmetic, measured rather than estimated. One `PipelineCutSpec` with every list at the leaf's bound -- 256 file changes, 64 deletes, keeps, adds, builds, tests, negative checks and operator checks, a full authority map and structural delta -- is about 980,000 bytes of field content. As a `View` response, base64 in the operation envelope and MessagePack around that, it encodes to 1,315,551 bytes. The window is `MAX_PENDING_RELIABLE_PACKETS` (1024) times `MAX_FRAGMENT_BYTES` (1200), so 1,228,800. A single document at the leaf's own bounds therefore does not fit, by 86,751 bytes. The window's values are unchanged by ruling: what a list read should return is an open question, and raising the window would bake multi-megabyte answers in as ordinary traffic before that question is answered. The module documentation states 1,228,800 as the current bound rather than as a design target. The test admits two cut specs into a real mind: one at 256 file changes and one narrowed to 180, whose view encodes to 1,189,495 bytes. Over one loopback session the query, the wide view and the open items are each refused by name, and the narrow view is then delivered whole. Both halves are load-bearing: the delivered answer sits 39,305 bytes under the limit, so `D22` and `D22L`, which shrink the configured window, break it. `D20` removes the gate, `D20L` measures against a larger number than the hub carries, `D20L2` and `D20L3` collapse the two fields the refusal reports, `D21` sends it as a failure envelope instead, and `D22`, `D22L` and `D22L2` shrink each half of the window the gate trusts. All eight die. The whole suite, 51 entries and M0, is green. Two reads pipelined on one session are still not both answered, and the module documentation says so: the window is per session and counts what is unacknowledged, so a second large reply sent before the first is acknowledged fails to send even though each passes the gate alone. The gate measures one answer against the window, not against what the session still has room for. That is not fixed here. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-17 00:08:10 +02:00
"type": "object",
"properties": {
"ResponseTooLarge": {
"type": "object",
"properties": {
"bytes": {
"type": "integer",
"format": "uint64",
"minimum": 0
},
"limit": {
"type": "integer",
"format": "uint64",
"minimum": 0
}
},
"required": [
"bytes",
"limit"
]
}
},
"additionalProperties": false,
"required": [
"ResponseTooLarge"
]
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
{
"description": "A selection the substrate or the organ's value door refused: `field`\nis the selection field the client sent, `value` the offending part.",
"type": "object",
"properties": {
"SelectionInvalid": {
"type": "object",
"properties": {
"field": {
"type": "string"
},
"message": {
"type": "string"
},
"value": {
"type": [
"string",
"null"
]
}
},
"required": [
"field",
"message"
]
}
},
"additionalProperties": false,
"required": [
"SelectionInvalid"
]
},
{
"description": "A cursor that does not decode, does not belong to this selection or\nwas not minted by this process, or names a snapshot this mind has not\nreached.",
"type": "object",
"properties": {
"CursorInvalid": {
"type": "object",
"properties": {
"message": {
"type": "string"
}
},
"required": [
"message"
]
}
},
"additionalProperties": false,
"required": [
"CursorInvalid"
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
{
"type": "object",
"properties": {
"Unavailable": {
"type": "object",
"properties": {
"detail": {
"type": "string"
}
},
"required": [
"detail"
]
}
},
"additionalProperties": false,
"required": [
"Unavailable"
]
}
]
},
"MindStatus": {
"description": "What a mind says about itself: the typed state a dashboard projects.",
"type": "object",
"properties": {
"documents": {
"description": "Pipeline documents in the image; the epoch record and the receipts are\nnot documents and are not counted here.",
"type": "integer",
"format": "uint32",
"minimum": 0
},
Cut 11a: the index write side huginn-mind::index owns what of a document is searchable: index_text is a pure function per kind, Mind::index_entries builds the entries with the writing receipt's ordinal, INDEX_TEXT_VERSION says when the rule changed. huginn-daemon::index owns the projection. A Projector reconciles the mind against the collection at startup (the only place a point is judged missing: set difference on point ids, rebuild when the model name, digest, dimensions or text version differ, refuse a collection that is not this instance's) and one worker thread embeds and upserts in batches of 32, retrying with a 30 s to 10 min backoff. IndexSink::committed builds entries and leaves them in an inbox; admission never waits on the embedder or on Qdrant. Whoami reports the worker's health as IndexStatus. The Ollama and Qdrant adapters are the only files holding HTTP or JSON (ureq 3, no TLS). The daemon now requires --qdrant-url, --ollama-url and --embedding-model; NoIndex leaves the binary. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 08:05:26 +02:00
"index": {
"$ref": "#/$defs/IndexStatus"
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"instance": {
"$ref": "#/$defs/Slug"
},
Persona: compile fixes and the regenerated wire schemas The jsonschema error kind lives in jsonschema::error; the eureka-state tool closures own their input; huginn.mind_request/response.v1 carry the persona operations (derived by the existing published_wire_schemas test). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-10 05:47:00 +02:00
"persona": {
Regenerate the response wire schema for PersonaStatus; lock serde_path_to_error Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-10 08:38:42 +02:00
"description": "The persona door as `PersonaGet` would find it.",
"$ref": "#/$defs/PersonaStatus"
Persona: compile fixes and the regenerated wire schemas The jsonschema error kind lives in jsonschema::error; the eureka-state tool closures own their input; huginn.mind_request/response.v1 carry the persona operations (derived by the existing published_wire_schemas test). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-10 05:47:00 +02:00
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"receipts": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"schema_epoch": {
"type": "string"
}
},
"required": [
"instance",
"schema_epoch",
"documents",
Cut 11a: the index write side huginn-mind::index owns what of a document is searchable: index_text is a pure function per kind, Mind::index_entries builds the entries with the writing receipt's ordinal, INDEX_TEXT_VERSION says when the rule changed. huginn-daemon::index owns the projection. A Projector reconciles the mind against the collection at startup (the only place a point is judged missing: set difference on point ids, rebuild when the model name, digest, dimensions or text version differ, refuse a collection that is not this instance's) and one worker thread embeds and upserts in batches of 32, retrying with a 30 s to 10 min backoff. IndexSink::committed builds entries and leaves them in an inbox; admission never waits on the embedder or on Qdrant. Whoami reports the worker's health as IndexStatus. The Ollama and Qdrant adapters are the only files holding HTTP or JSON (ureq 3, no TLS). The daemon now requires --qdrant-url, --ollama-url and --embedding-model; NoIndex leaves the binary. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 08:05:26 +02:00
"receipts",
Regenerate the response wire schema for PersonaStatus; lock serde_path_to_error Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-10 08:38:42 +02:00
"index",
"persona"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
]
},
"MutationRecord": {
"description": "One mutation a report ran: a key-safe label a verdict claim can name,\nthe exact edit, and the tree it was applied to.",
"type": "object",
"properties": {
"after": {
"$ref": "#/$defs/Line"
},
"before": {
"$ref": "#/$defs/Line"
},
"commit": {
"$ref": "#/$defs/Sha"
},
"failed_as_expected": {
"type": "boolean"
},
"label": {
"$ref": "#/$defs/Label"
},
"location": {
"$ref": "#/$defs/CodeLocation"
},
"rule": {
"$ref": "#/$defs/Line"
}
},
"required": [
"label",
"rule",
"location",
"before",
"after",
"commit",
"failed_as_expected"
]
},
"NegativeCheck": {
"type": "object",
"properties": {
"pattern": {
"$ref": "#/$defs/Short"
},
"scope": {
"$ref": "#/$defs/Line"
}
},
"required": [
"pattern",
"scope"
]
},
repo-activity: a Mind hears of changes in her stewarded repos, on her first line and by one organ notice on change; a repo the anonymous read cannot reach is named, never a failed read (squash of hands/eureka-body-repo-activity 5a294ed..eee0b14; Soul s1-s4) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 04:54:26 +01:00
"OpenPr": {
"description": "A pull request open on the forge.",
"type": "object",
"properties": {
"author": {
"$ref": "#/$defs/Short"
},
"number": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"repo": {
"$ref": "#/$defs/OrgRepo"
},
"updated_at": {
"description": "Unix milliseconds.",
"type": "integer",
"format": "uint64",
"minimum": 0
}
},
"required": [
"repo",
"number",
"author",
"updated_at"
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"OrgRepo": {
BP-2: move Huginn to CultLib 6251cbc and the RS-L leaf 4891f2e5 One pin move: huginn-mind pins cultcache-rs at 6251cbc and the leaf at 4891f2e5; huginn-daemon pins cultnet-rs at 6251cbc. cargo tree shows one cultcache-rs and one cultnet-rs per crate. Adopting RS-L, which the new leaf carries: - Campaign, cut-spec, question and ruling fixtures carry a Title; the question and ruling fixtures gain the new required title field. - The epoch literals in daemon and envelope tests move v1 -> v2. A store written at an earlier epoch is refused at open (ForeignEpoch); no key migration. - Derived stewardship, hand-off and resolution keys are now the lowercased OrgRepo::identity(); test key literals follow. - The two published wire schemas are regenerated (Title, OrgRepo bound and description); the byte-for-byte pin test passes. CultLib 6251cbc gives CultNetMessage::Error code and details; the four construction sites and one pattern in huginn-daemon take None and `..`. No behaviour change: None is skipped on the wire. mind 70 and daemon 18 pass. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 03:56:03 +02:00
"description": "A GitHub repository as `Org/Repo`, at most 140 UTF-8 bytes (39 + 1 +\n100). The owner is 1 to 39 `[A-Za-z0-9-]` bytes with no leading or\ntrailing hyphen; the repo is 1 to 100 `[A-Za-z0-9._-]` bytes, is never\n`.` or `..`, and does not end in `.git`, ASCII-case-insensitively.\nIdentity is case-insensitive: `GameCult/Epiphany` and `gamecult/epiphany`\nare the same repository.",
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"type": "string",
BP-2: move Huginn to CultLib 6251cbc and the RS-L leaf 4891f2e5 One pin move: huginn-mind pins cultcache-rs at 6251cbc and the leaf at 4891f2e5; huginn-daemon pins cultnet-rs at 6251cbc. cargo tree shows one cultcache-rs and one cultnet-rs per crate. Adopting RS-L, which the new leaf carries: - Campaign, cut-spec, question and ruling fixtures carry a Title; the question and ruling fixtures gain the new required title field. - The epoch literals in daemon and envelope tests move v1 -> v2. A store written at an earlier epoch is refused at open (ForeignEpoch); no key migration. - Derived stewardship, hand-off and resolution keys are now the lowercased OrgRepo::identity(); test key literals follow. - The two published wire schemas are regenerated (Title, OrgRepo bound and description); the byte-for-byte pin test passes. CultLib 6251cbc gives CultNetMessage::Error code and details; the four construction sites and one pattern in huginn-daemon take None and `..`. No behaviour change: None is skipped on the wire. mind 70 and daemon 18 pass. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 03:56:03 +02:00
"maxLength": 140
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
},
"Para": {
"description": "Text of at most 4,000 UTF-8 bytes; longer narrative is cited by `DocRef`.",
"type": "string",
"maxLength": 4000
},
Persona: compile fixes and the regenerated wire schemas The jsonschema error kind lives in jsonschema::error; the eureka-state tool closures own their input; huginn.mind_request/response.v1 carry the persona operations (derived by the existing published_wire_schemas test). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-10 05:47:00 +02:00
"PersonaPutOutcome": {
"description": "How a put ended. A refusal is an answer, as for `admit`.",
"oneOf": [
{
"type": "object",
"properties": {
"Committed": {
"type": "object",
"properties": {
"receipt_id": {
"type": "string"
}
},
"required": [
"receipt_id"
]
}
},
"additionalProperties": false,
"required": [
"Committed"
]
},
{
"type": "object",
"properties": {
"Refused": {
"$ref": "#/$defs/MindRefusal"
}
},
"additionalProperties": false,
"required": [
"Refused"
]
}
]
},
"PersonaStateView": {
"description": "What `PersonaGet` answers: the stored document, its `updatedAt`, and the\nreceipt of the put that wrote it.",
"type": "object",
"properties": {
"receipt_id": {
"type": "string"
},
"updated_at": {
"type": "string"
},
"value": true
},
"required": [
"value",
"updated_at",
"receipt_id"
]
},
Regenerate the response wire schema for PersonaStatus; lock serde_path_to_error Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-10 08:38:42 +02:00
"PersonaStatus": {
"description": "What the persona door holds, in the one vocabulary the door itself answers\nin: nothing yet, a document with this `updatedAt`, or a stored document the\ndoor cannot read (`PersonaGet` and every put answer `Unavailable`).",
"oneOf": [
{
"type": "string",
"enum": [
"Absent",
"Unreadable"
]
},
{
"type": "object",
"properties": {
"Stored": {
"type": "object",
"properties": {
"updated_at": {
"type": "string"
}
},
"required": [
"updated_at"
]
}
},
"additionalProperties": false,
"required": [
"Stored"
]
}
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"PipelineAdmissionOutcome": {
"description": "How admission ended. `Committed.writes` names every document the batch\nlanded, derived writes included; Cut 11 indexes from it after `admit`\nreturns, and never inside it.",
"oneOf": [
{
"type": "object",
"properties": {
"Committed": {
"type": "object",
"properties": {
"committed_at": {
"type": "string"
},
"receipt_id": {
"type": "string"
},
"writes": {
"type": "array",
"items": {
"$ref": "#/$defs/PipelineRef"
}
}
},
"required": [
"receipt_id",
"committed_at",
"writes"
]
}
},
"additionalProperties": false,
"required": [
"Committed"
]
},
{
"type": "object",
"properties": {
"AlreadyAdmitted": {
"type": "object",
"properties": {
"receipt_id": {
"type": "string"
}
},
"required": [
"receipt_id"
]
}
},
"additionalProperties": false,
"required": [
"AlreadyAdmitted"
]
},
{
"type": "object",
"properties": {
"Refused": {
"$ref": "#/$defs/MindRefusal"
}
},
"additionalProperties": false,
"required": [
"Refused"
]
},
{
"type": "object",
"properties": {
"Conflict": {
"type": "object",
"properties": {
"identities": {
"type": "array",
"items": {
"$ref": "#/$defs/PipelineRef"
}
}
},
"required": [
"identities"
]
}
},
"additionalProperties": false,
"required": [
"Conflict"
]
}
]
},
"PipelineCampaign": {
"type": "object",
"properties": {
"repos": {
"type": "array",
"items": {
"$ref": "#/$defs/OrgRepo"
},
"maxItems": 8
},
"slug": {
"$ref": "#/$defs/Slug"
},
"target_doc": {
"$ref": "#/$defs/DocRef"
},
"title": {
BP-2: move Huginn to CultLib 6251cbc and the RS-L leaf 4891f2e5 One pin move: huginn-mind pins cultcache-rs at 6251cbc and the leaf at 4891f2e5; huginn-daemon pins cultnet-rs at 6251cbc. cargo tree shows one cultcache-rs and one cultnet-rs per crate. Adopting RS-L, which the new leaf carries: - Campaign, cut-spec, question and ruling fixtures carry a Title; the question and ruling fixtures gain the new required title field. - The epoch literals in daemon and envelope tests move v1 -> v2. A store written at an earlier epoch is refused at open (ForeignEpoch); no key migration. - Derived stewardship, hand-off and resolution keys are now the lowercased OrgRepo::identity(); test key literals follow. - The two published wire schemas are regenerated (Title, OrgRepo bound and description); the byte-for-byte pin test passes. CultLib 6251cbc gives CultNetMessage::Error code and details; the four construction sites and one pattern in huginn-daemon take None and `..`. No behaviour change: None is skipped on the wire. mind 70 and daemon 18 pass. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 03:56:03 +02:00
"$ref": "#/$defs/Title"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
},
"working_branch": {
"$ref": "#/$defs/Short"
}
},
"required": [
"slug",
"title",
"repos",
"working_branch",
"target_doc"
]
},
"PipelineCutReport": {
"type": "object",
"properties": {
"attempt": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"branch": {
"$ref": "#/$defs/Short"
},
"campaign": {
"$ref": "#/$defs/Slug"
},
"commits": {
"type": "array",
"items": {
"$ref": "#/$defs/ReportCommit"
},
"maxItems": 128
},
"cut_spec": {
"$ref": "#/$defs/Short"
},
"deviations": {
"type": "array",
"items": {
"$ref": "#/$defs/Deviation"
},
"maxItems": 32
},
"forks": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 8
},
"landed_names": {
"type": "array",
"items": {
"$ref": "#/$defs/LandedName"
},
"maxItems": 128
},
"mutations": {
"type": "array",
"items": {
"$ref": "#/$defs/MutationRecord"
},
"maxItems": 64
},
"promises": {
"type": "array",
"items": {
"$ref": "#/$defs/Promise"
},
"maxItems": 64
},
"range": {
"$ref": "#/$defs/CommitRange"
},
"repo": {
"$ref": "#/$defs/OrgRepo"
},
"structural_delta": {
"$ref": "#/$defs/StructuralDelta"
},
"undone": {
"type": "array",
"items": {
"$ref": "#/$defs/Line"
},
"maxItems": 32
},
"verification": {
"type": "array",
"items": {
"$ref": "#/$defs/Evidence"
},
"maxItems": 64
}
},
"required": [
"campaign",
"cut_spec",
"attempt",
"repo",
"branch",
"commits",
"range",
"verification",
"mutations",
"deviations",
"forks",
"structural_delta",
"landed_names",
"undone",
"promises"
]
},
"PipelineCutSpec": {
"type": "object",
"properties": {
"adds": {
"type": "array",
"items": {
"$ref": "#/$defs/Line"
},
"maxItems": 64
},
"authority_map": {
"anyOf": [
{
"$ref": "#/$defs/AuthorityMap"
},
{
"type": "null"
}
]
},
"base": {
"$ref": "#/$defs/Sha"
},
"branch": {
"$ref": "#/$defs/Short"
},
"campaign": {
"$ref": "#/$defs/Slug"
},
"cut": {
"$ref": "#/$defs/Label"
},
"deletes": {
"type": "array",
"items": {
"$ref": "#/$defs/CutDelete"
},
"maxItems": 64
},
"depends_on": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 8
},
"estimate": {
"$ref": "#/$defs/StructuralDelta"
},
"file_changes": {
"type": "array",
"items": {
"$ref": "#/$defs/FileChange"
},
"maxItems": 256
},
"first": {
"type": "array",
"items": {
"$ref": "#/$defs/Line"
},
"maxItems": 16
},
"keeps_moves": {
"type": "array",
"items": {
"$ref": "#/$defs/Line"
},
"maxItems": 64
},
"questions": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 16
},
Golden lines and published schemas derived for CodeLocation.symbol and CutSpec.reads Two golden lines appended (dumped by golden_dump on Yggdrasil at 44c010c; numstat 3 added, 0 deleted against the base) and the six schemas regenerated from the types. Builds; with 44c010c the workspace tests are expected to pass. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 21:12:25 +02:00
"reads": {
"type": "array",
"items": {
"$ref": "#/$defs/ReadAnchor"
},
"maxItems": 16
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"repo": {
"$ref": "#/$defs/OrgRepo"
},
"revision": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"rulings": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 32
},
"title": {
BP-2: move Huginn to CultLib 6251cbc and the RS-L leaf 4891f2e5 One pin move: huginn-mind pins cultcache-rs at 6251cbc and the leaf at 4891f2e5; huginn-daemon pins cultnet-rs at 6251cbc. cargo tree shows one cultcache-rs and one cultnet-rs per crate. Adopting RS-L, which the new leaf carries: - Campaign, cut-spec, question and ruling fixtures carry a Title; the question and ruling fixtures gain the new required title field. - The epoch literals in daemon and envelope tests move v1 -> v2. A store written at an earlier epoch is refused at open (ForeignEpoch); no key migration. - Derived stewardship, hand-off and resolution keys are now the lowercased OrgRepo::identity(); test key literals follow. - The two published wire schemas are regenerated (Title, OrgRepo bound and description); the byte-for-byte pin test passes. CultLib 6251cbc gives CultNetMessage::Error code and details; the four construction sites and one pattern in huginn-daemon take None and `..`. No behaviour change: None is skipped on the wire. mind 70 and daemon 18 pass. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 03:56:03 +02:00
"$ref": "#/$defs/Title"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
},
"verification": {
"$ref": "#/$defs/CutVerification"
}
},
"required": [
"campaign",
"cut",
"revision",
"title",
"repo",
"branch",
"base",
"depends_on",
"first",
"deletes",
"keeps_moves",
"adds",
"file_changes",
"verification",
"estimate",
"rulings",
"questions"
]
},
"PipelineDocument": {
memory: a persistent kind for what a Mind keeps (eureka-pipeline, huginn-mind) epiphany.pipeline.memory.v2, instance-rooted `<instance>:memory:<label>`: PipelineMemory with seven sorts (Asked, Decided, Committed, Learned, Did, Idea, Rapport), her own text, who it is about, where it was learned, whether directly, what it rests on, a salience that only ranks, and the memories a consolidating one replaces. Admission refuses a foreign instance and resolves a memory only Deferred to a follow-up (an ask taken on), Recorded, Withdrawn or Superseded by a memory. Memories have their own lineage so supersession stays within one mind. The read side selects by sort, about (multi-valued) and direct; the index carries the text; `consolidates` is a citation role. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 15:15:40 +01:00
"description": "The envelope enum, adjacently tagged on the kind name: a document\non a wire is `{ kind, value }`, and `kind` is exactly what\n`PipelineKind::name()` returns, so a reader dispatches on the kind\nsegment it already knows from the key and needs no second registry\nmapping variant spellings to kinds. Adjacent rather than internal\nbecause a value is a named map of its own and an internal tag would\nhave to be merged into it; the tag stays beside the value instead.\nThis is not a published schema: `schemas/cultnet` publishes the\nsixteen per-kind value documents, and the envelope is the wire's\nshape, not a document's.",
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"oneOf": [
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "campaign"
},
"value": {
"$ref": "#/$defs/PipelineCampaign"
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "target"
},
"value": {
"$ref": "#/$defs/PipelineTarget"
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "question"
},
"value": {
"$ref": "#/$defs/PipelineQuestion"
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "ruling"
},
"value": {
"$ref": "#/$defs/PipelineRuling"
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "cut_spec"
},
"value": {
"$ref": "#/$defs/PipelineCutSpec"
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "cut_report"
},
"value": {
"$ref": "#/$defs/PipelineCutReport"
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "verdict"
},
"value": {
"$ref": "#/$defs/PipelineVerdict"
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "finding"
},
"value": {
"$ref": "#/$defs/PipelineFinding"
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "follow_up"
},
"value": {
"$ref": "#/$defs/PipelineFollowUp"
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "resolution"
},
"value": {
"$ref": "#/$defs/PipelineResolution"
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "instance"
},
"value": {
"$ref": "#/$defs/PipelineInstance"
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "stewardship"
},
"value": {
"$ref": "#/$defs/PipelineStewardship"
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "hand_off"
},
"value": {
"$ref": "#/$defs/PipelineHandOff"
}
},
"required": [
"kind",
"value"
]
Mind: run admission with AlreadyClaimed, the run resolution row, the claims edge A run's instance must be this mind. Every claim must name a document in force (MissingReference, CitesResolvedDocument); a claim held by another run in force is refused AlreadyClaimed { item, run }, so the claim is the one consumption fact. A byte-identical replay of an admitted run owes its claims no fresh freedom and answers AlreadyAdmitted. A run resolves Recorded or Withdrawn only. Runs cite their claims under role `claims`, so cites and cited selections reach them; the header facts carry label, operator, turn, start and claims. The published schemas that embed PipelineKind (finding, follow_up, question, resolution, ruling) and the two mind wire schemas are re-derived: the Run variant, PipelineFacts::Run, AlreadyClaimed and the claims role. The leaf commit before this one has those five stale. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 16:07:19 +02:00
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "run"
},
"value": {
"$ref": "#/$defs/PipelineRun"
}
},
"required": [
"kind",
"value"
]
schemas: regenerate the mind request and response wire schemas for the Pulse kind Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 06:01:43 +01:00
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "pulse"
},
"value": {
"$ref": "#/$defs/PipelinePulse"
}
},
"required": [
"kind",
"value"
]
memory: a persistent kind for what a Mind keeps (eureka-pipeline, huginn-mind) epiphany.pipeline.memory.v2, instance-rooted `<instance>:memory:<label>`: PipelineMemory with seven sorts (Asked, Decided, Committed, Learned, Did, Idea, Rapport), her own text, who it is about, where it was learned, whether directly, what it rests on, a salience that only ranks, and the memories a consolidating one replaces. Admission refuses a foreign instance and resolves a memory only Deferred to a follow-up (an ask taken on), Recorded, Withdrawn or Superseded by a memory. Memories have their own lineage so supersession stays within one mind. The read side selects by sort, about (multi-valued) and direct; the index carries the text; `consolidates` is a citation role. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 15:15:40 +01:00
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "memory"
},
"value": {
"$ref": "#/$defs/PipelineMemory"
}
},
"required": [
"kind",
"value"
]
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
}
]
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"PipelineDocumentSummary": {
"description": "The organ's meaning of `projection: header`: a document's id, the facts of\nits admission, its status and the few fields of its kind a caller triages\nby. Derived per read and bounded by `SUMMARY_MAX_BYTES`.",
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"type": "object",
"properties": {
"admission": {
"$ref": "#/$defs/AdmissionFacts"
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"facts": {
"$ref": "#/$defs/PipelineFacts"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
},
"id": {
"$ref": "#/$defs/PipelineRef"
},
"status": {
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"$ref": "#/$defs/PipelineStatusSummary"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
}
},
"required": [
"id",
"admission",
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"status",
"facts"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
]
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"PipelineDocumentView": {
"description": "One document as a reader gets it: its id, the document, the facts of its\nadmission and its status. The id travels with the document because a\n`PipelineDocument` does not carry its key and a client must never derive\none.",
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"type": "object",
"properties": {
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"admission": {
"$ref": "#/$defs/AdmissionFacts"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"document": {
"$ref": "#/$defs/PipelineDocument"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"id": {
"$ref": "#/$defs/PipelineRef"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"status": {
"$ref": "#/$defs/PipelineStatus"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
}
},
"required": [
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"id",
"document",
"admission",
"status"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
]
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"PipelineEdge": {
"description": "One citation edge a hop traversed: the organ's typing of the substrate's\nedge, whose ends are record keys and whose role is a string.",
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"type": "object",
"properties": {
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"from": {
"$ref": "#/$defs/PipelineRef"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"role": {
"$ref": "#/$defs/CitationRole"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"to": {
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"$ref": "#/$defs/PipelineRef"
}
},
"required": [
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"from",
"role",
"to"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
]
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"PipelineFacts": {
"description": "The triage fields of each kind, in the leaf's own envelope spelling. Prose\n(`Para`) and unbounded lists are not carried; `finding.claim` and\n`follow_up.item` are, because the leaf typed them as one-line statements.",
"oneOf": [
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "campaign"
},
"value": {
"type": "object",
"properties": {
"repos": {
"type": "array",
"items": {
"$ref": "#/$defs/OrgRepo"
}
},
"title": {
"$ref": "#/$defs/Title"
}
},
"required": [
"title",
"repos"
]
}
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"required": [
"kind",
"value"
]
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "target"
},
"value": {
"type": "object",
"properties": {
"invariants": {
"type": "array",
"items": {
"$ref": "#/$defs/Label"
}
},
"revision": {
"type": "integer",
"format": "uint32",
"minimum": 0
}
},
"required": [
"revision",
"invariants"
]
}
},
"required": [
"kind",
"value"
]
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "question"
},
"value": {
"type": "object",
"properties": {
"asked_on": {
"$ref": "#/$defs/Date"
},
"label": {
"$ref": "#/$defs/Label"
},
"options": {
"type": "array",
"items": {
"$ref": "#/$defs/Label"
}
},
"raised_in": {
"anyOf": [
{
"$ref": "#/$defs/PipelineRef"
},
{
"type": "null"
}
]
},
"recommended": {
"$ref": "#/$defs/Label"
},
"title": {
"$ref": "#/$defs/Title"
}
},
"required": [
"label",
"title",
"options",
"recommended",
"asked_on"
]
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "ruling"
},
"value": {
"type": "object",
"properties": {
"answers": {
"anyOf": [
{
"$ref": "#/$defs/Short"
},
{
"type": "null"
}
]
},
"authority": {
"$ref": "#/$defs/RulingAuthority"
},
"choice": {
"anyOf": [
{
"$ref": "#/$defs/Label"
},
{
"type": "null"
}
]
},
"label": {
"$ref": "#/$defs/Label"
},
"ruled_on": {
"$ref": "#/$defs/Date"
},
"title": {
"$ref": "#/$defs/Title"
}
},
"required": [
"label",
"title",
"authority",
"ruled_on"
]
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "cut_spec"
},
"value": {
"type": "object",
"properties": {
"base": {
"$ref": "#/$defs/Sha"
},
"branch": {
"$ref": "#/$defs/Short"
},
"cut": {
"$ref": "#/$defs/Label"
},
"depends_on": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
}
},
"repo": {
"$ref": "#/$defs/OrgRepo"
},
"revision": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"title": {
"$ref": "#/$defs/Title"
}
},
"required": [
"cut",
"revision",
"title",
"repo",
"branch",
"base",
"depends_on"
]
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "cut_report"
},
"value": {
"type": "object",
"properties": {
"attempt": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"branch": {
"$ref": "#/$defs/Short"
},
"cut_spec": {
"$ref": "#/$defs/Short"
},
"range": {
"$ref": "#/$defs/CommitRange"
},
"repo": {
"$ref": "#/$defs/OrgRepo"
}
},
"required": [
"cut_spec",
"attempt",
"repo",
"branch",
"range"
]
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "verdict"
},
"value": {
"type": "object",
"properties": {
"cut_report": {
"$ref": "#/$defs/Short"
},
"outcomes": {
"type": "array",
"items": {
"$ref": "#/$defs/ClaimOutcome"
}
},
"pass": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"range": {
"$ref": "#/$defs/CommitRange"
}
},
"required": [
"cut_report",
"pass",
"range",
"outcomes"
]
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "finding"
},
"value": {
"type": "object",
"properties": {
"claim": {
"$ref": "#/$defs/Line"
},
"confidence": {
"$ref": "#/$defs/FindingConfidence"
},
"invariants": {
"type": "array",
"items": {
"$ref": "#/$defs/Label"
}
},
"label": {
"$ref": "#/$defs/Label"
},
"origin": {
"$ref": "#/$defs/FindingOrigin"
},
"range": {
"$ref": "#/$defs/CommitRange"
},
"severity": {
"$ref": "#/$defs/FindingSeverity"
},
"verdict": {
"$ref": "#/$defs/Short"
}
},
"required": [
"verdict",
"label",
"confidence",
"severity",
"origin",
"claim",
"invariants",
"range"
]
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "follow_up"
},
"value": {
"type": "object",
"properties": {
"item": {
"$ref": "#/$defs/Line"
},
"label": {
"$ref": "#/$defs/Label"
},
"owner": {
"$ref": "#/$defs/Short"
},
"repo": {
"$ref": "#/$defs/OrgRepo"
},
"source": {
"$ref": "#/$defs/PipelineRef"
}
},
"required": [
"label",
"source",
"repo",
"owner",
"item"
]
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "resolution"
},
"value": {
"type": "object",
"properties": {
"outcome": {
"$ref": "#/$defs/ResolutionOutcome"
},
"resolved_on": {
"$ref": "#/$defs/Date"
},
"sequence": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"subject": {
"$ref": "#/$defs/PipelineRef"
}
},
"required": [
"subject",
"sequence",
"outcome",
"resolved_on"
]
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "instance"
},
"value": {
"type": "object",
"properties": {
"created_at": {
"$ref": "#/$defs/Date"
},
"display_name": {
"$ref": "#/$defs/Short"
},
"host": {
"$ref": "#/$defs/Short"
},
"instance": {
"$ref": "#/$defs/Slug"
}
},
"required": [
"instance",
"display_name",
"host",
"created_at"
]
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "stewardship"
},
"value": {
"type": "object",
"properties": {
"assigned_on": {
"$ref": "#/$defs/Date"
},
"instance": {
"$ref": "#/$defs/Slug"
},
"note": {
"$ref": "#/$defs/Line"
},
"repo": {
"$ref": "#/$defs/OrgRepo"
},
"sequence": {
"type": "integer",
"format": "uint32",
"minimum": 0
}
},
"required": [
"instance",
"repo",
"sequence",
"assigned_on",
"note"
]
}
},
"required": [
"kind",
"value"
]
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "hand_off"
},
"value": {
"type": "object",
"properties": {
"from_instance": {
"$ref": "#/$defs/Slug"
},
"handed_on": {
"$ref": "#/$defs/Date"
},
"repo": {
"$ref": "#/$defs/OrgRepo"
},
"to_instance": {
"$ref": "#/$defs/Slug"
}
},
"required": [
"from_instance",
"to_instance",
"repo",
"handed_on"
]
}
},
"required": [
"kind",
"value"
]
Mind: run admission with AlreadyClaimed, the run resolution row, the claims edge A run's instance must be this mind. Every claim must name a document in force (MissingReference, CitesResolvedDocument); a claim held by another run in force is refused AlreadyClaimed { item, run }, so the claim is the one consumption fact. A byte-identical replay of an admitted run owes its claims no fresh freedom and answers AlreadyAdmitted. A run resolves Recorded or Withdrawn only. Runs cite their claims under role `claims`, so cites and cited selections reach them; the header facts carry label, operator, turn, start and claims. The published schemas that embed PipelineKind (finding, follow_up, question, resolution, ruling) and the two mind wire schemas are re-derived: the Run variant, PipelineFacts::Run, AlreadyClaimed and the claims role. The leaf commit before this one has those five stale. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 16:07:19 +02:00
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "run"
},
"value": {
"type": "object",
"properties": {
"claims": {
"type": "array",
"items": {
"$ref": "#/$defs/PipelineRef"
}
},
"label": {
"$ref": "#/$defs/Label"
},
"operated_by": {
"$ref": "#/$defs/RunOperator"
},
"started_on": {
"$ref": "#/$defs/Date"
},
"turn": {
"$ref": "#/$defs/RunTurn"
}
},
"required": [
"label",
"operated_by",
"turn",
"started_on",
"claims"
]
}
},
"required": [
"kind",
"value"
]
schemas: regenerate the mind request and response wire schemas for the Pulse kind Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 06:01:43 +01:00
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "pulse"
},
"value": {
"type": "object",
"properties": {
"label": {
"$ref": "#/$defs/Label"
},
"tempo_vote_beat_s": {
"type": [
"integer",
"null"
],
"format": "uint32",
"minimum": 0
},
schemas: the pulse, request and response schemas re-derived for tempo_vote_withdrawn Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 09:07:01 +01:00
"tempo_vote_withdrawn": {
"type": "boolean",
"default": false
},
schemas: regenerate the mind request and response wire schemas for the Pulse kind Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 06:01:43 +01:00
"urgency_permille": {
"type": [
"integer",
"null"
],
"format": "uint16",
"maximum": 65535,
"minimum": 0
}
},
"required": [
"label"
]
}
},
"required": [
"kind",
"value"
]
memory: a persistent kind for what a Mind keeps (eureka-pipeline, huginn-mind) epiphany.pipeline.memory.v2, instance-rooted `<instance>:memory:<label>`: PipelineMemory with seven sorts (Asked, Decided, Committed, Learned, Did, Idea, Rapport), her own text, who it is about, where it was learned, whether directly, what it rests on, a salience that only ranks, and the memories a consolidating one replaces. Admission refuses a foreign instance and resolves a memory only Deferred to a follow-up (an ask taken on), Recorded, Withdrawn or Superseded by a memory. Memories have their own lineage so supersession stays within one mind. The read side selects by sort, about (multi-valued) and direct; the index carries the text; `consolidates` is a citation role. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 15:15:40 +01:00
},
{
"type": "object",
"properties": {
"kind": {
"type": "string",
"const": "memory"
},
"value": {
"type": "object",
"properties": {
"about": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
}
},
"label": {
"$ref": "#/$defs/Label"
},
memory: golden and schemas re-derived for origin Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 17:48:18 +01:00
"origin": {
"$ref": "#/$defs/MemoryOrigin"
memory: a persistent kind for what a Mind keeps (eureka-pipeline, huginn-mind) epiphany.pipeline.memory.v2, instance-rooted `<instance>:memory:<label>`: PipelineMemory with seven sorts (Asked, Decided, Committed, Learned, Did, Idea, Rapport), her own text, who it is about, where it was learned, whether directly, what it rests on, a salience that only ranks, and the memories a consolidating one replaces. Admission refuses a foreign instance and resolves a memory only Deferred to a follow-up (an ask taken on), Recorded, Withdrawn or Superseded by a memory. Memories have their own lineage so supersession stays within one mind. The read side selects by sort, about (multi-valued) and direct; the index carries the text; `consolidates` is a citation role. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 15:15:40 +01:00
},
"salience_permille": {
"type": "integer",
"format": "uint16",
"maximum": 65535,
"minimum": 0
},
"sort": {
"$ref": "#/$defs/MemorySort"
}
},
"required": [
"label",
"sort",
"about",
memory: golden and schemas re-derived for origin Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 17:48:18 +01:00
"origin",
memory: a persistent kind for what a Mind keeps (eureka-pipeline, huginn-mind) epiphany.pipeline.memory.v2, instance-rooted `<instance>:memory:<label>`: PipelineMemory with seven sorts (Asked, Decided, Committed, Learned, Did, Idea, Rapport), her own text, who it is about, where it was learned, whether directly, what it rests on, a salience that only ranks, and the memories a consolidating one replaces. Admission refuses a foreign instance and resolves a memory only Deferred to a follow-up (an ask taken on), Recorded, Withdrawn or Superseded by a memory. Memories have their own lineage so supersession stays within one mind. The read side selects by sort, about (multi-valued) and direct; the index carries the text; `consolidates` is a citation role. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 15:15:40 +01:00
"salience_permille"
]
}
},
"required": [
"kind",
"value"
]
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
}
]
},
"PipelineFinding": {
"type": "object",
"properties": {
"campaign": {
"$ref": "#/$defs/Slug"
},
"claim": {
"$ref": "#/$defs/Line"
},
"confidence": {
"$ref": "#/$defs/FindingConfidence"
},
"evidence": {
"type": "array",
"items": {
"$ref": "#/$defs/Evidence"
},
"maxItems": 16
},
"failure_scenario": {
"$ref": "#/$defs/Para"
},
"invariants": {
"type": "array",
"items": {
"$ref": "#/$defs/Label"
},
"maxItems": 8
},
"label": {
"$ref": "#/$defs/Label"
},
"locations": {
"type": "array",
"items": {
"$ref": "#/$defs/CodeLocation"
},
"maxItems": 16
},
"origin": {
"$ref": "#/$defs/FindingOrigin"
},
"precedents": {
"type": "array",
"items": {
"$ref": "#/$defs/ForeignRef"
},
"maxItems": 8
},
"range": {
"$ref": "#/$defs/CommitRange"
},
"severity": {
"$ref": "#/$defs/FindingSeverity"
},
"verdict": {
"$ref": "#/$defs/Short"
}
},
"required": [
"campaign",
"verdict",
"label",
"range",
"confidence",
"severity",
"claim",
"invariants",
"locations",
"failure_scenario",
"evidence",
"precedents",
"origin"
]
},
"PipelineFollowUp": {
"type": "object",
"properties": {
"campaign": {
"$ref": "#/$defs/Slug"
},
"item": {
"$ref": "#/$defs/Line"
},
"label": {
"$ref": "#/$defs/Label"
},
"locations": {
"type": "array",
"items": {
"$ref": "#/$defs/CodeLocation"
},
"maxItems": 16
},
"owner": {
"$ref": "#/$defs/Short"
},
"repo": {
"$ref": "#/$defs/OrgRepo"
},
"source": {
"$ref": "#/$defs/PipelineRef"
},
"why_it_can_wait": {
"$ref": "#/$defs/Line"
}
},
"required": [
"campaign",
"label",
"source",
"repo",
"locations",
"item",
"why_it_can_wait",
"owner"
]
},
"PipelineHandOff": {
"description": "A reassignment of stewardship, recorded in both minds. `documents` names\nwhat travels with it.",
"type": "object",
"properties": {
"documents": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 256
},
"from_instance": {
"$ref": "#/$defs/Slug"
},
"handed_on": {
"$ref": "#/$defs/Date"
},
"reason": {
"$ref": "#/$defs/Para"
},
"repo": {
"$ref": "#/$defs/OrgRepo"
},
"to_instance": {
"$ref": "#/$defs/Slug"
}
},
"required": [
"from_instance",
"to_instance",
"repo",
"documents",
"reason",
"handed_on"
]
},
"PipelineInstance": {
"description": "A mind's identity document. A store is canonical to exactly one\ninstance, and this says which; identity lives in the state, not in a\npath.",
"type": "object",
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"properties": {
"created_at": {
"$ref": "#/$defs/Date"
},
"display_name": {
"$ref": "#/$defs/Short"
},
"host": {
"$ref": "#/$defs/Short"
},
"instance": {
"$ref": "#/$defs/Slug"
}
},
"required": [
"instance",
"display_name",
"created_at",
"host"
]
},
"PipelineKind": {
"type": "string",
"enum": [
"Campaign",
"Target",
"Question",
"Ruling",
"CutSpec",
"CutReport",
"Verdict",
"Finding",
"FollowUp",
"Resolution",
"Instance",
"Stewardship",
Mind: run admission with AlreadyClaimed, the run resolution row, the claims edge A run's instance must be this mind. Every claim must name a document in force (MissingReference, CitesResolvedDocument); a claim held by another run in force is refused AlreadyClaimed { item, run }, so the claim is the one consumption fact. A byte-identical replay of an admitted run owes its claims no fresh freedom and answers AlreadyAdmitted. A run resolves Recorded or Withdrawn only. Runs cite their claims under role `claims`, so cites and cited selections reach them; the header facts carry label, operator, turn, start and claims. The published schemas that embed PipelineKind (finding, follow_up, question, resolution, ruling) and the two mind wire schemas are re-derived: the Run variant, PipelineFacts::Run, AlreadyClaimed and the claims role. The leaf commit before this one has those five stale. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 16:07:19 +02:00
"HandOff",
schemas: regenerate the mind request and response wire schemas for the Pulse kind Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 06:01:43 +01:00
"Run",
memory: a persistent kind for what a Mind keeps (eureka-pipeline, huginn-mind) epiphany.pipeline.memory.v2, instance-rooted `<instance>:memory:<label>`: PipelineMemory with seven sorts (Asked, Decided, Committed, Learned, Did, Idea, Rapport), her own text, who it is about, where it was learned, whether directly, what it rests on, a salience that only ranks, and the memories a consolidating one replaces. Admission refuses a foreign instance and resolves a memory only Deferred to a follow-up (an ask taken on), Recorded, Withdrawn or Superseded by a memory. Memories have their own lineage so supersession stays within one mind. The read side selects by sort, about (multi-valued) and direct; the index carries the text; `consolidates` is a citation role. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 15:15:40 +01:00
"Pulse",
"Memory"
]
},
"PipelineMemory": {
memory: golden and schemas re-derived for origin Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 17:48:18 +01:00
"description": "One thing a Mind keeps for herself, in her own mind: what she was asked,\ndecided, committed to, learned or did, an idea, or the rapport between\nher and another Mind or person. `text` is her own words. `about` names\nthe Matrix users it concerns (Minds included) and nothing about where it\ncame from; `origin` is where and from whom she learned it, and `sources`\nthe event ids, commits or documents it rests on; the organ fills both,\nnot the model. `salience_permille` ranks it and decides nothing.\n`consolidates` names the memories a consolidating memory replaces.\nInstance-rooted: the key is `<instance>:memory:<label>`.",
memory: a persistent kind for what a Mind keeps (eureka-pipeline, huginn-mind) epiphany.pipeline.memory.v2, instance-rooted `<instance>:memory:<label>`: PipelineMemory with seven sorts (Asked, Decided, Committed, Learned, Did, Idea, Rapport), her own text, who it is about, where it was learned, whether directly, what it rests on, a salience that only ranks, and the memories a consolidating one replaces. Admission refuses a foreign instance and resolves a memory only Deferred to a follow-up (an ask taken on), Recorded, Withdrawn or Superseded by a memory. Memories have their own lineage so supersession stays within one mind. The read side selects by sort, about (multi-valued) and direct; the index carries the text; `consolidates` is a citation role. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 15:15:40 +01:00
"type": "object",
"properties": {
"about": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 8
},
"consolidates": {
"type": "array",
"items": {
"$ref": "#/$defs/PipelineRef"
},
"maxItems": 16
},
"instance": {
"$ref": "#/$defs/Slug"
},
"label": {
"$ref": "#/$defs/Label"
},
memory: golden and schemas re-derived for origin Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 17:48:18 +01:00
"origin": {
"$ref": "#/$defs/MemoryOrigin"
memory: a persistent kind for what a Mind keeps (eureka-pipeline, huginn-mind) epiphany.pipeline.memory.v2, instance-rooted `<instance>:memory:<label>`: PipelineMemory with seven sorts (Asked, Decided, Committed, Learned, Did, Idea, Rapport), her own text, who it is about, where it was learned, whether directly, what it rests on, a salience that only ranks, and the memories a consolidating one replaces. Admission refuses a foreign instance and resolves a memory only Deferred to a follow-up (an ask taken on), Recorded, Withdrawn or Superseded by a memory. Memories have their own lineage so supersession stays within one mind. The read side selects by sort, about (multi-valued) and direct; the index carries the text; `consolidates` is a citation role. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 15:15:40 +01:00
},
"salience_permille": {
"type": "integer",
"format": "uint16",
"maximum": 65535,
"minimum": 0
},
"sort": {
"$ref": "#/$defs/MemorySort"
},
"sources": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 8
},
"text": {
"$ref": "#/$defs/Line"
}
},
"required": [
"instance",
"label",
"sort",
"text",
"about",
memory: golden and schemas re-derived for origin Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 17:48:18 +01:00
"origin",
memory: a persistent kind for what a Mind keeps (eureka-pipeline, huginn-mind) epiphany.pipeline.memory.v2, instance-rooted `<instance>:memory:<label>`: PipelineMemory with seven sorts (Asked, Decided, Committed, Learned, Did, Idea, Rapport), her own text, who it is about, where it was learned, whether directly, what it rests on, a salience that only ranks, and the memories a consolidating one replaces. Admission refuses a foreign instance and resolves a memory only Deferred to a follow-up (an ask taken on), Recorded, Withdrawn or Superseded by a memory. Memories have their own lineage so supersession stays within one mind. The read side selects by sort, about (multi-valued) and direct; the index carries the text; `consolidates` is a citation role. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 15:15:40 +01:00
"sources",
"salience_permille",
"consolidates"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
]
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"PipelinePageItems": {
"description": "The items of a page, chosen once by the selection's `projection`.",
"oneOf": [
{
"type": "object",
"properties": {
"Headers": {
"type": "array",
"items": {
"$ref": "#/$defs/PipelineDocumentSummary"
}
}
},
"additionalProperties": false,
"required": [
"Headers"
]
},
{
"type": "object",
"properties": {
"Documents": {
"type": "array",
"items": {
"$ref": "#/$defs/PipelineDocumentView"
}
}
},
"additionalProperties": false,
"required": [
"Documents"
]
}
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"PipelineProvenance": {
"description": "Who admitted a batch: the faculty, the agent, its session and the tool.\nA field on the receipt and nothing else; the digest excludes it.",
"type": "object",
"properties": {
"agent": {
"$ref": "#/$defs/Short"
},
"faculty": {
"$ref": "#/$defs/Faculty"
},
"session": {
"$ref": "#/$defs/Short"
},
"tool": {
"$ref": "#/$defs/Short"
}
},
"required": [
"faculty",
"agent",
"session",
"tool"
]
},
schemas: regenerate the mind request and response wire schemas for the Pulse kind Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 06:01:43 +01:00
"PipelinePulse": {
schemas: the pulse, request and response schemas re-derived for tempo_vote_withdrawn Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 09:07:01 +01:00
"description": "One Mind's heartbeat vote, in her own mind: the beat she wants (the swarm's\ntempo is the lower median of every Mind's newest vote), the withdrawal of\nher standing vote (`tempo_vote_withdrawn`, an explicit null: she counts as\nsilent again), and the urgency she declares for herself until her next\nPersona turn. A pulse says at least one of the three; a withdrawal and a\nbeat are never both. Instance-rooted: the key is `<instance>:pulse:<label>`, the label\ntime-ordered like a run's.",
schemas: regenerate the mind request and response wire schemas for the Pulse kind Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 06:01:43 +01:00
"type": "object",
"properties": {
"instance": {
"$ref": "#/$defs/Slug"
},
"label": {
"$ref": "#/$defs/Label"
},
"note": {
"$ref": "#/$defs/Line"
},
"tempo_vote_beat_s": {
"type": [
"integer",
"null"
],
"format": "uint32",
"minimum": 0
},
schemas: the pulse, request and response schemas re-derived for tempo_vote_withdrawn Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 09:07:01 +01:00
"tempo_vote_withdrawn": {
"type": "boolean"
},
schemas: regenerate the mind request and response wire schemas for the Pulse kind Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 06:01:43 +01:00
"urgency_permille": {
"type": [
"integer",
"null"
],
"format": "uint16",
"maximum": 65535,
"minimum": 0
}
},
"required": [
"instance",
"label",
"note"
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"PipelineQuestion": {
"type": "object",
"properties": {
"asked_on": {
"$ref": "#/$defs/Date"
},
"campaign": {
"$ref": "#/$defs/Slug"
},
"depends": {
"type": "array",
"items": {
"$ref": "#/$defs/Line"
},
"maxItems": 8
},
"label": {
"$ref": "#/$defs/Label"
},
"options": {
"type": "array",
"items": {
"$ref": "#/$defs/QuestionOption"
},
"maxItems": 8
},
"question": {
"$ref": "#/$defs/Para"
},
"raised_in": {
"anyOf": [
{
"$ref": "#/$defs/PipelineRef"
},
{
"type": "null"
}
]
},
"recommended": {
"$ref": "#/$defs/Label"
BP-2: move Huginn to CultLib 6251cbc and the RS-L leaf 4891f2e5 One pin move: huginn-mind pins cultcache-rs at 6251cbc and the leaf at 4891f2e5; huginn-daemon pins cultnet-rs at 6251cbc. cargo tree shows one cultcache-rs and one cultnet-rs per crate. Adopting RS-L, which the new leaf carries: - Campaign, cut-spec, question and ruling fixtures carry a Title; the question and ruling fixtures gain the new required title field. - The epoch literals in daemon and envelope tests move v1 -> v2. A store written at an earlier epoch is refused at open (ForeignEpoch); no key migration. - Derived stewardship, hand-off and resolution keys are now the lowercased OrgRepo::identity(); test key literals follow. - The two published wire schemas are regenerated (Title, OrgRepo bound and description); the byte-for-byte pin test passes. CultLib 6251cbc gives CultNetMessage::Error code and details; the four construction sites and one pattern in huginn-daemon take None and `..`. No behaviour change: None is skipped on the wire. mind 70 and daemon 18 pass. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 03:56:03 +02:00
},
"title": {
"$ref": "#/$defs/Title"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
}
},
"required": [
"campaign",
"label",
BP-2: move Huginn to CultLib 6251cbc and the RS-L leaf 4891f2e5 One pin move: huginn-mind pins cultcache-rs at 6251cbc and the leaf at 4891f2e5; huginn-daemon pins cultnet-rs at 6251cbc. cargo tree shows one cultcache-rs and one cultnet-rs per crate. Adopting RS-L, which the new leaf carries: - Campaign, cut-spec, question and ruling fixtures carry a Title; the question and ruling fixtures gain the new required title field. - The epoch literals in daemon and envelope tests move v1 -> v2. A store written at an earlier epoch is refused at open (ForeignEpoch); no key migration. - Derived stewardship, hand-off and resolution keys are now the lowercased OrgRepo::identity(); test key literals follow. - The two published wire schemas are regenerated (Title, OrgRepo bound and description); the byte-for-byte pin test passes. CultLib 6251cbc gives CultNetMessage::Error code and details; the four construction sites and one pattern in huginn-daemon take None and `..`. No behaviour change: None is skipped on the wire. mind 70 and daemon 18 pass. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 03:56:03 +02:00
"title",
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"question",
"options",
"recommended",
"depends",
"asked_on"
]
},
"PipelineRef": {
"description": "A reference to another document. The id is parsed as a full pipeline id of\nthe declared `kind`, so the kind and the id's kind segment cannot disagree.",
"type": "object",
"properties": {
"id": {
"$ref": "#/$defs/Short"
},
"kind": {
"$ref": "#/$defs/PipelineKind"
}
},
"required": [
"kind",
"id"
]
},
"PipelineRefusal": {
"description": "Typed refusals of the pipeline documents: bounds, formats and key identity\n(D2's document half), and `ForeignStore`, raised by `decode` for an\nenvelope of any other type. This is every refusal the leaf decides; a\nstore's identity and its schema epoch are not decided here, since this\ncrate owns no store, and belong to the organ that will admit these\ndocuments.\n\nSerialised externally tagged, serde's default for an enum: each variant is\na one-key map from the variant's name to its named fields, so `field` and\n`value` are on the wire under their own names and a reader of a refusal\ncarried over a wire reads the same parts a local caller matches on. No\nattribute buys that, which is why there is none: an internal or adjacent\ntag would move the fields under a content key without making any of them\nmore visible.",
"oneOf": [
{
"type": "object",
"properties": {
"FieldBound": {
"type": "object",
"properties": {
"actual": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"field": {
"type": "string"
},
"limit": {
"type": "integer",
"format": "uint32",
"minimum": 0
}
},
"required": [
"field",
"limit",
"actual"
]
}
},
"additionalProperties": false,
"required": [
"FieldBound"
]
},
{
"type": "object",
"properties": {
"InvalidFormat": {
"type": "object",
"properties": {
"field": {
"type": "string"
},
"value": {
"type": "string"
}
},
"required": [
"field",
"value"
]
}
},
"additionalProperties": false,
"required": [
"InvalidFormat"
]
},
{
"type": "object",
"properties": {
"InvalidIdentity": {
"type": "object",
"properties": {
"expected": {
"type": "string"
},
"key": {
"type": "string"
},
"kind": {
"$ref": "#/$defs/PipelineKind"
}
},
"required": [
"kind",
"key",
"expected"
]
}
},
"additionalProperties": false,
"required": [
"InvalidIdentity"
]
},
BP-2: move Huginn to CultLib 6251cbc and the RS-L leaf 4891f2e5 One pin move: huginn-mind pins cultcache-rs at 6251cbc and the leaf at 4891f2e5; huginn-daemon pins cultnet-rs at 6251cbc. cargo tree shows one cultcache-rs and one cultnet-rs per crate. Adopting RS-L, which the new leaf carries: - Campaign, cut-spec, question and ruling fixtures carry a Title; the question and ruling fixtures gain the new required title field. - The epoch literals in daemon and envelope tests move v1 -> v2. A store written at an earlier epoch is refused at open (ForeignEpoch); no key migration. - Derived stewardship, hand-off and resolution keys are now the lowercased OrgRepo::identity(); test key literals follow. - The two published wire schemas are regenerated (Title, OrgRepo bound and description); the byte-for-byte pin test passes. CultLib 6251cbc gives CultNetMessage::Error code and details; the four construction sites and one pattern in huginn-daemon take None and `..`. No behaviour change: None is skipped on the wire. mind 70 and daemon 18 pass. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 03:56:03 +02:00
{
"type": "object",
"properties": {
"DuplicateRepo": {
"type": "object",
"properties": {
"field": {
"type": "string"
},
"repo": {
"type": "string"
}
},
"required": [
"field",
"repo"
]
}
},
"additionalProperties": false,
"required": [
"DuplicateRepo"
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
{
"type": "object",
"properties": {
"ForeignStore": {
"type": "object",
"properties": {
"type": {
"type": "string"
}
},
"required": [
"type"
]
}
},
"additionalProperties": false,
"required": [
"ForeignStore"
]
}
]
},
"PipelineResolution": {
"description": "The record of how a subject was closed and by what. `sequence` is per\nsubject and set by the writer, `1` for the first, and it is the last\npart of the key, so a subject's resolutions share a prefix and a\nwithdrawn one is kept under its subject rather than overwritten.\nWhether a sequence is the previous plus one, and whether an earlier\nresolution still stands, are admission's rules: this crate refuses\nneither `0` nor a gap, exactly as it refuses neither `revision: 0` nor\na `revision` with no predecessor.",
"type": "object",
"properties": {
"outcome": {
"$ref": "#/$defs/ResolutionOutcome"
},
"rationale": {
"$ref": "#/$defs/Para"
},
"resolved_on": {
"$ref": "#/$defs/Date"
},
"sequence": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"subject": {
"$ref": "#/$defs/PipelineRef"
}
},
"required": [
"subject",
"sequence",
"outcome",
"rationale",
"resolved_on"
]
},
"PipelineRuling": {
"type": "object",
"properties": {
"answers": {
"anyOf": [
{
"$ref": "#/$defs/Short"
},
{
"type": "null"
}
]
},
"authority": {
"$ref": "#/$defs/RulingAuthority"
},
"campaign": {
"$ref": "#/$defs/Slug"
},
"choice": {
"anyOf": [
{
"$ref": "#/$defs/Label"
},
{
"type": "null"
}
]
},
"label": {
"$ref": "#/$defs/Label"
},
"operator_quote": {
"anyOf": [
{
"$ref": "#/$defs/Para"
},
{
"type": "null"
}
]
},
"precedents": {
"type": "array",
"items": {
"$ref": "#/$defs/ForeignRef"
},
"maxItems": 8
},
"ruled_on": {
"$ref": "#/$defs/Date"
},
"ruling": {
"$ref": "#/$defs/Para"
BP-2: move Huginn to CultLib 6251cbc and the RS-L leaf 4891f2e5 One pin move: huginn-mind pins cultcache-rs at 6251cbc and the leaf at 4891f2e5; huginn-daemon pins cultnet-rs at 6251cbc. cargo tree shows one cultcache-rs and one cultnet-rs per crate. Adopting RS-L, which the new leaf carries: - Campaign, cut-spec, question and ruling fixtures carry a Title; the question and ruling fixtures gain the new required title field. - The epoch literals in daemon and envelope tests move v1 -> v2. A store written at an earlier epoch is refused at open (ForeignEpoch); no key migration. - Derived stewardship, hand-off and resolution keys are now the lowercased OrgRepo::identity(); test key literals follow. - The two published wire schemas are regenerated (Title, OrgRepo bound and description); the byte-for-byte pin test passes. CultLib 6251cbc gives CultNetMessage::Error code and details; the four construction sites and one pattern in huginn-daemon take None and `..`. No behaviour change: None is skipped on the wire. mind 70 and daemon 18 pass. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 03:56:03 +02:00
},
"title": {
"$ref": "#/$defs/Title"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
}
},
"required": [
"campaign",
"label",
BP-2: move Huginn to CultLib 6251cbc and the RS-L leaf 4891f2e5 One pin move: huginn-mind pins cultcache-rs at 6251cbc and the leaf at 4891f2e5; huginn-daemon pins cultnet-rs at 6251cbc. cargo tree shows one cultcache-rs and one cultnet-rs per crate. Adopting RS-L, which the new leaf carries: - Campaign, cut-spec, question and ruling fixtures carry a Title; the question and ruling fixtures gain the new required title field. - The epoch literals in daemon and envelope tests move v1 -> v2. A store written at an earlier epoch is refused at open (ForeignEpoch); no key migration. - Derived stewardship, hand-off and resolution keys are now the lowercased OrgRepo::identity(); test key literals follow. - The two published wire schemas are regenerated (Title, OrgRepo bound and description); the byte-for-byte pin test passes. CultLib 6251cbc gives CultNetMessage::Error code and details; the four construction sites and one pattern in huginn-daemon take None and `..`. No behaviour change: None is skipped on the wire. mind 70 and daemon 18 pass. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 03:56:03 +02:00
"title",
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"ruling",
"ruled_on",
"precedents",
"authority"
]
},
Mind: run admission with AlreadyClaimed, the run resolution row, the claims edge A run's instance must be this mind. Every claim must name a document in force (MissingReference, CitesResolvedDocument); a claim held by another run in force is refused AlreadyClaimed { item, run }, so the claim is the one consumption fact. A byte-identical replay of an admitted run owes its claims no fresh freedom and answers AlreadyAdmitted. A run resolves Recorded or Withdrawn only. Runs cite their claims under role `claims`, so cites and cited selections reach them; the header facts carry label, operator, turn, start and claims. The published schemas that embed PipelineKind (finding, follow_up, question, resolution, ruling) and the two mind wire schemas are re-derived: the Run variant, PipelineFacts::Run, AlreadyClaimed and the claims role. The leaf commit before this one has those five stale. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 16:07:19 +02:00
"PipelineRun": {
"description": "One launch of a Self or a Persona turn: the one record of what it took\non. `claims` are the work it holds, and a claim is live while its run\nhas no resolution in force. `budget_usd` is a canonical decimal string,\n`0` for an interactive run. Instance-rooted like stewardship: the key\nis `<instance>:run:<label>`. Whether a claim is free is admission's rule.",
"type": "object",
"properties": {
"budget_usd": {
"$ref": "#/$defs/Short"
},
"campaigns": {
"type": "array",
"items": {
"$ref": "#/$defs/Slug"
},
"maxItems": 8
},
"claims": {
"type": "array",
"items": {
"$ref": "#/$defs/PipelineRef"
},
"maxItems": 64
},
"host": {
"$ref": "#/$defs/Short"
},
"instance": {
"$ref": "#/$defs/Slug"
},
"label": {
"$ref": "#/$defs/Label"
},
"operated_by": {
"$ref": "#/$defs/RunOperator"
},
"started_on": {
"$ref": "#/$defs/Date"
},
"turn": {
"$ref": "#/$defs/RunTurn"
}
},
"required": [
"instance",
"label",
"operated_by",
"turn",
"host",
"started_on",
"budget_usd",
"claims",
"campaigns"
]
},
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"PipelineSelectionPage": {
A semantic query returns up to top_k members of its selection, with scores The mind decides membership (Mind::members) before the index is asked; the index scores exactly the members (Qdrant has_id + exact) and the page carries one cosine score per row. Deletes OVERSAMPLE_MAX, the x4 oversample, the unfiltered VectorIndex::search contract and check_semantic. Not yet compiled when committed: the first Yggdrasil run follows. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 19:51:29 +01:00
"description": "One page of a selection. `matched` is the count before paging, `as_of` the\nsnapshot the page and every cursor of its walk are exact as of, `edges`\nis present exactly when the selection follows a hop, and `scores` exactly\nwhen the answer is semantic: one cosine similarity per item, in order\n(higher is nearer), for display and thresholding. It is never stored.",
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
"type": "object",
"properties": {
"as_of": {
"type": "integer",
"format": "uint64",
"minimum": 0
},
"edges": {
"type": [
"array",
"null"
],
"items": {
"$ref": "#/$defs/PipelineEdge"
}
},
"items": {
"$ref": "#/$defs/PipelinePageItems"
},
"matched": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"next": {
"type": [
"string",
"null"
]
A semantic query returns up to top_k members of its selection, with scores The mind decides membership (Mind::members) before the index is asked; the index scores exactly the members (Qdrant has_id + exact) and the page carries one cosine score per row. Deletes OVERSAMPLE_MAX, the x4 oversample, the unfiltered VectorIndex::search contract and check_semantic. Not yet compiled when committed: the first Yggdrasil run follows. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 19:51:29 +01:00
},
"scores": {
"type": [
"array",
"null"
],
"items": {
"type": "number",
"format": "float"
}
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
}
},
"required": [
"matched",
"as_of",
"items"
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"PipelineStatus": {
"description": "Whether a document still stands, and if not, what closed it. Derived at\nread time; no document carries a status field and no admission writes one.\nThe whole closing record travels, not only its outcome, because a reader\nrehydrating wants why.",
"oneOf": [
{
"type": "string",
"enum": [
"InForce"
]
},
{
"type": "object",
"properties": {
"Resolved": {
"type": "object",
"properties": {
"record": {
"$ref": "#/$defs/PipelineResolution"
},
"resolution": {
"$ref": "#/$defs/PipelineRef"
}
},
"required": [
"resolution",
"record"
]
RS-3 2: the read side is CultNet's selection over the organ's rows The four hand-written filters, the order and the cap are deleted: PipelineQuery, PipelineQueryPage, QUERY_LIMIT_MAX, Reader::matches, ordered, repo_matches. Mind::query(selection, semantic) validates through cultnet_rs::validate, closes the values door (rows.rs refuse_values, S6), takes the snapshot from the cursor's own asOf (an asOf beyond the head is CursorInvalid), builds Reader::at(as_of) so every derivation runs over the documents admitted at or before it, and evaluates through cultnet_rs::select. The page carries matched, asOf, the next cursor, headers or whole views by projection, and typed edges when the selection hops. rows.rs is the organ's vocabulary: SelectionRow (a Row), Vocabulary (a RowSet: thirteen schemas, eleven aliases, fifteen roles) and the value door. huginn-mind links cultnet-rs at the rev the daemon pins. Selection refusals map totally onto SelectionInvalid, CursorInvalid or Unavailable. The wire's Query carries CultLib's selection by $ref, and both published schemas are regenerated. The relations RS-2 unpinned are re-pinned as selections. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 05:56:37 +02:00
}
},
"additionalProperties": false,
"required": [
"Resolved"
]
}
]
},
"PipelineStatusSummary": {
"description": "Whether a summarised document stands: the closing record's outcome, not its\nrationale. A caller who wants why opens the resolution.",
"oneOf": [
{
"type": "string",
"enum": [
"InForce"
]
},
{
"type": "object",
"properties": {
"Resolved": {
"type": "object",
"properties": {
"outcome": {
"$ref": "#/$defs/ResolutionOutcome"
},
"resolution": {
"$ref": "#/$defs/PipelineRef"
}
},
"required": [
"resolution",
"outcome"
]
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
}
},
"additionalProperties": false,
"required": [
"Resolved"
]
}
]
},
"PipelineStewardship": {
"description": "Stewardship over a repo, as an assignment recorded in a mind. One\ninstance may steward several repos, so the repo is part of the key.\n`sequence` is per `(instance, repo)`, set by the writer, `1` for the\nfirst, so a repo transferred away and back is two records under one\nprefix rather than one document overwriting the other. `assigned_on`\nis a field, not a key part. As on a resolution, whether the sequence\nis the previous plus one, and which assignment is in force, are\nadmission's rules and not this crate's.",
"type": "object",
"properties": {
"assigned_on": {
"$ref": "#/$defs/Date"
},
"instance": {
"$ref": "#/$defs/Slug"
},
"note": {
"$ref": "#/$defs/Line"
},
"repo": {
"$ref": "#/$defs/OrgRepo"
},
"sequence": {
"type": "integer",
"format": "uint32",
"minimum": 0
}
},
"required": [
"instance",
"repo",
"sequence",
"assigned_on",
"note"
]
},
"PipelineTarget": {
campaign-repos: a campaign's repo set changes by target revision; one line_of decides supersession lineage (squash of eureka-substrate/campaign-repos c0a1f2c..4442e1a) target.repos additive at epoch v2; Docs::repos_in_force owns membership; line_of owns lineage (targets per campaign, cut_specs per campaign+cut, stewardships per instance+repo, rulings and follow_ups global); rival_in_force owns one-assignment-in-force. Soul s5 holds (eureka-substrate:verdict:cut-campaign-repos.s5). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 23:38:20 +02:00
"description": "`repos`, when non-empty, is the campaign's whole repo set from this\nrevision on; empty keeps the previous set (ruling campaign-repo-set-home).",
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"type": "object",
"properties": {
"campaign": {
"$ref": "#/$defs/Slug"
},
"canonical_implementations": {
"type": "array",
"items": {
"$ref": "#/$defs/Line"
},
"maxItems": 16
},
"doc": {
"$ref": "#/$defs/DocRef"
},
"invariants": {
"type": "array",
"items": {
"$ref": "#/$defs/TargetInvariant"
},
"maxItems": 32
},
"not_in_scope": {
"type": "array",
"items": {
"$ref": "#/$defs/Line"
},
"maxItems": 32
},
campaign-repos: a campaign's repo set changes by target revision; one line_of decides supersession lineage (squash of eureka-substrate/campaign-repos c0a1f2c..4442e1a) target.repos additive at epoch v2; Docs::repos_in_force owns membership; line_of owns lineage (targets per campaign, cut_specs per campaign+cut, stewardships per instance+repo, rulings and follow_ups global); rival_in_force owns one-assignment-in-force. Soul s5 holds (eureka-substrate:verdict:cut-campaign-repos.s5). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 23:38:20 +02:00
"repos": {
"type": "array",
"items": {
"$ref": "#/$defs/OrgRepo"
},
"maxItems": 16
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"revision": {
"type": "integer",
"format": "uint32",
"minimum": 0
}
},
"required": [
"campaign",
"revision",
"invariants",
"not_in_scope",
"canonical_implementations",
"doc"
]
},
"PipelineVerdict": {
"type": "object",
"properties": {
"campaign": {
"$ref": "#/$defs/Slug"
},
"claims": {
"type": "array",
"items": {
"$ref": "#/$defs/VerdictClaim"
},
"maxItems": 64
},
"cut_report": {
"$ref": "#/$defs/Short"
},
"pass": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"range": {
"$ref": "#/$defs/CommitRange"
}
},
"required": [
"campaign",
"cut_report",
"pass",
"range",
"claims"
]
},
repo-activity: a Mind hears of changes in her stewarded repos, on her first line and by one organ notice on change; a repo the anonymous read cannot reach is named, never a failed read (squash of hands/eureka-body-repo-activity 5a294ed..eee0b14; Soul s1-s4) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 04:54:26 +01:00
"PrAction": {
"description": "What a pull-request event did. The words are the forge's op names, nothing\na person wrote.",
"type": "string",
"enum": [
"Opened",
"Merged",
"Closed",
"Reopened",
"Commented",
"Approved",
"Rejected",
"AutoMerge"
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"Promise": {
"description": "A promise a report makes about what it landed. Not a document and not\nresolvable: it is identified by its report's id and its label, as a\n`TargetInvariant` is by its target's. Soul measures every one (ruling\nA), and the rule that every one is measured is admission's.",
"type": "object",
"properties": {
"label": {
"$ref": "#/$defs/Label"
},
"text": {
"$ref": "#/$defs/Line"
}
},
"required": [
"label",
"text"
]
},
"QuestionOption": {
"type": "object",
"properties": {
"label": {
"$ref": "#/$defs/Label"
},
"text": {
"$ref": "#/$defs/Line"
}
},
"required": [
"label",
"text"
]
},
Golden lines and published schemas derived for CodeLocation.symbol and CutSpec.reads Two golden lines appended (dumped by golden_dump on Yggdrasil at 44c010c; numstat 3 added, 0 deleted against the base) and the six schemas regenerated from the types. Builds; with 44c010c the workspace tests are expected to pass. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 21:12:25 +02:00
"ReadAnchor": {
"description": "Code Hands must see but not change, in the spec's repo at the spec's base.",
"type": "object",
"properties": {
"location": {
"$ref": "#/$defs/CodeLocation"
},
"why": {
"$ref": "#/$defs/Short"
}
},
"required": [
"location",
"why"
]
},
repo-activity: a Mind hears of changes in her stewarded repos, on her first line and by one organ notice on change; a repo the anonymous read cannot reach is named, never a failed read (squash of hands/eureka-body-repo-activity 5a294ed..eee0b14; Soul s1-s4) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 04:54:26 +01:00
"RepoActivity": {
"description": "The answer to an activity read. `events` are other people's changes only,\nthe asker's own login already dropped, and on a read with no `after` only\nthose of the last 72 hours: the reader filters nothing again. `head` is the\nnewest feed id the read saw in those repos, whether or not any event\nsurvived the filter, an entry older than the window too: the cursor to ask\n`after` next. `capped` names the repos whose feed the read stopped reading at its page limit: their older entries were not read.\n`open_prs` comes only on a read with no `after`; `unseen` and `moved` come on every read, because a repo can go dark in the middle of a session.",
"type": "object",
"properties": {
"capped": {
"type": "array",
"items": {
"$ref": "#/$defs/OrgRepo"
}
},
"events": {
"type": "array",
"items": {
"$ref": "#/$defs/RepoEvent"
}
},
"head": {
"type": "integer",
"format": "uint64",
"minimum": 0
},
"moved": {
"description": "Of those, the ones whose feed answered a redirect to the forge's own feed route for another repo. The redirect is not followed; a `Location` that is anything else names nothing.",
"type": "array",
"items": {
"$ref": "#/$defs/RepoMoved"
}
},
"open_prs": {
"type": "array",
"items": {
"$ref": "#/$defs/OpenPr"
}
},
"unseen": {
"description": "Repos asked about that the anonymous read cannot see: their feed answered 404 or a redirect, and on a read with no `after` the org listing does not hold them either. A repo the listing holds whose feed is dark, and a read with an `after` in which every repo is dark, are not told here: they fail the read.",
"type": "array",
"items": {
"$ref": "#/$defs/OrgRepo"
}
}
},
"required": [
"head",
"events",
"capped",
"open_prs",
"unseen",
"moved"
]
},
"RepoChange": {
"description": "What an event was. No field carries text a person wrote: a title, a comment\nor a commit message is another person's word and has no place here.",
"oneOf": [
{
"description": "A push to the repo's default branch of `commits` commits.",
"type": "object",
"properties": {
"Pushed": {
"type": "object",
"properties": {
"commits": {
"type": "integer",
"format": "uint32",
"minimum": 0
}
},
"required": [
"commits"
]
}
},
"additionalProperties": false,
"required": [
"Pushed"
]
},
{
"type": "object",
"properties": {
"Pr": {
"type": "object",
"properties": {
"action": {
"$ref": "#/$defs/PrAction"
},
"number": {
"type": "integer",
"format": "uint32",
"minimum": 0
}
},
"required": [
"number",
"action"
]
}
},
"additionalProperties": false,
"required": [
"Pr"
]
}
]
},
"RepoEvent": {
"description": "One thing someone else did in a repo of the asker's.",
"type": "object",
"properties": {
"actor": {
"description": "The forge login that did it.",
"$ref": "#/$defs/Short"
},
"at": {
"description": "When it happened, Unix milliseconds.",
"type": "integer",
"format": "uint64",
"minimum": 0
},
"change": {
"$ref": "#/$defs/RepoChange"
},
"id": {
"description": "The forge's own monotonic feed id.",
"type": "integer",
"format": "uint64",
"minimum": 0
},
"repo": {
"$ref": "#/$defs/OrgRepo"
}
},
"required": [
"id",
"at",
"repo",
"actor",
"change"
]
},
"RepoMoved": {
"description": "A redirect the forge answered for a repo's feed: it points at `to`.",
"type": "object",
"properties": {
"from": {
"$ref": "#/$defs/OrgRepo"
},
"to": {
"$ref": "#/$defs/OrgRepo"
}
},
"required": [
"from",
"to"
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"ReportCommit": {
"type": "object",
"properties": {
"builds": {
"type": "boolean"
},
"sha": {
"$ref": "#/$defs/Sha"
},
"subject": {
"$ref": "#/$defs/Line"
}
},
"required": [
"sha",
"subject",
"builds"
]
},
"ResolutionOutcome": {
"description": "How a subject was resolved. Every referent is a parsed `PipelineRef`, so a\nresolution names its records by ids of the kinds they declare, validated\nwhere every other referent is; a `Fixed` commit is a `Sha` whose referent\nis outside the document set (ruling B). Whether a named document exists,\nand how many may supersede one subject, are admission's rules.",
"oneOf": [
{
"description": "Overturned, in whole or in part, by later records. The list is bounded\nhere because the enum is outside `value_types!`, the only place a list\nmaximum is emitted automatically.",
"type": "object",
"properties": {
"Superseded": {
"type": "object",
"properties": {
"by": {
"type": "array",
"items": {
"$ref": "#/$defs/PipelineRef"
},
"maxItems": 8
}
},
"required": [
"by"
]
}
},
"additionalProperties": false,
"required": [
"Superseded"
]
},
{
"type": "object",
"properties": {
"Answered": {
"type": "object",
"properties": {
"by": {
"$ref": "#/$defs/PipelineRef"
}
},
"required": [
"by"
]
}
},
"additionalProperties": false,
"required": [
"Answered"
]
},
{
"type": "object",
"properties": {
"Fixed": {
"type": "object",
"properties": {
"by": {
"anyOf": [
{
"$ref": "#/$defs/PipelineRef"
},
{
"type": "null"
}
]
},
"commit": {
"$ref": "#/$defs/Sha"
}
},
"required": [
"commit"
]
}
},
"additionalProperties": false,
"required": [
"Fixed"
]
},
{
"type": "object",
"properties": {
"Deferred": {
"type": "object",
"properties": {
"to": {
"$ref": "#/$defs/PipelineRef"
}
},
"required": [
"to"
]
}
},
"additionalProperties": false,
"required": [
"Deferred"
]
},
{
"type": "object",
"properties": {
"Recorded": {
"type": "object",
"properties": {
"reason": {
"$ref": "#/$defs/Line"
}
},
"required": [
"reason"
]
}
},
"additionalProperties": false,
"required": [
"Recorded"
]
},
{
"type": "object",
"properties": {
"Withdrawn": {
"type": "object",
"properties": {
"reason": {
"$ref": "#/$defs/Line"
}
},
"required": [
"reason"
]
}
},
"additionalProperties": false,
"required": [
"Withdrawn"
]
}
]
},
wear-facts: a Mind's first line shows the wear her own mind holds, specs with no report, open Soul findings and quiet campaigns on what she stewards, each leading to a record she can open (squash of hands/eureka-body-wear-facts ab61a53..6014554; Soul s1-s2) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 07:06:16 +01:00
"RootTouched": {
"description": "A root of the mind and the newest admission under it. `repos` is the repo set in force of a root that is an in-force campaign,\nand empty for any other root.",
"type": "object",
"properties": {
"admitted_at": {
"type": "string"
},
"ordinal": {
"type": "integer",
"format": "uint64",
"minimum": 1
},
"repos": {
"type": "array",
"items": {
"$ref": "#/$defs/OrgRepo"
}
},
"root": {
"$ref": "#/$defs/Slug"
}
},
"required": [
"root",
"admitted_at",
"ordinal",
"repos"
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"RulingAuthority": {
"type": "string",
"enum": [
"Operator",
"Standing",
RulingAuthority gains Mind: a ruling the Mind's Self makes is its own word Additive unit-enum variant; schemas regenerated by derivation. The query alias domain now derives from the enum (unit_enums! exposes NAMES), so the second authority list in huginn-mind rows.rs is gone. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 15:35:22 +02:00
"Defaulted",
"Mind"
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
]
},
huginn-mind: published response schema carries RunId Regenerated from schema_for!(HuginnMindResponse) as the wire test derives it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-10 05:18:38 +02:00
"RunId": {
"description": "The id of a run: a full pipeline id of kind Run. A refusal that names a\nholder carries one, so a reader gets a run's id from the wire only if it\nparses as one; a peer cannot fill it with any other string. The only ways\nin are `TryFrom<String>`, which every deserialized value passes, and the\nadmission rules, which name a run the mind holds. The error is a fixed\nmessage: it never echoes the offered value.",
"type": "string"
},
Mind: run admission with AlreadyClaimed, the run resolution row, the claims edge A run's instance must be this mind. Every claim must name a document in force (MissingReference, CitesResolvedDocument); a claim held by another run in force is refused AlreadyClaimed { item, run }, so the claim is the one consumption fact. A byte-identical replay of an admitted run owes its claims no fresh freedom and answers AlreadyAdmitted. A run resolves Recorded or Withdrawn only. Runs cite their claims under role `claims`, so cites and cited selections reach them; the header facts carry label, operator, turn, start and claims. The published schemas that embed PipelineKind (finding, follow_up, question, resolution, ruling) and the two mind wire schemas are re-derived: the Run variant, PipelineFacts::Run, AlreadyClaimed and the claims role. The leaf commit before this one has those five stale. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 16:07:19 +02:00
"RunOperator": {
"type": "string",
"enum": [
"Operator",
"Mind"
]
},
"RunTurn": {
"type": "string",
"enum": [
"PersonaTurn",
"SelfRun"
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"Sha": {
"description": "A git commit id: 7-40 lowercase hex characters.",
"type": "string",
"maxLength": 40
},
"Sha256Hex": {
"description": "A SHA-256 digest: exactly 64 lowercase hex characters.",
"type": "string",
"maxLength": 64
},
"Short": {
"description": "Text of at most 200 UTF-8 bytes.",
"type": "string",
"maxLength": 200
},
"Slug": {
"description": "A campaign slug or key segment: label parts joined by `.`.",
"type": "string",
"maxLength": 64
},
schemas: publish SearchSources and Sources (derived from the wire types) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 06:36:57 +01:00
"SourceHit": {
"description": "One chunk the index holds, as the index holds it: the repo it belongs to,\nthe path in that repo, the commit whose blob it was cut from, its 1-based\ninclusive line range, and its text.",
"type": "object",
"properties": {
"commit": {
"type": "string"
},
"line_end": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"line_start": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"path": {
"type": "string"
},
"repo": {
"type": "string"
},
"score": {
"type": "number",
"format": "float"
},
"text": {
"type": "string"
}
},
"required": [
"repo",
"path",
"commit",
"line_start",
"line_end",
"score",
"text"
]
},
"SourceHits": {
"description": "The answer to a source search, nearest first.",
"type": "object",
"properties": {
"hits": {
"type": "array",
"items": {
"$ref": "#/$defs/SourceHit"
}
},
"indexed_under": {
"$ref": "#/$defs/SourceModel"
}
},
"required": [
"indexed_under",
"hits"
]
},
"SourceModel": {
"description": "The model a source collection was built under, and so the one a query must\nbe embedded by. The address of the embedder is no part of it.",
"type": "object",
"properties": {
"digest": {
"type": "string"
},
"name": {
"type": "string"
}
},
"required": [
"name",
"digest"
]
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"StructuralDelta": {
"type": "object",
"properties": {
"dependencies_added": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 64
},
"dependencies_removed": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 64
},
"formats_added": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 64
},
"formats_removed": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 64
},
"lines_added": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"lines_removed": {
"type": "integer",
"format": "uint32",
"minimum": 0
},
"targets_added": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 64
},
"targets_removed": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 64
}
},
"required": [
"lines_added",
"lines_removed",
"dependencies_added",
"dependencies_removed",
"formats_added",
"formats_removed",
"targets_added",
"targets_removed"
]
},
Golden lines and published schemas derived for CodeLocation.symbol and CutSpec.reads Two golden lines appended (dumped by golden_dump on Yggdrasil at 44c010c; numstat 3 added, 0 deleted against the base) and the six schemas regenerated from the types. Builds; with 44c010c the workspace tests are expected to pass. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-09 21:12:25 +02:00
"Symbol": {
"description": "A name the location's lines must contain as written there (an\nidentifier or a YAML `&fileID`); not an identity. 1 to 128 bytes, no\nwhitespace and no control character.",
"type": "string",
"maxLength": 128,
"minLength": 1
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"TargetInvariant": {
"type": "object",
"properties": {
"label": {
"$ref": "#/$defs/Label"
},
"statement": {
"$ref": "#/$defs/Line"
}
},
"required": [
"label",
"statement"
]
},
BP-2: move Huginn to CultLib 6251cbc and the RS-L leaf 4891f2e5 One pin move: huginn-mind pins cultcache-rs at 6251cbc and the leaf at 4891f2e5; huginn-daemon pins cultnet-rs at 6251cbc. cargo tree shows one cultcache-rs and one cultnet-rs per crate. Adopting RS-L, which the new leaf carries: - Campaign, cut-spec, question and ruling fixtures carry a Title; the question and ruling fixtures gain the new required title field. - The epoch literals in daemon and envelope tests move v1 -> v2. A store written at an earlier epoch is refused at open (ForeignEpoch); no key migration. - Derived stewardship, hand-off and resolution keys are now the lowercased OrgRepo::identity(); test key literals follow. - The two published wire schemas are regenerated (Title, OrgRepo bound and description); the byte-for-byte pin test passes. CultLib 6251cbc gives CultNetMessage::Error code and details; the four construction sites and one pattern in huginn-daemon take None and `..`. No behaviour change: None is skipped on the wire. mind 70 and daemon 18 pass. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-29 03:56:03 +02:00
"Title": {
"description": "A title: 1 to 200 UTF-8 bytes, enforced by admission; JSON Schema\nlength counts characters. Holds at least one alphanumeric character,\nno control character, and no bidi control character (`U+061C`,\n`U+200E`, `U+200F`, `U+202A`-`U+202E`, `U+2066`-`U+2069`).",
"type": "string",
"maxLength": 200,
"minLength": 1
},
Give the mind a wire vocabulary and publish its two schemas `huginn-mind::wire` names one request per `Mind` method plus `whoami`, and one response per method plus the read side's refusal. The payloads are the admission and read types unchanged, so a client speaks the organ's own vocabulary rather than a projection of it. `operation()` and `instance()` say what the envelope carries; `status()` derives the envelope's status from the response, and a refusal is data in that response rather than a transport failure. `Mind::status` answers `whoami` from the image every time it is asked: the instance, the schema epoch, and how many pipeline documents and receipts the mind holds. Nothing stores a status and no configuration supplies one. `schemas/cultnet/` publishes the JSON schema of each wire type, derived from the type and pinned to it byte for byte by a test, so the schema catalog cannot advertise a shape the crate does not speak. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-16 22:52:53 +02:00
"VerdictClaim": {
"description": "The promise this claim measured, and the report's mutations it ran. An\n`Unproven` claim with a promise is one Soul could not reach.",
"type": "object",
"properties": {
"claim": {
"$ref": "#/$defs/Line"
},
"evidence": {
"type": "array",
"items": {
"$ref": "#/$defs/Evidence"
},
"maxItems": 8
},
"findings": {
"type": "array",
"items": {
"$ref": "#/$defs/Short"
},
"maxItems": 16
},
"mutations": {
"type": "array",
"items": {
"$ref": "#/$defs/Label"
},
"maxItems": 8
},
"outcome": {
"$ref": "#/$defs/ClaimOutcome"
},
"promise": {
"anyOf": [
{
"$ref": "#/$defs/Label"
},
{
"type": "null"
}
]
}
},
"required": [
"claim",
"outcome",
"evidence",
"findings",
"mutations"
]
},
"VerificationTest": {
"type": "object",
"properties": {
"name": {
"$ref": "#/$defs/Short"
},
"pins": {
"$ref": "#/$defs/Line"
}
},
"required": [
"name",
"pins"
]
}
}
}
Reference in a new issue Copy permalink