@veewo/claw-core 0.1.62 → 0.1.63

package/dist/src/plan-templates.js

@@ -1,26 +1,81 @@
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { ClawError } from "./errors.js";
-import { defaultPlanTemplate } from "./templates/plans/default.js";
-const PLAN_TEMPLATES = [defaultPlanTemplate];
+import { defaultPlanTemplate, } from "./templates/plans/default.js";
+const PLAN_TEMPLATES = [normalizePlanLikeTemplate(defaultPlanTemplate, { source: "builtin" })];
 export async function resolveSeedPlanTemplate(params) {
     const normalized = params.templateName?.trim().toLowerCase() || defaultPlanTemplate.id;
-    const projectTemplate = params.projectRoot ? await loadProjectSeedTemplate(params.projectRoot, normalized) : null;
+    const projectTemplate = params.projectRoot ? await loadProjectPlanTemplate(params.projectRoot, normalized) : null;
     if (projectTemplate) {
         return projectTemplate;
     }
-    const match = PLAN_TEMPLATES.find((template) => template.id.toLowerCase() === normalized || template.aliases.some((alias) => alias.toLowerCase() === normalized));
+    const projectSkillTemplate = params.projectRoot ? await loadProjectSkillPlanTemplate(params.projectRoot, normalized) : null;
+    if (projectSkillTemplate) {
+        return projectSkillTemplate;
+    }
+    const projectPackageTemplate = params.projectRoot ? await loadProjectPackagePlanTemplate(params.projectRoot, normalized) : null;
+    if (projectPackageTemplate) {
+        return projectPackageTemplate;
+    }
+    const globalTemplate = await loadGlobalPlanTemplate(normalized);
+    if (globalTemplate) {
+        return globalTemplate;
+    }
+    const globalSkillTemplate = await loadGlobalSkillPlanTemplate(normalized);
+    if (globalSkillTemplate) {
+        return globalSkillTemplate;
+    }
+    const globalPackageTemplate = await loadGlobalPackagePlanTemplate(normalized);
+    if (globalPackageTemplate) {
+        return globalPackageTemplate;
+    }
+    const match = PLAN_TEMPLATES.find((template) => template.id.toLowerCase() === normalized);
     if (!match) {
         throw new ClawError("PROJECT_CONFIG_INVALID", `Unknown plan template "${params.templateName ?? normalized}".`, {
             templateName: params.templateName ?? normalized,
-            availableTemplates: PLAN_TEMPLATES.flatMap((template) => [template.id, ...template.aliases]),
+            availableTemplates: PLAN_TEMPLATES.map((template) => template.id),
         });
     }
     return match;
 }
