syntaur 0.16.2 → 0.17.0

package/dist/launch/index.js

@@ -887,7 +887,20 @@ async function readConfig() {
   };
 }
 function getAgents(config) {
-  return config.agents ?? BUILTIN_AGENTS;
+  if (config.agents === null) return BUILTIN_AGENTS;
+  const builtinById = new Map(BUILTIN_AGENTS.map((a) => [a.id, a]));
+  return config.agents.map((agent) => {
+    const builtin = builtinById.get(agent.id);
+    if (!builtin) return agent;
+    const resume = agent.resume ?? builtin.resume;
+    const fork = agent.fork ?? builtin.fork;
+    if (resume === agent.resume && fork === agent.fork) return agent;
+    return {
+      ...agent,
+      ...resume ? { resume } : {},
+      ...fork ? { fork } : {}
+    };
+  });
 }
 function parseTerminalConfig(value) {
   if (value === void 0 || value === null || value === "") return null;
@@ -1333,7 +1346,7 @@ function buildTransitionTable(transitions) {
   return table;
 }
 function getTargetStatus(_from, command, table) {
-  if (!table || table === DEFAULT_TRANSITION_TABLE) {
+  if (!table) {
     return DEFAULT_COMMAND_TARGETS.get(command) ?? null;
   }
   return table.get(command) ?? table.get(`${_from}:${command}`) ?? null;
@@ -1715,6 +1728,10 @@ var init_overviewCopy = __esm({
 // src/dashboard/api.ts
 import { readdir as readdir6, readFile as readFile8, writeFile as writeFile3 } from "fs/promises";
 import { resolve as resolve11, dirname as dirname2, basename } from "path";
+function accumulatePhase(traces, label, ms) {
+  if (!traces) return;
+  traces.subPhases.set(label, (traces.subPhases.get(label) ?? 0) + ms);
+}
 async function listStandaloneRecords(assignmentsDir) {
   if (!assignmentsDir) return [];
   if (!await fileExists(assignmentsDir)) return [];
@@ -1759,12 +1776,17 @@ async function getStatusConfig() {
     const terminalSet = new Set(
       config.statuses.statuses.filter((s) => s.terminal).map((s) => s.id)
     );
+    const hasCustomTransitions = config.statuses.transitions.length > 0;
+    const effectiveTransitions = hasCustomTransitions ? config.statuses.transitions : Array.from(DEFAULT_TRANSITION_TABLE.entries()).map(([key, to]) => {
+      const [from, command] = key.split(":");
+      return { from, command, to };
+    });
     _cachedConfig = {
       custom: true,
       statuses: config.statuses.statuses,
       order: config.statuses.order,
-      transitions: config.statuses.transitions,
-      transitionTable: buildTransitionTable(config.statuses.transitions),
+      transitions: effectiveTransitions,
+      transitionTable: buildTransitionTable(effectiveTransitions),
       terminalStatuses: terminalSet.size > 0 ? terminalSet : /* @__PURE__ */ new Set(["completed", "failed"])
     };
   } else {
@@ -1792,16 +1814,17 @@ async function getStandaloneAvailableTransitions(assignment) {
   const transitionDefs = getTransitionDefinitions(config);
   const actions = [];
   for (const definition of transitionDefs) {
+    const target = getTargetStatus(assignment.status, definition.command, config.transitionTable);
+    if (target === null) continue;
     let warning = null;
     if (definition.command === "start" && !assignment.assignee) {
       warning = "No assignee set \u2014 consider assigning before starting.";
     }
-    const target = getTargetStatus(assignment.status, definition.command, config.transitionTable);
     actions.push({
       command: definition.command,
       label: definition.label,
       description: definition.description,
-      targetStatus: target ?? definition.command,
+      targetStatus: target,
       disabled: false,
       disabledReason: null,
       warning,
@@ -1895,6 +1918,7 @@ async function getAssignmentDetail(projectsDir, projectSlug, assignmentSlug) {
     slug: assignment.slug || assignmentSlug,
     title: assignment.title,
     status: assignment.status,
+    type: assignment.type,
     priority: assignment.priority,
     assignee: assignment.assignee,
     dependsOn: assignment.dependsOn,
@@ -2143,6 +2167,7 @@ async function buildStandaloneAssignmentDetail(resolved) {
     slug: assignment.slug || resolved.id,
     title: assignment.title,
     status: assignment.status,
+    type: assignment.type,
     priority: assignment.priority,
     assignee: assignment.assignee,
     dependsOn: [],
@@ -2169,7 +2194,7 @@ async function buildStandaloneAssignmentDetail(resolved) {
   };
   return detail;
 }
-async function listProjectRecords(projectsDir) {
+async function listProjectRecords(projectsDir, traces) {
   if (!await fileExists(projectsDir)) {
     return [];
   }
@@ -2179,61 +2204,75 @@ async function listProjectRecords(projectsDir) {
   }
   const entries = await readdir6(projectsDir, { withFileTypes: true });
   const projectDirs = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
-  const records = [];
-  for (const entry of projectDirs) {
-    const projectPath = resolve11(projectsDir, entry.name);
-    const projectMdPath = resolve11(projectPath, "project.md");
-    if (!await fileExists(projectMdPath)) {
-      continue;
-    }
-    const projectContent = await readFile8(projectMdPath, "utf-8");
-    const project = parseProject(projectContent);
-    const assignments = await listAssignmentRecords(projectPath);
-    const rollup = await buildProjectRollup(projectPath, project, assignments);
-    const updated = getProjectActivityTimestamp(project.updated, assignments);
-    records.push({
-      projectPath,
-      project,
-      assignments,
-      dependencyGraph: await loadDependencyGraph(projectPath, assignments),
-      summary: {
-        slug: project.slug || entry.name,
-        title: project.title,
-        status: rollup.status,
-        statusOverride: project.statusOverride,
-        archived: project.archived,
-        archivedAt: project.archivedAt,
-        archivedReason: project.archivedReason,
-        created: project.created,
-        updated,
-        tags: project.tags,
-        progress: rollup.progress,
-        needsAttention: rollup.needsAttention,
-        workspace: project.workspace
+  const maybeRecords = await Promise.all(
+    projectDirs.map(async (entry) => {
+      const projectPath = resolve11(projectsDir, entry.name);
+      const projectMdPath = resolve11(projectPath, "project.md");
+      if (!await fileExists(projectMdPath)) {
+        return null;
       }
-    });
-  }
+      const t0 = traces ? performance.now() : 0;
+      const projectContent = await readFile8(projectMdPath, "utf-8");
+      const project = parseProject(projectContent);
+      if (traces) accumulatePhase(traces, "parse-project-md", performance.now() - t0);
+      const t1 = traces ? performance.now() : 0;
+      const assignments = await listAssignmentRecords(projectPath, traces);
+      if (traces) accumulatePhase(traces, "list-assignments", performance.now() - t1);
+      const t2 = traces ? performance.now() : 0;
+      const rollup = await buildProjectRollup(projectPath, project, assignments, traces);
+      if (traces) accumulatePhase(traces, "build-rollup", performance.now() - t2);
+      const updated = getProjectActivityTimestamp(project.updated, assignments);
+      const t3 = traces ? performance.now() : 0;
+      const dependencyGraph = await loadDependencyGraph(projectPath, assignments);
+      if (traces) accumulatePhase(traces, "load-dep-graph", performance.now() - t3);
+      return {
+        projectPath,
+        project,
+        assignments,
+        dependencyGraph,
+        summary: {
+          slug: project.slug || entry.name,
+          title: project.title,
+          status: rollup.status,
+          statusOverride: project.statusOverride,
+          archived: project.archived,
+          archivedAt: project.archivedAt,
+          archivedReason: project.archivedReason,
+          created: project.created,
+          updated,
+          tags: project.tags,
+          progress: rollup.progress,
+          needsAttention: rollup.needsAttention,
+          workspace: project.workspace
+        }
+      };
+    })
+  );
+  const records = maybeRecords.filter((r) => r !== null);
   records.sort((left, right) => compareTimestamps(right.summary.updated, left.summary.updated));
   return records;
 }
-async function listAssignmentRecords(projectPath) {
+async function listAssignmentRecords(projectPath, traces) {
   const assignmentsDir = resolve11(projectPath, "assignments");
   if (!await fileExists(assignmentsDir)) {
     return [];
   }
   const entries = await readdir6(assignmentsDir, { withFileTypes: true });
-  const records = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) {
-      continue;
-    }
-    const assignmentMd = resolve11(assignmentsDir, entry.name, "assignment.md");
-    if (!await fileExists(assignmentMd)) {
-      continue;
-    }
-    const content = await readFile8(assignmentMd, "utf-8");
-    records.push(parseAssignmentFull(content));
-  }
+  const dirEntries = entries.filter((entry) => entry.isDirectory());
+  const maybeRecords = await Promise.all(
+    dirEntries.map(async (entry) => {
+      const assignmentMd = resolve11(assignmentsDir, entry.name, "assignment.md");
+      if (!await fileExists(assignmentMd)) {
+        return null;
+      }
+      const t0 = traces ? performance.now() : 0;
+      const content = await readFile8(assignmentMd, "utf-8");
+      const parsed = parseAssignmentFull(content);
+      if (traces) accumulatePhase(traces, "read-assignment-md", performance.now() - t0);
+      return parsed;
+    })
+  );
+  const records = maybeRecords.filter((r) => r !== null);
   records.sort((left, right) => compareTimestamps(right.updated, left.updated));
   return records;
 }
@@ -2249,13 +2288,20 @@ async function loadDependencyGraph(projectPath, assignments) {
   }
   return buildDependencyGraph(assignments);
 }
-async function buildProjectRollup(projectPath, project, assignments) {
+async function buildProjectRollup(projectPath, project, assignments, traces) {
   const progress = { total: assignments.length };
+  const perAssignment = await Promise.all(
+    assignments.map(async (assignment) => {
+      const t0 = traces ? performance.now() : 0;
+      const openQuestions2 = await countOpenQuestions(projectPath, assignment.slug);
+      if (traces) accumulatePhase(traces, "count-open-questions", performance.now() - t0);
+      return { status: assignment.status, openQuestions: openQuestions2 };
+    })
+  );
   let openQuestions = 0;
-  for (const assignment of assignments) {
-    const s = assignment.status;
-    progress[s] = (progress[s] ?? 0) + 1;
-    openQuestions += await countOpenQuestions(projectPath, assignment.slug);
+  for (const entry of perAssignment) {
+    progress[entry.status] = (progress[entry.status] ?? 0) + 1;
+    openQuestions += entry.openQuestions;
   }
   const needsAttention = {
     blockedCount: progress["blocked"] ?? 0,
@@ -2308,28 +2354,37 @@ function buildDependencyGraph(assignments) {
 function findAssignmentStatus(assignments, slug) {
   return assignments.find((assignment) => assignment.slug === slug)?.status ?? "pending";
 }
-async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug, assignment) {
+async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug, assignment, options) {
   const config = await getStatusConfig();
   const transitionDefs = getTransitionDefinitions(config);
   const actions = [];
   const projectPath = resolve11(projectsDir, projectSlug);
+  const traces = options?.traces;
   for (const definition of transitionDefs) {
+    const target = getTargetStatus(assignment.status, definition.command, config.transitionTable);
+    if (target === null) continue;
     let warning = null;
     if (definition.command === "start" && !assignment.assignee) {
       warning = "No assignee set \u2014 consider assigning before starting.";
     }
     if (definition.command === "start" && assignment.dependsOn.length > 0) {
-      const unmetDependencies = await getUnmetDependencies(projectPath, assignment.dependsOn, config.terminalStatuses);
+      const t0 = traces ? performance.now() : 0;
+      const unmetDependencies = await getUnmetDependencies(
+        projectPath,
+        assignment.dependsOn,
+        config.terminalStatuses,
+        options?.dependencyStatusMap
+      );
+      if (traces) accumulatePhase(traces, "get-unmet-dependencies", performance.now() - t0);
       if (unmetDependencies.length > 0) {
         warning = `Unmet dependencies: ${unmetDependencies.join(", ")}.`;
       }
     }
-    const target = getTargetStatus(assignment.status, definition.command, config.transitionTable);
     actions.push({
       command: definition.command,
       label: definition.label,
       description: definition.description,
-      targetStatus: target ?? definition.command,
+      targetStatus: target,
       disabled: false,
       disabledReason: null,
       warning,
@@ -2338,10 +2393,19 @@ async function getAvailableTransitions(projectsDir, projectSlug, assignmentSlug,
   }
   return actions;
 }
-async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses) {
+async function getUnmetDependencies(projectPath, dependsOn, terminalStatuses, dependencyStatusMap) {
   const terminals = terminalStatuses ?? /* @__PURE__ */ new Set(["completed"]);
   const unmet = [];
   for (const dependency of dependsOn) {
+    if (dependencyStatusMap) {
+      const mappedStatus = dependencyStatusMap.get(dependency);
+      if (mappedStatus !== void 0) {
+        if (!terminals.has(mappedStatus)) {
+          unmet.push(`${dependency} (${mappedStatus})`);
+        }
+        continue;
+      }
+    }
     const dependencyPath = resolve11(projectPath, "assignments", dependency, "assignment.md");
     if (!await fileExists(dependencyPath)) {
       unmet.push(`${dependency} (missing)`);