mdkg 0.0.3 → 0.0.5

package/dist/commands/skill_support.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SKILL_REGISTRY_END = exports.SKILL_REGISTRY_START = void 0;
+exports.resolveSkillTemplatePath = resolveSkillTemplatePath;
+exports.loadSkillTemplate = loadSkillTemplate;
+exports.renderSkillTemplate = renderSkillTemplate;
+exports.registryTemplate = registryTemplate;
+exports.ensureSkillsRegistry = ensureSkillsRegistry;
+exports.refreshSkillsRegistry = refreshSkillsRegistry;
+exports.formatSkillCard = formatSkillCard;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const skills_indexer_1 = require("../graph/skills_indexer");
+exports.SKILL_REGISTRY_START = "<!-- mdkg:skill-registry:start -->";
+exports.SKILL_REGISTRY_END = "<!-- mdkg:skill-registry:end -->";
+function renderYamlList(values) {
+    return `[${values.join(", ")}]`;
+}
+function renderOptionalLine(key, values) {
+    if (values.length === 0) {
+        return "";
+    }
+    return `${key}: ${renderYamlList(values)}\n`;
+}
+function resolveSkillTemplatePath() {
+    return path_1.default.resolve(__dirname, "..", "init", "skills", "SKILL.md.example");
+}
+function loadSkillTemplate() {
+    const templatePath = resolveSkillTemplatePath();
+    if (!fs_1.default.existsSync(templatePath)) {
+        throw new Error(`missing skill template artifact: ${templatePath}`);
+    }
+    return fs_1.default.readFileSync(templatePath, "utf8");
+}
+function renderSkillTemplate(data) {
+    const template = loadSkillTemplate();
+    return template
+        .replace("{{name}}", data.name)
+        .replace("{{description}}", data.description)
+        .replace("{{tags_block}}", renderOptionalLine("tags", data.tags))
+        .replace("{{authors_block}}", renderOptionalLine("authors", data.authors))
+        .replace("{{links_block}}", renderOptionalLine("links", data.links));
+}
+function registryTemplate() {
+    return [
+        "# Skills Registry",
+        "",
+        "This directory stores Agent Skills packages used by mdkg tooling and orchestrators.",
+        "",
+        "Use `mdkg skill new <slug> \"<name>\" --description \"...\"` to scaffold a new skill from the built-in Anthropic-aligned template.",
+        "Use `mdkg skill sync` to mirror canonical skills into `.agents/skills/` and `.claude/skills/` when agent bootstrap is enabled.",
+        "Use `CLI_COMMAND_MATRIX.md` as the canonical command and flag reference when updating skill procedures.",
+        "",
+        "## Conventions",
+        "",
+        "- One folder per skill slug.",
+        "- Use `SKILL.md` as the canonical skill entrypoint.",
+        "- Keep procedures deterministic and avoid embedding secrets.",
+        "- Create `scripts/` only when deterministic execution cannot be expressed safely as instructions.",
+        "",
+        "## Registered Skills",
+        "",
+        `${exports.SKILL_REGISTRY_START}`,
+        "_No skills registered yet. Run `mdkg skill new` to add one._",
+        `${exports.SKILL_REGISTRY_END}`,
+        "",
+    ].join("\n");
+}
+function renderRegistryLines(skillsIndex) {
+    const skills = Object.values(skillsIndex.skills).sort((a, b) => a.slug.localeCompare(b.slug));
+    if (skills.length === 0) {
+        return ["_No skills registered yet. Run `mdkg skill new` to add one._"];
+    }
+    const lines = [];
+    for (const skill of skills) {
+        lines.push(`- \`${skill.slug}\``);
+        lines.push(`  - name: \`${skill.name}\``);
+        const stageTag = skill.tags.find((tag) => tag.startsWith("stage:"));
+        if (stageTag) {
+            lines.push(`  - stage: \`${stageTag}\``);
+        }
+        const writerTag = skill.tags.find((tag) => tag.startsWith("writer:"));
+        if (writerTag) {
+            lines.push(`  - writer role: \`${writerTag}\``);
+        }
+        lines.push(`  - description: ${skill.description}`);
+    }
+    return lines;
+}
+function replaceManagedSection(raw, lines) {
+    const managed = `${exports.SKILL_REGISTRY_START}\n${lines.join("\n")}\n${exports.SKILL_REGISTRY_END}`;
+    if (raw.includes(exports.SKILL_REGISTRY_START) && raw.includes(exports.SKILL_REGISTRY_END)) {
+        const pattern = new RegExp(`${exports.SKILL_REGISTRY_START}[\\s\\S]*?${exports.SKILL_REGISTRY_END}`, "m");
+        const replaced = raw.replace(pattern, managed);
+        return replaced.endsWith("\n") ? replaced : `${replaced}\n`;
+    }
+    const trimmed = raw.trimEnd();
+    const prefix = trimmed.length > 0 ? `${trimmed}\n\n## Registered Skills\n\n` : "## Registered Skills\n\n";
+    return `${prefix}${managed}\n`;
+}
+function ensureSkillsRegistry(root, config) {
+    const skillsRoot = (0, skills_indexer_1.resolveSkillsRoot)(root, config);
+    const registryPath = path_1.default.join(skillsRoot, "registry.md");
+    if (!fs_1.default.existsSync(registryPath)) {
+        fs_1.default.mkdirSync(path_1.default.dirname(registryPath), { recursive: true });
+        fs_1.default.writeFileSync(registryPath, registryTemplate(), "utf8");
+    }
+    return registryPath;
+}
+function refreshSkillsRegistry(root, config) {
+    const registryPath = ensureSkillsRegistry(root, config);
+    const raw = fs_1.default.readFileSync(registryPath, "utf8");
+    const index = (0, skills_indexer_1.buildSkillsIndex)(root, config);
+    const updated = replaceManagedSection(raw, renderRegistryLines(index));
+    fs_1.default.writeFileSync(registryPath, updated, "utf8");
+}
+function formatSkillCard(skill) {
+    return [skill.qid, "skill", "-/-", skill.name, skill.path].join(" | ");
+}

