@devtrack-solution/codesdd 1.2.3 → 1.2.4

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

@@ -1,10 +1,37 @@
 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>;
@@ -13,8 +40,8 @@ export declare const parallelFeatAutomationRequestSchema: z.ZodObject<{
     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";
+        codex: "codex";
         deepagents: "deepagents";
         fake: "fake";
         "claude-code": "claude-code";
@@ -28,18 +55,47 @@ export declare const parallelFeatAutomationRequestSchema: z.ZodObject<{
     }, 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<{
+        opencode: "opencode";
+        codex: "codex";
+        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<{
-            "local-codex": "local-codex";
             "agent-adapter": "agent-adapter";
+            "local-codex": "local-codex";
         }>;
         provider: z.ZodOptional<z.ZodEnum<{
-            codex: "codex";
             opencode: "opencode";
+            codex: "codex";
             deepagents: "deepagents";
             fake: "fake";
             "claude-code": "claude-code";
@@ -53,6 +109,9 @@ export declare const parallelFeatAutomationStepSchema: z.ZodObject<{
         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<{
@@ -69,12 +128,12 @@ export declare const parallelFeatAutomationWaveSchema: z.ZodObject<{
         sequence: z.ZodNumber;
         delegation: z.ZodObject<{
             mode: z.ZodEnum<{
-                "local-codex": "local-codex";
                 "agent-adapter": "agent-adapter";
+                "local-codex": "local-codex";
             }>;
             provider: z.ZodOptional<z.ZodEnum<{
-                codex: "codex";
                 opencode: "opencode";
+                codex: "codex";
                 deepagents: "deepagents";
                 fake: "fake";
                 "claude-code": "claude-code";
@@ -88,6 +147,9 @@ export declare const parallelFeatAutomationWaveSchema: z.ZodObject<{
             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>;
@@ -100,6 +162,19 @@ export declare const parallelFeatAutomationPlanSchema: z.ZodObject<{
         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;
@@ -115,12 +190,12 @@ export declare const parallelFeatAutomationPlanSchema: z.ZodObject<{
             sequence: z.ZodNumber;
             delegation: z.ZodObject<{
                 mode: z.ZodEnum<{
-                    "local-codex": "local-codex";
                     "agent-adapter": "agent-adapter";
+                    "local-codex": "local-codex";
                 }>;
                 provider: z.ZodOptional<z.ZodEnum<{
-                    codex: "codex";
                     opencode: "opencode";
+                    codex: "codex";
                     deepagents: "deepagents";
                     fake: "fake";
                     "claude-code": "claude-code";
@@ -134,6 +209,9 @@ export declare const parallelFeatAutomationPlanSchema: z.ZodObject<{
                 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>>>;
@@ -143,10 +221,110 @@ export declare const parallelFeatAutomationPlanSchema: z.ZodObject<{
         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<{
+                        opencode: "opencode";
+                        codex: "codex";
+                        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

package/dist/core/sdd/parallel-feat-automation.js

@@ -1,6 +1,12 @@
 import { z } from 'zod';
 const FEATURE_REF_PATTERN = /^FEAT-\d{4}$/;
 const featureRefSchema = z.string().regex(FEATURE_REF_PATTERN);
+const sddPolicyPathSchema = z
+    .string()
+    .min(1)
+    .refine((value) => value === '.sdd' || value.startsWith('.sdd/'), {
+    message: 'Execution plans may only declare writes inside the canonical .sdd boundary.',
+});
 const agentProviderSchema = z.enum([
     'codex',
     'opencode',
@@ -9,12 +15,30 @@ const agentProviderSchema = z.enum([
     'deepagents',
     'fake',
 ]);
+export const parallelFeatStateBoundarySchema = z.object({
+    id: z.literal('codesdd-canonical-sdd-state'),
+    canonical_state_glob: z.literal('.sdd/state/*.yaml'),
+    project_state_root: z.literal('.sdd'),
+    hidden_state_allowed: z.literal(false),
+    external_state_allowed: z.literal(false),
+});
+export 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 const parallelFeatAutomationFeatureSchema = z.object({
     feature_ref: featureRefSchema,
     title: z.string().min(3),
     recommended_skills: z.array(z.string().min(1)).default([]),
     lock_domains: z.array(z.string().min(1)).default([]),
 });
+export const parallelFeatSchedulerFeatureSchema = parallelFeatAutomationFeatureSchema.extend({
+    blocked_by: z.array(featureRefSchema).default([]),
+    status: z.enum(['READY', 'IN_PROGRESS', 'BLOCKED', 'DONE']).default('READY'),
+});
 export const parallelFeatAutomationRequestSchema = z
     .object({
     schema_version: z.literal(1).default(1),
@@ -50,6 +74,30 @@ export const parallelFeatAutomationRequestSchema = z
         }
     }
 });
+export const parallelFeatSchedulerRequestSchema = z
+    .object({
+    schema_version: z.literal(1).default(1),
+    generated_at: z.string().datetime().optional(),
+    max_agents: z.number().int().min(1).max(10).default(5),
+    require_clean_worktree: z.boolean().default(true),
+    require_commit_per_feature: z.boolean().default(true),
+    require_finalize_before_commit: z.boolean().default(true),
+    agent_provider: agentProviderSchema.optional(),
+    features: z.array(parallelFeatSchedulerFeatureSchema).default([]),
+})
+    .superRefine((request, context) => {
+    const seenFeatureRefs = new Set();
+    for (const [featureIndex, feature] of request.features.entries()) {
+        if (seenFeatureRefs.has(feature.feature_ref)) {
+            context.addIssue({
+                code: 'custom',
+                path: ['features', featureIndex, 'feature_ref'],
+                message: `Feature ${feature.feature_ref} appears more than once.`,
+            });
+        }
+        seenFeatureRefs.add(feature.feature_ref);
+    }
+});
 export const parallelFeatAutomationStepSchema = z.object({
     feature_ref: featureRefSchema,
     title: z.string().min(3),
@@ -65,6 +113,9 @@ export const parallelFeatAutomationStepSchema = z.object({
         commit_per_feature: z.boolean(),
         commit_message: z.string().min(1),
     }),
+    state_boundary_ref: z.literal('codesdd-canonical-sdd-state'),
+    allowed_state_writes: z.array(sddPolicyPathSchema).min(1),
+    forbidden_state_writes: z.array(z.string().min(1)).default(['.codesdd/**', 'external-context/**']),
     evidence_required: z.array(z.string().min(1)).default([]),
 });
 export const parallelFeatAutomationWaveSchema = z.object({
@@ -79,6 +130,13 @@ export const parallelFeatAutomationPlanSchema = z.object({
     generated_at: z.string().datetime(),
     status: z.enum(['ready', 'blocked', 'empty']),
     max_agents: z.number().int().positive(),
+    state_boundary: parallelFeatStateBoundarySchema,
+    write_policy: z.object({
+        allowed_root: z.literal('.sdd'),
+        canonical_state_glob: z.literal('.sdd/state/*.yaml'),
+        hidden_state_allowed: z.literal(false),
+        external_state_allowed: z.literal(false),
+    }),
     rules: z.array(z.string().min(1)).default([]),
     waves: z.array(parallelFeatAutomationWaveSchema).default([]),
     summary: z.object({
@@ -87,6 +145,25 @@ export const parallelFeatAutomationPlanSchema = z.object({
         blocked_wave_count: z.number().int().nonnegative(),
     }),
 });
+export const parallelFeatSchedulerBlockedFeatureSchema = z.object({
+    feature_ref: featureRefSchema,
+    blocked_by: z.array(featureRefSchema).default([]),
+    reason: z.string().min(1),
+});
+export const parallelFeatSchedulerResultSchema = z.object({
+    schema_version: z.literal(1),
+    generated_at: z.string().datetime(),
+    status: z.enum(['ready', 'blocked', 'empty']),
+    plan: parallelFeatAutomationPlanSchema,
+    blocked_features: z.array(parallelFeatSchedulerBlockedFeatureSchema).default([]),
+    summary: z.object({
+        feature_count: z.number().int().nonnegative(),
+        scheduled_feature_count: z.number().int().nonnegative(),
+        done_feature_count: z.number().int().nonnegative(),
+        blocked_feature_count: z.number().int().nonnegative(),
+        wave_count: z.number().int().nonnegative(),
+    }),
+});
 export function buildParallelFeatAutomationPlan(input) {
     const request = parallelFeatAutomationRequestSchema.parse(input);
     const generatedAt = request.generated_at ?? new Date().toISOString();
@@ -98,6 +175,8 @@ export function buildParallelFeatAutomationPlan(input) {
             generated_at: generatedAt,
             status: 'empty',
             max_agents: request.max_agents,
+            state_boundary: PARALLEL_FEAT_STATE_BOUNDARY,
+            write_policy: buildWritePolicy(),
             rules: automationRules(request),
             waves: [],
             summary: {
@@ -124,6 +203,8 @@ export function buildParallelFeatAutomationPlan(input) {
         generated_at: generatedAt,
         status: blockedWaveCount > 0 ? 'blocked' : 'ready',
         max_agents: request.max_agents,
+        state_boundary: PARALLEL_FEAT_STATE_BOUNDARY,
+        write_policy: buildWritePolicy(),
         rules: automationRules(request),
         waves,
         summary: {
@@ -133,6 +214,85 @@ export function buildParallelFeatAutomationPlan(input) {
         },
     });
 }
+export function scheduleChainedFeatWaves(input) {
+    const request = parallelFeatSchedulerRequestSchema.parse(input);
+    const generatedAt = request.generated_at ?? new Date().toISOString();
+    const doneFeatureRefs = new Set(request.features
+        .filter((feature) => feature.status === 'DONE')
+        .map((feature) => feature.feature_ref));
+    const pendingFeatures = request.features.filter((feature) => feature.status !== 'DONE');
+    if (pendingFeatures.length === 0) {
+        const plan = buildParallelFeatAutomationPlan({
+            ...request,
+            generated_at: generatedAt,
+            features: [],
+            waves: [],
+        });
+        return parallelFeatSchedulerResultSchema.parse({
+            schema_version: 1,
+            generated_at: generatedAt,
+            status: 'empty',
+            plan,
+            blocked_features: [],
+            summary: {
+                feature_count: request.features.length,
+                scheduled_feature_count: 0,
+                done_feature_count: doneFeatureRefs.size,
+                blocked_feature_count: 0,
+                wave_count: 0,
+            },
+        });
+    }
+    const featureMap = new Map(request.features.map((feature) => [feature.feature_ref, feature]));
+    const scheduledFeatureRefs = new Set(doneFeatureRefs);
+    const unscheduled = new Map(pendingFeatures.map((feature) => [feature.feature_ref, feature]));
+    const waves = [];
+    while (unscheduled.size > 0) {
+        const candidates = [...unscheduled.values()].filter((feature) => getBlockingDependencies(feature, scheduledFeatureRefs, featureMap).length === 0);
+        if (candidates.length === 0) {
+            break;
+        }
+        const wave = selectConflictFreeWave(candidates, request.max_agents);
+        waves.push(wave.map((feature) => feature.feature_ref));
+        for (const feature of wave) {
+            scheduledFeatureRefs.add(feature.feature_ref);
+            unscheduled.delete(feature.feature_ref);
+        }
+    }
+    const scheduledFeatures = waves
+        .flat()
+        .map((featureRef) => featureMap.get(featureRef));
+    const blockedFeatures = [...unscheduled.values()].map((feature) => {
+        const blockedBy = getBlockingDependencies(feature, scheduledFeatureRefs, featureMap);
+        return parallelFeatSchedulerBlockedFeatureSchema.parse({
+            feature_ref: feature.feature_ref,
+            blocked_by: blockedBy,
+            reason: blockedBy.length > 0
+                ? `Waiting for unscheduled dependencies: ${blockedBy.join(', ')}.`
+                : 'Deferred because no dependency-safe execution slot was available.',
+        });
+    });
+    const plan = buildParallelFeatAutomationPlan({
+        ...request,
+        generated_at: generatedAt,
+        features: scheduledFeatures.map(toAutomationFeature),
+        waves,
+    });
+    return parallelFeatSchedulerResultSchema.parse({
+        schema_version: 1,
+        generated_at: generatedAt,
+        status: blockedFeatures.length > 0 ? 'blocked' : plan.status,
+        plan,
+        blocked_features: blockedFeatures,
+        summary: {
+            feature_count: request.features.length,
+            scheduled_feature_count: scheduledFeatures.length,
+            done_feature_count: doneFeatureRefs.size,
+            blocked_feature_count: blockedFeatures.length,
+            wave_count: waves.length,
+        },
+    });
+}
 function normalizeWaves(request) {
     const sourceWaves = request.waves.length > 0
         ? request.waves
@@ -177,6 +337,15 @@ function buildStep(feature, sequence, request) {
             commit_per_feature: request.require_commit_per_feature,
             commit_message: `feat(sdd): execute ${feature.feature_ref.toLowerCase()}`,
         },
+        state_boundary_ref: 'codesdd-canonical-sdd-state',
+        allowed_state_writes: [
+            `.sdd/active/${feature.feature_ref}/`,
+            `.sdd/archived/${feature.feature_ref}/`,
+            '.sdd/state/backlog.yaml',
+            '.sdd/state/finalize-queue.yaml',
+            '.sdd/state/transition-log.yaml',
+        ],
+        forbidden_state_writes: ['.codesdd/**', 'external-context/**'],
         evidence_required: [
             'focused_coverage',
             'build',
@@ -189,8 +358,17 @@ function buildStep(feature, sequence, request) {
         ],
     });
 }
+function buildWritePolicy() {
+    return {
+        allowed_root: '.sdd',
+        canonical_state_glob: '.sdd/state/*.yaml',
+        hidden_state_allowed: false,
+        external_state_allowed: false,
+    };
+}
 function automationRules(request) {
     return [
+        'state_boundary=codesdd-canonical-sdd-state',
         `max_agents=${request.max_agents}`,
         `clean_worktree_required=${request.require_clean_worktree}`,
         `commit_per_feature=${request.require_commit_per_feature}`,
@@ -209,4 +387,38 @@ function detectLockConflicts(features, waveIndex) {
         .filter(([, owners]) => owners.length > 1)
         .map(([lockDomain, owners]) => `wave ${waveIndex} lock ${lockDomain} shared by ${owners.join(', ')}`);
 }
+function getBlockingDependencies(feature, scheduledFeatureRefs, featureMap) {
+    return feature.blocked_by.filter((dependencyRef) => {
+        if (scheduledFeatureRefs.has(dependencyRef)) {
+            return false;
+        }
+        return featureMap.has(dependencyRef) || !scheduledFeatureRefs.has(dependencyRef);
+    });
+}
+function selectConflictFreeWave(candidates, maxAgents) {
+    const selected = [];
+    const selectedLockDomains = new Set();
+    for (const candidate of candidates) {
+        if (selected.length >= maxAgents) {
+            break;
+        }
+        const hasLockConflict = candidate.lock_domains.some((lockDomain) => selectedLockDomains.has(lockDomain));
+        if (hasLockConflict) {
+            continue;
+        }
+        selected.push(candidate);
+        for (const lockDomain of candidate.lock_domains) {
+            selectedLockDomains.add(lockDomain);
+        }
+    }
+    return selected;
+}
+function toAutomationFeature(feature) {
+    return {
+        feature_ref: feature.feature_ref,
+        title: feature.title,
+        recommended_skills: feature.recommended_skills,
+        lock_domains: feature.lock_domains,
+    };
+}
 //# sourceMappingURL=parallel-feat-automation.js.map