diff --git a/.gitignore b/.gitignore index abc9a18..47a3a86 100644 --- a/.gitignore +++ b/.gitignore @@ -10,6 +10,8 @@ /tests/ext/libagent.dylib /tests/ext/skel.mq.md /tests/ext/out-demo.mq.md +/tests/ext/ticket.txt +/tests/ext/ticket-stub.txt /tests/ext/agents/ /tests/ext/runbooks/ /tests/ext/templates/ diff --git a/doc/design/ext-agent.md b/doc/design/ext-agent.md index 3a3682e..9c70f19 100644 --- a/doc/design/ext-agent.md +++ b/doc/design/ext-agent.md @@ -60,6 +60,8 @@ Root markers (any): directory `agents` or `runbooks`, or file `marqdo.agent.json | `agent_ensure_layout` | `root` | int (dirs created) | | `agent_probe` | `root` | map (`has_agents`, …, `root`) | | `agent_scaffold` | `root`, `name`, `template`, `dest` | path written; body substitutes `{{name}}` | +| `agent_match_skill` | `skill`, `members` | member map or `null` (JSON array of objects) | +| `agent_bump_load` | `member`, `delta` | updated member map | Path safety: under `root`; reject `..`. Build: `cargo build -p marqdo_plugin_agent`. @@ -67,13 +69,18 @@ Path safety: under `root`; reject `..`. Build: `cargo build -p marqdo_plugin_age | English | Chinese | Role | |---------|---------|------| -| `## load_native` | `## 加载原生` | Env `MARQDO_AGENT_PLUGIN` → `lib/plugin` load | +| `## load_native` | `## 加载原生` | Env / `ext add` → load ABI plugin | | `# agent` | `# 智能体` | Workspace handle; optional `root=` | -| `## probe` | `## 探测` | Layout probe | -| `## ensure_layout` | `## 确保布局` | Create convention dirs | -| `## scaffold` | `## 脚手架` | `name=` `template=` `dest=` | +| `## probe` / `ensure_layout` / `scaffold` | `## 探测` / `确保布局` / `脚手架` | Layout | +| `## match_skill` | `## 技能匹配` | Match member maps; lowest load | +| `## assign_task` | `## 分配任务` | `{success, task_id, assignee}` | +| `## update_load` | `## 更新负载` | Bump load via ABI | +| `## create_ticket` / `notify` | `## 创建工单` / `通知` | Stubs | +| `## draft_message` | `## 起草消息` | Delegate to `ext/llm` | -Gold: `tests/ext/agent-scaffold.mq.md`. +Multi-column GFM tables → **list of maps** (header keys). Single-column stays list of cells. + +Gold: `tests/ext/agent-scaffold.mq.md`, `tests/ext/agent-assign.mq.md`. --- @@ -152,8 +159,8 @@ Exact helper names (`技能匹配` / `match_skill`, `分配任务` / `assign`, | Slice | Content | |-------|---------| | **A — Install** | [`ext-cli.md`](ext-cli.md): **shipped** `marqdo ext list` / `add` / `remove` | -| **B — Compose LLM** | `ext/agent` frontmatter imports `ext/llm`; helpers that take a model handle or call `complete` internally | -| **C — Match / assign** | Table-oriented match (substring / tag) + optional LLM rerank; assign + load update; escalate / ticket stubs (print or `reports/` files first) | +| **B — Compose LLM** | **shipped**: `ext/agent` imports `ext/llm`; `## draft_message` / `## 起草消息` | +| **C — Match / assign** | **shipped**: multi-column tables → row maps; `match_skill` / `update_load` (ABI); `assign_task`, `create_ticket`, `notify` stubs | | **D — Channels** | Optional notify hooks (mail/chat) via `lib/net` or thin ABI — still no third-party marketplace | | **E — Multi-agent** | Later: handoff between agent programs; out of scope until C is solid | diff --git a/ext/agent.mq.md b/ext/agent.mq.md index 0acf8b8..860fd38 100644 --- a/ext/agent.mq.md +++ b/ext/agent.mq.md @@ -1,14 +1,13 @@ --- title: ext/agent -description: Agent project layout via ABI plugin (English). Not stdlib — import ext/agent.mq.md. +description: Agent development framework (layout ABI + match/assign). Compose with ext/llm. > lib/plugin.mq.md -> lib/sys.mq.md -> lib/json.mq.md +> ext/llm.mq.md --- ## load_native -Load `plugins/agent` shared library. Order: env `MARQDO_AGENT_PLUGIN`, then installed path from `marqdo ext add agent` (`host_ext_native_path`). +Load `plugins/agent` shared library. Order: env `MARQDO_AGENT_PLUGIN`, then `marqdo ext add agent` (`host_ext_native_path`). *`envp` = > env_get name=MARQDO_AGENT_PLUGIN * + `envp` @@ -24,7 +23,7 @@ Load `plugins/agent` shared library. Order: env `MARQDO_AGENT_PLUGIN`, then inst # agent - root -Construct a workspace handle. Optional `root=`; otherwise `agent_find_root` from cwd. +Workspace handle. Optional `root=`; else `agent_find_root` from cwd. + `root` *`r` = `root`* @@ -56,3 +55,63 @@ Construct a workspace handle. Optional `root=`; otherwise `agent_find_root` from *`root` = > get value=`self` key=root * **> agent_scaffold root=`root` name=`name` template=`template` dest=`dest`** + +## match_skill + - skill + - members + +Deterministic skill match over a list of member maps (`技能`/`skills`, `负载`/`load`). Picks lowest load among matches. Returns member map or `None`. + +**> agent_match_skill skill=`skill` members=`members`** + +## assign_task + - task_id + - assignee + +Record a successful assignment (map). Caller updates load separately. + +*`t` = > parse text={"p":"{\"success\":true,\"task_id\":","m":",\"assignee\":","s":"}"} * +*`qid` = > quote text=`task_id` * +*`qa` = > stringify value=`assignee` * +*`p` = > get value=`t` key=p * +*`m` = > get value=`t` key=m * +*`s` = > get value=`t` key=s * +*`raw` = `p` + `qid` + `m` + `qa` + `s` * +**> parse text=`raw`** + +## update_load + - member + - delta + +**> agent_bump_load member=`member` delta=`delta`** + +## create_ticket + - title + - detail + +Stub ticket: ensure layout, write `ticket-stub.txt` under cwd (sandbox). Returns the filename. + +*`_n` = > `self`.ensure_layout * +*`body` = `title` * +*`out` = ticket.txt * +> host_write_text path=ticket.txt text=`body` +**`out`** + +## notify + - to + - text + +Stub channel: print a notification line. + +> print text=notify +> print text=`to` +> print text=`text` +**** + +## draft_message + - model + - prompt + +Optional LLM helper: `model` is an `ext/llm` handle. + +**> `model`.complete prompt=`prompt`** diff --git a/ext/智能体.mq.md b/ext/智能体.mq.md index ecf11b4..20385bc 100644 --- a/ext/智能体.mq.md +++ b/ext/智能体.mq.md @@ -1,14 +1,13 @@ --- title: ext/智能体 -description: 经 ABI 插件的智能体项目布局(中文)。非标准库 — 导入 ext/智能体.mq.md。 +description: 智能体开发框架(布局 ABI + 匹配/派发)。可组合 ext/大模型。 > lib/插件.mq.md -> lib/系统.mq.md -> lib/json.mq.md +> ext/大模型.mq.md --- ## 加载原生 -加载 `plugins/agent` 共享库。顺序:环境变量 `MARQDO_AGENT_PLUGIN`,否则 `marqdo ext add agent` 安装路径(`host_ext_native_path`)。 +加载 `plugins/agent`。顺序:`MARQDO_AGENT_PLUGIN`,否则 `marqdo ext add agent`。 *`环境路径` = > 取环境 名=MARQDO_AGENT_PLUGIN * + `环境路径` @@ -24,8 +23,6 @@ description: 经 ABI 插件的智能体项目布局(中文)。非标准库 # 智能体 - 根 -构造工作区句柄。可选 `根=`;否则从工作目录向上 `agent_find_root`。 - + `根` *`r` = `根`* + * @@ -56,3 +53,53 @@ description: 经 ABI 插件的智能体项目布局(中文)。非标准库 *`root` = > get value=`自` key=root * **> agent_scaffold root=`root` name=`名` template=`模板` dest=`目标`** + +## 技能匹配 + - 技能 + - 成员表 + +**> agent_match_skill skill=`技能` members=`成员表`** + +## 分配任务 + - 任务ID + - 分配给 + +*`t` = > parse text={"p":"{\"success\":true,\"task_id\":","m":",\"assignee\":","s":"}"} * +*`qid` = > quote text=`任务ID` * +*`qa` = > stringify value=`分配给` * +*`p` = > get value=`t` key=p * +*`m` = > get value=`t` key=m * +*`s` = > get value=`t` key=s * +*`raw` = `p` + `qid` + `m` + `qa` + `s` * +**> parse text=`raw`** + +## 更新负载 + - 成员 + - 变化 + +**> agent_bump_load member=`成员` delta=`变化`** + +## 创建工单 + - 标题 + - 详情 + +*`_n` = > `自`.确保布局 * +*`body` = `标题` * +*`out` = ticket.txt * +> host_write_text path=ticket.txt text=`body` +**`out`** + +## 通知 + - 收件人 + - 内容 + +> 打印 内容=notify +> 打印 内容=`收件人` +> 打印 内容=`内容` +**** + +## 起草消息 + - 模型 + - 提示 + +**> `模型`.运行 提示=`提示`** diff --git a/plugins/agent/src/lib.rs b/plugins/agent/src/lib.rs index 93c768e..430b192 100644 --- a/plugins/agent/src/lib.rs +++ b/plugins/agent/src/lib.rs @@ -183,6 +183,95 @@ fn scaffold(root: &Path, name: &str, template: &str, dest: &str) -> Result(m: &'a serde_json::Value, keys: &[&str]) -> Option<&'a str> { + let obj = m.as_object()?; + for k in keys { + if let Some(v) = obj.get(*k) { + if let Some(s) = v.as_str() { + return Some(s); + } + if let Some(n) = v.as_i64() { + // allow numeric fields to be read as display later + let _ = n; + } + } + } + None +} + +fn map_get_i64(m: &serde_json::Value, keys: &[&str]) -> i64 { + let Some(obj) = m.as_object() else { + return i64::MAX; + }; + for k in keys { + if let Some(v) = obj.get(*k) { + if let Some(n) = v.as_i64() { + return n; + } + if let Some(s) = v.as_str() { + if let Ok(n) = s.parse::() { + return n; + } + } + } + } + i64::MAX +} + +fn skills_text(m: &serde_json::Value) -> String { + map_get_str(m, &["技能", "skills", "skill"]) + .unwrap_or("") + .to_string() +} + +fn match_skill(skill: &str, members: &serde_json::Value) -> Result { + let arr = members + .as_array() + .ok_or_else(|| "members must be a JSON array".to_string())?; + let skill = skill.trim(); + if skill.is_empty() { + return Err("skill is empty".into()); + } + let mut best: Option<&serde_json::Value> = None; + let mut best_load = i64::MAX; + for m in arr { + let sk = skills_text(m); + if sk.split(',').any(|p| p.trim() == skill) || sk.contains(skill) { + let load = map_get_i64(m, &["负载", "load"]); + if load < best_load { + best_load = load; + best = Some(m); + } + } + } + Ok(best.cloned().unwrap_or(serde_json::Value::Null)) +} + +fn bump_load(member: &serde_json::Value, delta: i64) -> Result { + let mut obj = member + .as_object() + .cloned() + .ok_or_else(|| "member must be a JSON object".to_string())?; + let key = if obj.contains_key("负载") { + "负载" + } else if obj.contains_key("load") { + "load" + } else { + obj.insert("负载".into(), serde_json::Value::Number(0.into())); + "负载" + }; + let cur = match obj.get(key) { + Some(serde_json::Value::Number(n)) => n.as_i64().unwrap_or(0), + Some(serde_json::Value::String(s)) => s.parse().unwrap_or(0), + _ => 0, + }; + obj.insert( + key.into(), + serde_json::Value::Number((cur + delta).into()), + ); + Ok(serde_json::Value::Object(obj)) +} + unsafe extern "C" fn agent_find_root( args_json: *const c_char, out_json: *mut *mut c_char, @@ -335,6 +424,99 @@ unsafe extern "C" fn agent_scaffold( } } +unsafe extern "C" fn agent_match_skill( + args_json: *const c_char, + out_json: *mut *mut c_char, + err_msg: *mut *mut c_char, +) -> c_int { + let v = match parse_args(args_json) { + Ok(v) => v, + Err(e) => { + set_err(err_msg, &format!("agent_match_skill: {e}")); + return 1; + } + }; + let skill = match arg_str(&v, "skill") { + Ok(s) => s, + Err(e) => { + set_err(err_msg, &format!("agent_match_skill: {e}")); + return 1; + } + }; + let members = match v.get("members") { + Some(m) => m.clone(), + None => { + set_err(err_msg, "agent_match_skill: missing members"); + return 1; + } + }; + // members may be a JSON string (from Marqdo stringify) or already an array + let members = if let Some(s) = members.as_str() { + match serde_json::from_str::(s) { + Ok(j) => j, + Err(e) => { + set_err(err_msg, &format!("agent_match_skill: members JSON: {e}")); + return 1; + } + } + } else { + members + }; + match match_skill(skill, &members) { + Ok(j) => { + set_out(out_json, &j.to_string()); + 0 + } + Err(e) => { + set_err(err_msg, &format!("agent_match_skill: {e}")); + 1 + } + } +} + +unsafe extern "C" fn agent_bump_load( + args_json: *const c_char, + out_json: *mut *mut c_char, + err_msg: *mut *mut c_char, +) -> c_int { + let v = match parse_args(args_json) { + Ok(v) => v, + Err(e) => { + set_err(err_msg, &format!("agent_bump_load: {e}")); + return 1; + } + }; + let member = match v.get("member") { + Some(m) => m.clone(), + None => { + set_err(err_msg, "agent_bump_load: missing member"); + return 1; + } + }; + let member = if let Some(s) = member.as_str() { + match serde_json::from_str::(s) { + Ok(j) => j, + Err(e) => { + set_err(err_msg, &format!("agent_bump_load: member JSON: {e}")); + return 1; + } + } + } else { + member + }; + let delta = v.get("delta").and_then(|x| x.as_i64()).unwrap_or(1); + match bump_load(&member, delta) { + Ok(j) => { + set_out(out_json, &j.to_string()); + 0 + } + Err(e) => { + set_err(err_msg, &format!("agent_bump_load: {e}")); + 1 + } + } +} + fn register(host: &MarqdoHostApi, name: &str, params: &str, fn_ptr: PluginFn) -> c_int { let register = match host.register_fn { Some(f) => f, @@ -376,6 +558,12 @@ pub unsafe extern "C" fn marqdo_plugin_init(host: *const MarqdoHostApi) -> c_int { return 1; } + if register(host, "agent_match_skill", "skill,members", agent_match_skill) != 0 { + return 1; + } + if register(host, "agent_bump_load", "member,delta", agent_bump_load) != 0 { + return 1; + } 0 } diff --git a/src/ast.rs b/src/ast.rs index fab421b..918d0e5 100644 --- a/src/ast.rs +++ b/src/ast.rs @@ -100,6 +100,8 @@ pub enum Expr { }, Call(CallExpr), List(Vec), + /// Object literal / table row (`map` value). + Map(Vec<(String, Expr)>), /// Parsed `$$…$$` formula tree (from assignment RHS). Formula(FormulaExpr), /// Bound ```lang … ``` fence (`code` value). diff --git a/src/bytecode/compile.rs b/src/bytecode/compile.rs index 1f5e657..98317ee 100644 --- a/src/bytecode/compile.rs +++ b/src/bytecode/compile.rs @@ -792,6 +792,14 @@ impl<'a> FnCompiler<'a> { } self.emit(Op::BuildList(items.len() as u16)); } + Expr::Map(pairs) => { + for (k, e) in pairs { + let ki = self.add_const(Value::Text(k.clone())); + self.emit(Op::Constant(ki)); + self.compile_expr(e)?; + } + self.emit(Op::BuildMap(pairs.len() as u16)); + } Expr::Formula(e) => { let i = self.add_const(Value::Formula(e.clone())); self.emit(Op::Constant(i)); diff --git a/src/bytecode/mod.rs b/src/bytecode/mod.rs index d192d0d..b1b430e 100644 --- a/src/bytecode/mod.rs +++ b/src/bytecode/mod.rs @@ -37,6 +37,8 @@ pub enum Op { /// Pop prompt text, print it (no newline), read one stdin line → push Text. Input, BuildList(u16), + /// Stack (bottom→top): k0, v0, k1, v1, … (n pairs); push Map. + BuildMap(u16), /// Pop value → push `len` (text/list). Len, /// Pop value → push display text. diff --git a/src/bytecode/vm.rs b/src/bytecode/vm.rs index 9c8ecb3..3cdf970 100644 --- a/src/bytecode/vm.rs +++ b/src/bytecode/vm.rs @@ -253,6 +253,23 @@ impl Vm { items.reverse(); stack.push(Value::List(items)); } + Op::BuildMap(n) => { + let n = n as usize; + let mut pairs = Vec::with_capacity(n); + for _ in 0..n { + let v = pop(&mut stack).map_err(|m| self.err_at(span, m))?; + let k = pop(&mut stack).map_err(|m| self.err_at(span, m))?; + let ks = match k { + Value::Text(s) => s, + _ => { + return Err(self.err_at(span, "map key must be text")); + } + }; + pairs.push((ks, v)); + } + pairs.reverse(); + stack.push(Value::Map(pairs)); + } Op::Len => { let v = pop(&mut stack).map_err(|m| self.err_at(span, m))?; let n = builtin_len(&v).map_err(|m| self.err_at(span, m))?; diff --git a/src/interp.rs b/src/interp.rs index ce78746..76db71b 100644 --- a/src/interp.rs +++ b/src/interp.rs @@ -408,6 +408,13 @@ impl Interpreter { } Ok(Value::List(out)) } + Expr::Map(pairs) => { + let mut out = Vec::new(); + for (k, e) in pairs { + out.push((k.clone(), self.eval_expr(module, fun, env, e)?)); + } + Ok(Value::Map(out)) + } Expr::Formula(e) => Ok(Value::Formula(e.clone())), Expr::Code(c) => Ok(Value::Code(c.clone())), } diff --git a/src/parse/mod.rs b/src/parse/mod.rs index 0dc7e67..3411e6e 100644 --- a/src/parse/mod.rs +++ b/src/parse/mod.rs @@ -307,10 +307,7 @@ impl<'a> Cursor<'a> { } else { span.line }; - return Ok(( - Expr::List(list.into_iter().map(Expr::Literal).collect()), - end_line, - )); + return Ok((Expr::List(list), end_line)); } if let Some(expr) = try_parse_inline_formula(rhs)? { return Ok((expr, span.line)); @@ -433,9 +430,10 @@ impl<'a> Cursor<'a> { Ok((Expr::Formula(expr), end_line)) } - fn consume_table(&mut self) -> Result> { + fn consume_table(&mut self) -> Result> { self.skip_noise(); - let mut rows = Vec::new(); + let mut header: Vec = Vec::new(); + let mut rows: Vec = Vec::new(); let mut header_done = false; let mut sep_done = false; while let Some(l) = self.peek() { @@ -449,20 +447,31 @@ impl<'a> Cursor<'a> { self.bump(); let cells = split_table_row(t); if !header_done { + header = cells; header_done = true; continue; } - if !sep_done && cells.iter().all(|c| c.chars().all(|ch| ch == '-' || ch == ':' || ch.is_whitespace() || ch == '|')) + if !sep_done + && cells + .iter() + .all(|c| c.chars().all(|ch| ch == '-' || ch == ':' || ch.is_whitespace())) { - // separator row like |----| sep_done = true; continue; } - // data row — single column examples: take first cell - if let Some(cell) = cells.first() { - rows.push(Literal::Text(cell.clone())); - } sep_done = true; + if header.len() <= 1 { + if let Some(cell) = cells.first() { + rows.push(Expr::Literal(cell_literal(cell))); + } + } else { + let mut pairs = Vec::new(); + for (i, key) in header.iter().enumerate() { + let raw = cells.get(i).map(|s| s.as_str()).unwrap_or(""); + pairs.push((key.clone(), Expr::Literal(cell_literal(raw)))); + } + rows.push(Expr::Map(pairs)); + } } if !header_done { bail!("expected GFM table after empty assignment"); @@ -712,6 +721,17 @@ fn indent_of(text: &str) -> usize { .sum() } +fn cell_literal(raw: &str) -> Literal { + let t = raw.trim(); + let digits = |s: &str| !s.is_empty() && s.bytes().all(|b| b.is_ascii_digit()); + if digits(t) || t.strip_prefix('-').is_some_and(digits) { + if let Ok(n) = t.parse::() { + return Literal::Int(n); + } + } + Literal::Text(t.to_string()) +} + fn split_table_row(line: &str) -> Vec { let t = line.trim(); let t = t.strip_prefix('|').unwrap_or(t); diff --git a/src/value.rs b/src/value.rs index 633f2fd..2825d9c 100644 --- a/src/value.rs +++ b/src/value.rs @@ -19,7 +19,7 @@ pub enum Value { /// Floating-point number (`type` → `num`). Num(f64), Text(String), - /// Single-column table rows (v0); multi-column later. + /// Single-column table rows, or list of row maps for multi-column tables. List(Vec), /// JSON object / string-keyed map (insertion order). Map(Vec<(String, Value)>), diff --git a/src/view/render.rs b/src/view/render.rs index 4ab9aca..67cb832 100644 --- a/src/view/render.rs +++ b/src/view/render.rs @@ -117,6 +117,11 @@ fn collect_input_prompts_expr(expr: &Expr, out: &mut Vec) { collect_input_prompts_expr(e, out); } } + Expr::Map(pairs) => { + for (_, e) in pairs { + collect_input_prompts_expr(e, out); + } + } Expr::Literal(_) | Expr::Var(_) | Expr::Interp(_) | Expr::Formula(_) | Expr::Code(_) => {} } } @@ -644,6 +649,13 @@ fn expr_prec(expr: &Expr, parent_prec: u8) -> String { let parts: Vec = items.iter().map(|e| expr_prec(e, 0)).collect(); format!("[{}]", parts.join(", ")) } + Expr::Map(pairs) => { + let parts: Vec = pairs + .iter() + .map(|(k, e)| format!("{}: {}", k, expr_prec(e, 0))) + .collect(); + format!("{{{}}}", parts.join(", ")) + } Expr::Formula(e) => format!("$$ {} $$", e.as_display()), Expr::Code(c) => format!("```{} …```", c.lang), } diff --git a/tests/ext/agent-assign.mq.md b/tests/ext/agent-assign.mq.md new file mode 100644 index 0000000..150fe49 --- /dev/null +++ b/tests/ext/agent-assign.mq.md @@ -0,0 +1,35 @@ +--- +title: ext/agent match and assign +description: Multi-column tables + skill match (needs MARQDO_AGENT_PLUGIN). +> ext/agent.mq.md +--- + +# main + +> load_native + +*`cwd` = > cwd * +*`bot` = > agent root=`cwd` * + +`技能表` = +| 成员 | 技能 | 负载 | +|------|------|------| +| 张三 | Python, ML | 2 | +| 李四 | 前端, UX | 1 | +| 王五 | 后端, 运维 | 3 | +| 赵六 | 数据分析 | 0 | + +*`m` = > `bot`.match_skill skill=Python members=`技能表` * +*`name` = > get value=`m` key=成员 * +> print text=`name` + +*`m2` = > `bot`.match_skill skill=安全审计 members=`技能表` * ++ `m2` + > print text=unexpected-match ++ * + *`path` = > `bot`.create_ticket title=no_owner detail=security * + > print text=`path` + +*`m3` = > `bot`.update_load member=`m` delta=1 * +*`load` = > get value=`m3` key=负载 * +> print text=`load` diff --git a/tests/gold.rs b/tests/gold.rs index fbfd8ff..f7ce569 100644 --- a/tests/gold.rs +++ b/tests/gold.rs @@ -728,6 +728,45 @@ fn ext_cli_add_agent_with_native() { assert!(tmp.join("agent.plugin").is_file()); } +#[test] +fn ext_agent_assign() { + let status = Command::new(env!("CARGO")) + .args(["build", "-p", "marqdo_plugin_agent"]) + .status() + .expect("cargo build plugin agent"); + assert!(status.success(), "failed to build marqdo_plugin_agent"); + + let lib_name = if cfg!(windows) { + "agent.dll" + } else if cfg!(target_os = "macos") { + "libagent.dylib" + } else { + "libagent.so" + }; + let built = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("target") + .join("debug") + .join(lib_name); + let ext_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")) + .join("tests") + .join("ext"); + let plugin = ext_dir.join(lib_name); + std::fs::copy(&built, &plugin).expect("copy agent plugin"); + let _ = std::fs::remove_file(ext_dir.join("ticket.txt")); + let _ = std::fs::remove_file(ext_dir.join("ticket-stub.txt")); + + let output = Command::new(env!("CARGO_BIN_EXE_marqdo")) + .args(["run", "tests/ext/agent-assign.mq.md"]) + .env("MARQDO_AGENT_PLUGIN", lib_name) + .output() + .expect("run agent-assign"); + let code = output.status.code().unwrap_or(1); + let stdout = String::from_utf8_lossy(&output.stdout); + let stderr = String::from_utf8_lossy(&output.stderr); + assert_eq!(code, 0, "agent-assign stderr={stderr}"); + assert_eq!(stdout.trim_end(), "张三\nticket.txt\n3", "agent-assign"); +} + #[test] fn ext_agent_scaffold() { let status = Command::new(env!("CARGO"))