@veewo/claw-core 0.1.59 → 0.1.61

package/dist/src/plan-templates.js

@@ -1,81 +1,26 @@
 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 = [normalizePlanLikeTemplate(defaultPlanTemplate, { source: "builtin" })];
+import { defaultPlanTemplate } from "./templates/plans/default.js";
+const PLAN_TEMPLATES = [defaultPlanTemplate];
 export async function resolveSeedPlanTemplate(params) {
     const normalized = params.templateName?.trim().toLowerCase() || defaultPlanTemplate.id;
-    const projectTemplate = params.projectRoot ? await loadProjectPlanTemplate(params.projectRoot, normalized) : null;
+    const projectTemplate = params.projectRoot ? await loadProjectSeedTemplate(params.projectRoot, normalized) : null;
     if (projectTemplate) {
         return projectTemplate;
     }
-    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);
+    const match = PLAN_TEMPLATES.find((template) => template.id.toLowerCase() === normalized || template.aliases.some((alias) => alias.toLowerCase() === normalized));
     if (!match) {
         throw new ClawError("PROJECT_CONFIG_INVALID", `Unknown plan template "${params.templateName ?? normalized}".`, {
             templateName: params.templateName ?? normalized,
-            availableTemplates: PLAN_TEMPLATES.map((template) => template.id),
+            availableTemplates: PLAN_TEMPLATES.flatMap((template) => [template.id, ...template.aliases]),
         });
     }
     return match;
 }
-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) {
+async function loadProjectSeedTemplate(projectRoot, normalizedTemplateName) {
+    const templatesDir = path.join(projectRoot, ".claw", "templates");
     if (!fs.existsSync(templatesDir)) {
         return null;
     }
@@ -95,533 +40,34 @@ async function loadPlanTemplateFromDirectory(templatesDir, normalizedTemplateNam
             candidatePaths: candidateEntries.map((entryName) => path.join(templatesDir, entryName)),
         });
     }
-    return resolvePlanTemplateFile(path.join(templatesDir, candidateEntries[0]));
-}
-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;
+    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);
 }
-function validatePlanLikeTemplate(raw, templatePath) {
-    const candidate = raw;
-    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,
-        });
-    }
-    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}.`, {
+function validateSeedPlanTemplate(raw, templatePath) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid plan template at ${templatePath}.`, {
             templatePath,
         });
     }
-    if (candidate.retrospective !== undefined && !isPlanRetrospective(candidate.retrospective)) {
-        throw new ClawError("PROJECT_CONFIG_INVALID", `Invalid template retrospective at ${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}.`, {
             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;
+    return candidate;
 }
 export function renderSeedTemplateText(template, vars) {
     return template.replace(/{{\s*planningSkill\s*}}/g, vars.planningSkill);