1use std::path::Path;
2
3use anyhow::{Context, Result};
4use serde::Deserialize;
5use tracing::warn;
6
7use super::{GeneratedTask, TaskSpec};
8use crate::task::load_tasks_from_dir;
9
10#[derive(Debug, Deserialize)]
11struct Frontmatter {
12 title: Option<String>,
13 priority: Option<String>,
14 depends_on: Option<Vec<u32>>,
15 tags: Option<Vec<String>>,
16}
17
18pub fn parse_planning_response(response: &str) -> Vec<TaskSpec> {
20 let mut specs = Vec::new();
21 let trimmed = response.trim();
22 if trimmed.is_empty() {
23 return specs;
24 }
25
26 let mut rest = trimmed;
27 loop {
28 rest = rest.trim_start();
29 let Some(after_open) = rest.strip_prefix("---") else {
30 break;
31 };
32 let after_open = after_open.strip_prefix('\n').unwrap_or(after_open);
33 let Some(frontmatter_end) = after_open.find("\n---") else {
34 warn!("skipping tact block with unterminated frontmatter");
35 break;
36 };
37
38 let frontmatter_raw = &after_open[..frontmatter_end];
39 let after_frontmatter = &after_open[frontmatter_end + 4..];
40 let body_start = after_frontmatter
41 .strip_prefix('\n')
42 .unwrap_or(after_frontmatter);
43
44 let next_block = body_start.find("\n---");
45 let (body_raw, next_rest) = match next_block {
46 Some(index) => (&body_start[..index], Some(&body_start[index..])),
47 None => (body_start, None),
48 };
49
50 match serde_yaml::from_str::<Frontmatter>(frontmatter_raw) {
51 Ok(frontmatter) => {
52 let Some(title) = frontmatter.title.map(|title| title.trim().to_string()) else {
53 warn!("skipping tact block without title");
54 rest = next_rest.unwrap_or("");
55 continue;
56 };
57 if title.is_empty() {
58 warn!("skipping tact block with empty title");
59 rest = next_rest.unwrap_or("");
60 continue;
61 }
62 let body = body_raw.trim().to_string();
63 specs.push(TaskSpec {
64 title,
65 body,
66 priority: frontmatter.priority.map(|value| value.trim().to_string()),
67 depends_on: frontmatter.depends_on.unwrap_or_default(),
68 tags: frontmatter.tags.unwrap_or_default(),
69 });
70 }
71 Err(error) => warn!(%error, "skipping tact block with malformed frontmatter"),
72 }
73
74 rest = next_rest.unwrap_or("");
75 if rest.trim().is_empty() {
76 break;
77 }
78 }
79
80 specs
81}
82
83pub fn parse_task_specs(response: &str) -> Vec<TaskSpec> {
84 parse_planning_response(response)
85}
86
87fn build_create_task_args(spec: &TaskSpec) -> Vec<String> {
88 let mut args = vec![
89 "create".to_string(),
90 spec.title.clone(),
91 "--body".to_string(),
92 spec.body.clone(),
93 ];
94 if let Some(priority) = spec.priority.as_deref() {
95 args.push("--priority".to_string());
96 args.push(priority.to_string());
97 }
98 if !spec.tags.is_empty() {
99 args.push("--tags".to_string());
100 args.push(spec.tags.join(","));
101 }
102 if !spec.depends_on.is_empty() {
103 args.push("--depends-on".to_string());
104 args.push(
105 spec.depends_on
106 .iter()
107 .map(u32::to_string)
108 .collect::<Vec<_>>()
109 .join(","),
110 );
111 }
112 args
113}
114
115fn normalize_generated_text(value: &str) -> String {
116 let mut normalized = String::with_capacity(value.len());
117 let mut last_was_space = false;
118
119 for ch in value.chars().flat_map(char::to_lowercase) {
120 if ch.is_ascii_alphanumeric() {
121 normalized.push(ch);
122 last_was_space = false;
123 } else if !last_was_space {
124 normalized.push(' ');
125 last_was_space = true;
126 }
127 }
128
129 normalized.trim().to_string()
130}
131
132fn normalize_generated_title(title: &str) -> String {
133 normalize_generated_text(title)
134}
135
136fn normalize_generated_body(body: &str) -> String {
137 normalize_generated_text(body)
138}
139
140fn is_open_task_status(status: &str) -> bool {
141 !matches!(status, "done" | "archived")
142}
143
144fn generated_task_equivalence_key(task: &GeneratedTask) -> String {
145 let mut tags = task
146 .tags
147 .iter()
148 .map(|tag| normalize_generated_text(tag))
149 .filter(|tag| !tag.is_empty())
150 .collect::<Vec<_>>();
151 tags.sort();
152 tags.dedup();
153
154 let priority = task
155 .priority
156 .as_deref()
157 .map(normalize_generated_text)
158 .unwrap_or_default();
159 let depends_on = task
160 .depends_on
161 .iter()
162 .map(u32::to_string)
163 .collect::<Vec<_>>()
164 .join(",");
165
166 format!(
167 "{}|{}|{}|{}",
168 normalize_generated_body(&task.body),
169 priority,
170 tags.join(","),
171 depends_on
172 )
173}
174
175fn looks_like_raw_test_log(body: &str) -> bool {
176 let has_running_header = body.lines().any(|line| {
177 let trimmed = line.trim();
178 trimmed.starts_with("running ") && trimmed.ends_with(" tests")
179 });
180 let test_line_count = body
181 .lines()
182 .filter(|line| line.trim_start().starts_with("test "))
183 .count();
184 let has_failure_marker = body.lines().any(|line| {
185 let trimmed = line.trim();
186 trimmed.ends_with("FAILED")
187 || trimmed.starts_with("failures:")
188 || trimmed.starts_with("error:")
189 || trimmed.contains("panicked at")
190 || trimmed.contains("No such file or directory")
191 });
192
193 (has_running_header && has_failure_marker && test_line_count >= 1)
194 || (has_running_header && test_line_count >= 3)
195 || (test_line_count >= 5 && has_failure_marker)
196}
197
198fn sanitize_generated_task(spec: &GeneratedTask) -> Option<GeneratedTask> {
199 let title = spec.title.trim();
200 let body = spec.body.trim();
201
202 if title.is_empty() {
203 warn!("rejecting generated task with empty title");
204 return None;
205 }
206 if body.is_empty() {
207 warn!(title, "rejecting generated task with empty body");
208 return None;
209 }
210 if looks_like_raw_test_log(body) {
211 warn!(title, "rejecting generated task with raw log body");
212 return None;
213 }
214
215 Some(GeneratedTask {
216 title: title.to_string(),
217 body: body.to_string(),
218 priority: spec.priority.as_ref().map(|value| value.trim().to_string()),
219 depends_on: spec.depends_on.clone(),
220 tags: spec.tags.iter().map(|tag| tag.trim().to_string()).collect(),
221 })
222}
223
224pub(crate) fn dedupe_generated_tasks(
225 existing: &[crate::task::Task],
226 proposed: Vec<GeneratedTask>,
227) -> Vec<GeneratedTask> {
228 let mut open_titles = existing
229 .iter()
230 .filter(|task| is_open_task_status(&task.status))
231 .map(|task| normalize_generated_title(&task.title))
232 .filter(|title| !title.is_empty())
233 .collect::<std::collections::HashSet<_>>();
234 let mut open_specs = existing
235 .iter()
236 .filter(|task| is_open_task_status(&task.status))
237 .filter_map(|task| {
238 let body = task.description.trim();
239 if body.is_empty() {
240 return None;
241 }
242 Some(generated_task_equivalence_key(&GeneratedTask {
243 title: task.title.clone(),
244 body: body.to_string(),
245 priority: Some(task.priority.clone()),
246 depends_on: task.depends_on.clone(),
247 tags: task.tags.clone(),
248 }))
249 })
250 .collect::<std::collections::HashSet<_>>();
251 let mut seen_titles = std::collections::HashSet::new();
252 let mut seen_specs = std::collections::HashSet::new();
253 let mut deduped = Vec::with_capacity(proposed.len());
254
255 for task in proposed {
256 let title_key = normalize_generated_title(&task.title);
257 let spec_key = generated_task_equivalence_key(&task);
258 let duplicate_title = !title_key.is_empty()
259 && (!seen_titles.insert(title_key.clone()) || open_titles.contains(&title_key));
260 let duplicate_spec = !spec_key.is_empty()
261 && (!seen_specs.insert(spec_key.clone()) || open_specs.contains(&spec_key));
262
263 if duplicate_title || duplicate_spec {
264 warn!(
265 title = %task.title,
266 duplicate_title,
267 duplicate_spec,
268 "suppressing duplicate generated task"
269 );
270 continue;
271 }
272
273 if !title_key.is_empty() {
274 open_titles.insert(title_key);
275 }
276 if !spec_key.is_empty() {
277 open_specs.insert(spec_key);
278 }
279 deduped.push(task);
280 }
281
282 deduped
283}
284
285fn create_board_tasks_with_program(
286 specs: &[TaskSpec],
287 board_dir: &Path,
288 program: &str,
289) -> Result<Vec<u32>> {
290 if !board_dir.exists() {
291 anyhow::bail!("board directory does not exist: {}", board_dir.display());
292 }
293
294 let existing_tasks = load_tasks_from_dir(&board_dir.join("tasks")).unwrap_or_default();
295 let generated = specs
296 .iter()
297 .filter_map(sanitize_generated_task)
298 .collect::<Vec<_>>();
299 let deduped = dedupe_generated_tasks(&existing_tasks, generated);
300 let mut created_ids = Vec::with_capacity(deduped.len());
301 for sanitized in deduped {
302 let args = build_create_task_args(&sanitized);
303 let arg_refs = args.iter().map(String::as_str).collect::<Vec<_>>();
304 let output = crate::team::board_cmd::run_board_with_program(program, board_dir, &arg_refs)
305 .with_context(|| format!("failed to create board task '{}'", sanitized.title))?;
306
307 let task_id = output
308 .stdout
309 .trim()
310 .strip_prefix("Created task #")
311 .unwrap_or(output.stdout.trim());
312 let parsed_id = task_id
313 .parse::<u32>()
314 .with_context(|| format!("invalid task id returned by kanban-md: '{task_id}'"))?;
315 created_ids.push(parsed_id);
316 }
317 Ok(created_ids)
318}
319
320pub fn create_board_tasks(specs: &[TaskSpec], board_dir: &Path) -> Result<Vec<u32>> {
322 create_board_tasks_with_program(specs, board_dir, "kanban-md")
323}
324
325#[cfg(test)]
326mod tests {
327 use super::*;
328
329 fn setup_fake_kanban(tmp: &tempfile::TempDir) -> std::path::PathBuf {
330 let fake_bin = tmp.path().join("fake-bin");
331 std::fs::create_dir_all(&fake_bin).unwrap();
332 let script = fake_bin.join("kanban-md");
333 std::fs::write(
334 &script,
335 "#!/bin/bash\nset -euo pipefail\nif [ \"$1\" != \"create\" ]; then exit 1; fi\nshift\ntitle=\"$1\"\nshift\nbody=\"\"\npriority=\"high\"\ntags=\"\"\ndepends_on=\"\"\nwhile [ $# -gt 0 ]; do\n case \"$1\" in\n --body) body=\"$2\"; shift 2 ;;\n --priority) priority=\"$2\"; shift 2 ;;\n --tags) tags=\"$2\"; shift 2 ;;\n --depends-on) depends_on=\"$2\"; shift 2 ;;\n --dir) board_dir=\"$2\"; shift 2 ;;\n *) shift ;;\n esac\ndone\nmkdir -p \"$board_dir/tasks\"\ncount=$(find \"$board_dir/tasks\" -maxdepth 1 -name '*.md' | wc -l | tr -d ' ')\nid=$((count + 1))\nprintf -- '---\\nid: %s\\ntitle: %s\\nstatus: todo\\npriority: %s\\n' \"$id\" \"$title\" \"$priority\" > \"$board_dir/tasks/$(printf '%03d' \"$id\")-task.md\"\nif [ -n \"$tags\" ]; then printf 'tags: [%s]\\n' \"$tags\" >> \"$board_dir/tasks/$(printf '%03d' \"$id\")-task.md\"; fi\nif [ -n \"$depends_on\" ]; then printf 'depends_on: [%s]\\n' \"$depends_on\" >> \"$board_dir/tasks/$(printf '%03d' \"$id\")-task.md\"; fi\nprintf -- '---\\n\\n%s\\n' \"$body\" >> \"$board_dir/tasks/$(printf '%03d' \"$id\")-task.md\"\nprintf 'Created task #%s\\n' \"$id\"\n",
336 )
337 .unwrap();
338 #[cfg(unix)]
339 {
340 use std::os::unix::fs::PermissionsExt;
341 std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
342 }
343 fake_bin
344 }
345
346 fn write_task_file(board_dir: &Path, id: u32, title: &str, status: &str) {
347 std::fs::write(
348 board_dir.join("tasks").join(format!("{id:03}-task.md")),
349 format!(
350 "---\nid: {id}\ntitle: {title}\nstatus: {status}\npriority: critical\n---\n\nTask body.\n"
351 ),
352 )
353 .unwrap();
354 }
355
356 #[test]
357 fn parse_single_task() {
358 let response = r#"---
359title: "Add tact parser"
360priority: high
361tags: [core, tact]
362---
363Implement parser logic."#;
364
365 let specs = parse_planning_response(response);
366 assert_eq!(specs.len(), 1);
367 assert_eq!(specs[0].title, "Add tact parser");
368 assert_eq!(specs[0].priority.as_deref(), Some("high"));
369 assert_eq!(specs[0].tags, vec!["core", "tact"]);
370 assert_eq!(specs[0].body, "Implement parser logic.");
371 }
372
373 #[test]
374 fn test_parse_task_specs_single() {
375 let response = r#"---
376title: "Add tact parser"
377priority: high
378---
379Implement parser logic."#;
380
381 let specs = parse_task_specs(response);
382 assert_eq!(specs.len(), 1);
383 assert_eq!(specs[0].title, "Add tact parser");
384 }
385
386 #[test]
387 fn parse_multiple_tasks() {
388 let response = r#"---
389title: "Task one"
390priority: low
391---
392Body one.
393---
394title: "Task two"
395priority: medium
396---
397Body two.
398---
399title: "Task three"
400priority: high
401---
402Body three."#;
403
404 let specs = parse_planning_response(response);
405 assert_eq!(specs.len(), 3);
406 assert_eq!(specs[0].title, "Task one");
407 assert_eq!(specs[1].title, "Task two");
408 assert_eq!(specs[2].title, "Task three");
409 }
410
411 #[test]
412 fn test_parse_task_specs_multiple() {
413 let response = r#"---
414title: "Task one"
415priority: low
416---
417Body one.
418---
419title: "Task two"
420priority: medium
421---
422Body two."#;
423
424 let specs = parse_task_specs(response);
425 assert_eq!(specs.len(), 2);
426 }
427
428 #[test]
429 fn parse_with_dependencies() {
430 let response = r#"---
431title: "Dependent task"
432depends_on: [1, 2, 8]
433---
434Body."#;
435
436 let specs = parse_planning_response(response);
437 assert_eq!(specs[0].depends_on, vec![1, 2, 8]);
438 }
439
440 #[test]
441 fn test_parse_task_specs_with_depends() {
442 let response = r#"---
443title: "Dependent task"
444depends_on: [42]
445---
446Body."#;
447
448 let specs = parse_task_specs(response);
449 assert_eq!(specs[0].depends_on, vec![42]);
450 }
451
452 #[test]
453 fn parse_malformed_skips_bad_blocks() {
454 let response = r#"---
455title: "Good task"
456priority: high
457---
458Good body.
459---
460title: [unterminated
461---
462Bad body.
463---
464title: "Second good task"
465---
466Second body."#;
467
468 let specs = parse_planning_response(response);
469 assert_eq!(specs.len(), 2);
470 assert_eq!(specs[0].title, "Good task");
471 assert_eq!(specs[1].title, "Second good task");
472 }
473
474 #[test]
475 fn parse_empty_response() {
476 assert!(parse_planning_response("").is_empty());
477 assert!(parse_planning_response(" \n\t").is_empty());
478 }
479
480 #[test]
481 fn test_parse_task_specs_empty() {
482 assert!(parse_task_specs("").is_empty());
483 assert!(parse_task_specs("garbage").is_empty());
484 }
485
486 #[test]
487 fn parse_no_frontmatter() {
488 assert!(parse_planning_response("just some freeform planning text").is_empty());
489 }
490
491 #[test]
492 fn parse_missing_title_skips_block() {
493 let response = r#"---
494priority: high
495---
496No title here."#;
497 assert!(parse_planning_response(response).is_empty());
498 }
499
500 #[test]
501 fn create_board_tasks_round_trip_creates_tasks_with_metadata() {
502 let tmp = tempfile::tempdir().unwrap();
503 let board_dir = tmp.path().join("board");
504 std::fs::create_dir_all(board_dir.join("tasks")).unwrap();
505 let fake_kanban = setup_fake_kanban(&tmp).join("kanban-md");
506
507 let specs = vec![
508 TaskSpec {
509 title: "Task one".into(),
510 body: "Body one".into(),
511 priority: Some("high".into()),
512 depends_on: vec![],
513 tags: vec!["tact".into()],
514 },
515 TaskSpec {
516 title: "Task two".into(),
517 body: "Body two".into(),
518 priority: Some("medium".into()),
519 depends_on: vec![1],
520 tags: vec!["integration".into()],
521 },
522 ];
523
524 let ids =
525 create_board_tasks_with_program(&specs, &board_dir, fake_kanban.to_str().unwrap())
526 .unwrap();
527 assert_eq!(ids, vec![1, 2]);
528 let tasks = crate::task::load_tasks_from_dir(&board_dir.join("tasks")).unwrap();
529 assert_eq!(tasks.len(), 2);
530 assert_eq!(tasks[1].depends_on, vec![1]);
531 assert_eq!(tasks[1].tags, vec!["integration"]);
532 }
533
534 #[test]
535 fn create_board_tasks_missing_board_dir_returns_clear_error() {
536 let specs = vec![TaskSpec {
537 title: "Task one".into(),
538 body: "Body one".into(),
539 priority: None,
540 depends_on: vec![],
541 tags: vec![],
542 }];
543 let tmp = tempfile::tempdir().unwrap();
544 let error = create_board_tasks(&specs, &tmp.path().join("missing")).unwrap_err();
545 assert!(error.to_string().contains("board directory does not exist"),);
546 }
547
548 #[test]
549 fn test_create_board_tasks_formats_command() {
550 let args = build_create_task_args(&TaskSpec {
551 title: "Plan tact".into(),
552 body: "Create the daemon prompt.".into(),
553 priority: Some("high".into()),
554 depends_on: vec![17],
555 tags: vec!["tact".into(), "daemon".into()],
556 });
557 assert_eq!(
558 args,
559 vec![
560 "create",
561 "Plan tact",
562 "--body",
563 "Create the daemon prompt.",
564 "--priority",
565 "high",
566 "--tags",
567 "tact,daemon",
568 "--depends-on",
569 "17",
570 ]
571 );
572 }
573
574 #[test]
575 fn create_board_tasks_rejects_raw_log_dump() {
576 let tmp = tempfile::tempdir().unwrap();
577 let board_dir = tmp.path().join("board");
578 std::fs::create_dir_all(board_dir.join("tasks")).unwrap();
579 let fake_kanban = setup_fake_kanban(&tmp).join("kanban-md");
580
581 let raw_body = "\
582running 3144 tests
583test agent::claude::tests::default_mode_is_interactive ... ok
584test tmux::tests::split_window_horizontal_creates_new_pane ... FAILED
585
586failures:
587
588---- tmux::tests::split_window_horizontal_creates_new_pane stdout ----
589thread 'tmux::tests::split_window_horizontal_creates_new_pane' panicked at src/tmux.rs:1903:71:
590called `Result::unwrap()` on an `Err` value: failed to create tmux session 'batty-test-hsplit'
591
592Caused by:
593 No such file or directory (os error 2)
594
595test result: FAILED. 3011 passed; 14 failed; 119 ignored; 0 measured; 0 filtered out;
596";
597 let specs = vec![TaskSpec {
598 title: "Reopen tmux runtime test hardening - make cargo test green on main".into(),
599 body: raw_body.into(),
600 priority: Some("critical".into()),
601 depends_on: vec![],
602 tags: vec!["stability".into(), "tmux".into()],
603 }];
604
605 let ids =
606 create_board_tasks_with_program(&specs, &board_dir, fake_kanban.to_str().unwrap())
607 .unwrap();
608 assert!(ids.is_empty());
609
610 let tasks = crate::task::load_tasks_from_dir(&board_dir.join("tasks")).unwrap();
611 assert!(tasks.is_empty());
612 }
613
614 #[test]
615 fn create_board_tasks_skips_duplicate_open_reopen_title_variants() {
616 let tmp = tempfile::tempdir().unwrap();
617 let board_dir = tmp.path().join("board");
618 std::fs::create_dir_all(board_dir.join("tasks")).unwrap();
619 let fake_kanban = setup_fake_kanban(&tmp).join("kanban-md");
620
621 write_task_file(
622 &board_dir,
623 41,
624 "Reopen tmux runtime test hardening - make cargo test green on main",
625 "todo",
626 );
627
628 let specs = vec![TaskSpec {
629 title: "Reopen tmux runtime test hardening — make cargo test green on main".into(),
630 body: "running 3144 tests\ntest tmux::tests::split_window_horizontal_creates_new_pane ... FAILED\n".into(),
631 priority: Some("critical".into()),
632 depends_on: vec![],
633 tags: vec!["stability".into()],
634 }];
635
636 let ids =
637 create_board_tasks_with_program(&specs, &board_dir, fake_kanban.to_str().unwrap())
638 .unwrap();
639 assert!(ids.is_empty());
640
641 let tasks = crate::task::load_tasks_from_dir(&board_dir.join("tasks")).unwrap();
642 assert_eq!(tasks.len(), 1);
643 assert_eq!(tasks[0].id, 41);
644 }
645
646 #[test]
647 fn create_board_tasks_skips_duplicate_open_title() {
648 let tmp = tempfile::tempdir().unwrap();
649 let board_dir = tmp.path().join("board");
650 std::fs::create_dir_all(board_dir.join("tasks")).unwrap();
651 let fake_kanban = setup_fake_kanban(&tmp).join("kanban-md");
652
653 write_task_file(&board_dir, 41, "Ship planning telemetry", "todo");
654
655 let specs = vec![TaskSpec {
656 title: "Ship planning telemetry".into(),
657 body: "Fresh body that should still be suppressed.".into(),
658 priority: Some("high".into()),
659 depends_on: vec![],
660 tags: vec!["tact".into()],
661 }];
662
663 let ids =
664 create_board_tasks_with_program(&specs, &board_dir, fake_kanban.to_str().unwrap())
665 .unwrap();
666 assert!(ids.is_empty());
667
668 let tasks = crate::task::load_tasks_from_dir(&board_dir.join("tasks")).unwrap();
669 assert_eq!(tasks.len(), 1);
670 assert_eq!(tasks[0].id, 41);
671 }
672
673 #[test]
674 fn create_board_tasks_skips_equivalent_generated_specs() {
675 let tmp = tempfile::tempdir().unwrap();
676 let board_dir = tmp.path().join("board");
677 std::fs::create_dir_all(board_dir.join("tasks")).unwrap();
678 let fake_kanban = setup_fake_kanban(&tmp).join("kanban-md");
679
680 let specs = vec![
681 TaskSpec {
682 title: "Plan planning telemetry".into(),
683 body: "Record planning cycle events in the orchestrator log.".into(),
684 priority: Some("high".into()),
685 depends_on: vec![],
686 tags: vec!["tact".into(), "telemetry".into()],
687 },
688 TaskSpec {
689 title: "Backfill planning telemetry".into(),
690 body: "Record planning cycle events in the orchestrator log.".into(),
691 priority: Some("high".into()),
692 depends_on: vec![],
693 tags: vec!["telemetry".into(), "tact".into()],
694 },
695 ];
696
697 let ids =
698 create_board_tasks_with_program(&specs, &board_dir, fake_kanban.to_str().unwrap())
699 .unwrap();
700 assert_eq!(ids, vec![1]);
701
702 let tasks = crate::task::load_tasks_from_dir(&board_dir.join("tasks")).unwrap();
703 assert_eq!(tasks.len(), 1);
704 assert_eq!(tasks[0].title, "Plan planning telemetry");
705 }
706
707 #[test]
708 fn create_board_tasks_allows_new_reopen_after_terminal_duplicate() {
709 let tmp = tempfile::tempdir().unwrap();
710 let board_dir = tmp.path().join("board");
711 std::fs::create_dir_all(board_dir.join("tasks")).unwrap();
712 let fake_kanban = setup_fake_kanban(&tmp).join("kanban-md");
713
714 write_task_file(
715 &board_dir,
716 41,
717 "Reopen tmux runtime test hardening - make cargo test green on main",
718 "archived",
719 );
720
721 let specs = vec![TaskSpec {
722 title: "Reopen tmux runtime test hardening — make cargo test green on main".into(),
723 body: "Automatic reopen after failed verification.".into(),
724 priority: Some("critical".into()),
725 depends_on: vec![],
726 tags: vec!["stability".into()],
727 }];
728
729 let ids =
730 create_board_tasks_with_program(&specs, &board_dir, fake_kanban.to_str().unwrap())
731 .unwrap();
732 assert_eq!(ids, vec![2]);
733
734 let tasks = crate::task::load_tasks_from_dir(&board_dir.join("tasks")).unwrap();
735 assert_eq!(tasks.len(), 2);
736 }
737}