@afokapu/atdd-flow 0.3.11 → 0.3.13

package/package.json

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

package/src/seats.ts

@@ -162,6 +162,21 @@ export function resolveModelCommand(config: Desk, candidate: ModelCandidate) {
   return { agent: resolveExecutable(config, candidate.executable), args: candidate.args ?? [] };
 }
 
+async function launchEligibleTasks(root: string, record: Seat) {
+  const tasks = await seatTasks(root, record.project, record.address);
+  const eligible = await Promise.all(tasks.map(async (entry) => {
+    if (entry.task.assignee !== record.address || entry.task.blocker) return undefined;
+    if (entry.task.status === "in_progress") return entry;
+    if (entry.task.status !== "todo") return undefined;
+    const dependencies = await Promise.all((entry.task.depends_on ?? []).map(async (id) => {
+      try { return (await readYaml<{ status?: string }>(paths(root).taskFile(record.project, id))).status === "done"; }
+      catch { return false; }
+    }));
+    return dependencies.every(Boolean) ? entry : undefined;
+  }));
+  return eligible.filter((entry): entry is NonNullable<typeof entry> => Boolean(entry));
+}
+
 async function chooseLaunchModel(root: string, config: Desk, record: Seat, portfolio: ModelPortfolio, select: (input: ModelSelectionInput) => Promise<ModelSelectionResponse> = selectModel) {
   const candidates = availableModelCandidates(config, portfolio);
   if (!candidates.length) throw new Error("No enabled model in models.yaml has an available executable.");
@@ -261,8 +276,8 @@ export async function launchPiRuntime(root: string, address: string, args: strin
   const resume = args.includes("--resume");
   const dryRun = args.includes("--dry-run");
   if (args.some((argument) => !["--pane", pane, "--herdr-session", herdrSession, "--resume", "--dry-run"].includes(argument))) throw new Error("Use `pi runtime launch <seat> --pane <existing-pane> --herdr-session <session> [--resume] [--dry-run]`.");
-  const active = (await seatTasks(root, record.project, resolved)).filter((entry) => entry.task.status === "in_progress");
-  if (!active.length) throw new Error(`${resolved} has no active bounded task; refusing runtime launch.`);
+  const active = await launchEligibleTasks(root, record);
+  if (!active.length) throw new Error(`${resolved} has no launch-eligible task; refusing runtime launch.`);
   const selection = await chooseLaunchModel(root, config, record, required(await modelPortfolio(root), "models.yaml for Pi runtime launch"), dependencies.select);
   const model = resolveModelCommand(config, selection.candidate);
   if (basename(model.agent) !== "pi") throw new Error(`Pi runtime launch requires a Pi candidate, received ${selection.candidate.id}.`);

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;