@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/core/sdd/package-structure-gate.js

@@ -0,0 +1,357 @@
+import { z } from 'zod';
+export const DerivationProfileSchema = z.enum(['prototype', 'foundation-compatible', 'enterprise-strict']);
+export const PreviewGateStatusSchema = z.enum(['pending', 'approved', 'corrected', 'rejected']);
+export const PackageStructureNodeKindSchema = z.enum(['dir', 'file']);
+export const PackageStructureNodeSchema = z.lazy(() => z.object({
+    name: z.string().min(1),
+    kind: PackageStructureNodeKindSchema,
+    description: z.string().optional(),
+    children: z.array(PackageStructureNodeSchema).optional(),
+}));
+export const PackageStructurePreviewSchema = z.object({
+    schema_version: z.literal(1),
+    generated_at: z.string(),
+    project_name: z.string().min(1),
+    profile: DerivationProfileSchema,
+    contexts: z.array(z.string()),
+    subsystems: z.array(z.string()),
+    transports: z.array(z.string()),
+    tree: PackageStructureNodeSchema,
+});
+export const HumanValidationGateSchema = z.object({
+    gate_id: z.string(),
+    rule_ref: z.literal('DTAPI-P0-PREVIEW-001'),
+    status: PreviewGateStatusSchema,
+    preview_ref: z.string(),
+    approved_at: z.string().optional(),
+    approved_by: z.string().optional(),
+    correction_notes: z.string().optional(),
+    exception_refs: z.array(z.string()).default([]),
+});
+export function generatePackageStructurePreview(input) {
+    const profile = input.profile ?? 'foundation-compatible';
+    const contexts = input.contexts ?? ['auth'];
+    const subsystems = input.subsystems ?? ['orm', 'cache', 'configuration'];
+    const transports = input.transports ?? ['rest', 'graphql', 'cli'];
+    const generatedAt = input.generated_at ?? new Date().toISOString();
+    return {
+        schema_version: 1,
+        generated_at: generatedAt,
+        project_name: input.project_name,
+        profile,
+        contexts,
+        subsystems,
+        transports,
+        tree: buildProjectTree(profile, contexts, subsystems, transports),
+    };
+}
+export function formatPreviewAsTree(node, prefix = '') {
+    const lines = [];
+    const label = node.description ? `${node.name}  (${node.description})` : node.name;
+    lines.push(`${prefix}${node.kind === 'dir' ? '[dir]' : '[file]'} ${label}`);
+    if (node.children) {
+        const childPrefix = `${prefix}  `;
+        for (const child of node.children) {
+            const childOutput = formatPreviewAsTree(child, childPrefix);
+            lines.push(childOutput);
+        }
+    }
+    return lines.join('\n');
+}
+export function buildHumanValidationGate(preview) {
+    return {
+        gate_id: `GATE-PKG-${preview.project_name.replace(/[^a-zA-Z0-9-]/g, '-')}`,
+        rule_ref: 'DTAPI-P0-PREVIEW-001',
+        status: 'pending',
+        preview_ref: `devtrack-api-package-preview-${preview.project_name}`,
+        exception_refs: [],
+    };
+}
+export function generateDevtrackApiDebGate(input) {
+    const preview = generatePackageStructurePreview(input);
+    const gate = buildHumanValidationGate(preview);
+    return {
+        selected_profile: input.profile ?? 'foundation-compatible',
+        package_preview: preview,
+        human_validation_gate: gate,
+        exception_list: [],
+        policy_pool_seed: [
+            'DTAPI-P0-PROFILE-001: derivation profile must be explicit',
+            'DTAPI-P0-PREVIEW-001: early planning must include package structure preview',
+            'DTAPI-P0-PATH-001: proposed paths must match canonical Foundation paths',
+        ],
+    };
+}
+export function isGatePending(gate) {
+    return gate.status === 'pending';
+}
+export function isGateApproved(gate) {
+    return gate.status === 'approved' || gate.status === 'corrected';
+}
+function buildProjectTree(profile, contexts, subsystems, transports) {
+    const layers = [];
+    const applicationLayer = buildApplicationLayer(contexts);
+    if (applicationLayer)
+        layers.push(applicationLayer);
+    const domainLayer = buildDomainLayer(contexts);
+    if (domainLayer)
+        layers.push(domainLayer);
+    const infrastructureLayer = buildInfrastructureLayer(subsystems, contexts);
+    if (infrastructureLayer)
+        layers.push(infrastructureLayer);
+    const presentationLayer = buildPresentationLayer(transports, contexts);
+    if (presentationLayer)
+        layers.push(presentationLayer);
+    const sharedLayer = buildSharedLayer();
+    if (sharedLayer)
+        layers.push(sharedLayer);
+    const rootFiles = [
+        { name: 'app.module.ts', kind: 'file', description: 'Root application module' },
+        { name: 'main.ts', kind: 'file', description: 'NestJS bootstrap entrypoint' },
+    ];
+    return {
+        name: 'src/',
+        kind: 'dir',
+        description: `devtrack-api project (${profile} profile)`,
+        children: [...layers, ...rootFiles],
+    };
+}
+function buildApplicationLayer(contexts) {
+    if (contexts.length === 0)
+        return null;
+    return {
+        name: 'application/',
+        kind: 'dir',
+        description: 'Application orchestration layer',
+        children: [
+            { name: 'application.module.ts', kind: 'file', description: 'Application layer module boundary' },
+            { name: 'runtime-settings.ts', kind: 'file', description: 'Runtime settings boundary' },
+            ...contexts.map((context) => buildApplicationContext(context)),
+        ],
+    };
+}
+function buildApplicationContext(context) {
+    return {
+        name: `business/${context}/`,
+        kind: 'dir',
+        children: [
+            {
+                name: 'use-cases/',
+                kind: 'dir',
+                children: [
+                    { name: '<verb-noun>.use-case.ts', kind: 'file', description: 'Use case orchestration' },
+                ],
+            },
+            {
+                name: 'ports/',
+                kind: 'dir',
+                children: [
+                    {
+                        name: 'in/',
+                        kind: 'dir',
+                        children: [
+                            { name: '<verb-noun>.use-case.port.ts', kind: 'file', description: 'Use case input port' },
+                        ],
+                    },
+                    {
+                        name: 'out/',
+                        kind: 'dir',
+                        children: [
+                            { name: '<name>.port.ts', kind: 'file', description: 'Collaborator output port' },
+                            { name: '<name>-repository.port.ts', kind: 'file', description: 'Repository output port (BO-pattern)' },
+                        ],
+                    },
+                ],
+            },
+            { name: 'services/', kind: 'dir', children: [{ name: '<name>.service.ts', kind: 'file', description: 'Application service' }] },
+            { name: 'handlers/', kind: 'dir', children: [{ name: '<name>.handler.ts', kind: 'file', description: 'Event handler' }] },
+            { name: `${context}.application.module.ts`, kind: 'file', description: 'Context application module' },
+        ],
+    };
+}
+function buildDomainLayer(contexts) {
+    if (contexts.length === 0)
+        return null;
+    return {
+        name: 'domain/',
+        kind: 'dir',
+        description: 'Domain business rules layer',
+        children: contexts.map((context) => ({
+            name: `${context}/`,
+            kind: 'dir',
+            description: 'Business context (BO-pattern)',
+            children: [
+                {
+                    name: 'business-objects/',
+                    kind: 'dir',
+                    children: [{ name: '<name>.bo.ts', kind: 'file', description: 'Business object' }],
+                },
+                {
+                    name: 'value-objects/',
+                    kind: 'dir',
+                    children: [{ name: '<name>.vo.ts', kind: 'file', description: 'Value object' }],
+                },
+                {
+                    name: 'types/',
+                    kind: 'dir',
+                    children: [{ name: '<name>.type.ts', kind: 'file', description: 'Domain type' }],
+                },
+                {
+                    name: 'constants/',
+                    kind: 'dir',
+                    children: [{ name: '<name>.const.ts', kind: 'file', description: 'Domain constant' }],
+                },
+            ],
+        })),
+    };
+}
+function buildInfrastructureLayer(subsystems, contexts) {
+    if (subsystems.length === 0 && contexts.length === 0)
+        return null;
+    return {
+        name: 'infrastructure/',
+        kind: 'dir',
+        description: 'Infrastructure adapters and settings',
+        children: [
+            { name: 'infrastructure.module.ts', kind: 'file', description: 'Infrastructure layer module boundary' },
+            { name: 'settings/', kind: 'dir', children: [{ name: 'app-configuration.ts', kind: 'file', description: 'Typed config source' }] },
+            {
+                name: 'adapters/',
+                kind: 'dir',
+                children: [
+                    ...(subsystems.includes('orm') ? [buildOrmSubsystem()] : []),
+                    ...subsystems.filter((s) => s !== 'orm').map((subsystem) => {
+                        const subsystemNode = {
+                            name: `${subsystem}/`,
+                            kind: 'dir',
+                            children: [
+                                { name: `<name>.adapter.ts`, kind: 'file', description: `${subsystem} adapter` },
+                                { name: `${subsystem}.module.ts`, kind: 'file', description: `${subsystem} module` },
+                            ],
+                        };
+                        return subsystemNode;
+                    }),
+                ],
+            },
+        ],
+    };
+}
+function buildOrmSubsystem() {
+    return {
+        name: 'orm/',
+        kind: 'dir',
+        children: [
+            { name: 'typeorm.config.ts', kind: 'file', description: 'TypeORM root configuration' },
+            { name: 'typeorm-cli.datasource.ts', kind: 'file', description: 'TypeORM CLI datasource' },
+            { name: 'orm.module.ts', kind: 'file', description: 'Single ORM module exporting TypeORM repositories' },
+            {
+                name: 'entities/',
+                kind: 'dir',
+                children: [{ name: '<name>.orm-entity.ts', kind: 'file', description: 'ORM entity' }],
+            },
+            {
+                name: 'repositories/',
+                kind: 'dir',
+                children: [{ name: '<name>.typeorm-repository.ts', kind: 'file', description: 'TypeORM repository' }],
+            },
+            {
+                name: 'mappers/',
+                kind: 'dir',
+                children: [{ name: '<name>.mapper.ts', kind: 'file', description: 'Domain-ORM mapper' }],
+            },
+            {
+                name: 'migrations/',
+                kind: 'dir',
+                children: [{ name: '<timestamp>-<action>.migration.ts', kind: 'file', description: 'Database migration' }],
+            },
+        ],
+    };
+}
+function buildPresentationLayer(transports, contexts) {
+    if (transports.length === 0 || contexts.length === 0)
+        return null;
+    return {
+        name: 'presentation/',
+        kind: 'dir',
+        description: 'Presentation transport layer',
+        children: [
+            { name: 'presentation.module.ts', kind: 'file', description: 'Presentation layer module boundary' },
+            ...transports.map((transport) => {
+                const transportNode = {
+                    name: `${transport}/`,
+                    kind: 'dir',
+                    children: [
+                        { name: `${transport}.presentation.module.ts`, kind: 'file', description: `${transport} channel module` },
+                        ...contexts.map((context) => buildPresentationContext(transport, context)),
+                    ],
+                };
+                return transportNode;
+            }),
+        ],
+    };
+}
+function buildPresentationContext(transport, context) {
+    return {
+        name: `${context}/`,
+        kind: 'dir',
+        children: [
+            {
+                name: 'controllers/',
+                kind: 'dir',
+                children: [{ name: '<verb-noun>.controller.ts', kind: 'file', description: 'Controller' }],
+            },
+            {
+                name: 'presentation-validators/',
+                kind: 'dir',
+                children: [{ name: '<verb-noun>.presentation-validator.ts', kind: 'file', description: 'Request validator' }],
+            },
+            {
+                name: 'guards/',
+                kind: 'dir',
+                children: [{ name: '<name>.guard.ts', kind: 'file', description: 'Auth guard' }],
+            },
+            {
+                name: 'decorators/',
+                kind: 'dir',
+                children: [{ name: '<name>.decorator.ts', kind: 'file', description: 'Custom decorator' }],
+            },
+            { name: `${context}.module.ts`, kind: 'file', description: `${context} ${transport} module` },
+        ],
+    };
+}
+function buildSharedLayer() {
+    return {
+        name: 'shared/',
+        kind: 'dir',
+        description: 'Cross-cutting shared primitives',
+        children: [
+            {
+                name: 'domain/',
+                kind: 'dir',
+                children: [
+                    { name: 'exceptions/', kind: 'dir', children: [{ name: '<name>.exception.ts', kind: 'file', description: 'Domain exception' }] },
+                    { name: 'value-objects/', kind: 'dir', children: [{ name: '<name>.vo.ts', kind: 'file', description: 'Shared VO' }] },
+                    { name: 'validators/', kind: 'dir', children: [{ name: '<name>.validator.ts', kind: 'file', description: 'Domain validator' }] },
+                    { name: 'types/', kind: 'dir', children: [{ name: '<name>.type.ts', kind: 'file', description: 'Shared type' }] },
+                ],
+            },
+            {
+                name: 'infrastructure/',
+                kind: 'dir',
+                children: [
+                    { name: 'adapter/', kind: 'dir', children: [{ name: '<subsystem>/', kind: 'dir', children: [{ name: '<name>.port.ts', kind: 'file', description: 'Adapter port' }] }] },
+                ],
+            },
+            {
+                name: 'presentation/',
+                kind: 'dir',
+                children: [
+                    { name: 'filters/', kind: 'dir', children: [{ name: '<name>.filter.ts', kind: 'file', description: 'Exception filter' }] },
+                    { name: 'interceptors/', kind: 'dir', children: [{ name: '<name>.interceptor.ts', kind: 'file', description: 'Interceptor' }] },
+                    { name: 'pipes/', kind: 'dir', children: [{ name: '<name>.pipe.ts', kind: 'file', description: 'Validation pipe' }] },
+                ],
+            },
+        ],
+    };
+}
+//# sourceMappingURL=package-structure-gate.js.map

