sdd-agent-platform 0.4.2 → 0.5.1

package/node_modules/@sdd-agent-platform/core/src/workflow-state/affected-file-conflicts.ts

@@ -1,94 +1,96 @@
-import type { RunState } from '../run-state/model.js';
-
-export interface WorkflowAffectedFileConflict {
-  file: string;
-  partition: string;
-  gitBranch: string | null;
-  taskId: string;
-  runId: string;
-  runStatus: RunState['status'];
-  updatedAt: string;
-}
-
-export function affectedFileConflictsForSelectedRun(states: RunState[], selected: RunState): WorkflowAffectedFileConflict[] {
-  if (!selected.partition || !selected.taskId || selected.affectedFiles.length === 0) {
-    return [];
-  }
-
-  const selectedFiles = new Set(selected.affectedFiles);
-  const conflicts: WorkflowAffectedFileConflict[] = [];
-  for (const state of states) {
-    if (!isAffectedFileConflictCandidate(state, selected)) {
-      continue;
-    }
-    for (const file of state.affectedFiles) {
-      if (selectedFiles.has(file)) {
-        conflicts.push({
-          file,
-          partition: state.partition,
-          gitBranch: state.gitBranch,
-          taskId: state.taskId,
-          runId: state.runId,
-          runStatus: state.status,
-          updatedAt: state.updatedAt
-        });
-      }
-    }
-  }
-  return conflicts.sort((left, right) => left.file.localeCompare(right.file) || left.partition.localeCompare(right.partition) || left.taskId.localeCompare(right.taskId) || left.runId.localeCompare(right.runId));
-}
-
-export function affectedFileConflictsForSelectedRuns(states: RunState[], selectedRuns: RunState[]): WorkflowAffectedFileConflict[] {
-  const conflicts = selectedRuns.flatMap((selected) => affectedFileConflictsForSelectedRun(states, selected));
-  return uniqueBy(conflicts, (conflict) => `${conflict.file}:${conflict.partition}:${conflict.taskId}:${conflict.runId}`);
-}
-
-function isAffectedFileConflictCandidate(candidate: RunState, selected: RunState): candidate is RunState & { partition: string; taskId: string } {
-  if (candidate.runId === selected.runId || candidate.status === 'archived' || !candidate.partition || !candidate.taskId) {
-    return false;
-  }
-  if (isNonAuthoritativeForegroundRun(candidate)) {
-    return false;
-  }
-  if (selectedSupersedesCandidate(selected, candidate)) {
-    return false;
-  }
-  return isActiveAffectedFileRun(candidate);
-}
-
-function isActiveAffectedFileRun(state: RunState): boolean {
-  return state.status === 'created' || state.status === 'running';
-}
-
-function selectedSupersedesCandidate(selected: RunState, candidate: RunState): boolean {
-  return Boolean(
-    selected.partition &&
-    selected.taskId &&
-    selected.partition === candidate.partition &&
-    selected.taskId === candidate.taskId &&
-    selected.status === 'completed' &&
-    selected.validation.status === 'pass' &&
-    Date.parse(selected.updatedAt) > Date.parse(candidate.updatedAt) &&
-    (candidate.status === 'failed' || candidate.status === 'blocked' || candidate.validation.status === 'fail' || candidate.validation.status === 'blocked')
-  );
-}
-
-function isNonAuthoritativeForegroundRun(state: RunState): boolean {
-  if (state.phase === 'foreground-subagents') {
-    return true;
-  }
-  const delegations = Object.values(state.delegations);
-  return delegations.length > 0 && delegations.every((delegation) => delegation.runMode === 'foreground' && !delegation.blocking && !delegation.requiredForPhaseExit);
-}
-
-function uniqueBy<T>(items: T[], keyOf: (item: T) => string): T[] {
-  const seen = new Set<string>();
-  return items.filter((item) => {
-    const key = keyOf(item);
-    if (seen.has(key)) {
-      return false;
-    }
-    seen.add(key);
-    return true;
-  });
+import type { RunState } from '../run-state/model.js';
+
+export interface WorkflowAffectedFileConflict {
+  file: string;
+  partition: string;
+  gitBranch: string | null;
+  taskId: string;
+  runId: string;
+  runStatus: RunState['status'];
+  syncBackStatus: RunState['syncBack']['status'];
+  updatedAt: string;
+}
+
+export function affectedFileConflictsForSelectedRun(states: RunState[], selected: RunState): WorkflowAffectedFileConflict[] {
+  if (!selected.partition || !selected.taskId || selected.affectedFiles.length === 0) {
+    return [];
+  }
+
+  const selectedFiles = new Set(selected.affectedFiles);
+  const conflicts: WorkflowAffectedFileConflict[] = [];
+  for (const state of states) {
+    if (!isAffectedFileConflictCandidate(state, selected)) {
+      continue;
+    }
+    for (const file of state.affectedFiles) {
+      if (selectedFiles.has(file)) {
+        conflicts.push({
+          file,
+          partition: state.partition,
+          gitBranch: state.gitBranch,
+          taskId: state.taskId,
+          runId: state.runId,
+          runStatus: state.status,
+          syncBackStatus: state.syncBack.status,
+          updatedAt: state.updatedAt
+        });
+      }
+    }
+  }
+  return conflicts.sort((left, right) => left.file.localeCompare(right.file) || left.partition.localeCompare(right.partition) || left.taskId.localeCompare(right.taskId) || left.runId.localeCompare(right.runId));
+}
+
+export function affectedFileConflictsForSelectedRuns(states: RunState[], selectedRuns: RunState[]): WorkflowAffectedFileConflict[] {
+  const conflicts = selectedRuns.flatMap((selected) => affectedFileConflictsForSelectedRun(states, selected));
+  return uniqueBy(conflicts, (conflict) => `${conflict.file}:${conflict.partition}:${conflict.taskId}:${conflict.runId}`);
+}
+
+function isAffectedFileConflictCandidate(candidate: RunState, selected: RunState): candidate is RunState & { partition: string; taskId: string } {
+  if (candidate.runId === selected.runId || candidate.status === 'archived' || !candidate.partition || !candidate.taskId) {
+    return false;
+  }
+  if (isNonAuthoritativeForegroundRun(candidate)) {
+    return false;
+  }
+  if (selectedSupersedesCandidate(selected, candidate)) {
+    return false;
+  }
+  return isActiveAffectedFileRun(candidate);
+}
+
+function isActiveAffectedFileRun(state: RunState): boolean {
+  return state.status === 'created' || state.status === 'running';
+}
+
+function selectedSupersedesCandidate(selected: RunState, candidate: RunState): boolean {
+  return Boolean(
+    selected.partition &&
+    selected.taskId &&
+    selected.partition === candidate.partition &&
+    selected.taskId === candidate.taskId &&
+    selected.status === 'completed' &&
+    selected.validation.status === 'pass' &&
+    Date.parse(selected.updatedAt) > Date.parse(candidate.updatedAt) &&
+    (candidate.status === 'failed' || candidate.status === 'blocked' || candidate.validation.status === 'fail' || candidate.validation.status === 'blocked' || candidate.syncBack.status === 'proposed')
+  );
+}
+
+function isNonAuthoritativeForegroundRun(state: RunState): boolean {
+  if (state.phase === 'foreground-subagents') {
+    return true;
+  }
+  const delegations = Object.values(state.delegations);
+  return delegations.length > 0 && delegations.every((delegation) => delegation.runMode === 'foreground' && !delegation.blocking && !delegation.requiredForPhaseExit);
+}
+
+function uniqueBy<T>(items: T[], keyOf: (item: T) => string): T[] {
+  const seen = new Set<string>();
+  return items.filter((item) => {
+    const key = keyOf(item);
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
 }

package/node_modules/@sdd-agent-platform/core/src/workflow-state/dependencies.test.ts

@@ -1,32 +1,32 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import { parseSddTasksMarkdown } from '../sdd-docs/task-parser.js';
-import { resolveTaskDependencyReadiness, workflowDependencyBlockers } from './dependencies.js';
-
-function taskBlock(id: string, status: string, dependsOn: string[]): string {
-  const dependsOnBlock = dependsOn.length === 0 ? 'depends_on: []' : `depends_on:\n${dependsOn.map((dependency) => `  - ${dependency}`).join('\n')}`;
-  return `### ${id}: Dependency fixture\n\n\`\`\`sdd-task\nid: ${id}\nstatus: ${status}\nwave: 1\n${dependsOnBlock}\nacceptance_refs:\n  - AC-${id}\nplan_refs:\n  - Plan\naffected_files:\n  - docs/${id}.md\nvalidation:\n  - npm test\nrisk: []\n\`\`\`\n`;
-}
-
-test('dependency readiness blocks tasks until dependencies are completed', () => {
-  const model = parseSddTasksMarkdown(`# Tasks\n\n${taskBlock('DEP1', 'pending', [])}\n${taskBlock('DEP2', 'pending', ['DEP1'])}`, { tasksPath: 'tasks.md' });
-
-  const readiness = resolveTaskDependencyReadiness(model, 'DEP2');
-
-  assert.equal(readiness.ready, false);
-  assert.deepEqual(readiness.dependencies.map((dependency) => `${dependency.taskId}:${dependency.status}:${dependency.ready}`), ['DEP1:pending:false']);
-  assert.match(readiness.blockingReasons[0], /DEP2 depends on DEP1, but DEP1 has not passed required verification/);
-  assert.deepEqual(workflowDependencyBlockers(model).map((blocker) => `${blocker.taskId}->${blocker.dependencyId}:${blocker.dependencyStatus}`), ['DEP2->DEP1:pending']);
-});
-
-test('dependency readiness accepts completed dependencies and reports missing dependencies', () => {
-  const readyModel = parseSddTasksMarkdown(`# Tasks\n\n${taskBlock('DEP1', 'completed', [])}\n${taskBlock('DEP2', 'pending', ['DEP1'])}`, { tasksPath: 'tasks.md' });
-  const missingModel = parseSddTasksMarkdown(`# Tasks\n\n${taskBlock('DEP2', 'pending', ['MISSING'])}`, { tasksPath: 'tasks.md' });
-
-  assert.equal(resolveTaskDependencyReadiness(readyModel, 'DEP2').ready, true);
-  const missing = resolveTaskDependencyReadiness(missingModel, 'DEP2');
-  assert.equal(missing.ready, false);
-  assert.equal(missing.dependencies[0].status, 'missing');
-  assert.match(missing.blockingReasons[0], /MISSING was not found/);
-});
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { parseSddTasksMarkdown } from '../sdd-docs/task-parser.js';
+import { resolveTaskDependencyReadiness, workflowDependencyBlockers } from './dependencies.js';
+
+function taskBlock(id: string, status: string, dependsOn: string[]): string {
+  const dependsOnBlock = dependsOn.length === 0 ? 'depends_on: []' : `depends_on:\n${dependsOn.map((dependency) => `  - ${dependency}`).join('\n')}`;
+  return `### ${id}: Dependency fixture\n\n\`\`\`sdd-task\nid: ${id}\nstatus: ${status}\nwave: 1\n${dependsOnBlock}\nacceptance_refs:\n  - AC-${id}\nplan_refs:\n  - Plan\naffected_files:\n  - docs/${id}.md\nvalidation:\n  - npm test\nrisk: []\n\`\`\`\n`;
+}
+
+test('dependency readiness blocks tasks until dependencies are completed', () => {
+  const model = parseSddTasksMarkdown(`# Tasks\n\n${taskBlock('DEP1', 'pending', [])}\n${taskBlock('DEP2', 'pending', ['DEP1'])}`, { tasksPath: 'tasks.md' });
+
+  const readiness = resolveTaskDependencyReadiness(model, 'DEP2');
+
+  assert.equal(readiness.ready, false);
+  assert.deepEqual(readiness.dependencies.map((dependency) => `${dependency.taskId}:${dependency.status}:${dependency.ready}`), ['DEP1:pending:false']);
+  assert.match(readiness.blockingReasons[0], /DEP2 depends on DEP1, but DEP1 has not passed required verification/);
+  assert.deepEqual(workflowDependencyBlockers(model).map((blocker) => `${blocker.taskId}->${blocker.dependencyId}:${blocker.dependencyStatus}`), ['DEP2->DEP1:pending']);
+});
+
+test('dependency readiness accepts completed dependencies and reports missing dependencies', () => {
+  const readyModel = parseSddTasksMarkdown(`# Tasks\n\n${taskBlock('DEP1', 'completed', [])}\n${taskBlock('DEP2', 'pending', ['DEP1'])}`, { tasksPath: 'tasks.md' });
+  const missingModel = parseSddTasksMarkdown(`# Tasks\n\n${taskBlock('DEP2', 'pending', ['MISSING'])}`, { tasksPath: 'tasks.md' });
+
+  assert.equal(resolveTaskDependencyReadiness(readyModel, 'DEP2').ready, true);
+  const missing = resolveTaskDependencyReadiness(missingModel, 'DEP2');
+  assert.equal(missing.ready, false);
+  assert.equal(missing.dependencies[0].status, 'missing');
+  assert.match(missing.blockingReasons[0], /MISSING was not found/);
+});

package/node_modules/@sdd-agent-platform/core/src/workflow-state/dependencies.ts

@@ -1,114 +1,114 @@
-import type { RunStateTaskRuntime } from '../run-state/model.js';
-import type { SddTask, SddTaskModel } from '../sdd-docs/task-parser.js';
-type TaskDependencyModel = Pick<SddTaskModel, 'tasks'>;
-
-export interface TaskDependencyReadinessOptions {
-  runtimeByTask?: Map<string, RunStateTaskRuntime>;
-}
-
-export interface TaskDependencyReadinessEntry {
-  taskId: string;
-  status: SddTask['status'] | 'missing';
-  ready: boolean;
-  reason: string | null;
-}
-
-export interface TaskDependencyReadiness {
-  taskId: string;
-  ready: boolean;
-  dependencies: TaskDependencyReadinessEntry[];
-  blockingReasons: string[];
-}
-
-export interface WorkflowDependencyBlocker {
-  taskId: string;
-  dependencyId: string;
-  dependencyStatus: SddTask['status'] | 'missing';
-  reason: string;
-}
-
-export function resolveTaskDependencyReadiness(model: TaskDependencyModel, taskId: string, options: TaskDependencyReadinessOptions = {}): TaskDependencyReadiness {
-  const task = model.tasks.find((candidate) => candidate.id === taskId) ?? null;
-  if (!task) {
-    return { taskId, ready: false, dependencies: [], blockingReasons: [`Task ${taskId} was not found.`] };
-  }
-
-  const dependencies = task.dependsOn.map((dependencyId) => dependencyReadinessEntry(task.id, dependencyId, model.tasks.find((candidate) => candidate.id === dependencyId) ?? null, options.runtimeByTask?.get(dependencyId)));
-  const blockingReasons = dependencies.map((dependency) => dependency.reason).filter((reason): reason is string => Boolean(reason));
-  return {
-    taskId: task.id,
-    ready: blockingReasons.length === 0,
-    dependencies,
-    blockingReasons
-  };
-}
-
-export function dependencyBlockingReasonsForTask(model: TaskDependencyModel, taskId: string, options: TaskDependencyReadinessOptions = {}): string[] {
-  return resolveTaskDependencyReadiness(model, taskId, options).blockingReasons;
-}
-
-export function workflowDependencyBlockers(model: TaskDependencyModel, options: TaskDependencyReadinessOptions = {}): WorkflowDependencyBlocker[] {
-  const blockers: WorkflowDependencyBlocker[] = [];
-  for (const task of model.tasks) {
-    if (task.status === 'completed' || task.status === 'deferred') {
-      continue;
-    }
-    for (const dependency of resolveTaskDependencyReadiness(model, task.id, options).dependencies) {
-      if (!dependency.ready && dependency.reason) {
-        blockers.push({
-          taskId: task.id,
-          dependencyId: dependency.taskId,
-          dependencyStatus: dependency.status,
-          reason: dependency.reason
-        });
-      }
-    }
-  }
-  return blockers;
-}
-
-export function nextDependencyTaskId(model: TaskDependencyModel, taskId: string, options: TaskDependencyReadinessOptions = {}): string | null {
-  return resolveTaskDependencyReadiness(model, taskId, options).dependencies.find((dependency) => !dependency.ready)?.taskId ?? null;
-}
-
-function dependencyReadinessEntry(taskId: string, dependencyId: string, dependency: SddTask | null, runtime: RunStateTaskRuntime | undefined): TaskDependencyReadinessEntry {
-  if (!dependency) {
-    return {
-      taskId: dependencyId,
-      status: 'missing',
-      ready: false,
-      reason: `Task ${taskId} depends on ${dependencyId}, but ${dependencyId} was not found; restore or remove the dependency before continuing ${taskId}.`
-    };
-  }
-  if (dependency.status === 'completed' || dependencyRuntimeSatisfiesImplementationBoundary(dependency, runtime)) {
-    return {
-      taskId: dependency.id,
-      status: dependency.status,
-      ready: true,
-      reason: null
-    };
-  }
-  return {
-    taskId: dependency.id,
-    status: dependency.status,
-    ready: false,
-    reason: dependencyRequiresVerifiedBoundary(dependency)
-      ? `Task ${taskId} depends on ${dependency.id}, but ${dependency.id} has not passed required verification; run sdd test task-${dependency.id} before continuing ${taskId}.`
-      : `Task ${taskId} depends on ${dependency.id}, but ${dependency.id} is not implemented; run sdd do task ${dependency.id} before continuing ${taskId}.`
-  };
-}
-
-function dependencyRuntimeSatisfiesImplementationBoundary(task: SddTask, runtime: RunStateTaskRuntime | undefined): boolean {
-  if (!runtimeTaskImplemented(runtime)) {
-    return false;
-  }
-  return !dependencyRequiresVerifiedBoundary(task) || runtime?.verificationStatus === 'pass' || runtime?.status === 'implemented_verified';
-}
-
-function dependencyRequiresVerifiedBoundary(task: SddTask): boolean {
-  return task.requiresVerifyBeforeNext || task.validationTiming === 'task_end';
-}
-
-function runtimeTaskImplemented(runtime: RunStateTaskRuntime | undefined): boolean {
-  return runtime?.implementationStatus === 'implemented' || runtime?.status === 'implemented_pending_validation' || runtime?.status === 'implemented_verified';
-}
+import type { RunStateTaskRuntime } from '../run-state/model.js';
+import type { SddTask, SddTaskModel } from '../sdd-docs/task-parser.js';
+type TaskDependencyModel = Pick<SddTaskModel, 'tasks'>;
+
+export interface TaskDependencyReadinessOptions {
+  runtimeByTask?: Map<string, RunStateTaskRuntime>;
+}
+
+export interface TaskDependencyReadinessEntry {
+  taskId: string;
+  status: SddTask['status'] | 'missing';
+  ready: boolean;
+  reason: string | null;
+}
+
+export interface TaskDependencyReadiness {
+  taskId: string;
+  ready: boolean;
+  dependencies: TaskDependencyReadinessEntry[];
+  blockingReasons: string[];
+}
+
+export interface WorkflowDependencyBlocker {
+  taskId: string;
+  dependencyId: string;
+  dependencyStatus: SddTask['status'] | 'missing';
+  reason: string;
+}
+
+export function resolveTaskDependencyReadiness(model: TaskDependencyModel, taskId: string, options: TaskDependencyReadinessOptions = {}): TaskDependencyReadiness {
+  const task = model.tasks.find((candidate) => candidate.id === taskId) ?? null;
+  if (!task) {
+    return { taskId, ready: false, dependencies: [], blockingReasons: [`Task ${taskId} was not found.`] };
+  }
+
+  const dependencies = task.dependsOn.map((dependencyId) => dependencyReadinessEntry(task.id, dependencyId, model.tasks.find((candidate) => candidate.id === dependencyId) ?? null, options.runtimeByTask?.get(dependencyId)));
+  const blockingReasons = dependencies.map((dependency) => dependency.reason).filter((reason): reason is string => Boolean(reason));
+  return {
+    taskId: task.id,
+    ready: blockingReasons.length === 0,
+    dependencies,
+    blockingReasons
+  };
+}
+
+export function dependencyBlockingReasonsForTask(model: TaskDependencyModel, taskId: string, options: TaskDependencyReadinessOptions = {}): string[] {
+  return resolveTaskDependencyReadiness(model, taskId, options).blockingReasons;
+}
+
+export function workflowDependencyBlockers(model: TaskDependencyModel, options: TaskDependencyReadinessOptions = {}): WorkflowDependencyBlocker[] {
+  const blockers: WorkflowDependencyBlocker[] = [];
+  for (const task of model.tasks) {
+    if (task.status === 'completed' || task.status === 'deferred') {
+      continue;
+    }
+    for (const dependency of resolveTaskDependencyReadiness(model, task.id, options).dependencies) {
+      if (!dependency.ready && dependency.reason) {
+        blockers.push({
+          taskId: task.id,
+          dependencyId: dependency.taskId,
+          dependencyStatus: dependency.status,
+          reason: dependency.reason
+        });
+      }
+    }
+  }
+  return blockers;
+}
+
+export function nextDependencyTaskId(model: TaskDependencyModel, taskId: string, options: TaskDependencyReadinessOptions = {}): string | null {
+  return resolveTaskDependencyReadiness(model, taskId, options).dependencies.find((dependency) => !dependency.ready)?.taskId ?? null;
+}
+
+function dependencyReadinessEntry(taskId: string, dependencyId: string, dependency: SddTask | null, runtime: RunStateTaskRuntime | undefined): TaskDependencyReadinessEntry {
+  if (!dependency) {
+    return {
+      taskId: dependencyId,
+      status: 'missing',
+      ready: false,
+      reason: `Task ${taskId} depends on ${dependencyId}, but ${dependencyId} was not found; restore or remove the dependency before continuing ${taskId}.`
+    };
+  }
+  if (dependency.status === 'completed' || dependencyRuntimeSatisfiesImplementationBoundary(dependency, runtime)) {
+    return {
+      taskId: dependency.id,
+      status: dependency.status,
+      ready: true,
+      reason: null
+    };
+  }
+  return {
+    taskId: dependency.id,
+    status: dependency.status,
+    ready: false,
+    reason: dependencyRequiresVerifiedBoundary(dependency)
+      ? `Task ${taskId} depends on ${dependency.id}, but ${dependency.id} has not passed required verification; run sdd test task ${dependency.id} before continuing ${taskId}.`
+      : `Task ${taskId} depends on ${dependency.id}, but ${dependency.id} is not implemented; run sdd do task ${dependency.id} before continuing ${taskId}.`
+  };
+}
+
+function dependencyRuntimeSatisfiesImplementationBoundary(task: SddTask, runtime: RunStateTaskRuntime | undefined): boolean {
+  if (!runtimeTaskImplemented(runtime)) {
+    return false;
+  }
+  return !dependencyRequiresVerifiedBoundary(task) || runtime?.verificationStatus === 'pass' || runtime?.status === 'implemented_verified';
+}
+
+function dependencyRequiresVerifiedBoundary(task: SddTask): boolean {
+  return task.requiresVerifyBeforeNext || task.validationTiming === 'task_end';
+}
+
+function runtimeTaskImplemented(runtime: RunStateTaskRuntime | undefined): boolean {
+  return runtime?.implementationStatus === 'implemented' || runtime?.status === 'implemented_pending_validation' || runtime?.status === 'implemented_verified';
+}