sdd-agent-platform 0.4.2 → 0.5.1

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

@@ -1,158 +1,158 @@
-import type { SddTask, SddTaskModel } from '../sdd-docs/task-parser.js';
-import type { LatestEligibleRunSelection } from './latest-eligible-run.js';
-
-export type MixedVersionRecoveryIssueKind = 'legacy_artifact_ref' | 'non_executable_validation' | 'strict_stale_contract_drift' | 'legacy_stage_state' | 'missing_stage_evidence_rule';
-export type MixedVersionRecoveryIssueSeverity = 'info' | 'warn' | 'blocking';
-
-export interface MixedVersionRecoveryIssue {
-  kind: MixedVersionRecoveryIssueKind;
-  severity: MixedVersionRecoveryIssueSeverity;
-  file?: string;
-  taskId?: string;
-  current?: string;
-  expected?: string;
-  safeFixAvailable: boolean;
-  message: string;
-}
-
-export interface MixedVersionMechanicalUpdate {
-  issueKind: MixedVersionRecoveryIssueKind;
-  file: string;
-  current: string;
-  expected: string;
-  preview: string;
-}
-
-export interface MixedVersionStaleRunImpact {
-  taskId: string;
-  runId: string;
-  reasons: string[];
-}
-
-export interface MixedVersionRecoveryPlan {
-  detectedIssues: MixedVersionRecoveryIssue[];
-  safeMechanicalUpdates: MixedVersionMechanicalUpdate[];
-  behaviorChangingUpdates: MixedVersionRecoveryIssue[];
-  staleRunImpact: MixedVersionStaleRunImpact[];
-  evidenceReplayNeeded: string[];
-  nextCommands: string[];
-}
-
-export function buildMixedVersionRecoveryPlan(input: { model: SddTaskModel; latestEligibleRunsByTask: LatestEligibleRunSelection[]; verifyText?: string | null }): MixedVersionRecoveryPlan {
-  const issues = [
-    ...legacyArtifactRefIssues(input.model),
-    ...validationCommandIssues(input.model),
-    ...strictStaleIssues(input.latestEligibleRunsByTask)
-  ];
-  if (input.model.documents.verifyExists && input.verifyText !== undefined && !mentionsStageEvidenceRule(input.verifyText)) {
-    issues.push({
-      kind: 'missing_stage_evidence_rule',
-      severity: 'warn',
-      file: input.model.verifyPath,
-      current: 'missing stage evidence ref rule',
-      expected: 'verify.md states result evidence must use .sdd/runs/<branch>/<stage>/*.md refs',
-      safeFixAvailable: false,
-      message: 'verify.md does not state the stage evidence reference rule.'
-    });
-  }
-  const safeMechanicalUpdates = issues.flatMap((issue) => mechanicalUpdateForIssue(issue));
-  const staleRunImpact = input.latestEligibleRunsByTask.flatMap((selection) => selection.rejected
-    .filter((candidate) => candidate.reasons.some((reason) => reason.includes('strict_stale')))
-    .map((candidate) => ({ taskId: selection.taskId, runId: candidate.runId, reasons: candidate.reasons })));
-  const evidenceReplayNeeded = [...new Set(staleRunImpact.map((impact) => impact.taskId))].sort();
-  return {
-    detectedIssues: issues,
-    safeMechanicalUpdates,
-    behaviorChangingUpdates: issues.filter((issue) => !issue.safeFixAvailable),
-    staleRunImpact,
-    evidenceReplayNeeded,
-    nextCommands: nextCommands(input.model.branch, safeMechanicalUpdates.length, evidenceReplayNeeded)
-  };
-}
-
-export function canonicalRunRelativeArtifactRef(_branch: string, _ref: string): string | null {
-  return null;
-}
-
-function legacyArtifactRefIssues(model: SddTaskModel): MixedVersionRecoveryIssue[] {
-  return model.tasks.flatMap((task) => task.requiredArtifacts.flatMap((artifact) => {
-    const canonical = canonicalRunRelativeArtifactRef(model.branch, artifact);
-    return canonical ? [{
-      kind: 'legacy_artifact_ref' as const,
-      severity: 'warn' as const,
-      file: task.source.filePath,
-      taskId: task.id,
-      current: artifact,
-      expected: canonical,
-      safeFixAvailable: true,
-      message: `Task ${task.id} uses legacy evidence ref ${artifact}; use .sdd/runs/<branch>/<stage>/*.md stage evidence refs instead.`
-    }] : [];
-  }));
-}
-
-
-function validationCommandIssues(model: SddTaskModel): MixedVersionRecoveryIssue[] {
-  return model.tasks.flatMap((task) => task.validationCommands.flatMap((command) => nonExecutableValidationIssue(task, command.command)));
-}
-
-function nonExecutableValidationIssue(task: SddTask, command: string): MixedVersionRecoveryIssue[] {
-  const normalized = command.trim().toLowerCase();
-  if (!normalized.startsWith('```') && !normalized.startsWith('powershell') && !normalized.startsWith('manual:')) {
-    return [];
-  }
-  return [{
-    kind: 'non_executable_validation',
-    severity: 'blocking',
-    file: task.source.filePath,
-    taskId: task.id,
-    current: command,
-    expected: 'plain executable validation command',
-    safeFixAvailable: normalized.startsWith('```'),
-    message: `Task ${task.id} validation command is not directly executable: ${command}`
-  }];
-}
-
-function strictStaleIssues(selections: LatestEligibleRunSelection[]): MixedVersionRecoveryIssue[] {
-  return selections.flatMap((selection) => selection.rejected.flatMap((candidate) => candidate.reasons
-    .filter((reason) => reason.includes('strict_stale'))
-    .map((reason) => ({
-      kind: 'strict_stale_contract_drift' as const,
-      severity: 'warn' as const,
-      taskId: selection.taskId,
-      current: candidate.runId,
-      expected: 'replay evidence against current document contracts',
-      safeFixAvailable: false,
-      message: reason
-    }))));
-}
-
-function mentionsStageEvidenceRule(verifyText: string | null): boolean {
-  return Boolean(verifyText && /runs\/<branch>\/<stage>|stage evidence/i.test(verifyText));
-}
-
-function mechanicalUpdateForIssue(issue: MixedVersionRecoveryIssue): MixedVersionMechanicalUpdate[] {
-  if (!issue.safeFixAvailable || !issue.file || !issue.current || !issue.expected) {
-    return [];
-  }
-  return [{
-    issueKind: issue.kind,
-    file: issue.file,
-    current: issue.current,
-    expected: issue.expected,
-    preview: `replace ${issue.current} -> ${issue.expected}`
-  }];
-}
-
-function nextCommands(branch: string, safeFixes: number, replayTaskIds: string[]): string[] {
-  const commands: string[] = [];
-  if (safeFixes > 0) {
-    commands.push(`sdd doctor --branch ${branch} --latest-only`);
-  }
-  for (const taskId of replayTaskIds) {
-    commands.push(`sdd test task-${taskId} --branch ${branch}`);
-  }
-  if (commands.length === 0) {
-    commands.push(`sdd status --branch ${branch}`);
-  }
-  return commands;
-}
+import type { SddTask, SddTaskModel } from '../sdd-docs/task-parser.js';
+import type { LatestEligibleRunSelection } from './latest-eligible-run.js';
+
+export type MixedVersionRecoveryIssueKind = 'legacy_artifact_ref' | 'non_executable_validation' | 'strict_stale_contract_drift' | 'legacy_stage_state' | 'missing_stage_evidence_rule';
+export type MixedVersionRecoveryIssueSeverity = 'info' | 'warn' | 'blocking';
+
+export interface MixedVersionRecoveryIssue {
+  kind: MixedVersionRecoveryIssueKind;
+  severity: MixedVersionRecoveryIssueSeverity;
+  file?: string;
+  taskId?: string;
+  current?: string;
+  expected?: string;
+  safeFixAvailable: boolean;
+  message: string;
+}
+
+export interface MixedVersionMechanicalUpdate {
+  issueKind: MixedVersionRecoveryIssueKind;
+  file: string;
+  current: string;
+  expected: string;
+  preview: string;
+}
+
+export interface MixedVersionStaleRunImpact {
+  taskId: string;
+  runId: string;
+  reasons: string[];
+}
+
+export interface MixedVersionRecoveryPlan {
+  detectedIssues: MixedVersionRecoveryIssue[];
+  safeMechanicalUpdates: MixedVersionMechanicalUpdate[];
+  behaviorChangingUpdates: MixedVersionRecoveryIssue[];
+  staleRunImpact: MixedVersionStaleRunImpact[];
+  evidenceReplayNeeded: string[];
+  nextCommands: string[];
+}
+
+export function buildMixedVersionRecoveryPlan(input: { model: SddTaskModel; latestEligibleRunsByTask: LatestEligibleRunSelection[]; verifyText?: string | null }): MixedVersionRecoveryPlan {
+  const issues = [
+    ...legacyArtifactRefIssues(input.model),
+    ...validationCommandIssues(input.model),
+    ...strictStaleIssues(input.latestEligibleRunsByTask)
+  ];
+  if (input.model.documents.verifyExists && input.verifyText !== undefined && !mentionsStageEvidenceRule(input.verifyText)) {
+    issues.push({
+      kind: 'missing_stage_evidence_rule',
+      severity: 'warn',
+      file: input.model.verifyPath,
+      current: 'missing stage evidence ref rule',
+      expected: 'verify.md states result evidence must use .sdd/runs/<branch>/<stage>/*.md refs',
+      safeFixAvailable: false,
+      message: 'verify.md does not state the stage evidence reference rule.'
+    });
+  }
+  const safeMechanicalUpdates = issues.flatMap((issue) => mechanicalUpdateForIssue(issue));
+  const staleRunImpact = input.latestEligibleRunsByTask.flatMap((selection) => selection.rejected
+    .filter((candidate) => candidate.reasons.some((reason) => reason.includes('strict_stale')))
+    .map((candidate) => ({ taskId: selection.taskId, runId: candidate.runId, reasons: candidate.reasons })));
+  const evidenceReplayNeeded = [...new Set(staleRunImpact.map((impact) => impact.taskId))].sort();
+  return {
+    detectedIssues: issues,
+    safeMechanicalUpdates,
+    behaviorChangingUpdates: issues.filter((issue) => !issue.safeFixAvailable),
+    staleRunImpact,
+    evidenceReplayNeeded,
+    nextCommands: nextCommands(input.model.branch, safeMechanicalUpdates.length, evidenceReplayNeeded)
+  };
+}
+
+export function canonicalRunRelativeArtifactRef(_branch: string, _ref: string): string | null {
+  return null;
+}
+
+function legacyArtifactRefIssues(model: SddTaskModel): MixedVersionRecoveryIssue[] {
+  return model.tasks.flatMap((task) => task.requiredArtifacts.flatMap((artifact) => {
+    const canonical = canonicalRunRelativeArtifactRef(model.branch, artifact);
+    return canonical ? [{
+      kind: 'legacy_artifact_ref' as const,
+      severity: 'warn' as const,
+      file: task.source.filePath,
+      taskId: task.id,
+      current: artifact,
+      expected: canonical,
+      safeFixAvailable: true,
+      message: `Task ${task.id} uses legacy evidence ref ${artifact}; use .sdd/runs/<branch>/<stage>/*.md stage evidence refs instead.`
+    }] : [];
+  }));
+}
+
+
+function validationCommandIssues(model: SddTaskModel): MixedVersionRecoveryIssue[] {
+  return model.tasks.flatMap((task) => task.validationCommands.flatMap((command) => nonExecutableValidationIssue(task, command.command)));
+}
+
+function nonExecutableValidationIssue(task: SddTask, command: string): MixedVersionRecoveryIssue[] {
+  const normalized = command.trim().toLowerCase();
+  if (!normalized.startsWith('```') && !normalized.startsWith('powershell') && !normalized.startsWith('manual:')) {
+    return [];
+  }
+  return [{
+    kind: 'non_executable_validation',
+    severity: 'blocking',
+    file: task.source.filePath,
+    taskId: task.id,
+    current: command,
+    expected: 'plain executable validation command',
+    safeFixAvailable: normalized.startsWith('```'),
+    message: `Task ${task.id} validation command is not directly executable: ${command}`
+  }];
+}
+
+function strictStaleIssues(selections: LatestEligibleRunSelection[]): MixedVersionRecoveryIssue[] {
+  return selections.flatMap((selection) => selection.rejected.flatMap((candidate) => candidate.reasons
+    .filter((reason) => reason.includes('strict_stale'))
+    .map((reason) => ({
+      kind: 'strict_stale_contract_drift' as const,
+      severity: 'warn' as const,
+      taskId: selection.taskId,
+      current: candidate.runId,
+      expected: 'replay evidence against current document contracts',
+      safeFixAvailable: false,
+      message: reason
+    }))));
+}
+
+function mentionsStageEvidenceRule(verifyText: string | null): boolean {
+  return Boolean(verifyText && /runs\/<branch>\/<stage>|stage evidence/i.test(verifyText));
+}
+
+function mechanicalUpdateForIssue(issue: MixedVersionRecoveryIssue): MixedVersionMechanicalUpdate[] {
+  if (!issue.safeFixAvailable || !issue.file || !issue.current || !issue.expected) {
+    return [];
+  }
+  return [{
+    issueKind: issue.kind,
+    file: issue.file,
+    current: issue.current,
+    expected: issue.expected,
+    preview: `replace ${issue.current} -> ${issue.expected}`
+  }];
+}
+
+function nextCommands(branch: string, safeFixes: number, replayTaskIds: string[]): string[] {
+  const commands: string[] = [];
+  if (safeFixes > 0) {
+    commands.push(`sdd doctor --branch ${branch} --latest-only`);
+  }
+  for (const taskId of replayTaskIds) {
+    commands.push(`sdd test task-${taskId} --branch ${branch}`);
+  }
+  if (commands.length === 0) {
+    commands.push(`sdd status --branch ${branch}`);
+  }
+  return commands;
+}

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

