@workflow-cannon/workspace-kit 0.17.0 → 0.18.0

package/dist/core/config-metadata.js

@@ -69,6 +69,46 @@ const REGISTRY = {
         exposure: "public",
         writableLayers: ["project", "user"]
     },
+    "planning.defaultQuestionDepth": {
+        key: "planning.defaultQuestionDepth",
+        type: "string",
+        description: "Planning interview depth mode: minimal (critical only), guided (critical + static follow-ups), or adaptive (context-driven follow-ups).",
+        default: "adaptive",
+        allowedValues: ["minimal", "guided", "adaptive"],
+        domainScope: "project",
+        owningModule: "planning",
+        sensitive: false,
+        requiresRestart: false,
+        requiresApproval: false,
+        exposure: "maintainer",
+        writableLayers: ["project", "user"]
+    },
+    "planning.hardBlockCriticalUnknowns": {
+        key: "planning.hardBlockCriticalUnknowns",
+        type: "boolean",
+        description: "When true, planning finalize requests fail until critical unknown questions are answered.",
+        default: true,
+        domainScope: "project",
+        owningModule: "planning",
+        sensitive: false,
+        requiresRestart: false,
+        requiresApproval: false,
+        exposure: "maintainer",
+        writableLayers: ["project", "user"]
+    },
+    "planning.rulePacks": {
+        key: "planning.rulePacks",
+        type: "object",
+        description: "Optional object overrides for planning rule packs by workflow type (`baseQuestions` and `adaptiveQuestions`).",
+        default: {},
+        domainScope: "project",
+        owningModule: "planning",
+        sensitive: false,
+        requiresRestart: false,
+        requiresApproval: false,
+        exposure: "maintainer",
+        writableLayers: ["project", "user"]
+    },
     "policy.extraSensitiveModuleCommands": {
         key: "policy.extraSensitiveModuleCommands",
         type: "array",

package/dist/core/workspace-kit-config.js

@@ -46,7 +46,11 @@ export const KIT_CONFIG_DEFAULTS = {
  */
 export const MODULE_CONFIG_CONTRIBUTIONS = {
     approvals: {},
-    planning: {}
+    planning: {
+        defaultQuestionDepth: "adaptive",
+        hardBlockCriticalUnknowns: true,
+        rulePacks: {}
+    }
 };
 export function deepMerge(target, source) {
     const out = { ...target };

package/dist/modules/planning/artifact.d.ts

@@ -0,0 +1,19 @@
+import type { PlanningWorkflowType } from "./types.js";
+export type PlanningWishlistArtifact = {
+    schemaVersion: 1;
+    planningType: PlanningWorkflowType;
+    generatedAt: string;
+    goals: string[];
+    approach: string;
+    majorTechnicalDecisions: string[];
+    candidateFeaturesOrChanges: string[];
+    assumptions: string[];
+    openQuestions: string[];
+    risksAndConstraints: string[];
+    sourceAnswers: Record<string, string>;
+};
+export declare function composePlanningWishlistArtifact(args: {
+    planningType: PlanningWorkflowType;
+    answers: Record<string, unknown>;
+    unresolvedCriticalQuestionIds: string[];
+}): PlanningWishlistArtifact;

package/dist/modules/planning/artifact.js

@@ -0,0 +1,72 @@
+function answer(answers, key, fallback) {
+    const value = answers[key];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return fallback;
+    }
+    return value.trim();
+}
+function list(answers, key) {
+    const value = answers[key];
+    if (Array.isArray(value)) {
+        return value.filter((x) => typeof x === "string" && x.trim().length > 0).map((x) => x.trim());
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        return [value.trim()];
+    }
+    return [];
+}
+export function composePlanningWishlistArtifact(args) {
+    const { planningType, answers, unresolvedCriticalQuestionIds } = args;
+    const sourceAnswers = {};
+    for (const [key, value] of Object.entries(answers)) {
+        if (typeof value === "string" && value.trim().length > 0) {
+            sourceAnswers[key] = value.trim();
+        }
+    }
+    const goals = list(answers, "goals");
+    if (goals.length === 0) {
+        const inferredGoal = answer(answers, "goal", "") ||
+            answer(answers, "featureGoal", "") ||
+            answer(answers, "changeGoal", "");
+        if (inferredGoal)
+            goals.push(inferredGoal);
+    }
+    const candidate = list(answers, "candidateFeaturesOrChanges");
+    if (candidate.length === 0) {
+        const inferred = answer(answers, "scope", "");
+        if (inferred)
+            candidate.push(inferred);
+    }
+    const majorTechnicalDecisions = list(answers, "majorTechnicalDecisions");
+    const decisionRationale = answer(answers, "decisionRationale", "");
+    if (decisionRationale && majorTechnicalDecisions.length === 0) {
+        majorTechnicalDecisions.push(decisionRationale);
+    }
+    const assumptions = list(answers, "assumptions");
+    const openQuestions = [
+        ...list(answers, "openQuestions"),
+        ...unresolvedCriticalQuestionIds.map((id) => `Unresolved critical question: ${id}`)
+    ];
+    const risksAndConstraints = list(answers, "risksAndConstraints");
+    const constraints = answer(answers, "constraints", "");
+    if (constraints) {
+        risksAndConstraints.push(`Constraint: ${constraints}`);
+    }
+    const riskPriority = answer(answers, "riskPriority", "");
+    if (riskPriority) {
+        risksAndConstraints.push(`Risk priority: ${riskPriority}`);
+    }
+    return {
+        schemaVersion: 1,
+        planningType,
+        generatedAt: new Date().toISOString(),
+        goals,
+        approach: answer(answers, "approach", "Context-driven workflow guided by planning rules."),
+        majorTechnicalDecisions,
+        candidateFeaturesOrChanges: candidate,
+        assumptions,
+        openQuestions,
+        risksAndConstraints,
+        sourceAnswers
+    };
+}

package/dist/modules/planning/index.js

@@ -1,3 +1,36 @@
+import { PLANNING_WORKFLOW_DESCRIPTORS, PLANNING_WORKFLOW_TYPES } from "./types.js";
+import { nextPlanningQuestions, resolvePlanningConfig, resolvePlanningRulePack } from "./question-engine.js";
+import { composePlanningWishlistArtifact } from "./artifact.js";
+import { openPlanningStores } from "../task-engine/planning-open.js";
+import { buildWishlistItemFromIntake, validateWishlistIntakePayload } from "../task-engine/wishlist-validation.js";
+function nextWishlistId(items) {
+    let max = 0;
+    for (const item of items) {
+        const match = /^W(\d+)$/.exec(item.id);
+        if (!match)
+            continue;
+        const parsed = Number(match[1]);
+        if (Number.isFinite(parsed)) {
+            max = Math.max(max, parsed);
+        }
+    }
+    return `W${max + 1}`;
+}
+function toCliGuidance(args) {
+    const { planningType, answers, unresolvedCriticalCount, totalCriticalCount, finalize } = args;
+    const answeredCritical = Math.max(0, totalCriticalCount - unresolvedCriticalCount);
+    const completionPct = totalCriticalCount > 0 ? Math.round((answeredCritical / totalCriticalCount) * 100) : 100;
+    return {
+        answeredCritical,
+        totalCritical: totalCriticalCount,
+        completionPct,
+        suggestedNextCommand: `workspace-kit run build-plan '${JSON.stringify({
+            planningType,
+            answers,
+            finalize: finalize === true
+        })}'`
+    };
+}
 export const planningModule = {
     registration: {
         id: "planning",
@@ -23,8 +56,240 @@ export const planningModule = {
                     name: "build-plan",
                     file: "build-plan.md",
                     description: "Generate a dependency-aware execution plan."
+                },
+                {
+                    name: "list-planning-types",
+                    file: "list-planning-types.md",
+                    description: "List supported planning workflow types and their intent."
+                },
+                {
+                    name: "explain-planning-rules",
+                    file: "explain-planning-rules.md",
+                    description: "Explain effective planning defaults and rule packs for a workflow type."
                 }
             ]
         }
+    },
+    async onCommand(command, ctx) {
+        if (command.name === "list-planning-types") {
+            return {
+                ok: true,
+                code: "planning-types-listed",
+                message: `Found ${PLANNING_WORKFLOW_DESCRIPTORS.length} planning workflow types`,
+                data: {
+                    planningTypes: PLANNING_WORKFLOW_DESCRIPTORS
+                }
+            };
+        }
+        if (command.name === "build-plan") {
+            const args = command.args ?? {};
+            const planningType = typeof args.planningType === "string" ? args.planningType.trim() : "";
+            if (!PLANNING_WORKFLOW_TYPES.includes(planningType)) {
+                return {
+                    ok: false,
+                    code: "invalid-planning-type",
+                    message: "build-plan requires planningType of: task-breakdown, sprint-phase, task-ordering, new-feature, change"
+                };
+            }
+            const descriptor = PLANNING_WORKFLOW_DESCRIPTORS.find((x) => x.type === planningType);
+            const resolvedRulePack = resolvePlanningRulePack(planningType, ctx.effectiveConfig);
+            const totalCriticalCount = resolvedRulePack.baseQuestions.length;
+            const answers = typeof args.answers === "object" && args.answers !== null && !Array.isArray(args.answers)
+                ? args.answers
+                : {};
+            const createWishlist = args.createWishlist !== false;
+            const finalize = args.finalize === true;
+            const { missingCritical, adaptiveFollowups } = nextPlanningQuestions(planningType, answers, ctx.effectiveConfig);
+            const config = resolvePlanningConfig(ctx.effectiveConfig);
+            if (finalize && missingCritical.length > 0) {
+                if (!config.hardBlockCriticalUnknowns) {
+                    return {
+                        ok: true,
+                        code: "planning-ready-with-warnings",
+                        message: `Finalize allowed with unresolved critical questions because planning.hardBlockCriticalUnknowns=false`,
+                        data: {
+                            planningType,
+                            status: "ready-with-warnings",
+                            unresolvedCritical: missingCritical,
+                            nextQuestions: [...missingCritical, ...adaptiveFollowups],
+                            capturedAnswers: answers,
+                            cliGuidance: toCliGuidance({
+                                planningType,
+                                answers,
+                                unresolvedCriticalCount: missingCritical.length,
+                                totalCriticalCount
+                            })
+                        }
+                    };
+                }
+                return {
+                    ok: false,
+                    code: "planning-critical-unknowns",
+                    message: `Cannot finalize ${planningType}: unresolved critical questions (${missingCritical.map((q) => q.id).join(", ")})`,
+                    data: {
+                        planningType,
+                        unresolvedCritical: missingCritical,
+                        nextQuestions: [...missingCritical, ...adaptiveFollowups],
+                        cliGuidance: toCliGuidance({
+                            planningType,
+                            answers,
+                            unresolvedCriticalCount: missingCritical.length,
+                            totalCriticalCount,
+                            finalize: true
+                        })
+                    }
+                };
+            }
+            if (missingCritical.length > 0) {
+                return {
+                    ok: true,
+                    code: "planning-questions",
+                    message: `${missingCritical.length} critical planning questions require answers before finalize`,
+                    data: {
+                        planningType,
+                        status: "needs-input",
+                        unresolvedCritical: missingCritical,
+                        nextQuestions: [...missingCritical, ...adaptiveFollowups],
+                        cliGuidance: toCliGuidance({
+                            planningType,
+                            answers,
+                            unresolvedCriticalCount: missingCritical.length,
+                            totalCriticalCount
+                        })
+                    }
+                };
+            }
+            const unresolvedIds = missingCritical.map((q) => q.id);
+            const artifact = composePlanningWishlistArtifact({
+                planningType: planningType,
+                answers,
+                unresolvedCriticalQuestionIds: unresolvedIds
+            });
+            if (!finalize || !createWishlist) {
+                return {
+                    ok: true,
+                    code: "planning-ready",
+                    message: `Planning interview complete for ${planningType}; artifact ready`,
+                    data: {
+                        planningType,
+                        descriptor,
+                        scaffoldVersion: 3,
+                        status: "ready-for-artifact",
+                        unresolvedCritical: [],
+                        adaptiveFollowups,
+                        capturedAnswers: answers,
+                        artifact,
+                        cliGuidance: toCliGuidance({
+                            planningType,
+                            answers,
+                            unresolvedCriticalCount: 0,
+                            totalCriticalCount,
+                            finalize: createWishlist
+                        })
+                    }
+                };
+            }
+            const stores = await openPlanningStores(ctx);
+            const wishlist = await stores.openWishlist();
+            const wishlistId = nextWishlistId(wishlist.getAllItems());
+            const now = new Date().toISOString();
+            const intake = {
+                id: wishlistId,
+                title: typeof args.title === "string" && args.title.trim().length > 0
+                    ? args.title.trim()
+                    : `${descriptor?.title ?? planningType} plan artifact`,
+                problemStatement: typeof answers.problemStatement === "string"
+                    ? answers.problemStatement
+                    : typeof answers.featureGoal === "string"
+                        ? answers.featureGoal
+                        : "Planning artifact generated from guided workflow.",
+                expectedOutcome: typeof answers.expectedOutcome === "string"
+                    ? answers.expectedOutcome
+                    : "Clear, reviewable planning artifact for execution decomposition.",
+                impact: typeof answers.impact === "string" ? answers.impact : "Improved planning quality and delivery confidence.",
+                constraints: typeof answers.constraints === "string"
+                    ? answers.constraints
+                    : artifact.risksAndConstraints.join("; ") || "None explicitly provided.",
+                successSignals: typeof answers.successSignals === "string"
+                    ? answers.successSignals
+                    : "Critical questions answered and artifact accepted by operators.",
+                requestor: typeof args.requestor === "string" && args.requestor.trim().length > 0
+                    ? args.requestor.trim()
+                    : ctx.resolvedActor ?? "planning-module",
+                evidenceRef: typeof args.evidenceRef === "string" && args.evidenceRef.trim().length > 0
+                    ? args.evidenceRef.trim()
+                    : `planning:${planningType}:${now}`
+            };
+            const valid = validateWishlistIntakePayload(intake);
+            if (!valid.ok) {
+                return {
+                    ok: false,
+                    code: "invalid-planning-artifact",
+                    message: valid.errors.join("; ")
+                };
+            }
+            const item = buildWishlistItemFromIntake(intake, now);
+            item.updatedAt = now;
+            item.metadata = {
+                planningType,
+                artifactSchemaVersion: artifact.schemaVersion,
+                artifact
+            };
+            wishlist.addItem(item);
+            await wishlist.save();
+            return {
+                ok: true,
+                code: "planning-artifact-created",
+                message: `Planning artifact created as wishlist item ${wishlistId}`,
+                data: {
+                    planningType,
+                    descriptor,
+                    scaffoldVersion: 3,
+                    status: "artifact-created",
+                    wishlistId,
+                    artifact,
+                    unresolvedCritical: [],
+                    adaptiveFollowups,
+                    capturedAnswers: answers,
+                    cliGuidance: toCliGuidance({
+                        planningType,
+                        answers,
+                        unresolvedCriticalCount: 0,
+                        totalCriticalCount,
+                        finalize: true
+                    })
+                }
+            };
+        }
+        if (command.name === "explain-planning-rules") {
+            const args = command.args ?? {};
+            const planningType = typeof args.planningType === "string" ? args.planningType.trim() : "";
+            if (!PLANNING_WORKFLOW_TYPES.includes(planningType)) {
+                return {
+                    ok: false,
+                    code: "invalid-planning-type",
+                    message: "explain-planning-rules requires planningType of: task-breakdown, sprint-phase, task-ordering, new-feature, change"
+                };
+            }
+            const config = resolvePlanningConfig(ctx.effectiveConfig);
+            const rulePack = resolvePlanningRulePack(planningType, ctx.effectiveConfig);
+            return {
+                ok: true,
+                code: "planning-rules-explained",
+                message: `Effective planning rules for ${planningType}`,
+                data: {
+                    planningType,
+                    defaultQuestionDepth: config.depth,
+                    hardBlockCriticalUnknowns: config.hardBlockCriticalUnknowns,
+                    baseQuestions: rulePack.baseQuestions,
+                    adaptiveQuestions: rulePack.adaptiveQuestions
+                }
+            };
+        }
+        return {
+            ok: false,
+            code: "unsupported-command",
+            message: `Planning module does not support command '${command.name}'`
+        };
     }
 };

