mythos-skill 0.1.1

Explicit-state recurrent synthesis: deterministic packet compiler for AI agent runs. Takes subagent output (evidence.jsonl, verifier findings, raw artifacts) and compiles a schema-validated, hash-provenanced next-pass packet that Prime can reason over without consuming raw subagent prose.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

use crate::compiler::evidence::{PacketValidationError, validate_packet_sources};
use crate::schema::{
    CandidateAction, CompiledFact, Contradiction, EvidenceRecord, HaltSignal, Hypothesis,
    MYTHOS_SCHEMA_VERSION, NextPassPacket, RecurringFailurePattern, SourceRef, VerifierFinding,
};

#[derive(Debug, Clone, PartialEq)]
pub struct CompilerInputBundle {
    pub objective_id: String,
    pub run_id: String,
    pub branch_id: String,
    pub pass_id: String,
    pub objective: String,
    pub evidence: Vec<EvidenceRecord>,
    pub trusted_facts: Vec<CompiledFact>,
    pub active_hypotheses: Vec<Hypothesis>,
    pub contradictions: Vec<Contradiction>,
    pub recurring_failure_patterns: Vec<RecurringFailurePattern>,
    pub candidate_actions: Vec<CandidateAction>,
    pub verifier_findings: Vec<VerifierFinding>,
    pub open_questions: Vec<String>,
    pub raw_drilldown_refs: Vec<SourceRef>,
    pub halt_signals: Vec<HaltSignal>,
    pub sources: Vec<SourceRef>,
}

pub fn build_next_pass_packet(
    input: CompilerInputBundle,
) -> Result<NextPassPacket, PacketValidationError> {
    let packet = NextPassPacket {
        schema_version: MYTHOS_SCHEMA_VERSION.to_string(),
        objective_id: input.objective_id,
        run_id: input.run_id,
        branch_id: input.branch_id,
        pass_id: input.pass_id,
        objective: input.objective,
        evidence: input.evidence,
        trusted_facts: input.trusted_facts,
        active_hypotheses: input.active_hypotheses,
        contradictions: input.contradictions,
        recurring_failure_patterns: input.recurring_failure_patterns,
        candidate_actions: input.candidate_actions,
        verifier_findings: input.verifier_findings,
        open_questions: input.open_questions,
        raw_drilldown_refs: input.raw_drilldown_refs,
        halt_signals: input.halt_signals,
        sources: input.sources,
    };

    validate_packet_sources(&packet)?;
    Ok(packet)
}

#[cfg(test)]
mod tests {
    use super::{CompilerInputBundle, build_next_pass_packet};

    #[test]
    fn builds_packet_from_compiler_input() {
        let packet = build_next_pass_packet(CompilerInputBundle {
            objective_id: "obj-1".to_string(),
            run_id: "run-1".to_string(),
            branch_id: "main".to_string(),
            pass_id: "pass-1".to_string(),
            objective: "Solve the task".to_string(),
            evidence: vec![crate::schema::EvidenceRecord {
                id: "ev-1".to_string(),
                kind: "observation".to_string(),
                summary: "shell output".to_string(),
                source_ids: vec!["src-1".to_string()],
                source_refs: vec![],
                observed_at: "2026-04-21T00:00:00Z".to_string(),
                agent_id: None,
                lane: None,
                confidence: None,
                rationale: None,
                diff_ref: None,
                span_before: None,
                span_after: None,
            }],
            trusted_facts: vec![],
            active_hypotheses: vec![],
            contradictions: vec![],
            recurring_failure_patterns: vec![],
            candidate_actions: vec![],
            verifier_findings: vec![],
            open_questions: vec!["What failed?".to_string()],
            raw_drilldown_refs: vec![crate::schema::SourceRef {
                source_id: "src-1".to_string(),
                path: "evidence/log.txt".to_string(),
                kind: "log".to_string(),
                hash: "abc".to_string(),
                hash_alg: "fnv1a-64".to_string(),
                span: None,
                observed_at: "2026-04-21T00:00:00Z".to_string(),
            }],
            halt_signals: vec![crate::schema::HaltSignal {
                id: "halt-1".to_string(),
                kind: "continue".to_string(),
                contribution: 0.1,
                rationale: "still unresolved".to_string(),
                source_ids: vec!["src-1".to_string()],
            }],
            sources: vec![crate::schema::SourceRef {
                source_id: "src-1".to_string(),
                path: "evidence/log.txt".to_string(),
                kind: "log".to_string(),
                hash: "abc".to_string(),
                hash_alg: "fnv1a-64".to_string(),
                span: None,
                observed_at: "2026-04-21T00:00:00Z".to_string(),
            }],
        })
        .expect("valid packet");

        assert_eq!(packet.objective_id, "obj-1");
        assert_eq!(packet.open_questions, vec!["What failed?".to_string()]);
    }
}