package/dist/commands/task.js

@@ -0,0 +1,278 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTaskStartCommand = runTaskStartCommand;
+exports.runTaskUpdateCommand = runTaskUpdateCommand;
+exports.runTaskDoneCommand = runTaskDoneCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../core/config");
+const indexer_1 = require("../graph/indexer");
+const index_cache_1 = require("../graph/index_cache");
+const frontmatter_1 = require("../graph/frontmatter");
+const skills_indexer_1 = require("../graph/skills_indexer");
+const date_1 = require("../util/date");
+const errors_1 = require("../util/errors");
+const qid_1 = require("../util/qid");
+const id_1 = require("../util/id");
+const event_support_1 = require("./event_support");
+const checkpoint_1 = require("./checkpoint");
+const MUTABLE_TASK_TYPES = new Set(["task", "bug", "test"]);
+const SKILL_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function parseCsvList(raw) {
+    if (!raw) {
+        return [];
+    }
+    return raw
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean);
+}
+function normalizeWorkspace(value) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.toLowerCase();
+    if (normalized === "all") {
+        throw new errors_1.UsageError("--ws all is not valid here");
+    }
+    return normalized;
+}
+function normalizeId(value, flag) {
+    const normalized = value.trim().toLowerCase();
+    if (!(0, id_1.isCanonicalId)(normalized)) {
+        throw new errors_1.UsageError(`${flag} entries must match <prefix>-<number> or reserved id: ${value}`);
+    }
+    return normalized;
+}
+function normalizeIdRef(value, flag) {
+    const normalized = value.trim().toLowerCase();
+    if (!(0, id_1.isCanonicalIdRef)(normalized)) {
+        throw new errors_1.UsageError(`${flag} entries must match <id> or <ws>:<id>: ${value}`);
+    }
+    return normalized;
+}
+function normalizeLowercaseList(raw) {
+    return parseCsvList(raw).map((value) => value.toLowerCase());
+}
+function normalizeIdList(raw, flag) {
+    return parseCsvList(raw).map((value) => normalizeId(value, flag));
+}
+function normalizeIdRefList(raw, flag) {
+    return parseCsvList(raw).map((value) => normalizeIdRef(value, flag));
+}
+function normalizeSkillList(raw) {
+    return parseCsvList(raw).map((value) => {
+        const normalized = value.toLowerCase();
+        if (!SKILL_SLUG_RE.test(normalized)) {
+            throw new errors_1.UsageError(`--add-skills entries must be kebab-case: ${value}`);
+        }
+        return normalized;
+    });
+}
+function appendUnique(existing, additions) {
+    const next = [...existing];
+    const seen = new Set(existing);
+    for (const value of additions) {
+        if (!seen.has(value)) {
+            next.push(value);
+            seen.add(value);
+        }
+    }
+    return next;
+}
+function toStringList(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => String(item));
+    }
+    return [];
+}
+function maybeReindex(root, config) {
+    if (!config.index.auto_reindex) {
+        return;
+    }
+    const outputPath = path_1.default.resolve(root, config.index.global_index_path);
+    (0, index_cache_1.writeIndex)(outputPath, (0, indexer_1.buildIndex)(root, config, { tolerant: config.index.tolerant }));
+}
+function loadMutableTaskNode(root, idOrQid, wsHint) {
+    const config = (0, config_1.loadConfig)(root);
+    const { index } = (0, index_cache_1.loadIndex)({ root, config });
+    const resolved = (0, qid_1.resolveQid)(index, idOrQid, normalizeWorkspace(wsHint));
+    if (resolved.status !== "ok") {
+        throw new errors_1.NotFoundError((0, qid_1.formatResolveError)("task", idOrQid, resolved, normalizeWorkspace(wsHint)));
+    }
+    const node = index.nodes[resolved.qid];
+    if (!node) {
+        throw new errors_1.NotFoundError(`task not found: ${idOrQid}`);
+    }
+    if (!MUTABLE_TASK_TYPES.has(node.type)) {
+        throw new errors_1.UsageError(`mdkg task only supports task, bug, and test nodes; use markdown editing for ${node.type}:${node.id}`);
+    }
+    const filePath = path_1.default.resolve(root, node.path);
+    const content = fs_1.default.readFileSync(filePath, "utf8");
+    const parsed = (0, frontmatter_1.parseFrontmatter)(content, filePath);
+    return {
+        config,
+        index,
+        qid: node.qid,
+        ws: node.ws,
+        id: node.id,
+        type: node.type,
+        filePath,
+        frontmatter: { ...parsed.frontmatter },
+        body: parsed.body,
+    };
+}
+function writeNodeFile(root, filePath, frontmatter, body) {
+    const lines = (0, frontmatter_1.formatFrontmatter)(frontmatter, frontmatter_1.DEFAULT_FRONTMATTER_KEY_ORDER);
+    const frontmatterBlock = ["---", ...lines, "---"].join("\n");
+    const content = body.length > 0 ? `${frontmatterBlock}\n${body}` : frontmatterBlock;
+    fs_1.default.writeFileSync(filePath, content, "utf8");
+}
+function ensureStatusAllowed(config, statusRaw, flag = "--status") {
+    const normalized = statusRaw.trim().toLowerCase();
+    const allowed = new Set(config.work.status_enum.map((value) => value.toLowerCase()));
+    if (!allowed.has(normalized)) {
+        throw new errors_1.UsageError(`${flag} must be one of ${Array.from(allowed).join(", ")}`);
+    }
+    return normalized;
+}
+function ensurePriorityAllowed(config, priority) {
+    if (!Number.isInteger(priority) ||
+        priority < config.work.priority_min ||
+        priority > config.work.priority_max) {
+        throw new errors_1.UsageError(`--priority must be between ${config.work.priority_min} and ${config.work.priority_max}`);
+    }
+    return priority;
+}
+function ensureNodeRefsExist(index, values, ws, label) {
+    for (const value of values) {
+        const resolved = (0, qid_1.resolveQid)(index, value, ws);
+        if (resolved.status !== "ok") {
+            throw new errors_1.NotFoundError((0, qid_1.formatResolveError)(label, value, resolved, ws));
+        }
+    }
+}
+function ensureSkillsExist(root, node, slugs) {
+    if (slugs.length === 0) {
+        return;
+    }
+    const skillsIndex = (0, skills_indexer_1.buildSkillsIndex)(root, node.config);
+    for (const slug of slugs) {
+        if (!skillsIndex.skills[slug]) {
+            throw new errors_1.NotFoundError(`skill not found: ${slug}`);
+        }
+    }
+}
+function updateUpdatedDate(frontmatter, now) {
+    frontmatter.updated = (0, date_1.formatDate)(now);
+}
+function maybeWarnEventsDisabled(root, config, ws) {
+    if ((0, event_support_1.isEventLoggingEnabled)(root, config, ws)) {
+        return;
+    }
+    console.error(`note: event logging not enabled for workspace ${ws}; run mdkg event enable --ws ${ws} if you want JSONL provenance`);
+}
+function runTaskStartCommand(options) {
+    const loaded = loadMutableTaskNode(options.root, options.id, options.ws);
+    const now = options.now ?? new Date();
+    loaded.frontmatter.status = ensureStatusAllowed(loaded.config, "progress");
+    updateUpdatedDate(loaded.frontmatter, now);
+    writeNodeFile(options.root, loaded.filePath, loaded.frontmatter, loaded.body);
+    maybeReindex(options.root, loaded.config);
+    (0, event_support_1.appendAutomaticEvent)({
+        root: options.root,
+        ws: loaded.ws,
+        kind: "TASK_STARTED",
+        status: "ok",
+        refs: [loaded.id],
+        notes: options.note ?? `status set to progress via mdkg task start`,
+        runId: options.runId,
+        now,
+    });
+    maybeWarnEventsDisabled(options.root, loaded.config, loaded.ws);
+    console.log(`task started: ${loaded.qid}`);
+}
+function runTaskUpdateCommand(options) {
+    const loaded = loadMutableTaskNode(options.root, options.id, options.ws);
+    const now = options.now ?? new Date();
+    if (options.status) {
+        loaded.frontmatter.status = ensureStatusAllowed(loaded.config, options.status);
+    }
+    if (options.priority !== undefined) {
+        loaded.frontmatter.priority = String(ensurePriorityAllowed(loaded.config, options.priority));
+    }
+    const nextLinks = appendUnique(toStringList(loaded.frontmatter.links), parseCsvList(options.addLinks));
+    const nextArtifacts = appendUnique(toStringList(loaded.frontmatter.artifacts), parseCsvList(options.addArtifacts));
+    const nextRefs = appendUnique(toStringList(loaded.frontmatter.refs), normalizeIdList(options.addRefs, "--add-refs"));
+    const nextTags = appendUnique(toStringList(loaded.frontmatter.tags), normalizeLowercaseList(options.addTags));
+    const nextSkills = appendUnique(toStringList(loaded.frontmatter.skills), normalizeSkillList(options.addSkills));
+    const blockedByAdditions = normalizeIdRefList(options.addBlockedBy, "--add-blocked-by");
+    ensureNodeRefsExist(loaded.index, blockedByAdditions, loaded.ws, "blocked_by");
+    const nextBlockedBy = options.clearBlockedBy
+        ? blockedByAdditions
+        : appendUnique(toStringList(loaded.frontmatter.blocked_by), blockedByAdditions);
+    ensureSkillsExist(options.root, loaded, nextSkills);
+    loaded.frontmatter.links = nextLinks;
+    loaded.frontmatter.artifacts = nextArtifacts;
+    loaded.frontmatter.refs = nextRefs;
+    loaded.frontmatter.tags = nextTags;
+    loaded.frontmatter.skills = nextSkills;
+    loaded.frontmatter.blocked_by = nextBlockedBy;
+    updateUpdatedDate(loaded.frontmatter, now);
+    writeNodeFile(options.root, loaded.filePath, loaded.frontmatter, loaded.body);
+    maybeReindex(options.root, loaded.config);
+    (0, event_support_1.appendAutomaticEvent)({
+        root: options.root,
+        ws: loaded.ws,
+        kind: "TASK_UPDATED",
+        status: "ok",
+        refs: [loaded.id],
+        artifacts: nextArtifacts,
+        notes: options.note ?? `task metadata updated via mdkg task update`,
+        runId: options.runId,
+        now,
+    });
+    console.log(`task updated: ${loaded.qid}`);
+}
+function runTaskDoneCommand(options) {
+    const loaded = loadMutableTaskNode(options.root, options.id, options.ws);
+    const now = options.now ?? new Date();
+    const nextLinks = appendUnique(toStringList(loaded.frontmatter.links), parseCsvList(options.addLinks));
+    const nextArtifacts = appendUnique(toStringList(loaded.frontmatter.artifacts), parseCsvList(options.addArtifacts));
+    const nextRefs = appendUnique(toStringList(loaded.frontmatter.refs), normalizeIdList(options.addRefs, "--add-refs"));
+    loaded.frontmatter.status = ensureStatusAllowed(loaded.config, "done");
+    loaded.frontmatter.links = nextLinks;
+    loaded.frontmatter.artifacts = nextArtifacts;
+    loaded.frontmatter.refs = nextRefs;
+    updateUpdatedDate(loaded.frontmatter, now);
+    writeNodeFile(options.root, loaded.filePath, loaded.frontmatter, loaded.body);
+    (0, event_support_1.appendAutomaticEvent)({
+        root: options.root,
+        ws: loaded.ws,
+        kind: "TASK_DONE",
+        status: "ok",
+        refs: [loaded.id],
+        artifacts: nextArtifacts,
+        notes: options.note ?? `status set to done via mdkg task done`,
+        runId: options.runId,
+        now,
+    });
+    if (options.checkpoint) {
+        (0, checkpoint_1.runCheckpointNewCommand)({
+            root: options.root,
+            title: options.checkpoint,
+            ws: loaded.ws,
+            relates: loaded.id,
+            scope: loaded.id,
+            runId: options.runId,
+            note: `checkpoint created from mdkg task done for ${loaded.id}`,
+            now,
+        });
+    }
+    maybeReindex(options.root, loaded.config);
+    maybeWarnEventsDisabled(options.root, loaded.config, loaded.ws);
+    console.log(`task done: ${loaded.qid}`);
+}