-async function loadProjectSeedTemplate(projectRoot, normalizedTemplateName) {
-    const templatesDir = path.join(projectRoot, ".claw", "templates");
+export async function resolvePlanTemplateFile(templatePath) {
+    const raw = templatePath.endsWith(".json")
+        ? JSON.parse(fs.readFileSync(templatePath, "utf-8"))
+        : await import(pathToFileURL(templatePath).href).then((module) => module.default ?? module);
+    return validatePlanTemplateSource(raw, templatePath, "project");
+}
+export function validatePlanTemplateSource(raw, templatePath, source = "project") {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid plan template at ${templatePath}.`, {
+            templatePath,
+        });
+    }
+    return normalizePlanLikeTemplate(validatePlanLikeTemplate(raw, templatePath), {
+        source,
+        templatePath: source === "project" ? templatePath : undefined,
+    });
+}
+async function loadProjectPlanTemplate(projectRoot, normalizedTemplateName) {
+    return loadPlanTemplateFromDirectory(path.join(projectRoot, ".claw", "templates"), normalizedTemplateName);
+}
+async function loadProjectSkillPlanTemplate(projectRoot, normalizedTemplateName) {
+    return loadPlanTemplateFromSkillRoots(resolveProjectSkillRoots(projectRoot), normalizedTemplateName);
+}
+async function loadProjectPackagePlanTemplate(projectRoot, normalizedTemplateName) {
+    return loadPlanTemplateFromTemplateDirs(resolveProjectPackageTemplateDirs(projectRoot), normalizedTemplateName);
+}
+async function loadGlobalPlanTemplate(normalizedTemplateName) {
+    return loadPlanTemplateFromDirectory(path.join(os.homedir(), ".claw", "templates"), normalizedTemplateName);
+}
+async function loadGlobalSkillPlanTemplate(normalizedTemplateName) {
+    return loadPlanTemplateFromSkillRoots(resolveGlobalSkillRoots(), normalizedTemplateName);
+}
+async function loadGlobalPackagePlanTemplate(normalizedTemplateName) {
+    return loadPlanTemplateFromTemplateDirs(resolveGlobalPackageTemplateDirs(), normalizedTemplateName);
+}
+async function loadPlanTemplateFromDirectory(templatesDir, normalizedTemplateName) {
     if (!fs.existsSync(templatesDir)) {
         return null;
     }
@@ -40,34 +95,533 @@ async function loadProjectSeedTemplate(projectRoot, normalizedTemplateName) {
             candidatePaths: candidateEntries.map((entryName) => path.join(templatesDir, entryName)),
         });
     }
-    const templatePath = path.join(templatesDir, candidateEntries[0]);
-    const raw = templatePath.endsWith(".json")
-        ? JSON.parse(fs.readFileSync(templatePath, "utf-8"))
-        : await import(pathToFileURL(templatePath).href).then((module) => module.default ?? module);
-    return validateSeedPlanTemplate(raw, templatePath);
+    return resolvePlanTemplateFile(path.join(templatesDir, candidateEntries[0]));
 }
-function validateSeedPlanTemplate(raw, templatePath) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid plan template at ${templatePath}.`, {
-            templatePath,
+async function loadPlanTemplateFromTemplateDirs(templateDirs, normalizedTemplateName) {
+    const matches = [];
+    for (const templateDir of templateDirs) {
+        const match = await loadPlanTemplateFromDirectory(templateDir, normalizedTemplateName);
+        if (match?.templatePath) {
+            matches.push(match.templatePath);
+        }
+    }
+    if (matches.length > 1) {
+        throw new ClawError("PROJECT_CONFIG_INVALID", `Multiple package plan templates matched "${normalizedTemplateName}".`, {
+            templateName: normalizedTemplateName,
+            candidatePaths: matches,
+        });
+    }
+    return matches.length === 1 ? resolvePlanTemplateFile(matches[0]) : null;
+}
+async function loadPlanTemplateFromSkillRoots(skillRoots, normalizedTemplateName) {
+    const matches = [];
+    for (const skillRoot of skillRoots) {
+        for (const templatePath of collectSkillTemplateFiles(skillRoot)) {
+            const template = await resolvePlanTemplateFile(templatePath);
+            if (template.id.toLowerCase() === normalizedTemplateName) {
+                matches.push({ path: templatePath, signature: signatureForTemplateConflict(template) });
+            }
+        }
+    }
+    if (matches.length > 1) {
+        const uniqueSignatures = new Set(matches.map((match) => match.signature));
+        if (uniqueSignatures.size === 1) {
+            return resolvePlanTemplateFile(matches[0].path);
+        }
+        throw new ClawError("PROJECT_CONFIG_INVALID", `Multiple skill-local plan templates matched "${normalizedTemplateName}".`, {
+            templateName: normalizedTemplateName,
+            candidatePaths: matches.map((match) => match.path),
         });
     }
+    return matches.length === 1 ? resolvePlanTemplateFile(matches[0].path) : null;
+}
+function signatureForTemplateConflict(template) {
+    const { source: _source, templatePath: _templatePath, ...portableTemplate } = template;
+    return JSON.stringify(portableTemplate);
+}
+function resolveProjectSkillRoots(projectRoot) {
+    const roots = [path.join(projectRoot, "skills")];
+    const packagesDir = path.join(projectRoot, "packages");
+    if (!fs.existsSync(packagesDir)) {
+        return roots;
+    }
+    for (const entry of fs.readdirSync(packagesDir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        roots.push(path.join(packagesDir, entry.name, "skills"));
+    }
+    return roots;
+}
+function resolveProjectPackageTemplateDirs(projectRoot) {
+    const templateDirs = [];
+    const packagesDir = path.join(projectRoot, "packages");
+    if (!fs.existsSync(packagesDir)) {
+        return templateDirs;
+    }
+    for (const entry of fs.readdirSync(packagesDir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        templateDirs.push(path.join(packagesDir, entry.name, "templates"));
+    }
+    return templateDirs;
+}
+function resolveGlobalSkillRoots() {
+    const homeDir = os.homedir();
+    const roots = [
+        path.join(homeDir, ".agents", "skills"),
+        path.join(homeDir, ".codex", "skills"),
+    ];
+    const cacheRoot = path.join(homeDir, ".codex", "plugins", "cache");
+    if (fs.existsSync(cacheRoot)) {
+        for (const vendor of fs.readdirSync(cacheRoot, { withFileTypes: true })) {
+            if (!vendor.isDirectory()) {
+                continue;
+            }
+            const vendorDir = path.join(cacheRoot, vendor.name);
+            for (const plugin of fs.readdirSync(vendorDir, { withFileTypes: true })) {
+                if (!plugin.isDirectory()) {
+                    continue;
+                }
+                const pluginDir = path.join(vendorDir, plugin.name);
+                roots.push(path.join(pluginDir, "skills"));
+                for (const version of fs.readdirSync(pluginDir, { withFileTypes: true })) {
+                    if (!version.isDirectory()) {
+                        continue;
+                    }
+                    roots.push(path.join(pluginDir, version.name, "skills"));
+                }
+            }
+        }
+    }
+    return roots;
+}
+function resolveGlobalPackageTemplateDirs() {
+    const homeDir = os.homedir();
+    const templateDirs = [];
+    const cacheRoot = path.join(homeDir, ".codex", "plugins", "cache");
+    if (!fs.existsSync(cacheRoot)) {
+        return templateDirs;
+    }
+    for (const vendor of fs.readdirSync(cacheRoot, { withFileTypes: true })) {
+        if (!vendor.isDirectory()) {
+            continue;
+        }
+        const vendorDir = path.join(cacheRoot, vendor.name);
+        for (const plugin of fs.readdirSync(vendorDir, { withFileTypes: true })) {
+            if (!plugin.isDirectory()) {
+                continue;
+            }
+            const pluginDir = path.join(vendorDir, plugin.name);
+            templateDirs.push(path.join(pluginDir, "templates"));
+            for (const version of fs.readdirSync(pluginDir, { withFileTypes: true })) {
+                if (!version.isDirectory()) {
+                    continue;
+                }
+                templateDirs.push(path.join(pluginDir, version.name, "templates"));
+            }
+        }
+    }
+    return templateDirs;
+}
+function collectSkillTemplateFiles(skillRoot) {
+    if (!fs.existsSync(skillRoot)) {
+        return [];
+    }
+    const templateFiles = [];
+    for (const entry of fs.readdirSync(skillRoot, { withFileTypes: true })) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const skillDir = path.join(skillRoot, entry.name);
+        for (const candidateName of [
+            "TEMPLATE.json",
+            "TEMPLATE.js",
+            "TEMPLATE.mjs",
+            "TEMPLATE.cjs",
+            "CLAW-TEMPLATE.json",
+            "CLAW-TEMPLATE.js",
+            "CLAW-TEMPLATE.mjs",
+            "CLAW-TEMPLATE.cjs",
+        ]) {
+            const candidatePath = path.join(skillDir, candidateName);
+            if (fs.existsSync(candidatePath)) {
+                templateFiles.push(candidatePath);
+            }
+        }
+    }
+    return templateFiles;
+}
+function validatePlanLikeTemplate(raw, templatePath) {
     const candidate = raw;
-    const aliasesValid = Array.isArray(candidate.aliases) && candidate.aliases.every((alias) => typeof alias === "string");
-    if (typeof candidate.id !== "string" ||
-        !aliasesValid ||
-        typeof candidate.planningEnabledStatus !== "string" ||
-        typeof candidate.planningDisabledStatus !== "string" ||
-        typeof candidate.planningTask?.title !== "string" ||
-        typeof candidate.planningTask?.detail !== "string" ||
-        typeof candidate.activationTask?.title !== "string" ||
-        typeof candidate.activationTask?.detail !== "string" ||
-        typeof candidate.activationTask?.goalModeDetail !== "string") {
-        throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid plan template at ${templatePath}.`, {
+    const allowedKeys = new Set([
+        "id",
+        "configOverride",
+        "title",
+        "status",
+        "goal",
+        "requirements",
+        "tasks",
+        "references",
+        "rules",
+        "keyDecisions",
+        "retrospective",
+    ]);
+    for (const key of Object.keys(candidate)) {
+        if (!allowedKeys.has(key)) {
+            throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid plan-like template field "${key}" at ${templatePath}.`, {
+                templatePath,
+                field: key,
+            });
+        }
+    }
+    if (!isTemplateConfigOverride(candidate.configOverride)) {
+        throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid template configOverride at ${templatePath}.`, {
+            templatePath,
+        });
+    }
+    if (typeof candidate.id !== "string" || typeof candidate.status !== "string") {
+        throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid plan-like template header at ${templatePath}.`, {
             templatePath,
         });
     }
-    return candidate;
+    if (candidate.title !== undefined && typeof candidate.title !== "string") {
+        throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid template title at ${templatePath}.`, {
+            templatePath,
+        });
+    }
+    if (candidate.goal !== undefined) {
+        if (!candidate.goal || typeof candidate.goal !== "object" || Array.isArray(candidate.goal)) {
+            throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid template goal at ${templatePath}.`, {
+                templatePath,
+            });
+        }
+        const goal = candidate.goal;
+        if (goal.text !== undefined && typeof goal.text !== "string") {
+            throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid template goal.text at ${templatePath}.`, {
+                templatePath,
+            });
+        }
+    }
+    if (candidate.requirements !== undefined && !isPlanRequirements(candidate.requirements)) {
+        throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid template requirements at ${templatePath}.`, {
+            templatePath,
+        });
+    }
+    if (!Array.isArray(candidate.tasks)) {
+        throw new ClawError("PROJECT_CONFIG_INVALID", `Template tasks must be an array at ${templatePath}.`, {
+            templatePath,
+        });
+    }
+    for (const task of candidate.tasks) {
+        if (!isPlanTemplateTask(task)) {
+            throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid template task at ${templatePath}.`, {
+                templatePath,
+            });
+        }
+    }
+    if (candidate.references !== undefined && !isPlanReferences(candidate.references)) {
+        throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid template references at ${templatePath}.`, {
+            templatePath,
+        });
+    }
+    if (candidate.rules !== undefined && (!Array.isArray(candidate.rules) || candidate.rules.some((item) => typeof item !== "string"))) {
+        throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid template rules at ${templatePath}.`, {
+            templatePath,
+        });
+    }
+    if (candidate.keyDecisions !== undefined
+        && (!Array.isArray(candidate.keyDecisions) || candidate.keyDecisions.some((item) => typeof item !== "string"))) {
+        throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid template keyDecisions at ${templatePath}.`, {
+            templatePath,
+        });
+    }
+    if (candidate.retrospective !== undefined && !isPlanRetrospective(candidate.retrospective)) {
+        throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid template retrospective at ${templatePath}.`, {
+            templatePath,
+        });
+    }
+    return raw;
+}
+function normalizePlanLikeTemplate(template, meta) {
+    return {
+        id: template.id,
+        configOverride: template.configOverride,
+        title: template.title,
+        status: template.status,
+        goal: template.goal,
+        requirements: template.requirements,
+        tasks: template.tasks,
+        references: template.references,
+        rules: template.rules,
+        keyDecisions: template.keyDecisions,
+        retrospective: template.retrospective,
+        source: meta.source,
+        templatePath: meta.templatePath,
+    };
+}
+export function getTemplateTaskDoneChoices(template, taskId) {
+    return getTemplateTaskGuidance(template, taskId)?.onDone?.choices;
+}
+export function getTemplateTaskDoneGuidanceRoute(template, taskId, choiceId) {
+    const onDone = getTemplateTaskGuidance(template, taskId)?.onDone;
+    if (!onDone) {
+        return undefined;
+    }
+    if (choiceId && onDone.choices && Object.prototype.hasOwnProperty.call(onDone.choices, choiceId)) {
+        return onDone.choices[choiceId];
+    }
+    return onDone.default;
+}
+export function getTemplateTaskGuidance(template, taskId) {
+    return template.tasks.find((task) => task.id === taskId)?.guidance;
+}
+function isPlanRequirements(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.summary === "string"
+        && Array.isArray(candidate.openQuestions)
+        && candidate.openQuestions.every((item) => typeof item === "string")
+        && Array.isArray(candidate.acceptanceCriteria)
+        && candidate.acceptanceCriteria.every((item) => typeof item === "string");
+}
+function isPlanReferences(value) {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    return value.every((reference) => reference
+        && typeof reference === "object"
+        && !Array.isArray(reference)
+        && typeof reference.path === "string"
+        && typeof reference.why === "string");
+}
+function isPlanRetrospective(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    if (typeof candidate.summary !== "string") {
+        return false;
+    }
+    for (const key of ["whatWorked", "issues", "followUps", "knowledgeCandidates"]) {
+        const field = candidate[key];
+        if (field !== undefined && (!Array.isArray(field) || field.some((item) => typeof item !== "string"))) {
+            return false;
+        }
+    }
+    return true;
+}
+function isPlanTemplateTask(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    const allowedKeys = new Set([
+        "id",
+        "title",
+        "detail",
+        "status",
+        "guidance",
+        "goalModeDetail",
+        "execution",
+        "sessionKey",
+    ]);
+    for (const key of Object.keys(candidate)) {
+        if (!allowedKeys.has(key)) {
+            return false;
+        }
+    }
+    if (!Number.isInteger(candidate.id)) {
+        return false;
+    }
+    if (typeof candidate.title !== "string") {
+        return false;
+    }
+    if (candidate.detail !== undefined && typeof candidate.detail !== "string") {
+        return false;
+    }
+    if (candidate.status !== "pending"
+        && candidate.status !== "in_progress"
+        && candidate.status !== "subagent_running"
+        && candidate.status !== "done"
+        && candidate.status !== "blocked") {
+        return false;
+    }
+    if (!isTemplateTaskGuidance(candidate.guidance)) {
+        return false;
+    }
+    if (candidate.goalModeDetail !== undefined && typeof candidate.goalModeDetail !== "string") {
+        return false;
+    }
+    if (candidate.execution !== undefined) {
+        if (!candidate.execution || typeof candidate.execution !== "object" || Array.isArray(candidate.execution)) {
+            return false;
+        }
+        const execution = candidate.execution;
+        if (execution.type !== undefined
+            && execution.type !== "default"
+            && execution.type !== "subagent"
+            && execution.type !== "subplan") {
+            return false;
+        }
+        if (execution.subplan !== undefined && typeof execution.subplan !== "string") {
+            return false;
+        }
+        if (execution.planPath !== undefined && typeof execution.planPath !== "string") {
+            return false;
+        }
+    }
+    if (candidate.sessionKey !== undefined && typeof candidate.sessionKey !== "string") {
+        return false;
+    }
+    return true;
+}
+function isTemplateConfigOverride(value) {
+    if (value === undefined) {
+        return true;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const allowedKeys = new Set([
+        "goalMode",
+        "truthDispatch",
+        "externalPlanningSkill",
+        "externalTruthSkill",
+        "externalAdrSkill",
+    ]);
+    const candidate = value;
+    for (const key of Object.keys(candidate)) {
+        if (!allowedKeys.has(key)) {
+            return false;
+        }
+    }
+    if (candidate.goalMode !== undefined && typeof candidate.goalMode !== "boolean") {
+        return false;
+    }
+    if (candidate.truthDispatch !== undefined && candidate.truthDispatch !== "per_task" && candidate.truthDispatch !== "final_only") {
+        return false;
+    }
+    if (candidate.externalPlanningSkill !== undefined && candidate.externalPlanningSkill !== null && typeof candidate.externalPlanningSkill !== "string") {
+        return false;
+    }
+    if (candidate.externalTruthSkill !== undefined && candidate.externalTruthSkill !== null && typeof candidate.externalTruthSkill !== "string") {
+        return false;
+    }
+    if (candidate.externalAdrSkill !== undefined && candidate.externalAdrSkill !== null && typeof candidate.externalAdrSkill !== "string") {
+        return false;
+    }
+    return true;
+}
+function isTemplateTaskGuidance(value) {
+    if (value === undefined) {
+        return true;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    const allowedKeys = new Set(["onDone"]);
+    for (const key of Object.keys(candidate)) {
+        if (!allowedKeys.has(key)) {
+            return false;
+        }
+    }
+    if (candidate.onDone === undefined) {
+        return true;
+    }
+    if (!candidate.onDone || typeof candidate.onDone !== "object" || Array.isArray(candidate.onDone)) {
+        return false;
+    }
+    const onDone = candidate.onDone;
+    const allowedOnDoneKeys = new Set(["default", "choices"]);
+    for (const key of Object.keys(onDone)) {
+        if (!allowedOnDoneKeys.has(key)) {
+            return false;
+        }
+    }
+    if (onDone.default !== undefined && !isTemplateGuidanceRoute(onDone.default)) {
+        return false;
+    }
+    if (onDone.choices !== undefined) {
+        if (!onDone.choices || typeof onDone.choices !== "object" || Array.isArray(onDone.choices)) {
+            return false;
+        }
+        for (const [choiceId, route] of Object.entries(onDone.choices)) {
+            if (!choiceId.trim() || !isTemplateGuidanceRoute(route)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function isTemplateGuidanceRoute(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    const allowedKeys = new Set([
+        "mergeMode",
+        "summary",
+        "nextsteps",
+        "notes",
+        "recommendedCommands",
+        "nextTaskId",
+        "label",
+        "delegateTruth",
+    ]);
+    for (const key of Object.keys(candidate)) {
+        if (!allowedKeys.has(key)) {
+            return false;
+        }
+    }
+    if (candidate.mergeMode !== undefined && candidate.mergeMode !== "override" && candidate.mergeMode !== "replace") {
+        return false;
+    }
+    if (candidate.summary !== undefined && typeof candidate.summary !== "string") {
+        return false;
+    }
+    if (candidate.nextsteps !== undefined && (!Array.isArray(candidate.nextsteps) || candidate.nextsteps.some((step) => typeof step !== "string"))) {
+        return false;
+    }
+    if (candidate.notes !== undefined && typeof candidate.notes !== "string") {
+        return false;
+    }
+    if (candidate.recommendedCommands !== undefined &&
+        (!Array.isArray(candidate.recommendedCommands) || candidate.recommendedCommands.some((command) => typeof command !== "string"))) {
+        return false;
+    }
+    if (candidate.nextTaskId !== undefined && !Number.isInteger(candidate.nextTaskId)) {
+        return false;
+    }
+    if (candidate.label !== undefined && typeof candidate.label !== "string") {
+        return false;
+    }
+    if (candidate.delegateTruth !== undefined && typeof candidate.delegateTruth !== "boolean") {
+        return false;
+    }
+    if (candidate.mergeMode === "replace") {
+        if (typeof candidate.summary !== "string") {
+            return false;
+        }
+        if (!Array.isArray(candidate.nextsteps) || candidate.nextsteps.some((step) => typeof step !== "string")) {
+            return false;
+        }
+    }
+    if (candidate.mergeMode !== "replace"
+        && candidate.summary === undefined
+        && candidate.nextsteps === undefined
+        && candidate.notes === undefined
+        && candidate.recommendedCommands === undefined
+        && candidate.nextTaskId === undefined
+        && candidate.label === undefined
+        && candidate.delegateTruth === undefined) {
+        return false;
+    }
+    return true;
 }
 export function renderSeedTemplateText(template, vars) {
     return template.replace(/{{\s*planningSkill\s*}}/g, vars.planningSkill);