agentera 3.0.0-dev.6 → 3.0.0-dev.69

package/dist/hooks/validateArtifact/index.js

@@ -1,9 +1,6 @@
 /**
- * Public surface for the validate-artifact hook. The CLI command
- * (`packages/cli/src/cli/commands/validate.ts`), the smoke checks, and
- * the dispatch entry all import the public classes from this barrel
- * to keep import paths stable as the file is split across the
- * per-responsibility submodules.
+ * Artifact validation used by the explicit `agentera check validate artifact`
+ * command and state publication.
  */
 import fs from "node:fs";
 import path from "node:path";
@@ -11,10 +8,8 @@ import { loadYamlMapping } from "../../core/yaml.js";
 import { resolvePath } from "../../core/paths.js";
 import { normalizeArtifactProtocolId } from "../../registries/artifactProtocolIds.js";
 import { DEFAULT_ARTIFACT_PATHS } from "../common.js";
-import { ArtifactWrite, RuntimeEventParser } from "./runtime.js";
-import { isMapping } from "./schema.js";
 import { validateMd } from "./markdown.js";
-import { artifactForWrite, defaultArtifactPath, readIfNeeded, compactAfterValidWrite, } from "./traversal.js";
+import { defaultArtifactPath, readIfNeeded, } from "./traversal.js";
 import { schemasDirDefault, validateYamlContent } from "./violations.js";
 import { AGENT_FACING_ARTIFACT_IDS, HUMAN_FACING_ARTIFACT_IDS } from "./agentFacing.js";
 export class ArtifactSchemaValidator {
@@ -28,6 +23,7 @@ export class ArtifactSchemaValidator {
         if (!this.schemaCache.has(name)) {
             const p = path.join(this.schemasDir, `${name}.yaml`);
             if (fs.existsSync(p) && fs.statSync(p).isFile()) {
+                // cast: artifact schema parsed from a YAML schema file
                 this.schemaCache.set(name, loadYamlMapping(fs.readFileSync(p, "utf8")));
             }
             else {
@@ -42,37 +38,6 @@ export class ArtifactSchemaValidator {
     validateMarkdown(content, name, schema = null) {
         return validateMd(content, name, schema);
     }
-    validateWrite(write, cwd) {
-        const absPath = path.isAbsolute(write.file_path) ? write.file_path : path.join(cwd, write.file_path);
-        const rel = path.relative(cwd, absPath).replace(/\\/g, "/");
-        const basename = path.basename(absPath);
-        const artifact = artifactForWrite(absPath, rel, basename, cwd);
-        if (artifact && AGENT_FACING_ARTIFACT_IDS.has(artifact)) {
-            const schema = this.loadSchema(artifact);
-            if (schema === null)
-                return [];
-            if (Object.keys(schema).length === 0)
-                return [`${artifact}: schema file is empty or contains no valid definitions`];
-            const content = readIfNeeded(write.content, absPath);
-            if (content === null)
-                return [];
-            let violations = this.validateYaml(content, schema, artifact);
-            if (violations.length > 0)
-                return violations;
-            return compactAfterValidWrite(artifact, absPath);
-        }
-        if (artifact && HUMAN_FACING_ARTIFACT_IDS.has(artifact)) {
-            const content = readIfNeeded(write.content, absPath);
-            if (content === null)
-                return [];
-            const schema = this.loadSchema(artifact);
-            const violations = this.validateMarkdown(content, artifact, schema);
-            if (violations.length > 0)
-                return violations;
-            return compactAfterValidWrite(artifact, absPath);
-        }
-        return [];
-    }
     validateExplicit(artifact, filePath, cwd) {
         const content = readIfNeeded(null, filePath);
         if (content === null)
@@ -102,32 +67,11 @@ export class ArtifactSchemaValidator {
 export function loadSchema(name) {
     return new ArtifactSchemaValidator().loadSchema(name);
 }
-export class HookCliAdapter {
-    parser;
+export class ArtifactValidationAdapter {
     validator;
-    constructor(parser, validator) {
-        this.parser = parser ?? new RuntimeEventParser();
+    constructor(validator) {
         this.validator = validator ?? new ArtifactSchemaValidator();
     }
-    run(raw, defaultCwd = null) {
-        let data;
-        try {
-            if (!raw.trim())
-                return [0, []];
-            data = JSON.parse(raw);
-        }
-        catch {
-            return [0, []];
-        }
-        if (!isMapping(data))
-            return [0, []];
-        const write = this.parser.parse(data);
-        if (write === null)
-            return [0, []];
-        const cwd = data.cwd ?? defaultCwd ?? process.cwd();
-        const violations = this.validator.validateWrite(write, cwd);
-        return violations.length > 0 ? [2, violations] : [0, []];
-    }
     runExplicit(artifact, filePath, cwd) {
         artifact = artifact.trim();
         const defaultPath = defaultArtifactPath(artifact, cwd);
@@ -145,5 +89,4 @@ export class HookCliAdapter {
         return violations.length > 0 ? [2, payload] : [0, payload];
     }
 }
-export { ArtifactWrite, RuntimeEventParser, resolvePath };
-//# sourceMappingURL=index.js.map
+export { resolvePath };

package/dist/hooks/validateArtifact/markdown.js

@@ -4,7 +4,52 @@
  * with required `field` entries and dispatches to the appropriate
  * section check (ITEM, RELEASE, TOKEN).
  */
+import { parseTodoMarkdownListItem } from "../../cli/todoMarkdown.js";
+import { classifyTodoSectionHeading, countTodoResolvedSectionHeadings, isLegacyStrikethroughTodoLine, } from "../compaction/parse.js";
 import { isMapping } from "./schema.js";
+function validateTodoResolvedPlacement(content, name) {
+    const violations = [];
+    let section = "other";
+    for (const line of content.split(/\r\n|\r|\n/)) {
+        const kind = classifyTodoSectionHeading(line);
+        if (kind === "resolved") {
+            section = "resolved";
+            continue;
+        }
+        if (kind === "severity") {
+            section = "severity";
+            continue;
+        }
+        if (/^##\s/.test(line.trim())) {
+            section = "other";
+            continue;
+        }
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("-"))
+            continue;
+        const parsed = parseTodoMarkdownListItem(trimmed);
+        if (parsed?.status === "resolved") {
+            if (section === "severity") {
+                violations.push(`${name}: resolved checkbox item must live under '## ✓ Resolved', not in severity bands`);
+                break;
+            }
+        }
+        if (isLegacyStrikethroughTodoLine(trimmed)) {
+            violations.push(`${name}: legacy strikethrough resolved items are not allowed; use '- [x]' under '## ✓ Resolved'`);
+            break;
+        }
+    }
+    // Exactly one section keeps parsing and compaction unambiguous, including
+    // before the first item is resolved. See todo.yaml TC8.
+    const resolvedHeadingCount = countTodoResolvedSectionHeadings(content);
+    if (resolvedHeadingCount === 0) {
+        violations.push(`${name}: missing required '## ✓ Resolved' section`);
+    }
+    else if (resolvedHeadingCount > 1) {
+        violations.push(`${name}: ${resolvedHeadingCount} '## ✓ Resolved' sections found; merge into exactly one (duplicate sections hide entries from the compaction gate and parsing processes only the first).`);
+    }
+    return violations;
+}
 const SKIP_META = new Set(["meta", "GROUP_PREFIXES", "BUDGET", "COMPACTION", "VALIDATION", "CONVENTION"]);
 export function validateMd(content, name, schema = null) {
     const violations = [];
@@ -43,7 +88,6 @@ export function validateMdItems(content, name, violations) {
         return;
     }
     const severityGlyphs = ["⇶", "⇉", "→", "⇢"];
-    const requiredItemGlyphs = new Set(["⇶"]);
     let found = false;
     for (const glyph of severityGlyphs) {
         const g = glyph.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -60,15 +104,22 @@ export function validateMdItems(content, name, violations) {
                     bodyStart += 1;
                 const sectionEnd = nextMatch ? idx + nextMatch.index : content.length;
                 const sectionBody = content.slice(bodyStart, sectionEnd);
-                if (requiredItemGlyphs.has(glyph) && !/^\s*-/m.test(sectionBody)) {
-                    const headingSlice = content.slice(sectionStart.index, sectionStart.index + sectionStart[0].length);
-                    const glyphNameMatch = new RegExp(`^##\\s*(${g}.+)$`, "m").exec(headingSlice);
-                    const headingText = glyphNameMatch ? glyphNameMatch[1] : glyph;
-                    violations.push(`${name}: severity section '${headingText}' has no list entries (expected '- [type]' items)`);
+                const headingSlice = content.slice(sectionStart.index, sectionStart.index + sectionStart[0].length);
+                const glyphNameMatch = new RegExp(`^##\\s*(${g}.+)$`, "m").exec(headingSlice);
+                const headingText = glyphNameMatch ? glyphNameMatch[1] : glyph;
+                const gluedNextSection = nextMatch?.index === 0;
+                if (gluedNextSection || /^\s*##\s/m.test(sectionBody)) {
+                    violations.push(`${name}: severity section '${headingText}' body contains a nested heading; add a blank line before the next '##' section`);
+                }
+                if (glyph === "⇶" && /^\s*-\s+\[x\]/im.test(sectionBody)) {
+                    violations.push(`${name}: severity section '⇶ Critical' must not contain resolved '- [x]' items; move them to '## ✓ Resolved'`);
                 }
             }
         }
     }
+    if (name === "TODO.md" || name === "todo") {
+        violations.push(...validateTodoResolvedPlacement(content, name));
+    }
     if (!found) {
         violations.push(`${name}: missing severity glyph in section headings (expected '## ⇶ Critical', '## ⇉ Degraded', '## → Normal', '## ⇢ Annoying')`);
     }
@@ -92,4 +143,3 @@ export function validateMdTokens(content, name, violations) {
         violations.push(`${name}: missing YAML code block with token definitions (expected '\`\`\`yaml')`);
     }
 }
-//# sourceMappingURL=markdown.js.map

package/dist/hooks/validateArtifact/schema.js

@@ -28,18 +28,28 @@ export function pyTypeName(v) {
 export function wordCount(text) {
     return (text.match(/\S+/g) ?? []).length;
 }
-const SKIP_META = new Set(["meta", "GROUP_PREFIXES", "BUDGET", "COMPACTION", "VALIDATION", "CONVENTION"]);
+const SKIP_META = new Set([
+    "meta",
+    "GROUP_PREFIXES",
+    "BUDGET",
+    "COMPACTION",
+    "VALIDATION",
+    "CONVENTION",
+]);
 const LIST_INDICATORS = new Set(["number", "entry", "summary"]);
 const SEQUENCE_KEYS_BY_ARTIFACT = {
     decisions: { DECISION: "decisions", ARCHIVE: "archive" },
     docs: { MAPPING: "mapping", INDEX: "index", AUDIT_LOG: "audit_log" },
     experiments: { EXPERIMENT: "experiments", ARCHIVE: "archive" },
-    plan: { TASK: "tasks" },
+    health: { AUDIT: "audits", ARCHIVE: "archive" },
+    plan: { TASK: "tasks", UNKNOWN: "unknowns", REJECTED: "rejected" },
     progress: { CYCLE: "cycles", ARCHIVE: "archive" },
     session: { BOOKMARK: "bookmarks" },
     vision: { PERSONA: "personas", PRINCIPLE: "principles" },
 };
-const NESTED_SEQUENCE_KEYS = [[["DECISION", "ALTERNATIVE"], "alternatives"]];
+const NESTED_SEQUENCE_KEYS = [
+    [["DECISION", "ALTERNATIVE"], "alternatives"],
+];
 const SEQUENCE_ORDER_BY_ARTIFACT = { "progress\0cycles": "descending" };
 export function collectSingletonGroups(schema) {
     const result = [];
@@ -48,7 +58,7 @@ export function collectSingletonGroups(schema) {
             continue;
         let isListOrSub = false;
         for (const e of Object.values(gv)) {
-            if (isMapping(e) && (LIST_INDICATORS.has(e.field) || e.parent)) {
+            if (isMapping(e) && (LIST_INDICATORS.has(String(e.field)) || e.parent)) {
                 isListOrSub = true;
                 break;
             }
@@ -58,7 +68,7 @@ export function collectSingletonGroups(schema) {
         const fields = [];
         for (const e of Object.values(gv)) {
             if (isMapping(e) && e.required && "field" in e)
-                fields.push(e.field);
+                fields.push(String(e.field));
         }
         if (fields.length > 0)
             result.push([gk, gk.toLowerCase(), fields]);
@@ -95,15 +105,19 @@ export function validateField(violations, name, scope, field, p) {
     }
 }
 export function allowedValues(entry) {
+    // cast: schema `validation` rules parsed from a YAML artifact schema file
     for (const rule of entry.validation ?? []) {
         if (typeof rule === "string" && rule.startsWith("Must be one of: ")) {
-            return rule.slice("Must be one of: ".length).split(",").map((v) => v.trim());
+            return rule
+                .slice("Must be one of: ".length)
+                .split(",")
+                .map((v) => v.trim());
         }
     }
     return [];
 }
 export function validateAllowedValue(violations, name, scope, entry, p) {
-    const field = entry.field;
+    const field = String(entry.field);
     const allowed = allowedValues(entry);
     if (!field || allowed.length === 0 || !(field in scope) || isEmptyRequired(scope[field]))
         return;
@@ -113,7 +127,7 @@ export function validateAllowedValue(violations, name, scope, entry, p) {
     }
 }
 export function validateFieldType(violations, name, scope, entry, p) {
-    const field = entry.field;
+    const field = String(entry.field);
     if (!field || !(field in scope))
         return true;
     const value = scope[field];
@@ -146,6 +160,12 @@ export function validateFieldType(violations, name, scope, entry, p) {
             isValid = false;
         }
     }
+    else if (expectedType === "list[integer|string]") {
+        if (!Array.isArray(value) || !value.every((x) => typeof x === "string" || (typeof x === "number" && Number.isInteger(x)))) {
+            violations.push(`${name}: '${fullPath}' must be a list of integers or strings`);
+            isValid = false;
+        }
+    }
     else if (expectedType === "list[map]") {
         if (!Array.isArray(value) || !value.every((x) => isMapping(x))) {
             violations.push(`${name}: '${fullPath}' must be a list of mappings`);
@@ -155,15 +175,18 @@ export function validateFieldType(violations, name, scope, entry, p) {
     return isValid;
 }
 export function validateFieldConstraints(violations, name, scope, entry, p) {
-    const field = entry.field;
+    const field = String(entry.field);
     if (!field || !(field in scope))
         return;
     const value = scope[field];
+    // cast: schema `validation` rules parsed from a YAML artifact schema file
     for (const rule of entry.validation ?? []) {
         if (typeof rule !== "string")
             continue;
         if (rule === "Must be a positive integer") {
-            if (typeof value === "boolean" || !(typeof value === "number" && Number.isInteger(value)) || value <= 0) {
+            if (typeof value === "boolean" ||
+                !(typeof value === "number" && Number.isInteger(value)) ||
+                value <= 0) {
                 const fullPath = p ? `${p}.${field}` : field;
                 violations.push(`${name}: '${fullPath}' must be a positive integer`);
             }
@@ -172,7 +195,7 @@ export function validateFieldConstraints(violations, name, scope, entry, p) {
 }
 export function validateRequiredFields(violations, name, schema, group, scope, p) {
     for (const entry of iterGroupEntries(schema, group)) {
-        const field = entry.field;
+        const field = String(entry.field);
         if (entry.parent || field === "entry")
             continue;
         if (entry.required)
@@ -185,9 +208,10 @@ export function validateRequiredFields(violations, name, schema, group, scope, p
         }
         const value = scope[field];
         if (isMapping(value)) {
+            // cast: schema `children` list parsed from a YAML artifact schema file
             for (const child of entry.children ?? []) {
                 if (isMapping(child) && child.field) {
-                    const childField = child.field;
+                    const childField = String(child.field);
                     const childPath = p ? `${p}.${field}` : field;
                     if (child.required)
                         validateField(violations, name, value, childField, childPath);
@@ -204,7 +228,7 @@ export function validateRequiredFields(violations, name, schema, group, scope, p
 }
 export function validateSingletonGroup(violations, name, schema, group, scope, p) {
     for (const entry of iterGroupEntries(schema, group)) {
-        const field = entry.field;
+        const field = String(entry.field);
         if (entry.parent || field === "entry")
             continue;
         if (entry.required)
@@ -221,7 +245,7 @@ export function schemaFieldNames(schema, group) {
     const out = new Set();
     for (const entry of iterGroupEntries(schema, group)) {
         if (entry.field && !entry.parent && entry.field !== "entry")
-            out.add(entry.field);
+            out.add(String(entry.field));
     }
     return out;
 }
@@ -257,6 +281,10 @@ export function validateFullPlanContract(data, violations) {
         validateField(violations, "plan", header, field, "header");
     }
     validateField(violations, "plan", data, "design", "");
+    const unknowns = data.unknowns;
+    if (!Array.isArray(unknowns) || unknowns.length === 0) {
+        violations.push("plan: full plans require at least one 'unknowns' entry");
+    }
     const criticIssues = header.critic_issues;
     if (!isEmptyRequired(criticIssues)) {
         const match = /^\s*(\d+)\s+found,\s*(\d+)\s+addressed,\s*(\d+)\s+dismissed\s*$/.exec(String(criticIssues));
@@ -301,7 +329,9 @@ export function parentRequirements(schema, parentGroup) {
                 entry.required &&
                 entry.field) {
                 const parentField = parent.slice(prefix.length);
-                (requirements[parentField] ??= []).push(entry.field);
+                const fields = requirements[parentField] ?? [];
+                fields.push(String(entry.field));
+                requirements[parentField] = fields;
             }
         }
     }
@@ -312,7 +342,7 @@ export function entryRequirements(schema, group) {
     const out = [];
     for (const entry of iterGroupEntries(schema, group)) {
         if (entry.parent === parent && entry.required && entry.field)
-            out.push(entry.field);
+            out.push(String(entry.field));
     }
     return out;
 }
@@ -332,6 +362,8 @@ export function validateSequences(data, schema, name, violations) {
         const childRequirements = parentRequirements(schema, group);
         seq.forEach((item, index) => {
             const p = `${key}[${index}]`;
+            if (name === "health" && group === "ARCHIVE" && typeof item === "string")
+                return;
             if (!isMapping(item)) {
                 violations.push(`${name}: '${p}' must be a mapping`);
                 return;
@@ -370,8 +402,62 @@ export function validateSequences(data, schema, name, violations) {
         });
     }
 }
+export function validatePlanDependencies(data, violations) {
+    if (!Array.isArray(data.tasks))
+        return;
+    const tasks = data.tasks.filter((task) => isMapping(task));
+    const byRef = new Map();
+    tasks.forEach((task, index) => {
+        if (task.number !== null && task.number !== undefined)
+            byRef.set(String(task.number), index);
+        const name = String(task.name ?? "").trim();
+        if (name && !byRef.has(name))
+            byRef.set(name, index);
+    });
+    const edges = tasks.map(() => []);
+    tasks.forEach((task, index) => {
+        if (!Array.isArray(task.depends_on))
+            return;
+        for (const dependency of task.depends_on) {
+            const dependencyRef = String(dependency);
+            const target = byRef.get(dependencyRef);
+            if (target === undefined) {
+                violations.push(`plan: 'tasks[${index}].depends_on' references unknown task '${dependencyRef}' (PV4)`);
+            }
+            else {
+                edges[index].push(target);
+            }
+        }
+    });
+    const state = tasks.map(() => 0);
+    const stack = [];
+    const visit = (index) => {
+        state[index] = 1;
+        stack.push(index);
+        for (const target of edges[index]) {
+            if (state[target] === 0 && visit(target))
+                return true;
+            if (state[target] === 1) {
+                const cycleStart = stack.indexOf(target);
+                const cycle = [...stack.slice(cycleStart), target]
+                    .map((taskIndex) => String(tasks[taskIndex]?.number ?? taskIndex + 1))
+                    .join(" -> ");
+                violations.push(`plan: circular dependency chain ${cycle} (PV4)`);
+                return true;
+            }
+        }
+        stack.pop();
+        state[index] = 2;
+        return false;
+    };
+    for (let index = 0; index < tasks.length; index += 1) {
+        if (state[index] === 0 && visit(index))
+            break;
+    }
+}
 export function validateDecisionAlternatives(data, name) {
     const violations = [];
+    // cast: `decisions` read from a parsed YAML artifact mapping
     (data.decisions ?? []).forEach((decision, index) => {
         if (!isMapping(decision))
             return;
@@ -389,8 +475,14 @@ export function validateDecisionSatisfaction(data, name) {
     const violations = [];
     const allowedStates = new Set(["open", "provisionally_satisfied", "user_confirmed_satisfied"]);
     const entries = [
-        ...(data.decisions ?? []).map((d, i) => [`decisions[${i}]`, d]),
-        ...(data.archive ?? []).map((d, i) => [`archive[${i}]`, d]),
+        ...(data.decisions ?? []).map((d, i) => [
+            `decisions[${i}]`,
+            d,
+        ]),
+        ...(data.archive ?? []).map((d, i) => [
+            `archive[${i}]`,
+            d,
+        ]),
     ];
     for (const [entryPath, decision] of entries) {
         if (!isMapping(decision) || !("satisfaction" in decision))
@@ -452,4 +544,3 @@ export function sequenceInOrder(nums, direction) {
     const sorted = [...nums].sort((a, b) => (reverse ? b - a : a - b));
     return nums.length === sorted.length && nums.every((n, i) => n === sorted[i]);
 }
-//# sourceMappingURL=schema.js.map

package/dist/hooks/validateArtifact/traversal.js

@@ -12,17 +12,19 @@ import { loadYamlMapping } from "../../core/yaml.js";
 import { ARTIFACT_PROTOCOL_PATHS, HUMAN_FACING_ARTIFACT_IDS, normalizeArtifactProtocolId, } from "../../registries/artifactProtocolIds.js";
 import { DEFAULT_ARTIFACT_PATHS } from "../common.js";
 import { COMPACTABLE_YAML_ARTIFACTS, compactFile, compactYamlFile } from "../compaction/index.js";
+import { withStateMutation } from "../../state/write/mutation.js";
 import { isMapping } from "./schema.js";
 const AGENT_YAML_RE = /\.agentera\/([a-z_]+)\.yaml$/;
 function resolvePathRel(fp, cwd) {
     return path.isAbsolute(fp) ? fp : path.join(cwd, fp);
 }
 function docsPathOverrides(cwd) {
-    const docsPath = path.join(cwd, ".agentera", "docs.yaml");
+    const docsPath = path.join(cwd, ARTIFACT_PROTOCOL_PATHS.docs);
     if (!fs.existsSync(docsPath) || !fs.statSync(docsPath).isFile())
         return {};
     let data;
     try {
+        // cast: docs.yaml path-override mapping parsed from a YAML file
         data = loadYamlMapping(fs.readFileSync(docsPath, "utf8"));
     }
     catch (exc) {
@@ -82,19 +84,20 @@ function readIfNeeded(content, absPath) {
         return null;
     }
 }
-function compactAfterValidWrite(artifact, absPath) {
+function compactAfterValidWrite(artifact, absPath, projectRoot) {
     if (!fs.existsSync(absPath))
         return [];
     try {
-        if (artifact === "todo") {
-            compactFile(absPath, "todo-resolved");
-        }
-        else if (artifact in COMPACTABLE_YAML_ARTIFACTS) {
-            compactYamlFile(absPath, artifact);
-        }
-        else {
+        if (artifact !== "todo" && !(artifact in COMPACTABLE_YAML_ARTIFACTS))
             return [];
-        }
+        withStateMutation(projectRoot, (transaction) => {
+            if (artifact === "todo") {
+                transaction.mutateProjection(absPath, (stage) => compactFile(stage, "todo-resolved"));
+            }
+            else {
+                transaction.mutateProjection(absPath, (stage) => compactYamlFile(stage, artifact, projectRoot));
+            }
+        });
     }
     catch (exc) {
         return [`${artifact}: compaction failed: ${exc.message}`];
@@ -102,4 +105,3 @@ function compactAfterValidWrite(artifact, absPath) {
     return [];
 }
 export { readIfNeeded, compactAfterValidWrite };
-//# sourceMappingURL=traversal.js.map

package/dist/hooks/validateArtifact/violations.js

@@ -10,7 +10,7 @@ import path from "node:path";
 import { parseYaml } from "../../core/yaml.js";
 import { resolveSourceRoot } from "../../core/sourceRoot.js";
 import { loadYamlMapping } from "../../core/yaml.js";
-import { expectedSequenceOrder, isMapping, sequenceInOrder, validationRuleSeverity, validateDecisionAlternatives, validateDecisionSatisfaction, validateFullPlanContract, validatePlanKnownFields, validateSequences, validateSingletonGroup, collectSingletonGroups, wordCount, } from "./schema.js";
+import { expectedSequenceOrder, isMapping, sequenceInOrder, validationRuleSeverity, validateDecisionAlternatives, validateDecisionSatisfaction, validateFullPlanContract, validatePlanDependencies, validatePlanKnownFields, validateSequences, validateSingletonGroup, collectSingletonGroups, wordCount, } from "./schema.js";
 function schemasDirDefault() {
     return path.join(resolveSourceRoot(), "skills", "agentera", "schemas", "artifacts");
 }
@@ -42,6 +42,7 @@ export function validateYamlContent(content, schema, name) {
     if (name === "plan") {
         validatePlanKnownFields(data, schema, violations);
         validateFullPlanContract(data, violations);
+        validatePlanDependencies(data, violations);
     }
     validateSequences(data, schema, name, violations);
     if (name === "decisions") {
@@ -56,7 +57,7 @@ export function validateYamlContent(content, schema, name) {
         const scope = be.scope ?? "";
         if (mw && String(scope).includes("full_file") && wordBudgetSeverity === "error") {
             const wc = wordCount(content);
-            if (wc > mw)
+            if (wc > Number(mw))
                 violations.push(`${name}: word count (${wc}) exceeds budget (${mw})`);
         }
     }
@@ -64,13 +65,15 @@ export function validateYamlContent(content, schema, name) {
         for (const ve of Object.values(schema[groupKey] ?? {})) {
             if (!isMapping(ve))
                 continue;
-            const rule = ve.rule ?? "";
+            const rule = String(ve.rule ?? "");
             if (ve.severity !== "error")
                 continue;
             if (rule.includes("unique") && rule.includes("number")) {
                 for (const [key, val] of Object.entries(data)) {
                     if (Array.isArray(val)) {
-                        const nums = val.filter((e) => isMapping(e) && "number" in e).map((e) => e.number);
+                        const nums = val
+                            .filter((e) => isMapping(e) && "number" in e)
+                            .map((e) => e.number);
                         if (nums.length > 0) {
                             if (nums.length !== new Set(nums).size) {
                                 violations.push(`${name}: duplicate numbers in '${key}'`);
@@ -102,4 +105,3 @@ export function validateYamlContent(content, schema, name) {
     return violations;
 }
 export { loadYamlMapping, schemasDirDefault };
-//# sourceMappingURL=violations.js.map