package/dist/modules/planning/question-engine.d.ts

@@ -0,0 +1,23 @@
+import { type PlanningWorkflowType } from "./types.js";
+export type PlanningQuestion = {
+    id: string;
+    prompt: string;
+    examples: string[];
+    whyItMatters: string;
+    critical: boolean;
+};
+export type PlanningQuestionDepth = "minimal" | "guided" | "adaptive";
+export type PlanningRulePack = {
+    baseQuestions: PlanningQuestion[];
+    adaptiveQuestions: PlanningQuestion[];
+};
+export declare function resolvePlanningConfig(config: Record<string, unknown> | undefined): {
+    depth: PlanningQuestionDepth;
+    hardBlockCriticalUnknowns: boolean;
+    rulePacks: Partial<Record<PlanningWorkflowType, PlanningRulePack>>;
+};
+export declare function resolvePlanningRulePack(planningType: PlanningWorkflowType, config: Record<string, unknown> | undefined): PlanningRulePack;
+export declare function nextPlanningQuestions(planningType: PlanningWorkflowType, answers: Record<string, unknown>, config?: Record<string, unknown>): {
+    missingCritical: PlanningQuestion[];
+    adaptiveFollowups: PlanningQuestion[];
+};

package/dist/modules/planning/question-engine.js

