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_request.v1.schema.json

2401 lines
57 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": "HuginnMindRequest",
"description": "Every operation a mind answers. `Admit` carries the batch whole because the\nbatch already names the instance and the asker; a second `instance` beside\nit would be two declarations. Every read names the instance because ruling\n14 refuses another mind's identity whatever the transport, and a read of\nthe wrong mind is that same collision on the read side. `Whoami` names\nnone: it is how a client learns which mind it reached.",
"oneOf": [
{
"type": "string",
"enum": [
"Whoami"
]
},
{
"type": "object",
"properties": {
"Admit": {
"$ref": "#/$defs/PipelineAdmissionBatch"
}
},
"additionalProperties": false,
"required": [
"Admit"
]
},
{
"type": "object",
"properties": {
"View": {
"type": "object",
"properties": {
"id": {
"$ref": "#/$defs/PipelineRef"
},
"instance": {
"$ref": "#/$defs/Slug"
}
},
"required": [
"instance",
"id"
]
}
},
"additionalProperties": false,
"required": [
"View"
]
},
{
"type": "object",
"properties": {
"Query": {
"type": "object",
"properties": {
"instance": {
"$ref": "#/$defs/Slug"
},
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
"selection": {
"$ref": "https://github.com/GameCult/CultLib/contracts/cultnet/cultnet.selection.schema.json"
},
"semantic": {
"anyOf": [
{
"$ref": "#/$defs/SemanticQuery"
},
{
"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": [
"instance",
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
"selection"
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"
]
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 mind's persona document, if one is stored.",
"type": "object",
"properties": {
"PersonaGet": {
"type": "object",
"properties": {
"instance": {
"$ref": "#/$defs/Slug"
}
},
"required": [
"instance"
]
}
},
"additionalProperties": false,
"required": [
"PersonaGet"
]
},
{
"description": "Replaces the mind's persona document whole. `expected_updated_at` is\nthe stored document's `updatedAt`, none for the first put. The\nprovenance is the asker's, as for `Admit`.",
"type": "object",
"properties": {
"PersonaPut": {
"type": "object",
"properties": {
"expected_updated_at": {
"type": [
"string",
"null"
]
},
"instance": {
"$ref": "#/$defs/Slug"
},
"provenance": {
"$ref": "#/$defs/PipelineProvenance"
},
"state": true
},
"required": [
"instance",
"provenance",
"state"
]
}
},
"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
},
{
"description": "Semantic search over the source index: the public forge repos' code and\ndocs, which no mind holds. The daemon embeds the text and asks the\nindex it does not write.",
"type": "object",
"properties": {
"SearchSources": {
"type": "object",
"properties": {
"instance": {
"$ref": "#/$defs/Slug"
},
"query": {
"$ref": "#/$defs/SourceQuery"
}
},
"required": [
"instance",
"query"
]
}
},
"additionalProperties": false,
"required": [
"SearchSources"
]
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
},
{
"description": "What others did in `repos` on the forge since the `after` cursor: the\ndaemon reads the forge and no document of the mind, and answers\n`Refused(Unavailable)` when it has no forge or the forge does not answer\nin time. The repos are the asker's to name (her stewardships); the\ninstance's own login is dropped from the answer.",
"type": "object",
"properties": {
"StewardedActivity": {
"type": "object",
"properties": {
"after": {
"type": [
"integer",
"null"
],
"format": "uint64",
"minimum": 0
},
"instance": {
"$ref": "#/$defs/Slug"
},
"repos": {
"type": "array",
"items": {
"$ref": "#/$defs/OrgRepo"
}
}
},
"required": [
"instance",
"repos"
]
}
},
"additionalProperties": false,
"required": [
"StewardedActivity"
]
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
},
{
"description": "Every root the mind holds a document under, with its newest admission and a campaign's repos in force: the mind's own\nrecords, one pass at the head.",
"type": "object",
"properties": {
"RootsTouched": {
"type": "object",
"properties": {
"instance": {
"$ref": "#/$defs/Slug"
}
},
"required": [
"instance"
]
}
},
"additionalProperties": false,
"required": [
"RootsTouched"
]
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": {
"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"
]
},
"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
},
"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
},
"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
schemas: the request wire schema is the derivation, without interleaved test output Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 06:07:17 +01:00
},
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
"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"
]
},
"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
},
"PipelineAdmissionBatch": {
"description": "One admission request: the mind it is for, who asks, and the documents.\nRides the wire whole (`wire::HuginnMindRequest::Admit`).",
"type": "object",
"properties": {
"documents": {
"type": "array",
"items": {
"$ref": "#/$defs/PipelineDocument"
}
},
"instance": {
"$ref": "#/$defs/Slug"
},
"provenance": {
"$ref": "#/$defs/PipelineProvenance"
}
},
"required": [
"instance",
"provenance",
"documents"
]
},
"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": {
schemas: the request wire schema is the derivation, without interleaved test output Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 06:07:17 +01:00
"$ref": "#/$defs/Line"
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
},
schemas: the request wire schema is the derivation, without interleaved test output Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 06:07:17 +01:00
"maxItems": 64
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
},
"authority_map": {
schemas: the request wire schema is the derivation, without interleaved test output Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-31 06:07:17 +01:00
"anyOf": [
{
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/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
}
]
},
"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",
"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
]
},
"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"
]
},
"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"
]
},
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
"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"
]
},
"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"
]
},
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"
]
}
]
},
"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
]
},
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
"SemanticQuery": {
Request schema: the SemanticQuery description keeps its newlines escaped The previous commit wrote raw newlines into the JSON string, which the published file must not hold. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-25 20:03:08 +01:00
"description": "A semantic query: the text to find documents near, and how many. The index\nowns which fields of each kind are text (`index_text`), so no substring\nfilter lives here to become a second answer to that question. `top_k` is\nthe most rows answered, all of them members of the selection: the\nselection decides membership before the index is asked.",
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": {
"text": {
"$ref": "#/$defs/Line"
},
"top_k": {
"type": "integer",
"format": "uint32",
"minimum": 0
}
},
"required": [
"text",
"top_k"
]
},
"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
"SourceQuery": {
"description": "A source search: the text to find chunks near, how many, and optionally the\none forge repo (by name) to look in.",
"type": "object",
"properties": {
"repo": {
"anyOf": [
{
"$ref": "#/$defs/Short"
},
{
"type": "null"
}
]
},
"text": {
"$ref": "#/$defs/Line"
},
"top_k": {
"type": "integer",
"format": "uint32",
"minimum": 0
}
},
"required": [
"text",
"top_k"
]
},
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