@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/core/sdd/agent-runtime-contract.js

@@ -0,0 +1,200 @@
+import { toJSONSchema, z } from 'zod';
+const JSON_SCHEMA_DRAFT = 'https://json-schema.org/draft/2020-12/schema';
+const FEATURE_REF_PATTERN = /^FEAT-\d{4}$/;
+export const agentRuntimeProviderSchema = z.enum(['deepagents', 'codex', 'opencode']);
+export const agentRuntimeModeSchema = z.enum(['read-only', 'plan', 'validate', 'apply-sandbox', 'apply-approved']);
+export const agentRuntimeSandboxSchema = z.enum(['read-only', 'workspace-write', 'danger-full-access']);
+export const agentRuntimeStatusSchema = z.enum(['planned', 'blocked']);
+export const opencodeExecutionStatusSchema = z.enum([
+    'planned',
+    'skipped',
+    'blocked',
+    'running',
+    'completed',
+    'failed',
+]);
+const agentRuntimeCommandSchema = z.object({
+    executable: z.string().min(1),
+    args: z.array(z.string()).default([]),
+    stdin: z.string().optional(),
+});
+const agentRuntimeEvidenceArtifactSchema = z.object({
+    kind: z.string().min(1),
+    ref: z.string().min(1),
+    path: z.string().min(1).optional(),
+    sha256: z.string().min(1).optional(),
+});
+const agentRuntimeRiskSchema = z.object({
+    id: z.string().min(1),
+    severity: z.enum(['low', 'medium', 'high', 'critical']),
+    summary: z.string().min(1),
+    mitigation: z.string().min(1).optional(),
+});
+export const agentRuntimeCommandPlanRequestSchema = z.object({
+    schema_version: z.literal(1).default(1),
+    feature_ref: z.string().regex(FEATURE_REF_PATTERN),
+    provider: agentRuntimeProviderSchema,
+    mode: agentRuntimeModeSchema.default('plan'),
+    instruction: z.string().min(1),
+    cwd: z.string().min(1).default('.'),
+    model: z.string().min(1).optional(),
+    sandbox: agentRuntimeSandboxSchema.default('read-only'),
+    output_schema: z.string().min(1).optional(),
+    output_last_message: z.string().min(1).optional(),
+    agent: z.string().min(1).optional(),
+    session: z.string().min(1).optional(),
+    files: z.array(z.string().min(1)).default([]),
+    approval_grants: z.array(z.enum(['maintainer', 'architecture-board', 'security'])).default([]),
+});
+export const agentRuntimeCommandPlanSchema = z.object({
+    schema_version: z.literal(1),
+    created_at: z.string().datetime(),
+    status: agentRuntimeStatusSchema,
+    request: agentRuntimeCommandPlanRequestSchema,
+    provider: agentRuntimeProviderSchema,
+    command: agentRuntimeCommandSchema.optional(),
+    evidence_contract: z.enum(['agent-runtime-v2/deepagents', 'agent-runtime-v2/codex-exec', 'agent-runtime-v2/opencode-run']),
+    structured_output: z.boolean(),
+    reasons: z.array(z.string()).default([]),
+    policy: z.object({
+        direct_state_write_allowed: z.literal(false),
+        requires_codesdd_finalize: z.literal(true),
+        mutating_modes_require_approval: z.literal(true),
+    }),
+});
+export const opencodeExecutionEvidenceSchema = z.object({
+    schema_version: z.literal(1),
+    contract: z.literal('agent-runtime-v2/opencode-run'),
+    provider: z.literal('opencode'),
+    feature_ref: z.string().regex(FEATURE_REF_PATTERN),
+    run_id: z.string().min(1),
+    created_at: z.string().datetime(),
+    mode: agentRuntimeModeSchema,
+    status: opencodeExecutionStatusSchema,
+    command: agentRuntimeCommandSchema.extend({
+        executable: z.literal('opencode'),
+    }),
+    command_plan_ref: z.string().min(1).optional(),
+    cwd: z.string().min(1).default('.'),
+    exit_code: z.number().int().nullable().default(null),
+    started_at: z.string().datetime().optional(),
+    completed_at: z.string().datetime().optional(),
+    duration_ms: z.number().int().nonnegative().optional(),
+    structured_output: z.record(z.string(), z.unknown()).default({}),
+    stdout_excerpt: z.string().max(8000).optional(),
+    stderr_excerpt: z.string().max(8000).optional(),
+    artifacts: z.array(agentRuntimeEvidenceArtifactSchema).default([]),
+    validations: z.array(z.string().min(1)).default([]),
+    redactions: z.array(z.string().min(1)).default([]),
+    risks: z.array(agentRuntimeRiskSchema).default([]),
+    policy: z.object({
+        direct_state_write_allowed: z.literal(false),
+        requires_codesdd_finalize: z.literal(true),
+        raw_secret_output_allowed: z.literal(false),
+        transcript_storage: z.enum(['forbidden', 'redacted-excerpts-only']).default('redacted-excerpts-only'),
+    }),
+    finalize_intent: z.boolean().default(false),
+});
+export function buildAgentRuntimeCommandPlan(request, createdAt = new Date().toISOString()) {
+    const parsed = agentRuntimeCommandPlanRequestSchema.parse(request);
+    const reasons = collectPolicyReasons(parsed);
+    const status = reasons.length > 0 ? 'blocked' : 'planned';
+    const command = status === 'planned' ? buildCommand(parsed) : undefined;
+    return agentRuntimeCommandPlanSchema.parse({
+        schema_version: 1,
+        created_at: createdAt,
+        status,
+        request: parsed,
+        provider: parsed.provider,
+        command,
+        evidence_contract: evidenceContract(parsed.provider),
+        structured_output: true,
+        reasons,
+        policy: {
+            direct_state_write_allowed: false,
+            requires_codesdd_finalize: true,
+            mutating_modes_require_approval: true,
+        },
+    });
+}
+export function buildOpenCodeExecutionEvidence(evidence) {
+    return opencodeExecutionEvidenceSchema.parse(evidence);
+}
+export function buildAgentRuntimeJsonSchemas() {
+    return {
+        'agent-runtime-command-plan.yaml': {
+            ...toJSONSchema(agentRuntimeCommandPlanSchema),
+            $schema: JSON_SCHEMA_DRAFT,
+            title: 'CodeSDD Agent Runtime Command Plan',
+            description: 'Provider-normalized command plan for DeepAgents, Codex exec, and OpenCode run agent runtimes.',
+        },
+        'agent-runtime-opencode-run-evidence.yaml': {
+            ...toJSONSchema(opencodeExecutionEvidenceSchema),
+            $schema: JSON_SCHEMA_DRAFT,
+            title: 'CodeSDD Agent Runtime OpenCode Run Evidence',
+            description: 'Machine-readable OpenCode run evidence with redacted excerpts, artifacts, validations, and finalize policy.',
+        },
+    };
+}
+function collectPolicyReasons(request) {
+    const reasons = [];
+    const mutating = request.mode === 'apply-sandbox' || request.mode === 'apply-approved';
+    if (mutating && request.approval_grants.length === 0) {
+        reasons.push(`Mode ${request.mode} requires explicit approval evidence before agent execution.`);
+    }
+    if (request.provider !== 'deepagents' && request.mode === 'apply-approved') {
+        reasons.push('Codex and OpenCode apply-approved execution is not enabled until plugin evidence ingestion is complete.');
+    }
+    if (request.provider === 'codex' && request.sandbox === 'danger-full-access') {
+        reasons.push('Codex danger-full-access sandbox is forbidden by the default CodeSDD agent runtime contract.');
+    }
+    return reasons;
+}
+function buildCommand(request) {
+    if (request.provider === 'deepagents') {
+        return {
+            executable: 'codesdd',
+            args: ['sdd', 'agent', 'run', request.feature_ref, '--provider', 'deepagents', '--mode', request.mode],
+        };
+    }
+    if (request.provider === 'codex') {
+        const args = ['exec', '--json', '--cd', request.cwd, '--sandbox', request.sandbox];
+        if (request.model)
+            args.push('--model', request.model);
+        if (request.output_schema)
+            args.push('--output-schema', request.output_schema);
+        if (request.output_last_message)
+            args.push('--output-last-message', request.output_last_message);
+        for (const file of request.files) {
+            args.push('--image', file);
+        }
+        args.push(request.instruction);
+        return {
+            executable: 'codex',
+            args,
+        };
+    }
+    const args = ['run', '--format', 'json', '--dir', request.cwd];
+    if (request.model)
+        args.push('--model', request.model);
+    if (request.agent)
+        args.push('--agent', request.agent);
+    if (request.session)
+        args.push('--session', request.session);
+    for (const file of request.files) {
+        args.push('--file', file);
+    }
+    args.push(request.instruction);
+    return {
+        executable: 'opencode',
+        args,
+    };
+}
+function evidenceContract(provider) {
+    if (provider === 'codex')
+        return 'agent-runtime-v2/codex-exec';
+    if (provider === 'opencode')
+        return 'agent-runtime-v2/opencode-run';
+    return 'agent-runtime-v2/deepagents';
+}
+//# sourceMappingURL=agent-runtime-contract.js.map