@@ -0,0 +1,277 @@
+const BASE_QUESTIONS = {
+    "task-breakdown": [
+        {
+            id: "goal",
+            prompt: "What is the primary goal of this work?",
+            examples: ["Improve release reliability", "Deliver planning module CLI flow"],
+            whyItMatters: "Clarifies what success looks like before decomposition.",
+            critical: true
+        },
+        {
+            id: "constraints",
+            prompt: "What constraints must we respect?",
+            examples: ["No breaking changes", "Single release", "CLI-first"],
+            whyItMatters: "Prevents planning paths that cannot be delivered safely.",
+            critical: true
+        },
+        {
+            id: "successSignals",
+            prompt: "How will we know the plan worked?",
+            examples: ["All gates pass", "Operators complete flow in under 5 minutes"],
+            whyItMatters: "Anchors acceptance criteria and evidence quality.",
+            critical: true
+        }
+    ],
+    "sprint-phase": [
+        {
+            id: "goal",
+            prompt: "What is the phase objective?",
+            examples: ["Ship planning module v1", "Complete stabilization hardening"],
+            whyItMatters: "Defines what this phase must deliver.",
+            critical: true
+        },
+        {
+            id: "timeline",
+            prompt: "What timeline window should this phase target?",
+            examples: ["Single release train", "Two sprint sequence"],
+            whyItMatters: "Sets ordering and scope pressure explicitly.",
+            critical: true
+        },
+        {
+            id: "criticalPath",
+            prompt: "What dependencies define the critical path?",
+            examples: ["Scaffold before adaptive engine", "Rules before artifact generation"],
+            whyItMatters: "Avoids deadlocks and unrealistic sequencing.",
+            critical: true
+        }
+    ],
+    "task-ordering": [
+        {
+            id: "goal",
+            prompt: "What outcome should ordering optimize for?",
+            examples: ["Risk reduction first", "Fastest path to demo"],
+            whyItMatters: "Provides ranking criteria for sequencing choices.",
+            critical: true
+        },
+        {
+            id: "dependencyIntent",
+            prompt: "What dependency constraints are mandatory?",
+            examples: ["T347 depends on T345", "Validation follows schema contracts"],
+            whyItMatters: "Ensures ordering respects hard blockers.",
+            critical: true
+        },
+        {
+            id: "riskPriority",
+            prompt: "Which risks should be front-loaded?",
+            examples: ["Policy approval edge cases", "Migration complexity"],
+            whyItMatters: "Improves confidence and rollback safety.",
+            critical: true
+        }
+    ],
+    "new-feature": [
+        {
+            id: "featureGoal",
+            prompt: "What user problem should the feature solve?",
+            examples: ["Guide planning interviews", "Improve dashboard visibility"],
+            whyItMatters: "Prevents building features disconnected from need.",
+            critical: true
+        },
+        {
+            id: "placement",
+            prompt: "Where should this feature be surfaced?",
+            examples: ["CLI command", "Extension dashboard panel", "Admin-only view"],
+            whyItMatters: "Drives architecture, permissions, and UX decisions.",
+            critical: true
+        },
+        {
+            id: "technology",
+            prompt: "What technology/runtime constraints apply?",
+            examples: ["TypeScript + CLI runtime", "No new native dependencies"],
+            whyItMatters: "Bounds implementation options early.",
+            critical: true
+        },
+        {
+            id: "targetAudience",
+            prompt: "Who is the target audience?",
+            examples: ["AI Agent Operators", "Developers", "Maintainers"],
+            whyItMatters: "Shapes defaults and interaction style.",
+            critical: true
+        }
+    ],
+    "change": [
+        {
+            id: "changeGoal",
+            prompt: "What behavior or system change is needed?",
+            examples: ["Replace brittle flow", "Refactor planning config handling"],
+            whyItMatters: "Separates desired outcome from implementation details.",
+            critical: true
+        },
+        {
+            id: "compatibilityRisk",
+            prompt: "What compatibility risks exist?",
+            examples: ["CLI contract changes", "state schema shifts"],
+            whyItMatters: "Supports migration-safe release planning.",
+            critical: true
+        },
+        {
+            id: "rollbackPlan",
+            prompt: "What rollback strategy is available?",
+            examples: ["Feature flag off switch", "Revert to prior command behavior"],
+            whyItMatters: "Maintains trustworthiness under failure.",
+            critical: true
+        }
+    ]
+};
+const BASE_ADAPTIVE_QUESTIONS = {
+    "task-breakdown": [
+        {
+            id: "handoffRisk",
+            prompt: "Where is handoff risk highest in this breakdown?",
+            examples: ["Schema-to-runtime boundary", "CLI-to-extension behavior"],
+            whyItMatters: "Highlights where extra tests or review checks are needed.",
+            critical: false
+        }
+    ],
+    "sprint-phase": [
+        {
+            id: "phaseExitSignal",
+            prompt: "What is the explicit exit signal for this phase?",
+            examples: ["All tasks completed and release gates pass", "PR merged with parity evidence"],
+            whyItMatters: "Prevents ambiguous “done” states.",
+            critical: false
+        }
+    ],
+    "task-ordering": [
+        {
+            id: "parallelization",
+            prompt: "Which work items can run in parallel safely?",
+            examples: ["Docs in parallel with runtime hardening", "UI after API contracts are stable"],
+            whyItMatters: "Improves throughput without violating dependencies.",
+            critical: false
+        }
+    ],
+    "new-feature": [
+        {
+            id: "decisionRationale",
+            prompt: "What major technical decision is most likely and why?",
+            examples: ["CLI-first before UI for safer rollout", "Reuse existing module config patterns"],
+            whyItMatters: "Captures rationale for later review and refinement.",
+            critical: false
+        }
+    ],
+    "change": [
+        {
+            id: "migrationNotes",
+            prompt: "What migration or rollout notes should operators receive?",
+            examples: ["No migration required", "Enable setting X before command Y"],
+            whyItMatters: "Protects compatibility and operator trust.",
+            critical: false
+        }
+    ]
+};
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function parseQuestionList(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const parsed = [];
+    for (const entry of value) {
+        const row = asRecord(entry);
+        if (!row)
+            continue;
+        const id = typeof row.id === "string" ? row.id.trim() : "";
+        const prompt = typeof row.prompt === "string" ? row.prompt.trim() : "";
+        const whyItMatters = typeof row.whyItMatters === "string" ? row.whyItMatters.trim() : "";
+        if (!id || !prompt || !whyItMatters)
+            continue;
+        parsed.push({
+            id,
+            prompt,
+            whyItMatters,
+            examples: Array.isArray(row.examples)
+                ? row.examples.filter((x) => typeof x === "string")
+                : [],
+            critical: row.critical === true
+        });
+    }
+    return parsed;
+}
+function parseDepth(value) {
+    if (value === "minimal" || value === "guided" || value === "adaptive") {
+        return value;
+    }
+    return "adaptive";
+}
+export function resolvePlanningConfig(config) {
+    const planning = asRecord(config?.planning);
+    const depth = parseDepth(planning?.defaultQuestionDepth);
+    const hardBlockCriticalUnknowns = planning?.hardBlockCriticalUnknowns !== false;
+    const rulesRoot = asRecord(planning?.rulePacks);
+    const rulePacks = {};
+    if (rulesRoot) {
+        for (const workflowType of Object.keys(BASE_QUESTIONS)) {
+            const pack = asRecord(rulesRoot[workflowType]);
+            if (!pack)
+                continue;
+            const baseQuestions = parseQuestionList(pack.baseQuestions);
+            const adaptiveQuestions = parseQuestionList(pack.adaptiveQuestions);
+            if (baseQuestions.length === 0 && adaptiveQuestions.length === 0)
+                continue;
+            rulePacks[workflowType] = {
+                baseQuestions: baseQuestions.length > 0 ? baseQuestions : BASE_QUESTIONS[workflowType],
+                adaptiveQuestions
+            };
+        }
+    }
+    return { depth, hardBlockCriticalUnknowns, rulePacks };
+}
+export function resolvePlanningRulePack(planningType, config) {
+    const resolved = resolvePlanningConfig(config);
+    const override = resolved.rulePacks[planningType];
+    return {
+        baseQuestions: override?.baseQuestions ?? BASE_QUESTIONS[planningType],
+        adaptiveQuestions: override?.adaptiveQuestions ?? BASE_ADAPTIVE_QUESTIONS[planningType]
+    };
+}
+export function nextPlanningQuestions(planningType, answers, config) {
+    const { depth } = resolvePlanningConfig(config);
+    const rules = resolvePlanningRulePack(planningType, config);
+    const base = rules.baseQuestions;
+    const missingCritical = base.filter((q) => {
+        const value = answers[q.id];
+        return !(typeof value === "string" && value.trim().length > 0);
+    });
+    if (depth === "minimal") {
+        return { missingCritical, adaptiveFollowups: [] };
+    }
+    const adaptiveFollowups = [...rules.adaptiveQuestions];
+    if (depth === "guided") {
+        return { missingCritical, adaptiveFollowups };
+    }
+    const complexity = typeof answers.complexity === "string" ? answers.complexity.toLowerCase() : "";
+    if (complexity === "high") {
+        adaptiveFollowups.push({
+            id: "mitigationPlan",
+            prompt: "What mitigation strategy addresses high complexity risks?",
+            examples: ["Ship in slices", "Add parity checks before release"],
+            whyItMatters: "Reduces probability of destabilizing execution.",
+            critical: false
+        });
+    }
+    if (planningType === "new-feature" && !answers["decisionRationale"]) {
+        if (!adaptiveFollowups.some((q) => q.id === "decisionRationale")) {
+            adaptiveFollowups.push({
+                id: "decisionRationale",
+                prompt: "What major technical decision is most likely and why?",
+                examples: ["CLI-first before UI for safer rollout", "Reuse existing module config patterns"],
+                whyItMatters: "Captures rationale for later review and refinement.",
+                critical: false
+            });
+        }
+    }
+    return { missingCritical, adaptiveFollowups };
+}

