sdd-agent-platform 0.3.0 → 0.4.1

package/node_modules/@sdd-agent-platform/core/src/task-risk-profile.ts

@@ -0,0 +1,193 @@
+export type TaskRiskLevel = 'low' | 'medium' | 'high';
+
+export type TaskFileClass = 'spec-doc' | 'runtime-state' | 'cli-source' | 'core-source' | 'test-source' | 'api-schema' | 'generated-ai-entry' | 'release-doc' | 'unknown';
+
+export interface TaskRiskProfile {
+  contract: 'sdd-task-risk-profile-v1';
+  taskId: string | null;
+  riskLevel: TaskRiskLevel;
+  rawTags: string[];
+  normalizedTags: string[];
+  fileClasses: TaskFileClass[];
+  sourceBoundary: boolean;
+  runtimeStateBoundary: boolean;
+  docsOnly: boolean;
+  validationOnly: boolean;
+  securitySensitive: boolean;
+  externalUnknown: boolean;
+  externalKnown: boolean;
+  contextRisk: boolean;
+  tokenRisk: boolean;
+  performanceRisk: boolean;
+  teamRecommendation: 'none' | 'review-lite' | 'team-required';
+  approvalRecommendation: 'direct' | 'review' | 'human-checkpoint';
+  reasons: string[];
+}
+
+export interface TaskRiskProfileInput {
+  id?: string | null;
+  risk?: string[];
+  affectedFiles?: string[];
+  validation?: string[];
+  requiredArtifacts?: string[];
+}
+
+export function buildTaskRiskProfile(task: TaskRiskProfileInput | null | undefined): TaskRiskProfile {
+  const rawTags = task?.risk ?? [];
+  const fileClasses = [...new Set((task?.affectedFiles ?? []).map(classifyTaskFile))].sort();
+  const fileDerivedTags = fileClasses.includes('api-schema') ? ['api-schema'] : [];
+  const normalizedTags = [...new Set([...rawTags.map(normalizeRiskTag).filter(Boolean), ...fileDerivedTags])].sort();
+  const sourceBoundary = fileClasses.includes('cli-source') || fileClasses.includes('core-source');
+  const runtimeStateBoundary = fileClasses.includes('runtime-state');
+  const docsOnly = fileClasses.length > 0 && fileClasses.every((fileClass) => fileClass === 'spec-doc' || fileClass === 'release-doc');
+  const validationOnly = normalizedTags.includes('validation-only') || (task?.validation?.length ?? 0) > 0 && !sourceBoundary && docsOnly;
+  const securitySensitive = normalizedTags.some((tag) => ['security', 'auth', 'token', 'secret', 'token-secret', 'credential', 'credentials', 'permission', 'sql-injection'].includes(tag));
+  const externalUnknown = normalizedTags.includes('external-unknown');
+  const externalKnown = normalizedTags.includes('external');
+  const contextRisk = normalizedTags.includes('context-risk') || normalizedTags.includes('context-budget');
+  const tokenRisk = normalizedTags.includes('token-risk');
+  const performanceRisk = normalizedTags.includes('performance') || normalizedTags.includes('latency') || normalizedTags.includes('cost');
+  const highRiskTag = normalizedTags.some((tag) => HIGH_RISK_TAGS.has(tag));
+  const mediumRiskTag = normalizedTags.length > 0;
+  const reasons: string[] = [];
+
+  if (sourceBoundary) {
+    reasons.push('Task touches CLI/core source boundary files.');
+  }
+  if (runtimeStateBoundary) {
+    reasons.push('Task touches runtime state or artifact storage paths.');
+  }
+  if (highRiskTag) {
+    reasons.push(`Task declares high-risk tags: ${normalizedTags.filter((tag) => HIGH_RISK_TAGS.has(tag)).join(', ')}.`);
+  }
+  if (securitySensitive) {
+    reasons.push('Task is security-sensitive.');
+  }
+  if (externalUnknown) {
+    reasons.push('Task depends on external behavior with unknown impact.');
+  }
+  if (externalKnown) {
+    reasons.push('Task depends on known external or third-party behavior.');
+  }
+  if (contextRisk || tokenRisk || performanceRisk) {
+    reasons.push('Task declares context, token, or performance risk signals.');
+  }
+
+  const riskLevel: TaskRiskLevel = sourceBoundary || highRiskTag || securitySensitive || externalUnknown ? 'high' : runtimeStateBoundary || mediumRiskTag || externalKnown || (task?.affectedFiles?.length ?? 0) > 3 ? 'medium' : 'low';
+  const teamRecommendation = riskLevel === 'high' ? 'team-required' : riskLevel === 'medium' || hasReviewArtifactRequirement(task) ? 'review-lite' : 'none';
+  const approvalRecommendation = riskLevel === 'high' ? 'human-checkpoint' : riskLevel === 'medium' ? 'review' : 'direct';
+
+  return {
+    contract: 'sdd-task-risk-profile-v1',
+    taskId: task?.id ?? null,
+    riskLevel,
+    rawTags: [...rawTags],
+    normalizedTags,
+    fileClasses,
+    sourceBoundary,
+    runtimeStateBoundary,
+    docsOnly,
+    validationOnly,
+    securitySensitive,
+    externalUnknown,
+    externalKnown,
+    contextRisk,
+    tokenRisk,
+    performanceRisk,
+    teamRecommendation,
+    approvalRecommendation,
+    reasons: reasons.length > 0 ? reasons : ['No source-boundary, runtime-state, security, external, context, token, performance, or high-risk tag signals were detected.']
+  };
+}
+
+export function normalizeRiskTag(value: string): string {
+  const normalized = value.trim().toLowerCase().replace(/[\s_]+/g, '-');
+  if (!normalized) {
+    return '';
+  }
+  if (normalized === 'highrisk') {
+    return 'high-risk';
+  }
+  if (normalized === 'state-machine' || normalized === 'state-machines') {
+    return 'state-machine';
+  }
+  if (normalized === 'api' || normalized === 'api-contract') {
+    return 'api-schema';
+  }
+  if (normalized === 'build' || normalized === 'ci') {
+    return 'ci-build';
+  }
+  if (normalized === 'data-loss' || normalized === 'database-data-loss') {
+    return 'data-loss';
+  }
+  if (normalized === 'external' || normalized === 'third-party') {
+    return 'external';
+  }
+  if (normalized === 'external-unknown' || normalized === 'unknown-external') {
+    return 'external-unknown';
+  }
+  if (normalized === 'unknown' || normalized === 'blocked-unknown') {
+    return 'unknown';
+  }
+  if (normalized === 'context') {
+    return 'context-risk';
+  }
+  if (normalized === 'tokens' || normalized === 'token-budget') {
+    return 'token-risk';
+  }
+  return normalized;
+}
+
+export function classifyTaskFile(filePath: string): TaskFileClass {
+  const normalized = filePath.replace(/\\/g, '/').replace(/^\.\//, '');
+  if (/^packages\/cli\/src\//.test(normalized)) {
+    return normalized.endsWith('.test.ts') ? 'test-source' : 'cli-source';
+  }
+  if (/^packages\/core\/src\//.test(normalized)) {
+    return normalized.endsWith('.test.ts') ? 'test-source' : 'core-source';
+  }
+  if (/^packages\/.+\.test\.ts$/.test(normalized) || /(^|\/)test-support\//.test(normalized)) {
+    return 'test-source';
+  }
+  if (/^\.sdd\//.test(normalized) || /^runs\//.test(normalized) || /^artifacts\//.test(normalized)) {
+    return 'runtime-state';
+  }
+  if (/^\.claude\//.test(normalized) || /^commands\//.test(normalized) || /^agents\//.test(normalized) || /^workflows\//.test(normalized)) {
+    return 'generated-ai-entry';
+  }
+  if (/^api\/.*\.(ya?ml|json)$/i.test(normalized) || /(^|\/)(openapi|swagger)\.(ya?ml|json)$/i.test(normalized)) {
+    return 'api-schema';
+  }
+  if (/release\.md$/.test(normalized)) {
+    return 'release-doc';
+  }
+  if (/^(specs|docs|context)\//.test(normalized) || /(^|\/)(README|CHANGELOG)\.md$/i.test(normalized)) {
+    return 'spec-doc';
+  }
+  return 'unknown';
+}
+
+function hasReviewArtifactRequirement(task: Pick<TaskRiskProfileInput, 'requiredArtifacts'> | null | undefined): boolean {
+  return Boolean(task?.requiredArtifacts?.some((artifact) => /review|validation|security|验证|评审|安全/i.test(artifact)));
+}
+
+const HIGH_RISK_TAGS = new Set([
+  'high-risk',
+  'source-boundary',
+  'platform-runtime',
+  'state-machine',
+  'concurrency',
+  'database',
+  'data-loss',
+  'sql',
+  'security',
+  'api-schema',
+  'ci-build',
+  'external-unknown',
+  'token',
+  'secret',
+  'token-secret',
+  'unknown',
+  'multi-agent-review',
+  'evidence-semantics'
+]);

package/node_modules/@sdd-agent-platform/core/src/test-support/fixtures.ts

@@ -0,0 +1,398 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+export async function appendProjectRuntimeConfig(root: string, runtimeConfig: string): Promise<void> {
+  const configPath = path.join(root, '.sdd', 'project.yml');
+  const current = await readFile(configPath, 'utf8');
+  await writeFile(configPath, `${current.trimEnd()}\n${runtimeConfig.trim()}\n`, 'utf8');
+}
+
+export function phase63ProjectRuntimeConfig(): string {
+  return `agent_runtime:
+  capability_sources:
+    - id: project_frontend_material
+      name: Project frontend material
+      kind: open_source_material
+      source_ref: docs/external/frontend-agent-manifest.yml
+      reuse_decision: adapt_via_host_adapter
+      quarantine_required: true
+      quarantine_status: quarantined
+      permission_model:
+        - project-scoped read/search only before quarantine pass
+        - no direct prompt import
+      provenance_requirements:
+        - project manifest path
+        - source attribution
+        - quarantine scan result
+      host_compatibility:
+        - claude-code:future_adapter
+        - host-neutral:future_adapter
+      allowed_evidence_types:
+        - candidate_evidence
+        - external_reference
+      forbidden_authority:
+        - lifecycle gate authority
+        - stage completion decision
+        - sync-back apply decision
+        - ship readiness pass
+        - permission escalation
+      allowed_use: declarative taxonomy and capability mapping only
+      attribution: project frontend manifest
+      rationale: project-provided agent metadata for validated contracts only
+  skill_capabilities:
+    - id: project.skill.frontend_review
+      name: Project frontend review skill
+      kind: skill
+      source: project
+      source_ref: project_frontend_material
+      capability_domain:
+        - frontend
+        - review
+        - ui
+      allowed_stages:
+        - plan
+        - do
+        - review
+        - verify
+      required_risk_ceiling: compact_boundary_only
+      evidence_type: artifact
+      reuse_decision: adapt_via_host_adapter
+  profiles:
+    - id: frontend
+      extends: implementer
+      stage_scope:
+        - do
+        - review
+      risk_ceiling: compact_boundary_only
+      default_autonomy: compact_boundary_only
+      required_artifacts:
+        - implementation artifact
+        - browser validation evidence
+      tool_scope:
+        - read
+        - edit
+        - test
+        - browser
+      model_policy_id: balanced
+      host_capability_requirements:
+        - host.search.grep_glob
+        - host.edit.hashline
+        - playwright.browser_validation
+        - project.skill.frontend_review
+      boundaries:
+        - edit declared frontend scope only
+        - browser validation must be evidence-backed
+  aliases:
+    frontend-dev: frontend
+  routing_rules:
+    - id: frontend-default
+      when:
+        keywords:
+          - frontend
+          - ui
+        affected_file_globs:
+          - "**/*.tsx"
+      prefer_profile: frontend
+      require_capabilities:
+        - project.skill.frontend_review
+        - playwright.browser_validation
+      category: implementation
+  adapter_mappings:
+    - profile: frontend
+      host_adapter: claude_code
+      projection: generated subagent profile
+      permission_policy: compact frontend tool scope`;
+}
+
+export function phase63InvalidProjectRuntimeConfig(): string {
+  return `agent_runtime:
+  capability_sources:
+    - id: unsafe_source
+      name: Unsafe external material
+      kind: open_source_material
+      source_ref: docs/external/unsafe-agent-pack.yml
+      reuse_decision: reuse_direct
+      quarantine_required: true
+      quarantine_status: not_required
+      allowed_use: direct execution and prompt import
+      attribution: ""
+      rationale: lifecycle authority request
+  skill_capabilities:
+    - id: project.skill.bad
+      name: Bad project skill
+      kind: skill
+      source: project
+      source_ref: missing_source
+      capability_domain:
+        - frontend
+      allowed_stages:
+        - do
+      required_risk_ceiling: compact_boundary_only
+      reuse_decision: adapt_via_host_adapter
+  profiles:
+    - id: bad_profile
+      extends: implementer
+      host_capability_requirements:
+        - missing.capability
+  aliases:
+    frontend-dev: missing_profile
+  routing_rules:
+    - id: bad-rule
+      when:
+        keywords:
+          - frontend
+      prefer_profile: missing_profile
+      require_capabilities:
+        - missing.capability
+      category: implementation`;
+}
+
+export function phase63FrontendTaskMarkdown(taskId: string): string {
+  return `# Tasks
+
+### ${taskId}: Frontend runtime route
+
+\`\`\`sdd-task
+id: ${taskId}
+status: pending
+wave: 1
+depends_on: []
+affected_files:
+  - src/App.tsx
+validation:
+  - browser validation with Playwright
+allowed_agents:
+  - frontend-dev
+agent_fit:
+  - frontend-dev
+required_artifacts:
+  - artifacts/browser-${taskId}.md
+risk: []
+\`\`\`
+
+#### Boundary
+
+Stay inside the declared frontend files.
+
+#### Acceptance
+
+- Browser validation evidence is captured.
+`;
+}
+
+export async function writeBranchDocs(root: string, branch: string, tasksMarkdown: string): Promise<void> {
+  const branchDir = path.join(root, 'specs', branch);
+  await mkdir(branchDir, { recursive: true });
+  await writeFile(path.join(branchDir, 'spec.md'), '# Spec\n', 'utf8');
+  await writeFile(path.join(branchDir, 'plan.md'), '# Plan\n', 'utf8');
+  await writeFile(path.join(branchDir, 'tasks.md'), tasksMarkdown, 'utf8');
+}
+
+export function hashTestDocument(raw: string): string {
+  return createHash('sha256').update(raw.replace(/\r\n/g, '\n'), 'utf8').digest('hex');
+}
+
+export function validResultArtifact(agent: string, task: string, status: string, artifactPath: string): string {
+  return `# ${agent} result\n\n\`\`\`sdd-result\ncontract: sdd-result-v1\nversion: 1.3.0\nagent: ${agent}\ntask: ${task}\nstatus: ${status}\nartifacts:\n  - ${artifactPath}\n\`\`\`\n`;
+}
+
+export function validTrustEvidence(task: string, acceptance: string, artifactPath: string): string {
+  return `\n\`\`\`sdd-evidence\ncontract: sdd-evidence-v1\nversion: 1.0.0\ntask: ${task}\nacceptance: ${acceptance}\nstatus: PASS\nclaim: Validation proves ${acceptance}.\nsource_artifact: ${artifactPath}\nevidence_refs:\n  - command:npm test\nprovenance_refs:\n  - artifact:${artifactPath}\npolicy_refs:\n  - acceptance-policy-v1:require-source-evidence\n\`\`\`\n`;
+}
+
+export function validTaskMarkdown(taskId: string, dependsOn: string[]): string {
+  const dependsOnBlock = dependsOn.length === 0 ? 'depends_on: []' : `depends_on:\n${dependsOn.map((dependency) => `  - ${dependency}`).join('\n')}`;
+  return `# Tasks
+
+### ${taskId}: Valid task
+
+\`\`\`sdd-task
+id: ${taskId}
+status: pending
+wave: 1
+${dependsOnBlock}
+acceptance_refs:
+  - AC-1
+plan_refs:
+  - "§4 Target Design Overview"
+affected_files:
+  - packages/core/src/index.ts
+validation:
+  - npm test
+risk: []
+\`\`\`
+
+#### Boundary
+
+Stay in parser files only.
+
+#### Acceptance
+
+- Parser behavior is covered.
+`;
+}
+
+export function taskMarkdownWithFiles(taskId: string, files: string[], risk: string[]): string {
+  const affectedFilesBlock = files.length === 0 ? 'affected_files: []' : `affected_files:\n${files.map((file) => `  - ${file}`).join('\n')}`;
+  const riskBlock = risk.length === 0 ? 'risk: []' : `risk:\n${risk.map((item) => `  - ${item}`).join('\n')}`;
+  return `### ${taskId}: Isolation task
+
+\`\`\`sdd-task
+id: ${taskId}
+status: pending
+wave: 1
+depends_on: []
+${affectedFilesBlock}
+validation:
+  - npm test
+${riskBlock}
+\`\`\`
+
+#### Acceptance
+
+- Isolation decision is inspectable.
+`;
+}
+
+export function adaptiveTeamTaskMarkdown(taskId: string, options: { allowedAgents: string[]; requiredArtifacts?: string[]; risk?: string[]; autonomy?: string; affectedFiles?: string[] }): string {
+  const risk = options.risk ?? [];
+  const requiredArtifacts = options.requiredArtifacts ?? [];
+  const affectedFiles = options.affectedFiles ?? ['packages/core/src/index.ts'];
+  const allowedAgentsBlock = `allowed_agents:\n${options.allowedAgents.map((agent) => `  - ${agent}`).join('\n')}`;
+  const requiredArtifactsBlock = requiredArtifacts.length === 0 ? 'required_artifacts: []' : `required_artifacts:\n${requiredArtifacts.map((artifact) => `  - ${artifact}`).join('\n')}`;
+  const affectedFilesBlock = affectedFiles.length === 0 ? 'affected_files: []' : `affected_files:\n${affectedFiles.map((file) => `  - ${file}`).join('\n')}`;
+  const riskBlock = risk.length === 0 ? 'risk: []' : `risk:\n${risk.map((item) => `  - ${item}`).join('\n')}`;
+  const autonomyBlock = options.autonomy ? `autonomy: ${options.autonomy}\n` : '';
+  return `### ${taskId}: Adaptive team task
+
+\`\`\`sdd-task
+id: ${taskId}
+status: pending
+wave: 1
+depends_on: []
+${affectedFilesBlock}
+validation:
+  - npm test
+${allowedAgentsBlock}
+${requiredArtifactsBlock}
+${riskBlock}
+${autonomyBlock}\`\`\`
+
+#### Boundary
+
+Stay within the declared adaptive routing fixture.
+
+#### Acceptance
+
+- Adaptive team-mode decision is inspectable.
+`;
+}
+
+export function graphTaskMarkdown(taskId: string, dependsOn: string[], files: string[], risk: string[]): string {
+  const dependsOnBlock = dependsOn.length === 0 ? 'depends_on: []' : `depends_on:\n${dependsOn.map((dependency) => `  - ${dependency}`).join('\n')}`;
+  const affectedFilesBlock = files.length === 0 ? 'affected_files: []' : `affected_files:\n${files.map((file) => `  - ${file}`).join('\n')}`;
+  const riskBlock = risk.length === 0 ? 'risk: []' : `risk:\n${risk.map((item) => `  - ${item}`).join('\n')}`;
+  return `### ${taskId}: Graph task
+
+\`\`\`sdd-task
+id: ${taskId}
+status: pending
+wave: 1
+${dependsOnBlock}
+${affectedFilesBlock}
+validation:
+  - npm test
+${riskBlock}
+\`\`\`
+
+#### Boundary
+
+Stay in graph planning only.
+
+#### Acceptance
+
+- Graph output is inspectable.
+`;
+}
+
+export function harnessTaskMarkdown(taskId: string): string {
+  return `### ${taskId}: Harness task
+
+\`\`\`sdd-task
+id: ${taskId}
+status: pending
+wave: 1
+depends_on: []
+affected_files:
+  - packages/core/src/index.ts
+file_ownership:
+  - packages/core/src/index.ts
+risk:
+  - runtime-evidence
+agent_fit:
+  - implementer
+  - validator
+verification_availability:
+  - unit-test
+  - cli-smoke
+autonomy: foreground_write
+allowed_agents:
+  - implementer
+  - validator
+required_artifacts:
+  - artifacts/implementer-${taskId}.md
+  - artifacts/validation-${taskId}.md
+gap_state: none
+validation:
+  - npm test
+\`\`\`
+
+#### Boundary
+
+Stay inside Phase 5.3 metadata parsing.
+
+#### Acceptance
+
+- Harness metadata is parsed.
+`;
+}
+
+export function withManagedHash(content: string): string {
+  const body = content.replace(/^---\n[\s\S]*?\n---\n\n?/, '');
+  return content.replace(/^sdd_hash:\s*sha256:[a-f0-9]+\s*$/m, `sdd_hash: sha256:${createHash('sha256').update(body, 'utf8').digest('hex')}`);
+}
+
+export function contextBuildTaskMarkdown(taskId: string): string {
+  return `# Tasks
+
+### ${taskId}: Context package task
+
+\`\`\`sdd-task
+id: ${taskId}
+status: pending
+wave: 1
+depends_on: []
+acceptance_refs:
+  - AC-1
+plan_refs:
+  - "§6 Context Build Packages"
+affected_files:
+  - packages/core/src/index.ts
+validation:
+  - npm test
+risk: []
+required_artifacts:
+  - artifacts/implement-${taskId}.md
+  - artifacts/validation-${taskId}.md
+\`\`\`
+
+#### Boundary
+
+Stay inside context package runtime.
+
+#### Acceptance
+
+- Context package is deterministic.
+`;
+}

package/node_modules/@sdd-agent-platform/core/src/test-support/run-state.ts

@@ -0,0 +1,70 @@
+import { writeArtifact } from '../run-state/artifacts.js';
+import { readRunState, writeRunState } from '../run-state/run-state.js';
+import { inspectSddTask } from '../sdd-docs/task-inspection.js';
+import { parseSddBranch } from '../sdd-docs/task-parser.js';
+import { hashTestDocument } from './fixtures.js';
+
+export async function bindTestRunState(root: string, runId: string, branch: string, taskId: string): Promise<void> {
+  const state = await readRunState(root, runId);
+  const model = await parseSddBranch(root, branch);
+  const task = inspectSddTask(model, taskId).task;
+  await writeRunState(root, {
+    ...state,
+    currentTask: taskId,
+    partition: branch,
+    gitBranch: branch,
+    taskId,
+    affectedFiles: task?.affectedFiles ?? [],
+    documentSnapshot: {
+      specHash: model.documents.specHash ?? null,
+      planHash: model.documents.planHash ?? null,
+      tasksHash: model.documents.tasksHash ?? null,
+      specContractHash: model.documents.specContractHash ?? null,
+      planContractHash: model.documents.planContractHash ?? null,
+      tasksContractHash: model.documents.tasksContractHash ?? null,
+      planBasedOnSpecHash: model.documents.planBasedOnSpecHash ?? null,
+      tasksBasedOnPlanHash: model.documents.tasksBasedOnPlanHash ?? null,
+      planBasedOnSpecContractHash: model.documents.planBasedOnSpecContractHash ?? null,
+      tasksBasedOnPlanContractHash: model.documents.tasksBasedOnPlanContractHash ?? null
+    }
+  });
+}
+
+export async function markTestRunReadyForSyncBack(root: string, runId: string, taskId: string): Promise<void> {
+  const state = await readRunState(root, runId);
+  const proposal = 'status: verified\n';
+  await writeArtifact(root, runId, 'sync-back-proposal.md', proposal);
+  await writeRunState(root, {
+    ...state,
+    status: 'completed',
+    tasks: {
+      ...state.tasks,
+      [taskId]: {
+        status: 'implemented_verified',
+        implementationStatus: 'implemented',
+        verificationStatus: 'pass',
+        validationBatch: null,
+        validationTiming: 'task_end',
+        requiresVerifyBeforeNext: true,
+        gaps: [],
+        artifacts: ['artifacts/sync-back-proposal.md']
+      }
+    },
+    validation: {
+      status: 'pass',
+      commands: ['npm test'],
+      evidence: ['artifacts/sync-back-proposal.md']
+    },
+    syncBack: {
+      mode: 'proposal',
+      proposalPath: 'artifacts/sync-back-proposal.md',
+      proposalDigest: hashTestDocument(proposal),
+      sourceVerifyStatus: 'PASS',
+      status: 'proposed'
+    },
+    artifacts: [
+      ...state.artifacts,
+      { path: 'artifacts/sync-back-proposal.md', kind: 'sync_back_proposal', task: taskId, agent: null, createdAt: new Date().toISOString() }
+    ]
+  });
+}

package/node_modules/@sdd-agent-platform/core/src/test-support.ts

@@ -0,0 +1,2 @@
+export * from './test-support/fixtures.js';
+export * from './test-support/run-state.js';