feat: implement send/receive/await/cancel concurrency primitives

Add the four worker messaging operations defined in grammar but previously
marked as "parser implementation pending":
- send <expr> to <worker>;    — send a message to a named worker
- receive from <worker>;      — receive a message from a named worker
- await <worker>;             — wait for a worker to complete
- cancel <worker>;            — cancel a running worker

- lexer/token.rs: Add Send, Receive, From, Await, Cancel, Channel tokens
- ast/mod.rs: SendMessage, ReceiveMessage, AwaitWorker, CancelWorker variants
- parser/mod.rs: recursive descent implementations for all four
- visitor/formatter/linter/typechecker: exhaustive match arm coverage
- grammar/wokelang.ebnf: remove "pending" notes, grammar is now canonical

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: hyperpolymath

grammar/wokelang.ebnf

@@ -47,7 +47,6 @@ top_level_item = function_def
 module_import = "use" , qualified_name , [ "renamed" , identifier ] , ";" ;
 
 module_export = "share" , identifier , ";" ;
-(* NOTE: parser implementation pending for module_export *)
 
 qualified_name = identifier , { "." , identifier } ;
 
@@ -152,16 +151,12 @@ superpower_decl = "superpower" , identifier , "{" , { statement } , "}" ;
 worker_spawn = "spawn" , "worker" , identifier , ";" ;
 
 (* --- Worker Messaging --- *)
-(* NOTE: parser implementation pending for send_message *)
 send_message = "send" , expression , "to" , identifier , ";" ;
 
-(* NOTE: parser implementation pending for receive_message *)
 receive_message = "receive" , "from" , identifier , ";" ;
 
-(* NOTE: parser implementation pending for await_worker *)
 await_worker = "await" , identifier , ";" ;
 
-(* NOTE: parser implementation pending for cancel_worker *)
 cancel_worker = "cancel" , identifier , ";" ;
 
 (* ===================================================================== *)

src/ast/mod.rs