package/dist/core/sdd/parallel-feat-automation.d.ts

@@ -0,0 +1,330 @@
+import { z } from 'zod';
+export declare const parallelFeatStateBoundarySchema: z.ZodObject<{
+    id: z.ZodLiteral<"codesdd-canonical-sdd-state">;
+    canonical_state_glob: z.ZodLiteral<".sdd/state/*.yaml">;
+    project_state_root: z.ZodLiteral<".sdd">;
+    hidden_state_allowed: z.ZodLiteral<false>;
+    external_state_allowed: z.ZodLiteral<false>;
+}, z.core.$strip>;
+export declare const PARALLEL_FEAT_STATE_BOUNDARY: {
+    id: "codesdd-canonical-sdd-state";
+    canonical_state_glob: ".sdd/state/*.yaml";
+    project_state_root: ".sdd";
+    hidden_state_allowed: false;
+    external_state_allowed: false;
+};
+export declare const parallelFeatAutomationFeatureSchema: z.ZodObject<{
+    feature_ref: z.ZodString;
+    title: z.ZodString;
+    recommended_skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    lock_domains: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const parallelFeatSchedulerFeatureSchema: z.ZodObject<{
+    feature_ref: z.ZodString;
+    title: z.ZodString;
+    recommended_skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    lock_domains: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    blocked_by: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    status: z.ZodDefault<z.ZodEnum<{
+        READY: "READY";
+        IN_PROGRESS: "IN_PROGRESS";
+        DONE: "DONE";
+        BLOCKED: "BLOCKED";
+    }>>;
+}, z.core.$strip>;
+export declare const parallelFeatAutomationRequestSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+    generated_at: z.ZodOptional<z.ZodString>;
+    max_agents: z.ZodDefault<z.ZodNumber>;
+    require_clean_worktree: z.ZodDefault<z.ZodBoolean>;
+    require_commit_per_feature: z.ZodDefault<z.ZodBoolean>;
+    require_finalize_before_commit: z.ZodDefault<z.ZodBoolean>;
+    agent_provider: z.ZodOptional<z.ZodEnum<{
+        codex: "codex";
+        opencode: "opencode";
+        deepagents: "deepagents";
+        fake: "fake";
+        "claude-code": "claude-code";
+        cloudcode: "cloudcode";
+    }>>;
+    features: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        feature_ref: z.ZodString;
+        title: z.ZodString;
+        recommended_skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        lock_domains: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    waves: z.ZodDefault<z.ZodArray<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export declare const parallelFeatSchedulerRequestSchema: z.ZodObject<{
+    schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+    generated_at: z.ZodOptional<z.ZodString>;
+    max_agents: z.ZodDefault<z.ZodNumber>;
+    require_clean_worktree: z.ZodDefault<z.ZodBoolean>;
+    require_commit_per_feature: z.ZodDefault<z.ZodBoolean>;
+    require_finalize_before_commit: z.ZodDefault<z.ZodBoolean>;
+    agent_provider: z.ZodOptional<z.ZodEnum<{
+        codex: "codex";
+        opencode: "opencode";
+        deepagents: "deepagents";
+        fake: "fake";
+        "claude-code": "claude-code";
+        cloudcode: "cloudcode";
+    }>>;
+    features: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        feature_ref: z.ZodString;
+        title: z.ZodString;
+        recommended_skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        lock_domains: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        blocked_by: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        status: z.ZodDefault<z.ZodEnum<{
+            READY: "READY";
+            IN_PROGRESS: "IN_PROGRESS";
+            DONE: "DONE";
+            BLOCKED: "BLOCKED";
+        }>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const parallelFeatAutomationStepSchema: z.ZodObject<{
+    feature_ref: z.ZodString;
+    title: z.ZodString;
+    sequence: z.ZodNumber;
+    delegation: z.ZodObject<{
+        mode: z.ZodEnum<{
+            "agent-adapter": "agent-adapter";
+            "local-codex": "local-codex";
+        }>;
+        provider: z.ZodOptional<z.ZodEnum<{
+            codex: "codex";
+            opencode: "opencode";
+            deepagents: "deepagents";
+            fake: "fake";
+            "claude-code": "claude-code";
+            cloudcode: "cloudcode";
+        }>>;
+    }, z.core.$strip>;
+    commands: z.ZodArray<z.ZodString>;
+    commit_boundary: z.ZodObject<{
+        clean_worktree_required: z.ZodBoolean;
+        finalize_before_commit: z.ZodBoolean;
+        commit_per_feature: z.ZodBoolean;
+        commit_message: z.ZodString;
+    }, z.core.$strip>;
+    state_boundary_ref: z.ZodLiteral<"codesdd-canonical-sdd-state">;
+    allowed_state_writes: z.ZodArray<z.ZodString>;
+    forbidden_state_writes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    evidence_required: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const parallelFeatAutomationWaveSchema: z.ZodObject<{
+    wave_index: z.ZodNumber;
+    max_parallel: z.ZodNumber;
+    status: z.ZodEnum<{
+        ready: "ready";
+        blocked: "blocked";
+    }>;
+    conflicts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    steps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        feature_ref: z.ZodString;
+        title: z.ZodString;
+        sequence: z.ZodNumber;
+        delegation: z.ZodObject<{
+            mode: z.ZodEnum<{
+                "agent-adapter": "agent-adapter";
+                "local-codex": "local-codex";
+            }>;
+            provider: z.ZodOptional<z.ZodEnum<{
+                codex: "codex";
+                opencode: "opencode";
+                deepagents: "deepagents";
+                fake: "fake";
+                "claude-code": "claude-code";
+                cloudcode: "cloudcode";
+            }>>;
+        }, z.core.$strip>;
+        commands: z.ZodArray<z.ZodString>;
+        commit_boundary: z.ZodObject<{
+            clean_worktree_required: z.ZodBoolean;
+            finalize_before_commit: z.ZodBoolean;
+            commit_per_feature: z.ZodBoolean;
+            commit_message: z.ZodString;
+        }, z.core.$strip>;
+        state_boundary_ref: z.ZodLiteral<"codesdd-canonical-sdd-state">;
+        allowed_state_writes: z.ZodArray<z.ZodString>;
+        forbidden_state_writes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        evidence_required: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const parallelFeatAutomationPlanSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    status: z.ZodEnum<{
+        ready: "ready";
+        blocked: "blocked";
+        empty: "empty";
+    }>;
+    max_agents: z.ZodNumber;
+    state_boundary: z.ZodObject<{
+        id: z.ZodLiteral<"codesdd-canonical-sdd-state">;
+        canonical_state_glob: z.ZodLiteral<".sdd/state/*.yaml">;
+        project_state_root: z.ZodLiteral<".sdd">;
+        hidden_state_allowed: z.ZodLiteral<false>;
+        external_state_allowed: z.ZodLiteral<false>;
+    }, z.core.$strip>;
+    write_policy: z.ZodObject<{
+        allowed_root: z.ZodLiteral<".sdd">;
+        canonical_state_glob: z.ZodLiteral<".sdd/state/*.yaml">;
+        hidden_state_allowed: z.ZodLiteral<false>;
+        external_state_allowed: z.ZodLiteral<false>;
+    }, z.core.$strip>;
+    rules: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    waves: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        wave_index: z.ZodNumber;
+        max_parallel: z.ZodNumber;
+        status: z.ZodEnum<{
+            ready: "ready";
+            blocked: "blocked";
+        }>;
+        conflicts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        steps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            feature_ref: z.ZodString;
+            title: z.ZodString;
+            sequence: z.ZodNumber;
+            delegation: z.ZodObject<{
+                mode: z.ZodEnum<{
+                    "agent-adapter": "agent-adapter";
+                    "local-codex": "local-codex";
+                }>;
+                provider: z.ZodOptional<z.ZodEnum<{
+                    codex: "codex";
+                    opencode: "opencode";
+                    deepagents: "deepagents";
+                    fake: "fake";
+                    "claude-code": "claude-code";
+                    cloudcode: "cloudcode";
+                }>>;
+            }, z.core.$strip>;
+            commands: z.ZodArray<z.ZodString>;
+            commit_boundary: z.ZodObject<{
+                clean_worktree_required: z.ZodBoolean;
+                finalize_before_commit: z.ZodBoolean;
+                commit_per_feature: z.ZodBoolean;
+                commit_message: z.ZodString;
+            }, z.core.$strip>;
+            state_boundary_ref: z.ZodLiteral<"codesdd-canonical-sdd-state">;
+            allowed_state_writes: z.ZodArray<z.ZodString>;
+            forbidden_state_writes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            evidence_required: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    summary: z.ZodObject<{
+        feature_count: z.ZodNumber;
+        wave_count: z.ZodNumber;
+        blocked_wave_count: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const parallelFeatSchedulerBlockedFeatureSchema: z.ZodObject<{
+    feature_ref: z.ZodString;
+    blocked_by: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export declare const parallelFeatSchedulerResultSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    status: z.ZodEnum<{
+        ready: "ready";
+        blocked: "blocked";
+        empty: "empty";
+    }>;
+    plan: z.ZodObject<{
+        schema_version: z.ZodLiteral<1>;
+        generated_at: z.ZodString;
+        status: z.ZodEnum<{
+            ready: "ready";
+            blocked: "blocked";
+            empty: "empty";
+        }>;
+        max_agents: z.ZodNumber;
+        state_boundary: z.ZodObject<{
+            id: z.ZodLiteral<"codesdd-canonical-sdd-state">;
+            canonical_state_glob: z.ZodLiteral<".sdd/state/*.yaml">;
+            project_state_root: z.ZodLiteral<".sdd">;
+            hidden_state_allowed: z.ZodLiteral<false>;
+            external_state_allowed: z.ZodLiteral<false>;
+        }, z.core.$strip>;
+        write_policy: z.ZodObject<{
+            allowed_root: z.ZodLiteral<".sdd">;
+            canonical_state_glob: z.ZodLiteral<".sdd/state/*.yaml">;
+            hidden_state_allowed: z.ZodLiteral<false>;
+            external_state_allowed: z.ZodLiteral<false>;
+        }, z.core.$strip>;
+        rules: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        waves: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            wave_index: z.ZodNumber;
+            max_parallel: z.ZodNumber;
+            status: z.ZodEnum<{
+                ready: "ready";
+                blocked: "blocked";
+            }>;
+            conflicts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            steps: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                feature_ref: z.ZodString;
+                title: z.ZodString;
+                sequence: z.ZodNumber;
+                delegation: z.ZodObject<{
+                    mode: z.ZodEnum<{
+                        "agent-adapter": "agent-adapter";
+                        "local-codex": "local-codex";
+                    }>;
+                    provider: z.ZodOptional<z.ZodEnum<{
+                        codex: "codex";
+                        opencode: "opencode";
+                        deepagents: "deepagents";
+                        fake: "fake";
+                        "claude-code": "claude-code";
+                        cloudcode: "cloudcode";
+                    }>>;
+                }, z.core.$strip>;
+                commands: z.ZodArray<z.ZodString>;
+                commit_boundary: z.ZodObject<{
+                    clean_worktree_required: z.ZodBoolean;
+                    finalize_before_commit: z.ZodBoolean;
+                    commit_per_feature: z.ZodBoolean;
+                    commit_message: z.ZodString;
+                }, z.core.$strip>;
+                state_boundary_ref: z.ZodLiteral<"codesdd-canonical-sdd-state">;
+                allowed_state_writes: z.ZodArray<z.ZodString>;
+                forbidden_state_writes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                evidence_required: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        summary: z.ZodObject<{
+            feature_count: z.ZodNumber;
+            wave_count: z.ZodNumber;
+            blocked_wave_count: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    blocked_features: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        feature_ref: z.ZodString;
+        blocked_by: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        reason: z.ZodString;
+    }, z.core.$strip>>>;
+    summary: z.ZodObject<{
+        feature_count: z.ZodNumber;
+        scheduled_feature_count: z.ZodNumber;
+        done_feature_count: z.ZodNumber;
+        blocked_feature_count: z.ZodNumber;
+        wave_count: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ParallelFeatAutomationFeature = z.infer<typeof parallelFeatAutomationFeatureSchema>;
+export type ParallelFeatAutomationRequest = z.infer<typeof parallelFeatAutomationRequestSchema>;
+export type ParallelFeatAutomationRequestInput = z.input<typeof parallelFeatAutomationRequestSchema>;
+export type ParallelFeatAutomationStep = z.infer<typeof parallelFeatAutomationStepSchema>;
+export type ParallelFeatAutomationPlan = z.infer<typeof parallelFeatAutomationPlanSchema>;
+export type ParallelFeatSchedulerFeature = z.infer<typeof parallelFeatSchedulerFeatureSchema>;
+export type ParallelFeatSchedulerRequest = z.infer<typeof parallelFeatSchedulerRequestSchema>;
+export type ParallelFeatSchedulerRequestInput = z.input<typeof parallelFeatSchedulerRequestSchema>;
+export type ParallelFeatSchedulerBlockedFeature = z.infer<typeof parallelFeatSchedulerBlockedFeatureSchema>;
+export type ParallelFeatSchedulerResult = z.infer<typeof parallelFeatSchedulerResultSchema>;
+export declare function buildParallelFeatAutomationPlan(input: ParallelFeatAutomationRequestInput): ParallelFeatAutomationPlan;
+export declare function scheduleChainedFeatWaves(input: ParallelFeatSchedulerRequestInput): ParallelFeatSchedulerResult;
+//# sourceMappingURL=parallel-feat-automation.d.ts.map