@@ -1,77 +1,77 @@
-import type { RuntimeRepairRecord, RuntimeRepairType } from '../storage/runtime-store.js';
-import { runtimeScopedId } from '../storage/runtime-store.js';
-
-export interface RepairClassificationInput {
-  branchSlug: string;
-  taskId?: string | null;
-  runId?: string | null;
-  gateDecisionId?: string | null;
-  message: string;
-  recommendedCommands?: string[];
-  requiredEvidence?: string[];
-}
-
-export function classifyRepairType(message: string): RuntimeRepairType {
-  const normalized = message.toLowerCase();
-  if (normalized.includes('mixed-version') || normalized.includes('legacy') || normalized.includes('0.4.x')) {
-    return 'migration_repair';
-  }
-  if (normalized.includes('contract') || normalized.includes('stale') || normalized.includes('spec') || normalized.includes('plan') || normalized.includes('verify.md') || normalized.includes('tasks.md')) {
-    return 'contract_repair';
-  }
-  if (normalized.includes('validation command') || normalized.includes('not directly executable') || normalized.includes('manual:')) {
-    return 'validation_command_repair';
-  }
-  if (normalized.includes('artifact') || normalized.includes('digest') || normalized.includes('evidence')) {
-    return 'artifact_repair';
-  }
-  if (normalized.includes('env') || normalized.includes('node:sqlite') || normalized.includes('maven') || normalized.includes('jdk') || normalized.includes('external service')) {
-    return 'environment_repair';
-  }
-  if (normalized.includes('gate') || normalized.includes('policy') || normalized.includes('human')) {
-    return 'gate_policy_repair';
-  }
-  return 'implementation_repair';
-}
-
-export function buildOpenRepairRecord(input: RepairClassificationInput): RuntimeRepairRecord {
-  const repairType = classifyRepairType(input.message);
-  const taskId = input.taskId ?? null;
-  const runId = input.runId ?? null;
-  return {
-    repairId: runtimeScopedId('repair', input.branchSlug, taskId ?? 'workflow', runId ?? 'none', repairType, input.message),
-    branchSlug: input.branchSlug,
-    taskId,
-    repairType,
-    repairOfRunId: runId,
-    repairOfGateDecisionId: input.gateDecisionId ?? null,
-    status: 'open',
-    affectedTasks: taskId ? [taskId] : [],
-    blockers: [input.message],
-    recommendedCommands: input.recommendedCommands ?? defaultRepairCommands(input.branchSlug, taskId, repairType),
-    requiredEvidence: input.requiredEvidence ?? defaultRequiredEvidence(repairType),
-    createdAt: new Date().toISOString(),
-    resolvedAt: null,
-    payload: { source: 'repair_classifier' }
-  };
-}
-
-function defaultRepairCommands(branchSlug: string, taskId: string | null, repairType: RuntimeRepairType): string[] {
-  if (repairType === 'contract_repair' || repairType === 'migration_repair' || repairType === 'validation_command_repair') {
-    return [`sdd doctor --branch ${branchSlug} --latest-only`];
-  }
-  if (taskId) {
-    return [`sdd test task-${taskId} --branch ${branchSlug}`];
-  }
-  return [`sdd status --branch ${branchSlug}`];
-}
-
-function defaultRequiredEvidence(repairType: RuntimeRepairType): string[] {
-  if (repairType === 'contract_repair' || repairType === 'migration_repair' || repairType === 'validation_command_repair') {
-    return ['current document contract and executable validation evidence'];
-  }
-  if (repairType === 'gate_policy_repair') {
-    return ['accepted workflow gate PASS decision'];
-  }
-  return ['new accepted validation evidence'];
-}
+import type { RuntimeRepairRecord, RuntimeRepairType } from '../storage/runtime-store.js';
+import { runtimeScopedId } from '../storage/runtime-store.js';
+
+export interface RepairClassificationInput {
+  branchSlug: string;
+  taskId?: string | null;
+  runId?: string | null;
+  gateDecisionId?: string | null;
+  message: string;
+  recommendedCommands?: string[];
+  requiredEvidence?: string[];
+}
+
+export function classifyRepairType(message: string): RuntimeRepairType {
+  const normalized = message.toLowerCase();
+  if (normalized.includes('mixed-version') || normalized.includes('legacy') || normalized.includes('0.4.x')) {
+    return 'migration_repair';
+  }
+  if (normalized.includes('contract') || normalized.includes('stale') || normalized.includes('spec') || normalized.includes('plan') || normalized.includes('verify.md') || normalized.includes('tasks.md')) {
+    return 'contract_repair';
+  }
+  if (normalized.includes('validation command') || normalized.includes('not directly executable') || normalized.includes('manual:')) {
+    return 'validation_command_repair';
+  }
+  if (normalized.includes('artifact') || normalized.includes('digest') || normalized.includes('evidence')) {
+    return 'artifact_repair';
+  }
+  if (normalized.includes('env') || normalized.includes('node:sqlite') || normalized.includes('maven') || normalized.includes('jdk') || normalized.includes('external service')) {
+    return 'environment_repair';
+  }
+  if (normalized.includes('gate') || normalized.includes('policy') || normalized.includes('human')) {
+    return 'gate_policy_repair';
+  }
+  return 'implementation_repair';
+}
+
+export function buildOpenRepairRecord(input: RepairClassificationInput): RuntimeRepairRecord {
+  const repairType = classifyRepairType(input.message);
+  const taskId = input.taskId ?? null;
+  const runId = input.runId ?? null;
+  return {
+    repairId: runtimeScopedId('repair', input.branchSlug, taskId ?? 'workflow', runId ?? 'none', repairType, input.message),
+    branchSlug: input.branchSlug,
+    taskId,
+    repairType,
+    repairOfRunId: runId,
+    repairOfGateDecisionId: input.gateDecisionId ?? null,
+    status: 'open',
+    affectedTasks: taskId ? [taskId] : [],
+    blockers: [input.message],
+    recommendedCommands: input.recommendedCommands ?? defaultRepairCommands(input.branchSlug, taskId, repairType),
+    requiredEvidence: input.requiredEvidence ?? defaultRequiredEvidence(repairType),
+    createdAt: new Date().toISOString(),
+    resolvedAt: null,
+    payload: { source: 'repair_classifier' }
+  };
+}
+
+function defaultRepairCommands(branchSlug: string, taskId: string | null, repairType: RuntimeRepairType): string[] {
+  if (repairType === 'contract_repair' || repairType === 'migration_repair' || repairType === 'validation_command_repair') {
+    return [`sdd doctor --branch ${branchSlug} --latest-only`];
+  }
+  if (taskId) {
+    return [`sdd test task-${taskId} --branch ${branchSlug}`];
+  }
+  return [`sdd status --branch ${branchSlug}`];
+}
+
+function defaultRequiredEvidence(repairType: RuntimeRepairType): string[] {
+  if (repairType === 'contract_repair' || repairType === 'migration_repair' || repairType === 'validation_command_repair') {
+    return ['current document contract and executable validation evidence'];
+  }
+  if (repairType === 'gate_policy_repair') {
+    return ['accepted workflow gate PASS decision'];
+  }
+  return ['new accepted validation evidence'];
+}