Skip to main content

vibe/task_scheduler/
execution.rs

1use super::registry::*;
2use crate::{
3    bind::Host,
4    error::Diagnostic,
5    eval::{Engine, Env},
6    span::Span,
7    value::Value,
8};
9use std::collections::BTreeMap;
10
11/// An unwind cannot leave a task eligible for a second effectful execution.
12struct ExecutionClaim {
13    _scope: TaskScope,
14    id: u64,
15}
16impl Drop for ExecutionClaim {
17    fn drop(&mut self) {
18        if let Ok(mut tasks) = registry().lock() {
19            if let Some(entry) = tasks.get_mut(&self.id) {
20                executor_checkpoint(entry);
21                if entry.state == State::Running {
22                    entry.state = State::Failed;
23                    entry.failure =
24                        Some("task execution unwound; prior effects require reconciliation".into());
25                }
26            }
27        }
28    }
29}
30
31pub fn await_scheduled_value<H: Host>(
32    engine: &mut Engine<'_, H>,
33    value: Value,
34    env: &mut Env,
35    span: Span,
36) -> Result<Value, Diagnostic> {
37    match value {
38        Value::Record(rec) if is_task_record(&rec) => join(engine, env, Value::Record(rec), span),
39        Value::Lambda { params, body } if params.is_empty() => engine.eval_expr(&body, env),
40        other => Ok(other),
41    }
42}
43
44fn join<H: Host>(
45    engine: &mut Engine<'_, H>,
46    env: &mut Env,
47    handle: Value,
48    span: Span,
49) -> Result<Value, Diagnostic> {
50    if engine.active_tasks.len() >= 8 {
51        return Err(error(span, "nested synchronous task limit exceeded (8)"));
52    }
53    let scope = env.task_scope.clone();
54    let (id, source) = {
55        let mut tasks = registry()
56            .lock()
57            .map_err(|_| error(span, "task registry is poisoned"))?;
58        let entry = owned(&scope, &mut tasks, &handle, span)?;
59        refresh_observer(entry);
60        match entry.state {
61            State::Completed => return Ok(record(entry)),
62            State::Running => return Err(error(
63                span,
64                "task already has an executor; synchronous await cannot suspend or run it twice",
65            )),
66            State::Cancelled | State::TimedOut | State::Failed => {
67                return Err(error(
68                    span,
69                    entry
70                        .failure
71                        .as_deref()
72                        .unwrap_or("task is terminal without a successful result"),
73                ))
74            }
75            State::Pending => {}
76        }
77        entry.state = State::Running;
78        (entry.id, entry.code.clone())
79    };
80    let claim = ExecutionClaim {
81        _scope: scope.clone(),
82        id,
83    };
84    let pinned_registry_gen = engine.extension_registry.generation();
85    let pinned_policy_gen = engine
86        .sentinel_gate
87        .as_ref()
88        .map(|g| g.current_policy_generation());
89    engine.active_tasks.push((scope.clone(), id));
90    let output = execute(engine, env, &source, span);
91    engine.active_tasks.pop();
92    let output = output.and_then(|value| {
93        if engine.extension_registry.generation() != pinned_registry_gen {
94            return Err(crate::extension_registry::trap_to_diagnostic(
95                vibescript_abi::VibeTrap::StaleRegistryGeneration,
96                "task.await",
97                span,
98            ));
99        }
100        if engine
101            .sentinel_gate
102            .as_ref()
103            .map(|g| g.current_policy_generation())
104            != pinned_policy_gen
105        {
106            return Err(crate::extension_registry::trap_to_diagnostic(
107                vibescript_abi::VibeTrap::MidExecutionPolicyRevoked,
108                "task.await",
109                span,
110            ));
111        }
112        let bytes = retained_bytes(&value, span)?;
113        engine.charge_task_source((bytes as u64).saturating_mul(2), span)?;
114        Ok((value, bytes))
115    });
116    let mut tasks = registry()
117        .lock()
118        .map_err(|_| error(span, "task registry is poisoned"))?;
119    let output = output.and_then(|(value, bytes)| {
120        admit_bytes(&scope, &tasks, bytes, span)?;
121        Ok((value, bytes))
122    });
123    let entry = owned(&scope, &mut tasks, &handle, span)?;
124    executor_checkpoint(entry); // The actual executor has returned from native code.
125    if entry.state != State::Running {
126        return Err(error(
127            span,
128            "task cancelled or deadline expired; prior external effects may require reconciliation",
129        ));
130    }
131    match output {
132        Ok((value, bytes)) => {
133            entry.retained_bytes += bytes;
134            entry.result = Some(value);
135            entry.state = State::Completed;
136        }
137        Err(diag) => {
138            entry.failure = Some(diag.message.clone());
139            entry.state = State::Failed;
140            return Err(diag);
141        }
142    }
143    let result = record(entry);
144    drop(tasks);
145    drop(claim);
146    Ok(result)
147}
148
149fn execute<H: Host>(
150    engine: &mut Engine<'_, H>,
151    env: &mut Env,
152    source: &str,
153    span: Span,
154) -> Result<Value, Diagnostic> {
155    let resolved;
156    let source = if source.trim().starts_with("sha256:") {
157        resolved = crate::stdlib_v2::topology_and_manifold::effects_and_systems::lookup_verified_ast_source(source.trim())
158            .ok_or_else(|| error(span, "task content-addressed source is unavailable or failed verification"))?;
159        resolved.trim()
160    } else {
161        source.trim()
162    };
163    if source.len() > 65_536 {
164        return Err(error(span, "resolved task source exceeds 65536 bytes"));
165    }
166    // Select from complete parser results before checking or executing anything.
167    // The cell parser handles comments before '='; full programs may start with
168    // imports, requirements or any declaration rather than a keyword heuristic.
169    let explicit_cell = crate::parse_cell(source);
170    if let Ok(expression) = explicit_cell {
171        crate::check_cell(&expression)?;
172        return engine.eval_expr(&expression, env);
173    }
174    match crate::parse_program(source) {
175        Ok(program) => {
176            crate::check_program(&program)?;
177            engine.eval_task_program(&program, env, span)
178        }
179        Err(program_error) => {
180            // Legacy bare-expression payloads retain their implicit '=' profile.
181            // This is parse-only fallback, never a retry after checking/effects.
182            let expression = match crate::parse_cell(&format!("= {source}")) {
183                Ok(expression) => expression,
184                Err(_) => return Err(program_error),
185            };
186            crate::check_cell(&expression)?;
187            engine.eval_expr(&expression, env)
188        }
189    }
190}
191
192/// Routing occurs only after the Engine phase gate. No fresh host or budget is created.
193pub(crate) fn dispatch_on_engine<H: Host>(
194    engine: &mut Engine<'_, H>,
195    path: &str,
196    args: &[Value],
197    env: &mut Env,
198    span: Span,
199) -> Result<Option<Value>, Diagnostic> {
200    let scope = env.task_scope.clone();
201    let first = || {
202        args.first()
203            .ok_or_else(|| error(span, "task operation requires an argument"))
204    };
205    let result = match path {
206        "task.spawn" => {
207            let code = first()?
208                .as_str()
209                .ok_or_else(|| error(span, "task.spawn expects source text"))?;
210            // Legacy args remain inert metadata: they never grant scope, authority or elapsed time.
211            engine.charge_task_source(code.len() as u64, span)?;
212            spawn(&scope, code, span)?
213        }
214        "code.spawn_at" => {
215            let node = first()?
216                .as_str()
217                .ok_or_else(|| error(span, "code.spawn_at expects a node identifier"))?;
218            if node != "did:q42:local_scheduler" {
219                return Err(error(
220                    span,
221                    "remote/provider task launch is unsupported; no admitted provider is connected",
222                ));
223            }
224            let code = args
225                .get(1)
226                .and_then(Value::as_str)
227                .ok_or_else(|| error(span, "code.spawn_at expects source or a verified digest"))?;
228            if code.starts_with("sha256:") && crate::stdlib_v2::topology_and_manifold::effects_and_systems::lookup_verified_ast_source(code).is_none() {
229                return Err(error(span, "content-addressed task source is unavailable"));
230            }
231            engine.charge_task_source(code.len() as u64, span)?;
232            spawn(&scope, code, span)?
233        }
234        "task.await" => await_scheduled_value(engine, first()?.clone(), env, span)?,
235        "task.status" => status(&scope, first()?, span)?,
236        "task.cancel" => cancel(&scope, first()?, span)?,
237        "task.with_timeout" => {
238            let ms = args
239                .get(1)
240                .and_then(Value::as_i64)
241                .ok_or_else(|| error(span, "task.with_timeout expects integer milliseconds"))?;
242            timeout(&scope, first()?, ms, span)?
243        }
244        "task.nursery" => nursery(engine, env, first()?, span)?,
245        _ => return Ok(None),
246    };
247    Ok(Some(result))
248}
249
250fn nursery<H: Host>(
251    engine: &mut Engine<'_, H>,
252    env: &mut Env,
253    input: &Value,
254    span: Span,
255) -> Result<Value, Diagnostic> {
256    let Value::List(tasks) = input else {
257        return Err(error(span, "task.nursery expects task handles"));
258    };
259    if tasks.len() > 256 {
260        return Err(error(span, "task nursery capacity exceeds 256"));
261    }
262    // Validate the complete group before effects. Authored status cannot certify failure or success.
263    let mut known_failure = false;
264    for task in tasks {
265        let Value::Record(current) = status(&env.task_scope, task, span)? else {
266            unreachable!()
267        };
268        known_failure |= matches!(
269            current.get("status").and_then(Value::as_str),
270            Some("failed" | "cancelled" | "timed_out")
271        );
272    }
273    let mut results = Vec::with_capacity(tasks.len());
274    let mut failure = known_failure
275        .then(|| "nursery already contains a failed, cancelled or timed-out task".to_string());
276    let mut cancelled_count = 0u64;
277    let mut requested_count = 0u64;
278    for task in tasks {
279        if failure.is_some() {
280            let cancelled = cancel(&env.task_scope, task, span)?;
281            if let Value::Record(record) = &cancelled {
282                cancelled_count +=
283                    u64::from(record.get("live_job_cancelled") == Some(&Value::Bool(true)));
284                requested_count += u64::from(
285                    record.get("cancellation_request_accepted") == Some(&Value::Bool(true)),
286                );
287            }
288            results.push(cancelled);
289        } else {
290            match join(engine, env, task.clone(), span) {
291                Ok(result) => results.push(result),
292                Err(diag) => {
293                    failure = Some(diag.message);
294                    results.push(status(&env.task_scope, task, span)?);
295                }
296            }
297        }
298    }
299    let mut out = BTreeMap::new();
300    out.insert("all_succeeded".into(), Value::Bool(failure.is_none()));
301    out.insert(
302        "cancelled_siblings".into(),
303        Value::Bool(cancelled_count > 0),
304    );
305    out.insert(
306        "live_siblings_cancelled".into(),
307        Value::U64(cancelled_count),
308    );
309    out.insert(
310        "cancellation_requested".into(),
311        Value::Bool(requested_count > 0),
312    );
313    out.insert(
314        "cancellation_requested_count".into(),
315        Value::U64(requested_count),
316    );
317    out.insert("tasks".into(), Value::List(results));
318    out.insert(
319        "execution_qualification".into(),
320        Value::String("sequential_local_nursery_no_async_suspension".into()),
321    );
322    if let Some(message) = failure {
323        out.insert("error".into(), Value::String(message));
324    }
325    Ok(Value::Record(out))
326}