@afokapu/atdd-flow 0.3.12 → 0.3.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@afokapu/atdd-flow",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "Filesystem-first Desk registry for projects, seats, tasks, threads, and handoffs.",
   "type": "module",
   "bin": {

package/src/core.ts

@@ -2,6 +2,7 @@ import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 
 export type Role = { address: string; branch: string; agent?: string; purpose?: string; worktree?: string; base?: string };
 export type Group = { role?: string; members?: string[] };
@@ -129,8 +130,8 @@ export const required = <T>(value: T | undefined, label: string) => {
   return value;
 };
 export const yaml = {
-  parse: <T>(text: string) => Bun.YAML.parse(text) as T,
-  print: (value: unknown) => Bun.YAML.stringify(value),
+  parse: <T>(text: string) => parseYaml(text) as T,
+  print: (value: unknown) => stringifyYaml(value, { collectionStyle: "flow", flowCollectionPadding: false }),
 };
 
 export function addressParts(address: string) {

package/src/tasks.ts

@@ -246,8 +246,10 @@ export async function unblock(root: string, projectName: string, id: string, arg
   const task = await readTask(root, projectName, taskId(id));
   const actor = await canonicalAddress(root, required(words(args, "--by"), "--by"));
   if (actor !== task.coordinator) throw new Error(`Only ${task.coordinator} may unblock task ${id}.`);
-  if (task.status !== "in_progress") throw new Error(`Task ${id} can only be unblocked while in_progress.`);
+  if (task.status !== "todo" && task.status !== "in_progress") throw new Error(`Task ${id} can only be unblocked while todo or in_progress.`);
   if (!task.blocker) throw new Error(`Task ${id} has no blocker to clear.`);
+  const waiting = await ready(root, projectName, task);
+  if (waiting.length) throw new Error(`Task ${id} is waiting on: ${waiting.join(", ")}.`);
   const { assertDependentsMayUnblock } = await import("./ephemeral-resources");
   await assertDependentsMayUnblock(root, { project: projectName, task: id });
   delete task.blocker;

package/src/threads.ts

@@ -84,12 +84,16 @@ function inboxDirectory(root: string, address: string) {
 }
 
 const pause = (milliseconds: number) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+const inboxLockStaleMs = 30_000;
+const inboxLockAcquireTimeoutMs = 5_000;
+const inboxLockRetryMs = 5;
 
 /** mkdir is atomic across CLI processes; stale locks are recoverable after a crashed writer. */
 async function withInboxLock<T>(directory: string, action: () => Promise<T>) {
   await mkdir(directory, { recursive: true });
   const lock = join(directory, "queue.lock");
-  for (let attempt = 0; attempt < 200; attempt += 1) {
+  const deadline = Date.now() + inboxLockAcquireTimeoutMs;
+  while (Date.now() < deadline) {
     try {
       await mkdir(lock, { recursive: false });
       try { return await action(); }
@@ -97,9 +101,10 @@ async function withInboxLock<T>(directory: string, action: () => Promise<T>) {
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
       try {
-        if (Date.now() - (await stat(lock)).mtimeMs > 30_000) await rm(lock, { recursive: true, force: true });
-        else await pause(5);
-      } catch { await pause(5); }
+        if (Date.now() - (await stat(lock)).mtimeMs > inboxLockStaleMs) await rm(lock, { recursive: true, force: true });
+      } catch { /* A competing release or recovery is retried below. */ }
+      const remaining = deadline - Date.now();
+      if (remaining > 0) await pause(Math.min(inboxLockRetryMs, remaining));
     }
   }
   throw new Error(`Timed out waiting for inbox queue lock ${directory}`);