yog 0.0.7

yog: the standalone server for litany loops — the world, the balls and the conversations, behind one wire
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

//! The decision queue's row encoder (§8.5, VISION §5 V5.2, STORIES S14) — a
//! sibling of [`super::rows`], kept out of it for the reason [`super::board`]
//! is: a row that carries a derived list of its own.
//!
//! The address fields are spelled with the **same keys the gestures take**
//! (`workspace`, `agent`) **and in the same vocabulary** — the §3.1 workspace
//! name, never a path — so answering a row is copying two values, never
//! translating between an answer's vocabulary and a question's. That second
//! half was the defect bl-22ab closed: the key matched and the value did not,
//! so a copied address earned `unknown workspace` from the very engine that
//! had just answered it.

use crate::attention::AttentionKind;
use crate::boundary::answer::queue::QueueRow;
use serde_json::{Value, json};

pub(super) fn queue_row(row: &QueueRow) -> Value {
    json!({
        "workspace": row.workspace,
        "agent": row.agent,
        "display": row.display,
        "state": super::rows::state_token(row.state),
        "uncertain": row.uncertain,
        "signals": row.signals.iter().map(|k| signal_token(*k)).collect::<Vec<&str>>(),
        "preview": row.preview,
        "age_secs": row.age_secs,
        "pending": row.pending,
        "held": row.held.as_ref().map(held),
    })
}

/// The parked invocation, when the row carries one (§8.6): what is waiting, and
/// the control's own sentence about it. A reader needs no other call to decide
/// — which is the point of the reason carrying the input summary and the class.
fn held(held: &crate::control::hold::Held) -> Value {
    json!({ "tool_use": held.tool_use_id, "tool": held.tool, "reason": held.reason })
}

/// The §6 signal tokens — the `ui.json` `seen` keys' own words for four of
/// them, so a reader of the queue and a reader of the watermark document are
/// reading one vocabulary.
fn signal_token(kind: AttentionKind) -> &'static str {
    match kind {
        AttentionKind::Notify => "notify",
        AttentionKind::Stopped => "stopped",
        AttentionKind::Budget => "budget",
        AttentionKind::Conflicted => "conflicted",
        AttentionKind::Mail => "mail",
        AttentionKind::Held => "held",
        AttentionKind::Refused => "refused",
    }
}

/// The §6 signal table — [`signal_token`]'s other half (bl-7067).
const SIGNALS: [(&str, AttentionKind); 7] = [
    ("notify", AttentionKind::Notify),
    ("stopped", AttentionKind::Stopped),
    ("budget", AttentionKind::Budget),
    ("conflicted", AttentionKind::Conflicted),
    ("mail", AttentionKind::Mail),
    ("held", AttentionKind::Held),
    // Rule 2's rest said in the word that is true of it (bl-b43b) — it stands
    // where `stopped` would, never beside it.
    ("refused", AttentionKind::Refused),
];

/// One queue row read back. `display` is answered rather than re-derived here
/// for the reason it is answered at all: the §3.3 ladder needs the agents this
/// process cannot see, so the row's own word for itself is the only one there
/// is.
pub(super) fn queue_row_of(v: &Value) -> Result<QueueRow, String> {
    use crate::boundary::codec::fields::{bool_of, i64_of, list_of, opt_val, str_of, usize_of};
    let o = v.as_object().ok_or("queue row: not an object")?;
    Ok(QueueRow {
        workspace: str_of(o, "workspace")?,
        agent: str_of(o, "agent")?,
        display: str_of(o, "display")?,
        state: super::rows::decode::state_of(o)?,
        uncertain: bool_of(o, "uncertain")?,
        signals: list_of(o, "signals", signal_of)?,
        preview: str_of(o, "preview")?,
        age_secs: i64_of(o, "age_secs")?,
        pending: usize_of(o, "pending")?,
        held: opt_val(o, "held", held_of)?,
    })
}

fn signal_of(v: &Value) -> Result<AttentionKind, String> {
    let token = v.as_str().ok_or("signal: not a string")?;
    SIGNALS
        .iter()
        .find(|(word, _)| *word == token)
        .map(|(_, kind)| *kind)
        .ok_or_else(|| format!("unknown signal {token:?}"))
}

fn held_of(v: &Value) -> Result<crate::control::hold::Held, String> {
    use crate::boundary::codec::fields::str_of;
    let o = v.as_object().ok_or("held: not an object")?;
    Ok(crate::control::hold::Held {
        tool_use_id: str_of(o, "tool_use")?,
        tool: str_of(o, "tool")?,
        reason: str_of(o, "reason")?,
    })
}