Skip to main content

magi/
talk_external.rs

1//! Local CLI ingress. Publication, TurnLease and worker ownership are the same
2//! as web Chat; an uncertain submission is never replayed.
3use super::*;
4use serde_json::{Value, json};
5use sha2::{Digest, Sha256};
6
7// Separate from the transcript so deleting a talk cannot free an owner
8// request ID for use against another destination.
9#[derive(PartialEq, Eq, Serialize, Deserialize)]
10struct OwnerBinding {
11    talk: String,
12    text_sha256: String,
13}
14
15fn digest(text: &str) -> String {
16    use std::fmt::Write as _;
17    let mut encoded = String::with_capacity(64);
18    for byte in Sha256::digest(text.as_bytes()) {
19        write!(encoded, "{byte:02x}").expect("write to String");
20    }
21    encoded
22}
23
24fn binding_path(store: &Talks, request: &str) -> PathBuf {
25    store.root.join("owner-requests").join(digest(request))
26}
27
28fn read_binding(store: &Talks, request: &str) -> Result<Option<OwnerBinding>> {
29    match std::fs::read(binding_path(store, request)) {
30        Ok(bytes) => Ok(Some(
31            serde_json::from_slice(&bytes).context("decode owner request binding")?,
32        )),
33        Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(None),
34        Err(error) => Err(error).context("read owner request binding"),
35    }
36}
37
38fn reserve_binding(store: &Talks, request: &str, binding: &OwnerBinding) -> Result<bool> {
39    let path = binding_path(store, request);
40    std::fs::create_dir_all(path.parent().expect("binding directory"))?;
41    publish_exclusive(
42        &path,
43        &path.with_extension(format!("tmp.{}", fresh_token())),
44        &serde_json::to_string(binding)?,
45    )
46    .context("reserve owner request binding")
47}
48
49/// A durable occurrence, committed atomically with its exact transcript input.
50#[derive(Debug, Clone, Serialize, Deserialize)]
51pub struct Request {
52    /// Caller-saved occurrence identifier.
53    pub request: String,
54    /// Self-reported external display label; never an authority credential.
55    pub sender: String,
56    /// Exact original input, retained to reject conflicting request replays.
57    pub text: String,
58    /// Exact appended input turn, not a search for the next operator turn.
59    pub input_turn: usize,
60    /// Exact response turn, committed with that response.
61    pub reply_turn: Option<usize>,
62    /// Durable execution boundary: accepted, started, replied, failed,
63    /// not_started. Uncertain observations do not change this boundary.
64    pub status: String,
65    /// Detached worker reservation that owns this occurrence.
66    pub worker: Option<String>,
67    /// Startup or response diagnostic, when known.
68    pub error: Option<String>,
69}
70
71// Older scheduler generations rewrite Talk through their own schema. They
72// preserve these receipt fields and the transcript, but not new fields.
73// The owner binding therefore lives outside Talk and is the authority.
74fn owner_input(
75    talk_id: &str,
76    input: Option<&Turn>,
77    record: &Request,
78    binding: Option<&OwnerBinding>,
79) -> Result<bool> {
80    let turn = input.context("recorded CLI input is missing")?;
81    let owner = binding.filter(|binding| binding.talk == talk_id);
82    if let Some(binding) = owner {
83        anyhow::ensure!(
84            binding.text_sha256 == digest(&record.text)
85                && record.sender.is_empty()
86                && turn.who == Who::Operator
87                && turn.sender == Some(Sender::Operator)
88                && turn.body == record.text
89                && turn.messages.iter().all(|message| {
90                    message.sender == Some(Sender::Operator) && message.body == record.text
91                }),
92            "saved owner input does not match its admission"
93        );
94    } else {
95        anyhow::ensure!(
96            turn.sender == Some(Sender::External),
97            "saved CLI input has no matching owner binding or external provenance"
98        );
99    }
100    Ok(owner.is_some())
101}
102
103fn ingress(owner: bool) -> &'static str {
104    if owner { "owner" } else { "external" }
105}
106
107fn resolve(store: &Talks, selector: &str) -> Result<std::result::Result<Talk, Value>> {
108    let (talks, unreadable) = store.list_counting_unreadable();
109    let mut hits: Vec<_> = talks
110        .into_iter()
111        .filter(|t| t.id == selector || t.id.starts_with(selector))
112        .collect();
113    if let Some(index) = hits.iter().position(|t| t.id == selector) {
114        return Ok(Ok(hits.swap_remove(index)));
115    }
116    Ok(match hits.len() {
117        0 => Err(json!({"status":"not_found", "selector":selector, "unreadable":unreadable})),
118        1 => Ok(hits.pop().expect("one match")),
119        _ => Err(
120            json!({"status":"ambiguous", "selector":selector, "candidates":hits.iter().map(|t| &t.id).collect::<Vec<_>>()}),
121        ),
122    })
123}
124
125/// Discover conversations without opening or reopening one.
126pub fn list(store: &Talks) -> Result<Value> {
127    let (talks, unreadable) = store.list_counting_unreadable();
128    Ok(
129        json!({"talks":talks.iter().map(|t| json!({"id":t.id,"repo":t.repo,"agent":t.agent,"status":t.status,"title":t.title})).collect::<Vec<_>>(),"unreadable":unreadable}),
130    )
131}
132
133fn cursor(talk: &Talk, turn: usize, message: usize) -> String {
134    use sha2::Digest as _;
135    let mut hash = sha2::Sha256::new();
136    if let Some(row) = talk.turns.get(turn) {
137        hash.update(serde_json::to_vec(&row.at).expect("timestamp serialization"));
138        let body = row
139            .messages
140            .get(message)
141            .map_or(row.body.as_str(), |m| m.body.as_str());
142        hash.update(body.as_bytes());
143    }
144    // A reverted admission may later reuse a coordinate. Bind the cursor to
145    // its contents and occurrence time so it never silently aliases that row.
146    use std::fmt::Write as _;
147    let mut id = format!("{}:{turn}:{message}:", talk.id);
148    id.reserve(64);
149    for byte in hash.finalize() {
150        write!(id, "{byte:02x}").expect("write to string");
151    }
152    id
153}
154
155/// Conversation-bound coordinates and occurrence fingerprints form stable IDs.
156pub fn history(store: &Talks, selector: &str, after: Option<&str>, limit: usize) -> Result<Value> {
157    anyhow::ensure!(
158        (1..=500).contains(&limit),
159        "limit must be between 1 and 500"
160    );
161    let talk = match resolve(store, selector)? {
162        Ok(t) => t,
163        Err(v) => return Ok(v),
164    };
165    let mut coordinates = talk
166        .turns
167        .iter()
168        .enumerate()
169        .flat_map(|(i, turn)| (0..turn.messages.len().max(1)).map(move |j| (i, j)));
170    if let Some(after) = after {
171        coordinates
172            .find(|&(i, j)| cursor(&talk, i, j) == after)
173            .context("cursor is not a message in this conversation")?;
174    } else {
175        let count: usize = talk.turns.iter().map(|t| t.messages.len().max(1)).sum();
176        for _ in 0..count.saturating_sub(limit) {
177            coordinates.next();
178        }
179    }
180    let messages: Vec<_> = coordinates
181        .by_ref()
182        .take(limit)
183        .map(|(i, j)| {
184            let turn = &talk.turns[i];
185            let message = turn.messages.get(j);
186            let body = message.map_or(turn.body.as_str(), |m| m.body.as_str());
187            let request = talk.external_requests.iter().find(|r| r.input_turn == i);
188            let kind = request
189                .map(|r| {
190                    let binding = read_binding(store, &r.request)?;
191                    owner_input(&talk.id, Some(turn), r, binding.as_ref()).map(ingress)
192                })
193                .transpose()?;
194            Ok(json!({"id":cursor(&talk,i,j),"sender":sender(turn,message),"body":body,"at":turn.at,
195                "request":request.map(|r| &r.request),"ingress":kind}))
196        })
197        .collect::<Result<_>>()?;
198    let more = coordinates.next().is_some();
199    let last = messages.last().and_then(|v| v["id"].as_str()).or(after);
200    Ok(json!({"talk":talk.id,"messages":messages,"cursor":last,"more":more}))
201}
202
203fn view(store: &Talks, talk: &Talk, record: &Request, owner: bool) -> Value {
204    use crate::worker::Status;
205    let mut status = record.status.as_str();
206    if matches!(status, "accepted" | "started") {
207        // A missing or ended worker without a settled reply is not permission
208        // to execute again. The owner path also probes the live execution lease.
209        let live = record
210            .worker
211            .as_deref()
212            .and_then(|id| crate::worker::get(store.home(), id).ok())
213            .is_some_and(|job| {
214                matches!(job.status, Status::Starting | Status::Running)
215                    && (!owner
216                        || crate::worker::observe_job_active(store.home(), &job).unwrap_or(false))
217            });
218        status = if !live {
219            "uncertain"
220        } else if owner && status == "accepted" {
221            "queued"
222        } else {
223            status
224        };
225    }
226    // A saved authorization (even a superseded one) is evidence of the
227    // effect. Persona prose, task status and an unrelated goal are not.
228    let mut goal_authorizations = Vec::new();
229    if owner {
230        for goal in &talk.goals {
231            if goal.source_turn == record.input_turn && goal.owner_input == record.text {
232                goal_authorizations.push(json!({"id":goal.id,"purpose":goal.purpose,
233                    "scope":goal.scope,"condition":goal.condition,"current":true,"state":goal.state}));
234            }
235            for revision in &goal.history {
236                if revision.source_turn == record.input_turn && revision.owner_input == record.text
237                {
238                    goal_authorizations.push(json!({"id":goal.id,"purpose":revision.purpose,
239                        "scope":revision.scope,"condition":revision.condition,
240                        "current":false,"state":revision.state}));
241                }
242            }
243        }
244    }
245    json!({"talk":talk.id,"request":record.request,"status":status,"accepted":true,
246        "ingress":ingress(owner),"goal_authorizations":goal_authorizations,
247        "input_id":cursor(talk,record.input_turn,0),
248        "reply_id":record.reply_turn.map(|i| cursor(talk,i,0)),
249        "reply":record.reply_turn.and_then(|i| talk.turns.get(i)).map(|t| &t.body),
250        "worker":record.worker,"error":record.error})
251}
252
253enum InputKind<'a> {
254    External(&'a str),
255    Owner,
256}
257
258/// Accept once, or return the saved occurrence. Duplicate calls never dispatch.
259pub async fn send(
260    store: &Talks,
261    selector: &str,
262    request: &str,
263    label: &str,
264    text: &str,
265) -> Result<Value> {
266    submit(store, selector, request, InputKind::External(label), text).await
267}
268
269/// Submit an explicit local operator request, independently of external ingress.
270pub async fn send_owner(store: &Talks, id: &str, request: &str, text: &str) -> Result<Value> {
271    let seat_environment = ["MAGI_RUN", "MAGI_NODE", "MAGI_SEAT"];
272    anyhow::ensure!(
273        !seat_environment
274            .iter()
275            .chain(crate::worker::INVOCATION_ENV.iter())
276            .chain(crate::chat_control::bridge::ENVIRONMENT)
277            .any(|key| std::env::var_os(key).is_some()),
278        "send-owner is unavailable inside a magi seat or worker; run it from the owner's trusted local terminal using their private MAGI_HOME"
279    );
280    submit(store, id, request, InputKind::Owner, text).await
281}
282
283async fn submit(
284    store: &Talks,
285    selector: &str,
286    request: &str,
287    input: InputKind<'_>,
288    text: &str,
289) -> Result<Value> {
290    let label = match input {
291        InputKind::External(label) => label,
292        InputKind::Owner => "",
293    };
294    let owner = matches!(input, InputKind::Owner);
295    anyhow::ensure!(
296        !request.is_empty()
297            && request.len() <= 128
298            && request
299                .bytes()
300                .all(|c| c.is_ascii_alphanumeric() || b"-_.".contains(&c)),
301        "request must contain 1..128 ASCII letters, digits, -, _ or ."
302    );
303    if let InputKind::External(label) = input {
304        anyhow::ensure!(
305            !label.trim().is_empty() && label.len() <= 128 && !label.chars().any(char::is_control),
306            "sender must be a nonempty single-line label of at most 128 bytes"
307        );
308    }
309    anyhow::ensure!(!text.trim().is_empty(), "nothing to send");
310    let expected_binding = owner.then(|| OwnerBinding {
311        talk: selector.to_owned(),
312        text_sha256: digest(text),
313    });
314    let binding_status = |binding: &OwnerBinding| {
315        let status = if Some(binding) == expected_binding.as_ref() {
316            "uncertain"
317        } else {
318            "conflict"
319        };
320        json!({"talk":selector,"request":request,"status":status})
321    };
322    let talk = match resolve(store, selector)? {
323        Ok(t) => t,
324        Err(v) => {
325            return Ok(if owner {
326                read_binding(store, request)?
327                    .as_ref()
328                    .map_or(v, binding_status)
329            } else {
330                v
331            });
332        }
333    };
334    anyhow::ensure!(
335        !owner || talk.id == selector,
336        "send-owner requires the full Chat ID from magi talk list"
337    );
338    // Owner bindings are home-wide for owner submissions only. Within the
339    // bound conversation, an incomplete owner receipt still fences both kinds.
340    let scoped_binding = || -> Result<Option<OwnerBinding>> {
341        Ok(read_binding(store, request)?.filter(|binding| owner || binding.talk == talk.id))
342    };
343    let replay = |talk: &Talk, r: &Request| -> Result<Value> {
344        let binding = scoped_binding()?;
345        let saved_owner = owner_input(&talk.id, talk.turns.get(r.input_turn), r, binding.as_ref())?;
346        Ok(
347            if saved_owner == owner && r.text == text && r.sender == label {
348                view(store, talk, r, saved_owner)
349            } else {
350                json!({"talk":talk.id,"request":request,"status":"conflict"})
351            },
352        )
353    };
354    if let Some(r) = talk.external_requests.iter().find(|r| r.request == request) {
355        return replay(&talk, r);
356    }
357    if let Some(binding) = scoped_binding()? {
358        // Re-read: the binding can become visible just before the atomic
359        // transcript write. Never dispatch again in that interval.
360        let fresh = read_path(&store.path_of(&talk.id))?;
361        return match fresh
362            .external_requests
363            .iter()
364            .find(|r| r.request == request)
365        {
366            Some(r) => replay(&fresh, r),
367            None => Ok(binding_status(&binding)),
368        };
369    }
370    let Some(_publication) = crate::chat_worker::try_publication_guard(store, &talk.id)? else {
371        return Ok(json!({"talk":talk.id,"request":request,"status":"busy"}));
372    };
373    // Replays are observational even if the conversation is now busy/closed.
374    let fresh = read_path(&store.path_of(&talk.id))?;
375    if let Some(r) = fresh
376        .external_requests
377        .iter()
378        .find(|r| r.request == request)
379    {
380        return replay(&fresh, r);
381    }
382    if !fresh.status.open() {
383        return Ok(json!({"talk":fresh.id,"request":request,"status":"closed"}));
384    }
385    // Refuse every live generation, including older executables unable to
386    // decode external provenance, before publishing a new-format record.
387    if crate::chat_worker::turn_worker_active(store, &fresh.id) {
388        return Ok(json!({"talk":fresh.id,"request":request,"status":"busy"}));
389    }
390    let Some(_turn) = store.claim_turn(&fresh.id)? else {
391        return Ok(json!({"talk":fresh.id,"request":request,"status":"busy"}));
392    };
393    {
394        let _guard = store.guard()?;
395        let mut fresh = read_path(&store.path_of(&talk.id))?;
396        if let Some(binding) = scoped_binding()? {
397            return Ok(binding_status(&binding));
398        }
399        if !fresh.status.open() {
400            return Ok(json!({"talk":fresh.id,"request":request,"status":"closed"}));
401        }
402        if !fresh.pending.is_empty()
403            || !fresh.pending_messages.is_empty()
404            || !fresh.pending_attachments.is_empty()
405        {
406            return Ok(json!({"talk":fresh.id,"request":request,"status":"busy"}));
407        }
408        let index = fresh.turns.len();
409        if let Some(binding) = &expected_binding
410            && !reserve_binding(store, request, binding)?
411        {
412            let winner =
413                read_binding(store, request)?.context("owner request binding disappeared")?;
414            return Ok(binding_status(&winner));
415        }
416        fresh.turns.push(match input {
417            InputKind::Owner => operator_turn(text, Vec::new(), None),
418            InputKind::External(label) => Turn {
419                sender: Some(Sender::External),
420                who: Who::Operator,
421                body: format!("External agent [{label}]:\n{text}"),
422                at: Timestamp::now(),
423                attachments: Vec::new(),
424                usage: None,
425                breaks: Some(Vec::new()),
426                messages: Vec::new(),
427                posted_by: None,
428            },
429        });
430        fresh.external_requests.push(Request {
431            request: request.to_owned(),
432            sender: label.to_owned(),
433            text: text.to_owned(),
434            input_turn: index,
435            reply_turn: None,
436            status: "accepted".into(),
437            worker: None,
438            error: None,
439        });
440        store.put(&mut fresh)?;
441    }
442    // The ledger is already durable. A crash at any subsequent boundary is an
443    // accepted but uncertain send, never an invitation to append or run again.
444    let result = crate::worker::spawn(
445        store.home(),
446        "chat",
447        &format!("chat-external:{}:{request}", talk.id),
448        json!({"talk":talk.id,"external_request":request}),
449    )
450    .await;
451    {
452        let _guard = store.guard()?;
453        let mut fresh = read_path(&store.path_of(&talk.id))?;
454        let r = fresh
455            .external_requests
456            .iter_mut()
457            .find(|r| r.request == request)
458            .context("CLI request disappeared")?;
459        record_launch(r, result);
460        store.put(&mut fresh)?;
461    }
462    let fresh = read_path(&store.path_of(&talk.id))?;
463    replay(
464        &fresh,
465        fresh
466            .external_requests
467            .iter()
468            .find(|r| r.request == request)
469            .context("CLI request disappeared")?,
470    )
471}
472
473fn record_launch(r: &mut Request, result: Result<crate::worker::Job>) {
474    match result {
475        Ok(job) => r.worker = Some(job.id),
476        Err(error) => {
477            // Acknowledgement is observation, not revocation. Only a proven
478            // non-start can close admission before the reserved worker runs.
479            if r.status == "accepted" {
480                if let Some(pending) = error.downcast_ref::<crate::worker::StartupUnacknowledged>()
481                {
482                    r.worker = Some(pending.id.clone());
483                } else if crate::worker::not_started(&error) {
484                    r.status = "not_started".into();
485                }
486            }
487            r.error = Some(format!("{error:#}"));
488        }
489    }
490}
491
492/// Observation only: timeout neither cancels nor repeats accepted work.
493pub async fn reply(store: &Talks, selector: &str, request: &str, wait: u64) -> Result<Value> {
494    let binding = read_binding(store, request)?;
495    let talk = match resolve(store, selector)? {
496        Ok(t) => t,
497        Err(v) => {
498            return Ok(if binding.as_ref().is_some_and(|b| b.talk == selector) {
499                json!({"talk":selector,"request":request,"status":"uncertain"})
500            } else {
501                v
502            });
503        }
504    };
505    let deadline = tokio::time::Instant::now()
506        .checked_add(Duration::from_secs(wait))
507        .context("wait duration exceeds the monotonic clock range")?;
508    loop {
509        let fresh = read_path(&store.path_of(&talk.id))?;
510        let Some(record) = fresh
511            .external_requests
512            .iter()
513            .find(|r| r.request == request)
514        else {
515            let status = match &binding {
516                Some(b) if b.talk == fresh.id => "uncertain",
517                Some(_) => "conflict",
518                None => "not_found",
519            };
520            return Ok(json!({"talk":talk.id,"request":request,"status":status}));
521        };
522        let binding = read_binding(store, request)?;
523        let owner = owner_input(
524            &fresh.id,
525            fresh.turns.get(record.input_turn),
526            record,
527            binding.as_ref(),
528        )?;
529        let mut value = view(store, &fresh, record, owner);
530        if wait == 0 || matches!(record.status.as_str(), "replied" | "failed" | "not_started") {
531            return Ok(value);
532        }
533        if tokio::time::Instant::now() >= deadline {
534            value["state"] = value["status"].clone();
535            value["status"] = json!("timeout");
536            return Ok(value);
537        }
538        tokio::time::sleep(Duration::from_millis(100)).await;
539    }
540}
541
542/// Called only by the ordinary detached chat worker, under its execution lease.
543pub(crate) async fn run_worker(store: &Talks, id: &str, request: &str) -> Result<()> {
544    let job = crate::worker::current_job(store.home())?.context("CLI submission has no worker")?;
545    anyhow::ensure!(
546        job.kind == "chat"
547            && job.payload["talk"].as_str() == Some(id)
548            && job.payload["external_request"].as_str() == Some(request),
549        "CLI submission does not belong to this worker"
550    );
551    loop {
552        if let Some(lease) = store.claim_turn(id)? {
553            let publication = crate::chat_worker::publication_guard(store, id).await?;
554            let (mut talk, index) = {
555                let _guard = store.guard()?;
556                let mut talk = read_path(&store.path_of(id))?;
557                let pos = talk
558                    .external_requests
559                    .iter()
560                    .position(|r| r.request == request)
561                    .context("CLI request missing")?;
562                let r = &talk.external_requests[pos];
563                // A second worker or uncertain restart cannot repeat a CLI call.
564                if r.status != "accepted" {
565                    return Ok(());
566                }
567                let binding = read_binding(store, request)?;
568                let owner = owner_input(id, talk.turns.get(r.input_turn), r, binding.as_ref())?;
569                let r = &mut talk.external_requests[pos];
570                if owner && !talk.status.open() {
571                    r.status = "not_started".into();
572                    r.error = Some("conversation closed before execution".into());
573                    store.put(&mut talk)?;
574                    return Ok(());
575                }
576                anyhow::ensure!(
577                    r.worker.as_deref().is_none_or(|worker| worker == job.id),
578                    "CLI submission belongs to a different worker"
579                );
580                r.status = "started".into();
581                r.worker = Some(job.id.clone());
582                r.error = None;
583                let index = r.input_turn;
584                store.put(&mut talk)?;
585                (talk, index)
586            };
587            let text = talk
588                .turns
589                .get(index)
590                .context("recorded CLI input is missing")?
591                .body
592                .clone();
593            drop(publication);
594            let (cfg, _) = Config::discover(&talk.repo, None)?;
595            return super::respond_at(&lease, &mut talk, store, &cfg, &text, Some(index)).await;
596        }
597        tokio::time::sleep(Duration::from_millis(100)).await;
598    }
599}
600
601#[cfg(test)]
602mod tests {
603    use super::*;
604
605    #[test]
606    fn stale_owner_admission_cannot_replace_a_request_binding() {
607        let home = tempfile::tempdir().unwrap();
608        let store = Talks::at(home.path().join("talks"));
609        let request = "follow";
610        let first = OwnerBinding {
611            talk: "first".into(),
612            text_sha256: digest("Observe the release"),
613        };
614        let second = OwnerBinding {
615            talk: "second".into(),
616            text_sha256: digest("Observe the release"),
617        };
618
619        // Both admissions observed an absent binding before the second won.
620        assert!(read_binding(&store, request).unwrap().is_none());
621        assert!(reserve_binding(&store, request, &second).unwrap());
622        assert!(!reserve_binding(&store, request, &first).unwrap());
623        assert!(!reserve_binding(&store, request, &second).unwrap());
624        assert!(read_binding(&store, request).unwrap().as_ref() == Some(&second));
625    }
626
627    #[test]
628    fn startup_timeout_preserves_the_reserved_request() {
629        let home = tempfile::tempdir().unwrap();
630        let store = Talks::at(home.path().join("talks"));
631        let mut talk = seeded_for_test("owner", home.path().to_owned());
632        let text = "Observe the release";
633        talk.turns.push(operator_turn(text, Vec::new(), None));
634        let mut record: Request = serde_json::from_value(json!({
635            "request":"follow", "sender":"", "text":text,
636            "input_turn":0, "status":"accepted"
637        }))
638        .unwrap();
639        let id = "12345678-1234-4321-8234-123456789abc";
640        let dir = home.path().join("workers/jobs").join(id);
641        std::fs::create_dir_all(&dir).unwrap();
642        std::fs::write(
643            dir.join("job.json"),
644            json!({
645                "id":id, "kind":"chat", "key":"chat-external:owner:follow",
646                "payload":{"talk":talk.id,"external_request":"follow"},
647                "generation":"fixture", "status":"starting", "created_at":0
648            })
649            .to_string(),
650        )
651        .unwrap();
652        record_launch(
653            &mut record,
654            Err(crate::worker::StartupUnacknowledged { id: id.into() }.into()),
655        );
656        assert_eq!(
657            record.status, "accepted",
658            "the worker must still be admitted"
659        );
660        let queued = view(&store, &talk, &record, true);
661        assert_eq!(queued["status"], "queued");
662        assert_eq!(queued["worker"], id);
663        std::fs::remove_file(dir.join("job.json")).unwrap();
664        assert_eq!(view(&store, &talk, &record, true)["status"], "uncertain");
665    }
666}