package/dist/commands/validate.js

@@ -9,9 +9,11 @@ const path_1 = __importDefault(require("path"));
 const config_1 = require("../core/config");
 const template_schema_1 = require("../graph/template_schema");
 const node_1 = require("../graph/node");
+const skills_indexer_1 = require("../graph/skills_indexer");
 const workspace_files_1 = require("../graph/workspace_files");
 const validate_graph_1 = require("../graph/validate_graph");
 const errors_1 = require("../util/errors");
+const skill_mirror_1 = require("./skill_mirror");
 const RECOMMENDED_HEADINGS = {
     task: [
         "Overview",
@@ -116,6 +118,7 @@ function buildIndexNode(root, ws, filePath, node) {
         artifacts: node.artifacts,
         refs: node.refs,
         aliases: node.aliases,
+        skills: node.skills,
         path: path_1.default.relative(root, filePath),
         edges: normalizeEdges(node.edges, ws),
     };
@@ -128,6 +131,65 @@ function buildWorkspaceMap(config) {
     }
     return workspaces;
 }
+function listDirectories(dirPath) {
+    if (!fs_1.default.existsSync(dirPath)) {
+        return [];
+    }
+    return fs_1.default
+        .readdirSync(dirPath, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path_1.default.join(dirPath, entry.name))
+        .sort();
+}
+function validateEventsJsonl(root, config, errors) {
+    for (const [alias, workspace] of Object.entries(config.workspaces)) {
+        if (!workspace.enabled) {
+            continue;
+        }
+        const eventsPath = path_1.default.resolve(root, workspace.path, workspace.mdkg_dir, "work", "events", "events.jsonl");
+        if (!fs_1.default.existsSync(eventsPath)) {
+            continue;
+        }
+        const lines = fs_1.default.readFileSync(eventsPath, "utf8").split(/\r?\n/);
+        for (let i = 0; i < lines.length; i += 1) {
+            const raw = lines[i].trim();
+            if (!raw) {
+                continue;
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                errors.push(`${eventsPath}:${i + 1}: invalid JSON`);
+                continue;
+            }
+            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                errors.push(`${eventsPath}:${i + 1}: event must be a JSON object`);
+                continue;
+            }
+            const event = parsed;
+            for (const key of ["ts", "run_id", "workspace", "agent", "kind", "status"]) {
+                const value = event[key];
+                if (typeof value !== "string" || value.trim().length === 0) {
+                    errors.push(`${eventsPath}:${i + 1}: ${key} is required and must be a non-empty string`);
+                }
+            }
+            if (!Array.isArray(event.refs)) {
+                errors.push(`${eventsPath}:${i + 1}: refs is required and must be a list`);
+            }
+            if (!Array.isArray(event.artifacts)) {
+                errors.push(`${eventsPath}:${i + 1}: artifacts is required and must be a list`);
+            }
+            if (typeof event.notes !== "string") {
+                errors.push(`${eventsPath}:${i + 1}: notes is required and must be a string`);
+            }
+            if (typeof event.workspace === "string" && event.workspace !== alias) {
+                errors.push(`${eventsPath}:${i + 1}: workspace must match ${alias}`);
+            }
+        }
+    }
+}
 function runValidateCommand(options) {
     const config = (0, config_1.loadConfig)(options.root);
     const templateSchemas = (0, template_schema_1.loadTemplateSchemas)(options.root, config, node_1.ALLOWED_TYPES);
@@ -196,9 +258,46 @@ function runValidateCommand(options) {
     };
     const graphErrors = (0, validate_graph_1.collectGraphErrors)(index, { allowMissing: false });
     errors.push(...graphErrors);
+    try {
+        const skillsIndex = (0, skills_indexer_1.buildSkillsIndex)(options.root, config);
+        const knownSkills = new Set(Object.keys(skillsIndex.skills));
+        for (const node of Object.values(nodes)) {
+            for (const slug of node.skills) {
+                if (!knownSkills.has(slug)) {
+                    errors.push(`${node.qid}: skills reference missing slug: ${slug}`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "unknown skill validation error";
+        errors.push(message);
+    }
+    const skillsRoot = (0, skills_indexer_1.resolveSkillsRoot)(options.root, config);
+    for (const dirPath of listDirectories(skillsRoot)) {
+        const canonicalPath = path_1.default.join(dirPath, "SKILL.md");
+        const compatPath = path_1.default.join(dirPath, "SKILLS.md");
+        const hasCanonical = fs_1.default.existsSync(canonicalPath);
+        const hasCompat = fs_1.default.existsSync(compatPath);
+        if (hasCanonical && hasCompat) {
+            errors.push(`${dirPath}: both SKILL.md and SKILLS.md exist`);
+            continue;
+        }
+        if (!hasCanonical && !hasCompat) {
+            errors.push(`${dirPath}: missing SKILL.md or SKILLS.md`);
+            continue;
+        }
+        if (hasCompat) {
+            warnings.push(`${path_1.default.relative(options.root, compatPath)}: using legacy SKILLS.md compatibility file`);
+        }
+    }
+    warnings.push(...(0, skill_mirror_1.auditSkillMirrors)(options.root, config));
+    validateEventsJsonl(options.root, config, errors);
+    const uniqueWarnings = Array.from(new Set(warnings));
+    const uniqueErrors = Array.from(new Set(errors));
     const reportLines = [
-        ...warnings.map((warning) => `warning: ${warning}`),
-        ...errors,
+        ...uniqueWarnings.map((warning) => `warning: ${warning}`),
+        ...uniqueErrors,
     ];
     let outPath = undefined;
     if (options.out) {
@@ -207,20 +306,20 @@ function runValidateCommand(options) {
         fs_1.default.writeFileSync(outPath, reportLines.join("\n"), "utf8");
     }
     if (!options.quiet) {
-        for (const warning of warnings) {
+        for (const warning of uniqueWarnings) {
             console.error(`warning: ${warning}`);
         }
     }
-    if (errors.length > 0) {
+    if (uniqueErrors.length > 0) {
         if (outPath) {
-            console.error(`validation failed: ${errors.length} error(s). details written to ${outPath}`);
+            console.error(`validation failed: ${uniqueErrors.length} error(s). details written to ${outPath}`);
         }
         else {
-            for (const error of errors) {
+            for (const error of uniqueErrors) {
                 console.error(error);
             }
         }
-        throw new errors_1.ValidationError(`validation failed with ${errors.length} error(s)`);
+        throw new errors_1.ValidationError(`validation failed with ${uniqueErrors.length} error(s)`);
     }
     if (outPath) {
         console.log(`validation report written: ${outPath}`);

package/dist/graph/edges.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractEdges = extractEdges;
-const ID_REF_RE = /^([a-z][a-z0-9_]*:)?[a-z]+-[0-9]+$/;
+const id_1 = require("../util/id");
 function formatError(filePath, key, message) {
     return new Error(`${filePath}: ${key} ${message}`);
 }
@@ -10,7 +10,7 @@ function normalizeIdRef(value, filePath, key) {
     if (normalized !== value) {
         throw formatError(filePath, key, "must be lowercase");
     }
-    if (!ID_REF_RE.test(normalized)) {
+    if (!(0, id_1.isCanonicalIdRef)(normalized)) {
         throw formatError(filePath, key, `invalid id reference: ${value}`);
     }
     return normalized;

package/dist/graph/frontmatter.js

@@ -24,6 +24,7 @@ exports.DEFAULT_FRONTMATTER_KEY_ORDER = [
     "blocks",
     "refs",
     "aliases",
+    "skills",
     "cases",
     "scope",
     "created",

package/dist/graph/indexer.js

@@ -81,6 +81,7 @@ function buildIndex(root, config, options = {}) {
                     artifacts: node.artifacts,
                     refs: node.refs,
                     aliases: node.aliases,
+                    skills: node.skills,
                     path: relPath,
                     edges: normalizedEdges,
                 };
@@ -140,5 +141,25 @@ function buildIndex(root, config, options = {}) {
         reverse_edges,
     };
     (0, validate_graph_1.validateGraph)(index, { allowMissing: tolerant });
+    const latestCheckpointByWorkspace = {};
+    for (const alias of workspaceAliases) {
+        const candidates = Object.values(nodes)
+            .filter((node) => node.ws === alias && node.type === "checkpoint")
+            .sort((a, b) => {
+            if (a.updated !== b.updated) {
+                return b.updated.localeCompare(a.updated);
+            }
+            if (a.created !== b.created) {
+                return b.created.localeCompare(a.created);
+            }
+            return b.qid.localeCompare(a.qid);
+        });
+        if (candidates.length > 0) {
+            latestCheckpointByWorkspace[alias] = candidates[0].qid;
+        }
+    }
+    if (Object.keys(latestCheckpointByWorkspace).length > 0) {
+        index.meta.latest_checkpoint_qid = latestCheckpointByWorkspace;
+    }
     return index;
 }