package/dist/core/sdd/backlog-cli.d.ts

@@ -0,0 +1,16 @@
+import { type BacklogProviderId, type BacklogProjectionPlan, type CanonicalBacklogItem } from './backlog-provider-contract.js';
+export interface BacklogProjectDryRunOptions {
+    provider: BacklogProviderId;
+    ref: string;
+    items?: CanonicalBacklogItem[];
+    created_at?: string;
+}
+export interface BacklogProjectDryRunResult {
+    schema_version: 1;
+    dry_run: true;
+    ref: string;
+    fixture: string;
+    plan: BacklogProjectionPlan;
+}
+export declare function buildBacklogProjectDryRun(options: BacklogProjectDryRunOptions): BacklogProjectDryRunResult;
+//# sourceMappingURL=backlog-cli.d.ts.map

package/dist/core/sdd/backlog-cli.js

@@ -0,0 +1,146 @@
+import { backlogProjectionPlanSchema, buildBacklogProjectionItem, } from './backlog-provider-contract.js';
+const azureDevOpsContract = {
+    schema_version: 1,
+    provider: 'azure-devops',
+    adapter_id: 'azure-devops',
+    label: 'Azure DevOps Boards',
+    status: 'experimental',
+    auth: {
+        mode: 'pat',
+        required_env: ['AZURE_DEVOPS_EXT_PAT'],
+        secret_fields: ['AZURE_DEVOPS_EXT_PAT'],
+    },
+    capabilities: [
+        {
+            operation: 'create',
+            entity_kinds: ['epic', 'feature'],
+            dry_run: true,
+            apply: false,
+            idempotent: true,
+            required_fields: ['System.Title', 'System.State', 'Custom.CodeSDDRef'],
+        },
+        {
+            operation: 'link',
+            entity_kinds: ['epic', 'feature'],
+            dry_run: true,
+            apply: false,
+            idempotent: true,
+        },
+    ],
+    mapping: {
+        external_project_field: 'System.TeamProject',
+        external_id_field: 'System.Id',
+        external_url_field: 'System.Url',
+        canonical_ref_field: 'Custom.CodeSDDRef',
+        parent_ref_field: 'Custom.CodeSDDParentRef',
+        entity_type_field: 'Custom.CodeSDDEntityType',
+        title_field: 'System.Title',
+        status_field: 'System.State',
+    },
+    canonical_state_boundary: {
+        source_of_truth: 'codesdd',
+        state_paths: ['.sdd/state/*.yaml'],
+        external_state_authoritative: false,
+        hidden_state_allowed: false,
+    },
+    governance: {
+        owner: 'platform-architecture',
+        sync_requires_dry_run: true,
+        mutation_requires_approval: true,
+        audit_event: 'codesdd.backlog.projection',
+    },
+};
+const epic0039Fixture = [
+    {
+        ref: 'EPIC-0039',
+        kind: 'epic',
+        title: 'Provider-agnostic backlog integration and CodeSDD naming governance',
+        status: 'SPLIT',
+        labels: ['codesdd', 'backlog-integration'],
+    },
+    {
+        ref: 'FEAT-0166',
+        kind: 'feature',
+        title: 'Backlog provider contract and canonical projection schema',
+        status: 'DONE',
+        parent_ref: 'EPIC-0039',
+        labels: ['codesdd', 'backlog-integration'],
+    },
+    {
+        ref: 'FEAT-0167',
+        kind: 'feature',
+        title: 'Azure DevOps dry-run projection planner',
+        status: 'IN_PROGRESS',
+        parent_ref: 'EPIC-0039',
+        labels: ['codesdd', 'backlog-integration'],
+    },
+    {
+        ref: 'FEAT-0168',
+        kind: 'feature',
+        title: 'Backlog sync conflict and idempotency policy',
+        status: 'IN_PROGRESS',
+        parent_ref: 'EPIC-0039',
+        labels: ['codesdd', 'backlog-integration'],
+    },
+    {
+        ref: 'FEAT-0169',
+        kind: 'feature',
+        title: 'Backlog integration CLI dry-run surface',
+        status: 'IN_PROGRESS',
+        parent_ref: 'EPIC-0039',
+        labels: ['codesdd', 'backlog-integration'],
+    },
+    {
+        ref: 'FEAT-0170',
+        kind: 'feature',
+        title: 'Backlog integration documentation and handoff',
+        status: 'IN_PROGRESS',
+        parent_ref: 'EPIC-0039',
+        labels: ['codesdd', 'backlog-integration'],
+    },
+];
+export function buildBacklogProjectDryRun(options) {
+    if (options.provider !== 'azure-devops') {
+        throw new Error(`Unsupported backlog provider for dry-run projection: ${options.provider}.`);
+    }
+    const items = options.items ?? resolveFixtureItems(options.ref);
+    const createdAt = options.created_at ?? new Date().toISOString();
+    const plan = backlogProjectionPlanSchema.parse({
+        schema_version: 1,
+        created_at: createdAt,
+        provider: options.provider,
+        mode: 'dry-run',
+        direction: 'push',
+        source_of_truth: 'codesdd',
+        items: items.map((item) => buildBacklogProjectionItem({
+            contract: azureDevOpsContract,
+            item,
+            external_type: toAzureDevOpsWorkItemType(item),
+        })),
+        warnings: [
+            'Dry-run only: no network calls, credentials, external IDs, or provider writes are used.',
+            `Projection source: ${options.items ? 'caller-provided canonical items' : `built-in ${options.ref} fixture`}.`,
+        ],
+    });
+    return {
+        schema_version: 1,
+        dry_run: true,
+        ref: options.ref,
+        fixture: options.items ? 'provided' : options.ref,
+        plan,
+    };
+}
+function resolveFixtureItems(ref) {
+    if (ref !== 'EPIC-0039') {
+        throw new Error(`No built-in backlog projection fixture for ${ref}. Provide canonical items in code or use EPIC-0039.`);
+    }
+    return epic0039Fixture;
+}
+function toAzureDevOpsWorkItemType(item) {
+    if (item.kind === 'epic')
+        return 'Epic';
+    if (item.kind === 'feature')
+        return 'User Story';
+    return item.kind;
+}
+//# sourceMappingURL=backlog-cli.js.map