@@ -128,6 +128,14 @@ pub enum Statement {
     Expression(Spanned<Expr>),
     /// `spawn worker name;`
     WorkerSpawn(WorkerSpawn),
+    /// `send expr to worker_name;`
+    SendMessage(SendMessage),
+    /// `receive from worker_name;`
+    ReceiveMessage(ReceiveMessage),
+    /// `await worker_name;`
+    AwaitWorker(AwaitWorker),
+    /// `cancel worker_name;`
+    CancelWorker(CancelWorker),
     /// `complain "message";`
     Complain(ComplainStmt),
     /// `@emote statement`
@@ -152,6 +160,10 @@ impl Statement {
             Statement::ConsentBlock(c) => c.span.clone(),
             Statement::Expression(e) => e.span.clone(),
             Statement::WorkerSpawn(w) => w.span.clone(),
+            Statement::SendMessage(s) => s.span.clone(),
+            Statement::ReceiveMessage(r) => r.span.clone(),
+            Statement::AwaitWorker(a) => a.span.clone(),
+            Statement::CancelWorker(c) => c.span.clone(),
             Statement::Complain(c) => c.span.clone(),
             Statement::EmoteAnnotated(e) => e.span.clone(),
             Statement::Decide(d) => d.span.clone(),
@@ -218,6 +230,35 @@ pub struct WorkerSpawn {
     pub span: Span,
 }
 
+/// Send message: `send expr to worker_name;`
+#[derive(Debug, Clone)]
+pub struct SendMessage {
+    pub message: Spanned<Expr>,
+    pub target: String,
+    pub span: Span,
+}
+
+/// Receive message: `receive from worker_name;`
+#[derive(Debug, Clone)]
+pub struct ReceiveMessage {
+    pub source: String,
+    pub span: Span,
+}
+
+/// Await worker: `await worker_name;`
+#[derive(Debug, Clone)]
+pub struct AwaitWorker {
+    pub worker_name: String,
+    pub span: Span,
+}
+
+/// Cancel worker: `cancel worker_name;`
+#[derive(Debug, Clone)]
+pub struct CancelWorker {
+    pub worker_name: String,
+    pub span: Span,
+}
+
 /// Complain statement: `complain "message";`
 #[derive(Debug, Clone)]
 pub struct ComplainStmt {

src/ast/visitor.rs

@@ -101,10 +101,11 @@ pub fn walk_statement<V: Visitor>(v: &mut V, stmt: &Statement) {
             }
         }
         Statement::Expression(e) => v.visit_expr(&e.node),
-        Statement::WorkerSpawn(_)
-        | Statement::Complain(_)
-        | Statement::Break(_)
-        | Statement::Continue(_) => {}
+        Statement::WorkerSpawn(_) | Statement::Complain(_)
+        | Statement::Break(_) | Statement::Continue(_)
+        | Statement::ReceiveMessage(_) | Statement::AwaitWorker(_)
+        | Statement::CancelWorker(_) => {}
+        Statement::SendMessage(s) => v.visit_expr(&s.message.node),
         Statement::EmoteAnnotated(e) => v.visit_statement(&e.statement),
         Statement::Decide(d) => {
             v.visit_expr(&d.scrutinee.node);

src/formatter/mod.rs

@@ -175,6 +175,22 @@ impl Formatter {
                 output.push_str(&indent_str);
                 output.push_str(&format!("spawn worker {};\n", w.worker_name));
             }
+            Statement::SendMessage(s) => {
+                output.push_str(&indent_str);
+                output.push_str(&format!("send ... to {};\n", s.target));
+            }
+            Statement::ReceiveMessage(r) => {
+                output.push_str(&indent_str);
+                output.push_str(&format!("receive from {};\n", r.source));
+            }
+            Statement::AwaitWorker(a) => {
+                output.push_str(&indent_str);
+                output.push_str(&format!("await {};\n", a.worker_name));
+            }
+            Statement::CancelWorker(c) => {
+                output.push_str(&indent_str);
+                output.push_str(&format!("cancel {};\n", c.worker_name));
+            }
             Statement::Complain(_) => {
                 output.push_str(&indent_str);
                 output.push_str("complain ...;\n");

src/lexer/token.rs

@@ -114,6 +114,24 @@ pub enum Token {
     #[token("spawn")]
     Spawn,
 
+    #[token("send")]
+    Send,
+
+    #[token("receive")]
+    Receive,
+
+    #[token("from")]
+    From,
+
+    #[token("await")]
+    Await,
+
+    #[token("cancel")]
+    Cancel,
+
+    #[token("channel")]
+    Channel,
+
     // === Keywords - Pattern Matching ===
     #[token("decide")]
     Decide,
@@ -329,6 +347,12 @@ impl std::fmt::Display for Token {
             Token::Quest => write!(f, "quest"),
             Token::Superpower => write!(f, "superpower"),
             Token::Spawn => write!(f, "spawn"),
+            Token::Send => write!(f, "send"),
+            Token::Receive => write!(f, "receive"),
+            Token::From => write!(f, "from"),
+            Token::Await => write!(f, "await"),
+            Token::Cancel => write!(f, "cancel"),
+            Token::Channel => write!(f, "channel"),
             Token::Decide => write!(f, "decide"),
             Token::Based => write!(f, "based"),
             Token::On => write!(f, "on"),

src/linter/mod.rs

@@ -154,6 +154,8 @@ impl Linter {
                 self.lint_expr(expr);
             }
             Statement::WorkerSpawn(_) => {}
+            Statement::SendMessage(s) => self.lint_expr(&s.message),
+            Statement::ReceiveMessage(_) | Statement::AwaitWorker(_) | Statement::CancelWorker(_) => {}
             Statement::Complain(_) => {}
             Statement::EmoteAnnotated(emote) => {
                 self.lint_statement(&emote.statement);

src/parser/mod.rs

@@ -607,6 +607,10 @@ impl<'a> Parser<'a> {
             Token::Attempt => self.parse_attempt_block(),
             Token::Only => Ok(Statement::ConsentBlock(self.parse_consent_block()?)),
             Token::Spawn => self.parse_worker_spawn(),
+            Token::Send => self.parse_send_message(),
+            Token::Receive => self.parse_receive_message(),
+            Token::Await => self.parse_await_worker(),
+            Token::Cancel => self.parse_cancel_worker(),
             Token::Complain => self.parse_complain(),
             Token::Decide => self.parse_decide(),
             Token::At => self.parse_emote_annotated(),
@@ -811,6 +815,54 @@ impl<'a> Parser<'a> {
         }))
     }
 
+    fn parse_send_message(&mut self) -> Result<Statement, ParseError> {
+        let start = self.current_span().start;
+        self.expect(Token::Send, "send")?;
+        let message = self.parse_expression()?;
+        self.expect(Token::To, "to")?;
+        let (target, _) = self.expect_identifier()?;
+        let end_span = self.expect(Token::Semicolon, ";")?;
+        Ok(Statement::SendMessage(SendMessage {
+            message,
+            target,
+            span: start..end_span.end,
+        }))
+    }
+
+    fn parse_receive_message(&mut self) -> Result<Statement, ParseError> {
+        let start = self.current_span().start;
+        self.expect(Token::Receive, "receive")?;
+        self.expect(Token::From, "from")?;
+        let (source, _) = self.expect_identifier()?;
+        let end_span = self.expect(Token::Semicolon, ";")?;
+        Ok(Statement::ReceiveMessage(ReceiveMessage {
+            source,
+            span: start..end_span.end,
+        }))
+    }
+
+    fn parse_await_worker(&mut self) -> Result<Statement, ParseError> {
+        let start = self.current_span().start;
+        self.expect(Token::Await, "await")?;
+        let (worker_name, _) = self.expect_identifier()?;
+        let end_span = self.expect(Token::Semicolon, ";")?;
+        Ok(Statement::AwaitWorker(AwaitWorker {
+            worker_name,
+            span: start..end_span.end,
+        }))
+    }
+
+    fn parse_cancel_worker(&mut self) -> Result<Statement, ParseError> {
+        let start = self.current_span().start;
+        self.expect(Token::Cancel, "cancel")?;
+        let (worker_name, _) = self.expect_identifier()?;
+        let end_span = self.expect(Token::Semicolon, ";")?;
+        Ok(Statement::CancelWorker(CancelWorker {
+            worker_name,
+            span: start..end_span.end,
+        }))
+    }
+
     fn parse_complain(&mut self) -> Result<Statement, ParseError> {
         let start = self.current_span().start;
         self.expect(Token::Complain, "complain")?;
@@ -1527,7 +1579,7 @@ to greet(name: String) -> String {
                 assert_eq!(func.params.len(), 1);
                 assert_eq!(func.params[0].name, "name");
             }
-            _ => panic!("Expected function"),
+            other => panic!("Expected function, got {other:?}"),
         }
     }
 

src/typechecker/mod.rs

@@ -1351,6 +1351,16 @@ impl TypeChecker {
                 Ok(sub.clone())
             }
 
+            // Worker messaging: send, receive, await, cancel
+            Statement::SendMessage(s) => {
+                self.infer_expr(&s.message, sub)?;
+                Ok(sub.clone())
+            }
+            Statement::ReceiveMessage(_) | Statement::AwaitWorker(_) | Statement::CancelWorker(_) => {
+                // TODO: Check worker/channel exists in scope
+                Ok(sub.clone())
+            }
+
             // Complain statement: complain "message";
             Statement::Complain(_) => Ok(sub.clone()),