1. 1#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
2. 2
3. 3//! A call a tool refuses from its arguments alone is refused before
4. 4//! permission is evaluated: nobody is asked to approve a text edit of a
5. 5//! Word file, which could only fail, and the model gets the repair hint.
6. 6//! And when correctable failures persist, the loop's repair directive is
7. 7//! runtime-authored control traffic, never a message from the person.
8. 8//! And an answer after a tool delivered a reviewable file (an Office
9. 9//! draft) is not sent back to be re-presented as a card; a repeat of the
10. 10//! delivering call writes no second draft, and a card previewing the
11. 11//! delivered file is not shown.
12. 12
13. 13use std::collections::VecDeque;
14. 14use std::sync::atomic::{AtomicUsize, Ordering};
15. 15use std::sync::{Arc, Mutex};
16. 16
17. 17use async_trait::async_trait;
18. 18use tokio::sync::mpsc;
19. 19use tokio_util::sync::CancellationToken;
20. 20
21. 21use vak_agent::{Agent, AgentConfig, AgentEvent, TurnOutcome};
22. 22use vak_llm::stream;
23. 23use vak_llm::types::{AssistantMessage, ChatRequest, ContentBlock, StopReason, Usage};
24. 24use vak_llm::{EventStream, LlmError, Provider};
25. 25use vak_permission::{Mode, PermissionEngine};
26. 26use vak_session::types::{FrozenContract, SessionHeader};
27. 27use vak_session::{SessionLog, SessionPath};
28. 28
29. 29struct Scripted(
30. 30 Mutex<VecDeque<AssistantMessage>>,
31. 31 Arc<Mutex<Vec<ChatRequest>>>,
32. 32);
33. 33
34. 34#[async_trait]
35. 35impl Provider for Scripted {
36. 36 fn name(&self) -> &str {
37. 37 "scripted"
38. 38 }
39. 39
40. 40 async fn stream(
41. 41 &self,
42. 42 request: ChatRequest,
43. 43 _cancel: CancellationToken,
44. 44 ) -> Result<EventStream, LlmError> {
45. 45 self.1.lock().unwrap().push(request);
46. 46 let next = self.0.lock().unwrap().pop_front();
47. 47 let (mut sink, rx) = stream::channel(64);
48. 48 match next {
49. 49 Some(m) => {
50. 50 sink.push(stream::StreamEvent::Start { partial: m.clone() });
51. 51 sink.close_message(m).await;
52. 52 }
53. 53 None => sink.close_error(LlmError::Parse("exhausted".into())).await,
54. 54 }
55. 55 Ok(rx)
56. 56 }
57. 57}
58. 58
59. 59fn msg(content: Vec<ContentBlock>, stop_reason: StopReason) -> AssistantMessage {
60. 60 AssistantMessage {
61. 61 content,
62. 62 stop_reason,
63. 63 usage: Usage {
64. 64 input_tokens: 1,
65. 65 output_tokens: 1,
66. 66 ..Default::default()
67. 67 },
68. 68 model: "test-model".into(),
69. 69 response_id: None,
70. 70 }
71. 71}
72. 72
73. 73#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
74. 74async fn a_text_edit_of_a_word_file_is_refused_without_asking_anyone() {
75. 75 let dir = tempfile::tempdir().unwrap();
76. 76 let home = dir.path().join("home");
77. 77 std::fs::create_dir_all(&home).unwrap();
78. 78 std::fs::write(
79. 79 dir.path().join("q3.docx"),
80. 80 b"PK\x03\x04 not really a package",
81. 81 )
82. 82 .unwrap();
83. 83 let header = SessionHeader {
84. 84 agent: None,
85. 85 session_id: "refusal".into(),
86. 86 created_at: chrono::Utc::now(),
87. 87 cwd: dir.path().to_path_buf(),
88. 88 parent_session_id: None,
89. 89 contract_id: None,
90. 90 work_item_id: None,
91. 91 conversation: None,
92. 92 contract: FrozenContract {
93. 93 app_version: "0".into(),
94. 94 provider: "scripted".into(),
95. 95 model: "test-model".into(),
96. 96 route_ladder: Vec::new(),
97. 97 route_objective: String::new(),
98. 98 route_annotations: Vec::new(),
99. 99 system_prompt: "sys".into(),
100. 100 permission_mode: "workspace-write".into(),
101. 101 capabilities: Vec::new(),
102. 102 prompt_layers: Vec::new(),
103. 103 },
104. 104 };
105. 105 let log = SessionLog::create(
106. 106 SessionPath::new_session_file(&home, dir.path(), "refusal"),
107. 107 header,
108. 108 )
109. 109 .unwrap();
110. 110 let mut cfg = AgentConfig::new("sys");
111. 111 cfg.model = "test-model".into();
112. 112 cfg.mode = Mode::WorkspaceWrite;
113. 113 cfg.retry_base_backoff_ms = 1;
114. 114 cfg.run_retry_base_backoff_ms = 1;
115. 115 // Every edit would ask for approval, so an approval request is what the
116. 116 // refusal must pre-empt.
117. 117 cfg.permission = Some(Arc::new(
118. 118 PermissionEngine::from_rule_strings(&["?edit".to_string()]).unwrap(),
119. 119 ));
120. 120 cfg.tools = vec![Arc::new(vak_tools::edit::EditTool)];
121. 121 let script = VecDeque::from([msg(
122. 122 vec![ContentBlock::ToolUse {
123. 123 id: "c1".into(),
124. 124 name: "edit".into(),
125. 125 input: serde_json::json!({
126. 126 "path": "q3.docx",
127. 127 "edits": [{"old_text": "Steady.", "new_text": "Growing."}]
128. 128 }),
129. 129 }],
130. 130 StopReason::ToolUse,
131. 131 )]);
132. 132 // Spare answers: a text answer after a failed call may be sent back for
133. 133 // a redo, and this test is about what happened before it.
134. 134 let mut script = script;
135. 135 for _ in 0..6 {
136. 136 script.push_back(msg(
137. 137 vec![ContentBlock::text(
138. 138 "The file is a Word document, so I will use office_apply.",
139. 139 )],
140. 140 StopReason::EndTurn,
141. 141 ));
142. 142 }
143. 143 let requests = Arc::new(Mutex::new(Vec::new()));
144. 144 let mut agent = Agent::new(
145. 145 Arc::new(Scripted(Mutex::new(script), requests.clone())),
146. 146 log,
147. 147 cfg,
148. 148 );
149. 149 let (tx, mut rx) = mpsc::channel(256);
150. 150 let outcome = agent
151. 151 .run("edit it", &Default::default(), CancellationToken::new(), tx)
152. 152 .await;
153. 153 assert!(
154. 154 matches!(outcome, TurnOutcome::Completed { .. }),
155. 155 "{outcome:?}"
156. 156 );
157. 157 let mut approvals = 0;
158. 158 while let Ok(event) = rx.try_recv() {
159. 159 if matches!(event, AgentEvent::ApprovalRequested { .. }) {
160. 160 approvals += 1;
161. 161 }
162. 162 }
163. 163 assert_eq!(
164. 164 approvals, 0,
165. 165 "a call that can only be refused is never put to a person"
166. 166 );
167. 167 let requests = requests.lock().unwrap();
168. 168 let refusal = requests
169. 169 .iter()
170. 170 .flat_map(|request| request.messages.iter())
171. 171 .flat_map(|message| message.content.iter())
172. 172 .find_map(|block| match block {
173. 173 ContentBlock::ToolResult {
174. 174 tool_use_id,
175. 175 content,
176. 176 is_error: true,
177. 177 } if tool_use_id == "c1" => Some(content.clone()),
178. 178 _ => None,
179. 179 })
180. 180 .expect("the model is told why");
181. 181 assert!(
182. 182 refusal.contains("office_apply") && refusal.contains("doc_read"),
183. 183 "{refusal}"
184. 184 );
185. 185}
186. 186
187. 187#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
188. 188async fn the_repair_directive_is_recorded_as_control_not_as_the_persons_words() {
189. 189 let dir = tempfile::tempdir().unwrap();
190. 190 let home = dir.path().join("home");
191. 191 std::fs::create_dir_all(&home).unwrap();
192. 192 std::fs::write(dir.path().join("notes.txt"), "plain").unwrap();
193. 193 let header = SessionHeader {
194. 194 agent: None,
195. 195 session_id: "directive".into(),
196. 196 created_at: chrono::Utc::now(),
197. 197 cwd: dir.path().to_path_buf(),
198. 198 parent_session_id: None,
199. 199 contract_id: None,
200. 200 work_item_id: None,
201. 201 conversation: None,
202. 202 contract: FrozenContract {
203. 203 app_version: "0".into(),
204. 204 provider: "scripted".into(),
205. 205 model: "test-model".into(),
206. 206 route_ladder: Vec::new(),
207. 207 route_objective: String::new(),
208. 208 route_annotations: Vec::new(),
209. 209 system_prompt: "sys".into(),
210. 210 permission_mode: "workspace-write".into(),
211. 211 capabilities: Vec::new(),
212. 212 prompt_layers: Vec::new(),
213. 213 },
214. 214 };
215. 215 let ledger = SessionPath::new_session_file(&home, dir.path(), "directive");
216. 216 let log = SessionLog::create(ledger.clone(), header).unwrap();
217. 217 let mut cfg = AgentConfig::new("sys");
218. 218 cfg.model = "test-model".into();
219. 219 cfg.mode = Mode::WorkspaceWrite;
220. 220 cfg.retry_base_backoff_ms = 1;
221. 221 cfg.run_retry_base_backoff_ms = 1;
222. 222 cfg.tools = vec![Arc::new(vak_tools::edit::EditTool)];
223. 223 // The same malformed call, step after step: `edits` is missing.
224. 224 let mut script: VecDeque<AssistantMessage> = (0..8)
225. 225 .map(|n| {
226. 226 msg(
227. 227 vec![ContentBlock::ToolUse {
228. 228 id: format!("c{n}"),
229. 229 name: "edit".into(),
230. 230 input: serde_json::json!({"path": "notes.txt"}),
231. 231 }],
232. 232 StopReason::ToolUse,
233. 233 )
234. 234 })
235. 235 .collect();
236. 236 for _ in 0..4 {
237. 237 script.push_back(msg(
238. 238 vec![ContentBlock::text("Stopped.")],
239. 239 StopReason::EndTurn,
240. 240 ));
241. 241 }
242. 242 let requests = Arc::new(Mutex::new(Vec::new()));
243. 243 let mut agent = Agent::new(
244. 244 Arc::new(Scripted(Mutex::new(script), requests.clone())),
245. 245 log,
246. 246 cfg,
247. 247 );
248. 248 let (tx, mut rx) = mpsc::channel(512);
249. 249 tokio::spawn(async move { while rx.recv().await.is_some() {} });
250. 250 agent
251. 251 .run(
252. 252 "fix the notes",
253. 253 &Default::default(),
254. 254 CancellationToken::new(),
255. 255 tx,
256. 256 )
257. 257 .await;
258. 258 let ledger = std::fs::read_to_string(&ledger).unwrap();
259. 259 let directives: Vec<&str> = ledger
260. 260 .lines()
261. 261 .filter(|line| line.contains("[repair-directive]"))
262. 262 .collect();
263. 263 assert!(!directives.is_empty(), "the loop issued a repair directive");
264. 264 for line in directives {
265. 265 assert!(
266. 266 line.contains("\"control\":\"repair_directive\""),
267. 267 "tagged as runtime control: {line}"
268. 268 );
269. 269 }
270. 270 assert!(
271. 271 !ledger.contains("[repair directive]"),
272. 272 "the retired inline marker is not written"
273. 273 );
274. 274}
275. 275
276. 276#[derive(Default)]
277. 277struct Deliverer {
278. 278 delivers: bool,
279. 279 runs: AtomicUsize,
280. 280}
281. 281
282. 282#[async_trait]
283. 283impl vak_tools::Tool for Deliverer {
284. 284 fn name(&self) -> &str {
285. 285 "make_draft"
286. 286 }
287. 287 fn description(&self) -> &str {
288. 288 "test stand-in"
289. 289 }
290. 290 fn schema(&self) -> serde_json::Value {
291. 291 serde_json::json!({"type": "object"})
292. 292 }
293. 293 fn delivered_file(&self, _args: &serde_json::Value) -> Option<String> {
294. 294 self.delivers.then(|| "deck.pptx".to_string())
295. 295 }
296. 296 async fn execute(
297. 297 &self,
298. 298 _args: &serde_json::Value,
299. 299 _ctx: &vak_tools::context::ToolContext,
300. 300 ) -> vak_tools::ToolOutput {
301. 301 self.runs.fetch_add(1, Ordering::SeqCst);
302. 302 vak_tools::ToolOutput::ok("Draft for deck.pptx written; the person reviews it.")
303. 303 }
304. 304}
305. 305
306. 306#[derive(Default)]
307. 307struct Shell {
308. 308 runs: AtomicUsize,
309. 309}
310. 310
311. 311#[async_trait]
312. 312impl vak_tools::Tool for Shell {
313. 313 fn name(&self) -> &str {
314. 314 "bash"
315. 315 }
316. 316 fn description(&self) -> &str {
317. 317 "test stand-in"
318. 318 }
319. 319 fn schema(&self) -> serde_json::Value {
320. 320 serde_json::json!({"type": "object"})
321. 321 }
322. 322 async fn execute(
323. 323 &self,
324. 324 _args: &serde_json::Value,
325. 325 _ctx: &vak_tools::context::ToolContext,
326. 326 ) -> vak_tools::ToolOutput {
327. 327 self.runs.fetch_add(1, Ordering::SeqCst);
328. 328 vak_tools::ToolOutput::ok("ran")
329. 329 }
330. 330}
331. 331
332. 332#[derive(Default)]
333. 333struct PreviewCard {
334. 334 runs: AtomicUsize,
335. 335}
336. 336
337. 337#[async_trait]
338. 338impl vak_tools::Tool for PreviewCard {
339. 339 fn name(&self) -> &str {
340. 340 "emit_ui_preview_card"
341. 341 }
342. 342 fn description(&self) -> &str {
343. 343 "test stand-in"
344. 344 }
345. 345 fn schema(&self) -> serde_json::Value {
346. 346 serde_json::json!({"type": "object"})
347. 347 }
348. 348 fn presents_cards(&self) -> bool {
349. 349 true
350. 350 }
351. 351 async fn execute(
352. 352 &self,
353. 353 _args: &serde_json::Value,
354. 354 _ctx: &vak_tools::context::ToolContext,
355. 355 ) -> vak_tools::ToolOutput {
356. 356 self.runs.fetch_add(1, Ordering::SeqCst);
357. 357 vak_tools::ToolOutput::ok(r#"{"ok":true}"#)
358. 358 }
359. 359}
360. 360
361. 361/// How many model requests one turn takes when the presentation check
362. 362/// always wants a card.
363. 363async fn requests_after_a_draft(delivers: bool) -> usize {
364. 364 let dir = tempfile::tempdir().unwrap();
365. 365 let home = dir.path().join("home");
366. 366 std::fs::create_dir_all(&home).unwrap();
367. 367 let header = SessionHeader {
368. 368 agent: None,
369. 369 session_id: "deliver".into(),
370. 370 created_at: chrono::Utc::now(),
371. 371 cwd: dir.path().to_path_buf(),
372. 372 parent_session_id: None,
373. 373 contract_id: None,
374. 374 work_item_id: None,
375. 375 conversation: None,
376. 376 contract: FrozenContract {
377. 377 app_version: "0".into(),
378. 378 provider: "scripted".into(),
379. 379 model: "test-model".into(),
380. 380 route_ladder: Vec::new(),
381. 381 route_objective: String::new(),
382. 382 route_annotations: Vec::new(),
383. 383 system_prompt: "sys".into(),
384. 384 permission_mode: "workspace-write".into(),
385. 385 capabilities: Vec::new(),
386. 386 prompt_layers: Vec::new(),
387. 387 },
388. 388 };
389. 389 let log = SessionLog::create(
390. 390 SessionPath::new_session_file(&home, dir.path(), "deliver"),
391. 391 header,
392. 392 )
393. 393 .unwrap();
394. 394 let mut cfg = AgentConfig::new("sys");
395. 395 cfg.model = "test-model".into();
396. 396 cfg.mode = Mode::WorkspaceWrite;
397. 397 cfg.retry_base_backoff_ms = 1;
398. 398 cfg.run_retry_base_backoff_ms = 1;
399. 399 cfg.tools = vec![Arc::new(Deliverer {
400. 400 delivers,
401. 401 ..Default::default()
402. 402 })];
403. 403 cfg.presentation_check = Some(Arc::new(|_text: &str, _offered: &[String]| {
404. 404 Some(vak_agent::PresentationNudge {
405. 405 tool: "make_draft".into(),
406. 406 text: "[presentation-check] show it as a card".into(),
407. 407 })
408. 408 }));
409. 409 let mut script = VecDeque::from([msg(
410. 410 vec![ContentBlock::ToolUse {
411. 411 id: "c1".into(),
412. 412 name: "make_draft".into(),
413. 413 input: serde_json::json!({}),
414. 414 }],
415. 415 StopReason::ToolUse,
416. 416 )]);
417. 417 for _ in 0..3 {
418. 418 script.push_back(msg(
419. 419 vec![ContentBlock::text(
420. 420 "Added the slide; the draft is ready for review.",
421. 421 )],
422. 422 StopReason::EndTurn,
423. 423 ));
424. 424 }
425. 425 let requests = Arc::new(Mutex::new(Vec::new()));
426. 426 let mut agent = Agent::new(
427. 427 Arc::new(Scripted(Mutex::new(script), requests.clone())),
428. 428 log,
429. 429 cfg,
430. 430 );
431. 431 let (tx, mut rx) = mpsc::channel(256);
432. 432 tokio::spawn(async move { while rx.recv().await.is_some() {} });
433. 433 let outcome = agent
434. 434 .run(
435. 435 "add a slide",
436. 436 &Default::default(),
437. 437 CancellationToken::new(),
438. 438 tx,
439. 439 )
440. 440 .await;
441. 441 assert!(
442. 442 matches!(outcome, TurnOutcome::Completed { .. }),
443. 443 "{outcome:?}"
444. 444 );
445. 445 requests.lock().unwrap().len()
446. 446}
447. 447
448. 448#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
449. 449async fn an_answer_after_a_delivered_draft_is_not_sent_back_to_become_a_card() {
450. 450 assert_eq!(
451. 451 requests_after_a_draft(true).await,
452. 452 2,
453. 453 "the tool call, then the answer, which ends the turn"
454. 454 );
455. 455 assert_eq!(
456. 456 requests_after_a_draft(false).await,
457. 457 3,
458. 458 "without a delivered file, the check still asks once for a card"
459. 459 );
460. 460}
461. 461
462. 462fn tool_call(id: &str, name: &str, input: serde_json::Value) -> AssistantMessage {
463. 463 msg(
464. 464 vec![ContentBlock::ToolUse {
465. 465 id: id.into(),
466. 466 name: name.into(),
467. 467 input,
468. 468 }],
469. 469 StopReason::ToolUse,
470. 470 )
471. 471}
472. 472
473. 473#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
474. 474async fn a_repeated_draft_writes_nothing_and_a_preview_of_the_draft_is_not_shown() {
475. 475 let dir = tempfile::tempdir().unwrap();
476. 476 let home = dir.path().join("home");
477. 477 std::fs::create_dir_all(&home).unwrap();
478. 478 let header = SessionHeader {
479. 479 agent: None,
480. 480 session_id: "repeat".into(),
481. 481 created_at: chrono::Utc::now(),
482. 482 cwd: dir.path().to_path_buf(),
483. 483 parent_session_id: None,
484. 484 contract_id: None,
485. 485 work_item_id: None,
486. 486 conversation: None,
487. 487 contract: FrozenContract {
488. 488 app_version: "0".into(),
489. 489 provider: "scripted".into(),
490. 490 model: "test-model".into(),
491. 491 route_ladder: Vec::new(),
492. 492 route_objective: String::new(),
493. 493 route_annotations: Vec::new(),
494. 494 system_prompt: "sys".into(),
495. 495 permission_mode: "workspace-write".into(),
496. 496 capabilities: Vec::new(),
497. 497 prompt_layers: Vec::new(),
498. 498 },
499. 499 };
500. 500 let log = SessionLog::create(
501. 501 SessionPath::new_session_file(&home, dir.path(), "repeat"),
502. 502 header,
503. 503 )
504. 504 .unwrap();
505. 505 let drafts = Arc::new(Deliverer {
506. 506 delivers: true,
507. 507 ..Default::default()
508. 508 });
509. 509 let cards = Arc::new(PreviewCard::default());
510. 510 let shell = Arc::new(Shell::default());
511. 511 let mut cfg = AgentConfig::new("sys");
512. 512 cfg.model = "test-model".into();
513. 513 cfg.mode = Mode::FullAccess;
514. 514 cfg.retry_base_backoff_ms = 1;
515. 515 cfg.run_retry_base_backoff_ms = 1;
516. 516 cfg.tools = vec![drafts.clone(), cards.clone(), shell.clone()];
517. 517 let slide = serde_json::json!({"path": "deck.pptx", "ops": [{"op": "add_slide_from_layout"}]});
518. 518 let script = VecDeque::from([
519. 519 tool_call("c1", "make_draft", slide.clone()),
520. 520 tool_call(
521. 521 "c2",
522. 522 "emit_ui_preview_card",
523. 523 serde_json::json!({"payload": {"artifact_path": "./deck.pptx", "html": "<h1>Next steps</h1>"}}),
524. 524 ),
525. 525 tool_call(
526. 526 "c4",
527. 527 "bash",
528. 528 serde_json::json!({"command": "cp .vak/scratch/vak/c1/deck.pptx ./deck.pptx"}),
529. 529 ),
530. 530 tool_call(
531. 531 "c5",
532. 532 "bash",
533. 533 serde_json::json!({"command": "ls .vak/scratch"}),
534. 534 ),
535. 535 tool_call("c3", "make_draft", slide),
536. 536 msg(
537. 537 vec![ContentBlock::text("Added the Next steps slide.")],
538. 538 StopReason::EndTurn,
539. 539 ),
540. 540 ]);
541. 541 let requests = Arc::new(Mutex::new(Vec::new()));
542. 542 let mut agent = Agent::new(
543. 543 Arc::new(Scripted(Mutex::new(script), requests.clone())),
544. 544 log,
545. 545 cfg,
546. 546 );
547. 547 let (tx, mut rx) = mpsc::channel(256);
548. 548 tokio::spawn(async move { while rx.recv().await.is_some() {} });
549. 549 let outcome = agent
550. 550 .run(
551. 551 "add a slide",
552. 552 &Default::default(),
553. 553 CancellationToken::new(),
554. 554 tx,
555. 555 )
556. 556 .await;
557. 557 assert!(
558. 558 matches!(outcome, TurnOutcome::Completed { .. }),
559. 559 "{outcome:?}"
560. 560 );
561. 561 assert_eq!(drafts.runs.load(Ordering::SeqCst), 1, "one draft written");
562. 562 assert_eq!(
563. 563 cards.runs.load(Ordering::SeqCst),
564. 564 0,
565. 565 "the preview never ran"
566. 566 );
567. 567 let requests = requests.lock().unwrap();
568. 568 let results: Vec<(String, String)> = requests
569. 569 .last()
570. 570 .unwrap()
571. 571 .messages
572. 572 .iter()
573. 573 .flat_map(|message| message.content.iter())
574. 574 .filter_map(|block| match block {
575. 575 ContentBlock::ToolResult {
576. 576 tool_use_id,
577. 577 content,
578. 578 ..
579. 579 } => Some((tool_use_id.clone(), format!("{content:?}"))),
580. 580 _ => None,
581. 581 })
582. 582 .collect();
583. 583 let result = |id: &str| {
584. 584 results
585. 585 .iter()
586. 586 .find(|(call, _)| call == id)
587. 587 .map(|(_, text)| text.clone())
588. 588 .unwrap_or_default()
589. 589 };
590. 590 assert!(result("c2").contains("Not shown: deck.pptx"), "{results:?}");
591. 591 assert!(
592. 592 result("c3").contains("Already drafted") && result("c3").contains("Draft for deck.pptx"),
593. 593 "{results:?}"
594. 594 );
595. 595 assert!(
596. 596 result("c4").contains("Not run: deck.pptx is a draft waiting for the person's review"),
597. 597 "copying the draft out of scratch is refused even in FullAccess: {results:?}"
598. 598 );
599. 599 assert_eq!(
600. 600 shell.runs.load(Ordering::SeqCst),
601. 601 1,
602. 602 "only the command that does not name the draft ran"
603. 603 );
604. 604}
605. 605