package/dist/core/sdd/backlog-conflict-policy.d.ts

@@ -0,0 +1,58 @@
+import type { BacklogEntityKind, BacklogProviderId } from './backlog-provider-contract.js';
+export type BacklogConflictClassification = 'none' | 'create' | 'update' | 'manual-review' | 'stale-external' | 'canonical-drift';
+export type BacklogSyncOperation = 'noop' | 'create' | 'update' | 'manual-review';
+export type BacklogSyncDecisionSeverity = 'info' | 'warning' | 'error';
+export interface BacklogSyncFieldSet {
+    title: string;
+    status: string;
+    parent_ref?: string;
+    labels?: string[];
+}
+export interface CanonicalBacklogSyncItem extends BacklogSyncFieldSet {
+    ref: string;
+    kind: Exclude<BacklogEntityKind, 'task'>;
+    updated_at?: string;
+    last_synced_at?: string;
+    last_synced_fingerprint?: string;
+    fields?: Record<string, string | string[] | undefined>;
+}
+export interface ExternalBacklogWorkItem extends Partial<BacklogSyncFieldSet> {
+    provider: BacklogProviderId;
+    external_id?: string;
+    canonical_ref?: string;
+    updated_at?: string;
+    last_synced_at?: string;
+    codesdd_fingerprint?: string;
+    idempotency_key?: string;
+    fields?: Record<string, string | string[] | undefined>;
+}
+export interface BacklogConflictDecision {
+    code: string;
+    severity: BacklogSyncDecisionSeverity;
+    message: string;
+    field?: string;
+    source_of_truth: 'codesdd';
+    canonical_value?: unknown;
+    external_value?: unknown;
+}
+export interface BacklogConflictPolicyInput {
+    provider: BacklogProviderId;
+    canonical: CanonicalBacklogSyncItem;
+    external?: ExternalBacklogWorkItem;
+    source_of_truth?: string;
+}
+export interface BacklogConflictPolicyResult {
+    classification: BacklogConflictClassification;
+    operation: BacklogSyncOperation;
+    idempotency_key: string;
+    canonical_fingerprint: string;
+    decisions: BacklogConflictDecision[];
+}
+export declare function classifyBacklogSyncConflict(input: BacklogConflictPolicyInput): BacklogConflictPolicyResult;
+export declare function buildBacklogSyncIdempotencyKey(input: {
+    provider: BacklogProviderId;
+    canonical_ref: string;
+    operation: BacklogSyncOperation;
+}): string;
+export declare function fingerprintBacklogSyncFields(fields: BacklogSyncFieldSet): string;
+//# sourceMappingURL=backlog-conflict-policy.d.ts.map