package/dist/modules/planning/types.d.ts

@@ -0,0 +1,9 @@
+export declare const PLANNING_WORKFLOW_TYPES: readonly ["task-breakdown", "sprint-phase", "task-ordering", "new-feature", "change"];
+export type PlanningWorkflowType = (typeof PLANNING_WORKFLOW_TYPES)[number];
+export type PlanningWorkflowDescriptor = {
+    type: PlanningWorkflowType;
+    title: string;
+    description: string;
+    outcomeFocus: string;
+};
+export declare const PLANNING_WORKFLOW_DESCRIPTORS: PlanningWorkflowDescriptor[];

package/dist/modules/planning/types.js

@@ -0,0 +1,39 @@
+export const PLANNING_WORKFLOW_TYPES = [
+    "task-breakdown",
+    "sprint-phase",
+    "task-ordering",
+    "new-feature",
+    "change"
+];
+export const PLANNING_WORKFLOW_DESCRIPTORS = [
+    {
+        type: "task-breakdown",
+        title: "Task Breakdown",
+        description: "Break work into coherent, reviewable slices with explicit acceptance criteria.",
+        outcomeFocus: "Clear decomposition into actionable units."
+    },
+    {
+        type: "sprint-phase",
+        title: "Sprint / Phase Plan",
+        description: "Define phase goals, sequencing, and completion checkpoints.",
+        outcomeFocus: "Time-ordered delivery framing with clear phase boundaries."
+    },
+    {
+        type: "task-ordering",
+        title: "Task Ordering",
+        description: "Prioritize and sequence tasks with dependency awareness.",
+        outcomeFocus: "Deterministic ordering with explicit dependency intent."
+    },
+    {
+        type: "new-feature",
+        title: "New Feature",
+        description: "Guide discovery for new feature goals, architecture choices, and rollout fit.",
+        outcomeFocus: "High-confidence feature direction and constraints."
+    },
+    {
+        type: "change",
+        title: "Change / Refactor",
+        description: "Assess behavior-impacting changes and migration/compatibility risks.",
+        outcomeFocus: "Safe, justified change plan with risk controls."
+    }
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow-cannon/workspace-kit",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "private": false,
   "packageManager": "pnpm@10.0.0",
   "license": "MIT",

package/schemas/task-engine-run-contracts.schema.json

@@ -6,13 +6,13 @@
   "type": "object",
   "required": ["schemaVersion", "packageVersion", "moduleId", "commands"],
   "additionalProperties": false,
-  "packageVersion": "0.17.0",
+  "packageVersion": "0.18.0",
   "properties": {
     "schemaVersion": {
       "const": 1
     },
     "packageVersion": {
-      "const": "0.17.0",
+      "const": "0.18.0",
       "description": "Must match package.json version."
     },
     "moduleId": {