package/dist/core/sdd/backlog-conflict-policy.js

@@ -0,0 +1,230 @@
+import { createHash } from 'node:crypto';
+const POLICY_VERSION = 'v1';
+export function classifyBacklogSyncConflict(input) {
+    const canonical = normalizeCanonical(input.canonical);
+    const sourceOfTruth = input.source_of_truth ?? 'codesdd';
+    const canonicalFingerprint = fingerprintBacklogSyncFields(canonical);
+    const decisions = [
+        {
+            code: 'source-of-truth.codesdd',
+            severity: 'info',
+            message: 'CodeSDD canonical state is authoritative for backlog sync decisions.',
+            source_of_truth: 'codesdd',
+        },
+    ];
+    if (sourceOfTruth !== 'codesdd') {
+        decisions.push({
+            code: 'source-of-truth.unsupported',
+            severity: 'error',
+            message: 'Backlog sync only supports CodeSDD as the source of truth.',
+            source_of_truth: 'codesdd',
+            external_value: sourceOfTruth,
+        });
+        return buildResult('manual-review', input.provider, canonical.ref, canonicalFingerprint, decisions);
+    }
+    if (!input.external) {
+        decisions.push({
+            code: 'external.missing',
+            severity: 'info',
+            message: 'No external work item is linked; create a provider item from canonical CodeSDD state.',
+            source_of_truth: 'codesdd',
+        });
+        return buildResult('create', input.provider, canonical.ref, canonicalFingerprint, decisions);
+    }
+    const external = normalizeExternal(input.external);
+    if (external.provider !== input.provider) {
+        decisions.push({
+            code: 'provider.mismatch',
+            severity: 'error',
+            message: 'External work item belongs to a different provider than the sync request.',
+            source_of_truth: 'codesdd',
+            canonical_value: input.provider,
+            external_value: external.provider,
+        });
+        return buildResult('manual-review', input.provider, canonical.ref, canonicalFingerprint, decisions);
+    }
+    if (external.canonical_ref && external.canonical_ref !== canonical.ref) {
+        decisions.push({
+            code: 'canonical-ref.mismatch',
+            severity: 'error',
+            message: 'External work item points at a different CodeSDD reference.',
+            field: 'canonical_ref',
+            source_of_truth: 'codesdd',
+            canonical_value: canonical.ref,
+            external_value: external.canonical_ref,
+        });
+        return buildResult('manual-review', input.provider, canonical.ref, canonicalFingerprint, decisions);
+    }
+    const diffs = diffSyncFields(canonical, external);
+    for (const diff of diffs) {
+        decisions.push({
+            code: 'field.diff',
+            severity: 'warning',
+            message: `External field ${diff.field} differs from canonical CodeSDD state.`,
+            field: diff.field,
+            source_of_truth: 'codesdd',
+            canonical_value: diff.canonical_value,
+            external_value: diff.external_value,
+        });
+    }
+    if (diffs.length === 0 && external.codesdd_fingerprint === canonicalFingerprint) {
+        decisions.push({
+            code: 'sync.clean',
+            severity: 'info',
+            message: 'External work item already matches the canonical CodeSDD fingerprint.',
+            source_of_truth: 'codesdd',
+        });
+        return buildResult('none', input.provider, canonical.ref, canonicalFingerprint, decisions);
+    }
+    if (diffs.length === 0 && !external.codesdd_fingerprint) {
+        decisions.push({
+            code: 'sync.equivalent-without-fingerprint',
+            severity: 'info',
+            message: 'External work item fields match canonical state, but provider fingerprint metadata is absent.',
+            source_of_truth: 'codesdd',
+        });
+        return buildResult('update', input.provider, canonical.ref, canonicalFingerprint, decisions);
+    }
+    const lastSyncedAt = latestDate(canonical.last_synced_at, external.last_synced_at);
+    const canonicalChanged = changedAfter(canonical.updated_at, lastSyncedAt);
+    const externalChanged = changedAfter(external.updated_at, lastSyncedAt);
+    if (diffs.length > 0 && canonicalChanged && externalChanged) {
+        decisions.push({
+            code: 'drift.concurrent',
+            severity: 'error',
+            message: 'Both canonical and external items changed after the last sync; manual review is required.',
+            source_of_truth: 'codesdd',
+        });
+        return buildResult('manual-review', input.provider, canonical.ref, canonicalFingerprint, decisions);
+    }
+    if (diffs.length > 0 && canonicalChanged) {
+        decisions.push({
+            code: 'canonical.drift',
+            severity: 'warning',
+            message: 'Canonical CodeSDD state changed after the last sync; push canonical state to the provider.',
+            source_of_truth: 'codesdd',
+        });
+        return buildResult('canonical-drift', input.provider, canonical.ref, canonicalFingerprint, decisions);
+    }
+    if (diffs.length > 0 && externalChanged) {
+        decisions.push({
+            code: 'external.stale',
+            severity: 'warning',
+            message: 'External work item drifted from CodeSDD; overwrite from canonical state unless reviewed.',
+            source_of_truth: 'codesdd',
+        });
+        return buildResult('stale-external', input.provider, canonical.ref, canonicalFingerprint, decisions);
+    }
+    decisions.push({
+        code: 'sync.update-required',
+        severity: 'warning',
+        message: 'External work item differs from canonical CodeSDD state and should be updated.',
+        source_of_truth: 'codesdd',
+    });
+    return buildResult('update', input.provider, canonical.ref, canonicalFingerprint, decisions);
+}
+export function buildBacklogSyncIdempotencyKey(input) {
+    return ['codesdd-backlog-sync', POLICY_VERSION, input.provider, input.canonical_ref, input.operation].join(':');
+}
+export function fingerprintBacklogSyncFields(fields) {
+    return `sha256:${createHash('sha256').update(stableStringify(normalizeFieldSet(fields))).digest('hex')}`;
+}
+function buildResult(classification, provider, canonicalRef, canonicalFingerprint, decisions) {
+    const operation = operationForClassification(classification);
+    return {
+        classification,
+        operation,
+        idempotency_key: buildBacklogSyncIdempotencyKey({ provider, canonical_ref: canonicalRef, operation }),
+        canonical_fingerprint: canonicalFingerprint,
+        decisions,
+    };
+}
+function operationForClassification(classification) {
+    if (classification === 'none')
+        return 'noop';
+    if (classification === 'create')
+        return 'create';
+    if (classification === 'manual-review')
+        return 'manual-review';
+    return 'update';
+}
+function normalizeCanonical(item) {
+    return {
+        ...item,
+        ...normalizeFieldSet(item),
+    };
+}
+function normalizeExternal(item) {
+    return {
+        ...item,
+        title: normalizeString(item.title),
+        status: normalizeString(item.status),
+        parent_ref: normalizeOptionalString(item.parent_ref),
+        labels: normalizeLabels(item.labels),
+    };
+}
+function normalizeFieldSet(fields) {
+    return {
+        title: normalizeString(fields.title),
+        status: normalizeString(fields.status),
+        parent_ref: normalizeOptionalString(fields.parent_ref) ?? '',
+        labels: normalizeLabels(fields.labels),
+    };
+}
+function normalizeString(value) {
+    return (value ?? '').trim();
+}
+function normalizeOptionalString(value) {
+    const normalized = normalizeString(value);
+    return normalized.length > 0 ? normalized : undefined;
+}
+function normalizeLabels(labels) {
+    return Array.from(new Set((labels ?? []).map((label) => label.trim()).filter(Boolean))).sort((left, right) => left.localeCompare(right));
+}
+function diffSyncFields(canonical, external) {
+    const canonicalFields = normalizeFieldSet(canonical);
+    const externalFields = normalizeFieldSet({
+        title: external.title ?? '',
+        status: external.status ?? '',
+        parent_ref: external.parent_ref,
+        labels: external.labels,
+    });
+    const diffs = [];
+    for (const field of ['title', 'status', 'parent_ref']) {
+        if (canonicalFields[field] !== externalFields[field]) {
+            diffs.push({ field, canonical_value: canonicalFields[field], external_value: externalFields[field] });
+        }
+    }
+    if (stableStringify(canonicalFields.labels) !== stableStringify(externalFields.labels)) {
+        diffs.push({ field: 'labels', canonical_value: canonicalFields.labels, external_value: externalFields.labels });
+    }
+    return diffs;
+}
+function latestDate(left, right) {
+    if (!left)
+        return right;
+    if (!right)
+        return left;
+    return Date.parse(left) >= Date.parse(right) ? left : right;
+}
+function changedAfter(candidate, baseline) {
+    if (!candidate || !baseline)
+        return false;
+    const candidateTime = Date.parse(candidate);
+    const baselineTime = Date.parse(baseline);
+    return Number.isFinite(candidateTime) && Number.isFinite(baselineTime) && candidateTime > baselineTime;
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value)
+            .filter(([, item]) => item !== undefined)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`);
+        return `{${entries.join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+//# sourceMappingURL=backlog-conflict-policy.js.map

package/dist/core/sdd/backlog-projection.d.ts

@@ -0,0 +1,8 @@
+import { type BacklogProjectionPlan, type BacklogProviderContract, type BacklogProviderContractInput, type CanonicalBacklogItem } from './backlog-provider-contract.js';
+export declare function builtInAzureDevOpsBacklogContract(): BacklogProviderContract;
+export declare function buildAzureDevOpsBacklogProjectionPlan(input: {
+    items: CanonicalBacklogItem[];
+    created_at?: string;
+    contract?: BacklogProviderContractInput;
+}): BacklogProjectionPlan;
+//# sourceMappingURL=backlog-projection.d.ts.map