mdkg 0.0.8 → 0.1.0

package/dist/graph/agent_file_types.js

@@ -0,0 +1,392 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_ATTRIBUTE_KEY_ORDER = exports.AGENT_FILE_BASENAMES = exports.AGENT_FILE_TYPES = void 0;
+exports.isAgentFileType = isAgentFileType;
+exports.validateAgentFileName = validateAgentFileName;
+exports.validateAgentFrontmatter = validateAgentFrontmatter;
+exports.extractAgentAttributes = extractAgentAttributes;
+const path_1 = __importDefault(require("path"));
+const id_1 = require("../util/id");
+exports.AGENT_FILE_TYPES = [
+    "spec",
+    "work",
+    "work_order",
+    "receipt",
+    "feedback",
+    "dispute",
+    "proposal",
+];
+exports.AGENT_FILE_BASENAMES = {
+    spec: "SPEC.md",
+    work: "WORK.md",
+    work_order: "WORK_ORDER.md",
+    receipt: "RECEIPT.md",
+    feedback: "FEEDBACK.md",
+    dispute: "DISPUTE.md",
+    proposal: "PROPOSAL.md",
+};
+exports.AGENT_ATTRIBUTE_KEY_ORDER = {
+    spec: [
+        "version",
+        "role",
+        "runtime_mode",
+        "work_contracts",
+        "requested_capabilities",
+        "skill_refs",
+        "tool_refs",
+        "model_refs",
+        "wasm_component_refs",
+        "runtime_image_refs",
+        "subagent_refs",
+        "resource_profile",
+        "update_policy",
+    ],
+    work: [
+        "version",
+        "agent_id",
+        "kind",
+        "pricing_model",
+        "required_capabilities",
+        "skill_refs",
+        "tool_refs",
+        "model_refs",
+        "wasm_component_refs",
+        "runtime_image_refs",
+        "subagent_refs",
+        "inputs",
+        "outputs",
+        "receipt_required",
+    ],
+    work_order: [
+        "version",
+        "work_id",
+        "work_version",
+        "requester",
+        "order_status",
+        "request_ref",
+    ],
+    receipt: [
+        "version",
+        "work_order_id",
+        "receipt_status",
+        "outcome",
+        "cost_ref",
+    ],
+    feedback: [
+        "version",
+        "target_id",
+        "sentiment",
+        "feedback_status",
+        "source_ref",
+    ],
+    dispute: [
+        "version",
+        "work_order_id",
+        "receipt_id",
+        "dispute_status",
+        "severity",
+    ],
+    proposal: [
+        "version",
+        "target_id",
+        "proposal_status",
+        "proposal_kind",
+        "evidence_refs",
+    ],
+};
+const SEMVER_RE = /^\d+\.\d+\.\d+(?:[-+][a-z0-9.-]+)?$/;
+const LOWER_TOKEN_RE = /^[a-z][a-z0-9_]*(?:-[a-z0-9_]+)*$/;
+const FIELD_DESCRIPTOR_RE = /^[a-z][a-z0-9_]*:[a-z][a-z0-9_]*(?::(?:required|optional))?$/;
+const ROLE_VALUES = new Set([
+    "orchestrator",
+    "subagent",
+    "standalone_agent",
+    "tool_service",
+    "remote_agent",
+]);
+const RUNTIME_MODE_VALUES = new Set([
+    "room_orchestrated",
+    "standalone",
+    "tool_service",
+    "remote",
+]);
+const UPDATE_POLICY_VALUES = new Set([
+    "manual",
+    "proposal_required",
+    "automatic",
+    "disabled",
+]);
+const PRICING_MODEL_VALUES = new Set([
+    "free",
+    "included",
+    "quoted",
+    "fixed",
+    "metered",
+    "subscription",
+]);
+const ORDER_STATUS_VALUES = new Set([
+    "submitted",
+    "accepted",
+    "running",
+    "completed",
+    "cancelled",
+    "failed",
+]);
+const RECEIPT_STATUS_VALUES = new Set(["recorded", "verified", "rejected"]);
+const OUTCOME_VALUES = new Set(["success", "partial", "failure"]);
+const SENTIMENT_VALUES = new Set(["positive", "neutral", "negative", "mixed"]);
+const FEEDBACK_STATUS_VALUES = new Set(["new", "triaged", "accepted", "rejected"]);
+const DISPUTE_STATUS_VALUES = new Set(["open", "investigating", "resolved", "rejected"]);
+const SEVERITY_VALUES = new Set(["low", "medium", "high", "critical"]);
+const PROPOSAL_STATUS_VALUES = new Set([
+    "proposed",
+    "accepted",
+    "rejected",
+    "superseded",
+    "implemented",
+]);
+const PROPOSAL_KIND_VALUES = new Set([
+    "spec_update",
+    "work_update",
+    "skill_update",
+    "policy_update",
+    "documentation",
+]);
+function formatError(filePath, message) {
+    return new Error(`${filePath}: ${message}`);
+}
+function isAgentFileType(type) {
+    return exports.AGENT_FILE_TYPES.includes(type);
+}
+function validateAgentFileName(type, filePath) {
+    const expected = exports.AGENT_FILE_BASENAMES[type];
+    if (path_1.default.basename(filePath) !== expected) {
+        throw formatError(filePath, `${type} files must be named ${expected}`);
+    }
+}
+function expectString(frontmatter, key, filePath) {
+    const value = frontmatter[key];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw formatError(filePath, `${key} is required and must be a non-empty string`);
+    }
+    if (value !== value.toLowerCase()) {
+        throw formatError(filePath, `${key} must be lowercase`);
+    }
+    return value;
+}
+function optionalString(frontmatter, key, filePath) {
+    const value = frontmatter[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw formatError(filePath, `${key} must be a non-empty string`);
+    }
+    if (value !== value.toLowerCase()) {
+        throw formatError(filePath, `${key} must be lowercase`);
+    }
+    return value;
+}
+function expectBoolean(frontmatter, key, filePath) {
+    const value = frontmatter[key];
+    if (typeof value !== "boolean") {
+        throw formatError(filePath, `${key} is required and must be a boolean`);
+    }
+    return value;
+}
+function expectList(frontmatter, key, filePath) {
+    const value = frontmatter[key];
+    if (!Array.isArray(value)) {
+        throw formatError(filePath, `${key} is required and must be a list`);
+    }
+    return value;
+}
+function optionalList(frontmatter, key, filePath) {
+    const value = frontmatter[key];
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw formatError(filePath, `${key} must be a list`);
+    }
+    return value;
+}
+function requirePortableId(value, key, filePath) {
+    if (!(0, id_1.isPortableId)(value)) {
+        throw formatError(filePath, `${key} must be a lowercase portable id`);
+    }
+}
+function requireSemver(value, key, filePath) {
+    if (!SEMVER_RE.test(value)) {
+        throw formatError(filePath, `${key} must be a semantic version like 1.0.0`);
+    }
+}
+function requireEnum(value, key, allowed, filePath) {
+    if (!allowed.has(value)) {
+        throw formatError(filePath, `${key} must be one of ${Array.from(allowed).join(", ")}`);
+    }
+}
+function requireLowerToken(value, key, filePath) {
+    if (!LOWER_TOKEN_RE.test(value)) {
+        throw formatError(filePath, `${key} must be lowercase snake/kebab style`);
+    }
+}
+function validateCapabilities(values, key, filePath) {
+    for (const [index, value] of values.entries()) {
+        if (value !== value.toLowerCase()) {
+            throw formatError(filePath, `${key}[${index}] must be lowercase`);
+        }
+        if (!(0, id_1.isPortableId)(value)) {
+            throw formatError(filePath, `${key}[${index}] must be a portable capability id`);
+        }
+    }
+}
+function validatePortableRefs(values, key, filePath) {
+    for (const [index, value] of values.entries()) {
+        if (value !== value.toLowerCase()) {
+            throw formatError(filePath, `${key}[${index}] must be lowercase`);
+        }
+        if (!(0, id_1.isPortableId)(value)) {
+            throw formatError(filePath, `${key}[${index}] must be a lowercase portable id`);
+        }
+    }
+}
+function validateRelativeMarkdownPaths(values, key, basename, filePath) {
+    for (const [index, value] of values.entries()) {
+        if (path_1.default.isAbsolute(value) || value.split(/[\\/]/).includes("..")) {
+            throw formatError(filePath, `${key}[${index}] must be a relative path`);
+        }
+        if (path_1.default.basename(value) !== basename) {
+            throw formatError(filePath, `${key}[${index}] must point to ${basename}`);
+        }
+    }
+}
+function validateFieldDescriptors(values, key, filePath) {
+    if (values.length === 0) {
+        throw formatError(filePath, `${key} must not be empty`);
+    }
+    for (const [index, value] of values.entries()) {
+        if (value !== value.toLowerCase() || !FIELD_DESCRIPTOR_RE.test(value)) {
+            throw formatError(filePath, `${key}[${index}] must use name:type or name:type:required|optional`);
+        }
+    }
+}
+function validateAgentFrontmatter(type, frontmatter, filePath) {
+    if (!isAgentFileType(type)) {
+        return;
+    }
+    validateAgentFileName(type, filePath);
+    const version = expectString(frontmatter, "version", filePath);
+    requireSemver(version, "version", filePath);
+    switch (type) {
+        case "spec": {
+            const role = expectString(frontmatter, "role", filePath);
+            requireEnum(role, "role", ROLE_VALUES, filePath);
+            const runtimeMode = expectString(frontmatter, "runtime_mode", filePath);
+            requireEnum(runtimeMode, "runtime_mode", RUNTIME_MODE_VALUES, filePath);
+            const updatePolicy = expectString(frontmatter, "update_policy", filePath);
+            requireEnum(updatePolicy, "update_policy", UPDATE_POLICY_VALUES, filePath);
+            validateRelativeMarkdownPaths(optionalList(frontmatter, "work_contracts", filePath), "work_contracts", "WORK.md", filePath);
+            validateCapabilities(optionalList(frontmatter, "requested_capabilities", filePath), "requested_capabilities", filePath);
+            validatePortableRefs(optionalList(frontmatter, "skill_refs", filePath), "skill_refs", filePath);
+            validatePortableRefs(optionalList(frontmatter, "tool_refs", filePath), "tool_refs", filePath);
+            validatePortableRefs(optionalList(frontmatter, "model_refs", filePath), "model_refs", filePath);
+            validatePortableRefs(optionalList(frontmatter, "wasm_component_refs", filePath), "wasm_component_refs", filePath);
+            validatePortableRefs(optionalList(frontmatter, "runtime_image_refs", filePath), "runtime_image_refs", filePath);
+            validatePortableRefs(optionalList(frontmatter, "subagent_refs", filePath), "subagent_refs", filePath);
+            const resourceProfile = optionalString(frontmatter, "resource_profile", filePath);
+            if (resourceProfile) {
+                requireLowerToken(resourceProfile, "resource_profile", filePath);
+            }
+            break;
+        }
+        case "work": {
+            const agentId = expectString(frontmatter, "agent_id", filePath);
+            requirePortableId(agentId, "agent_id", filePath);
+            const kind = expectString(frontmatter, "kind", filePath);
+            requireLowerToken(kind, "kind", filePath);
+            const pricingModel = expectString(frontmatter, "pricing_model", filePath);
+            requireEnum(pricingModel, "pricing_model", PRICING_MODEL_VALUES, filePath);
+            validateCapabilities(expectList(frontmatter, "required_capabilities", filePath), "required_capabilities", filePath);
+            validatePortableRefs(optionalList(frontmatter, "skill_refs", filePath), "skill_refs", filePath);
+            validatePortableRefs(optionalList(frontmatter, "tool_refs", filePath), "tool_refs", filePath);
+            validatePortableRefs(optionalList(frontmatter, "model_refs", filePath), "model_refs", filePath);
+            validatePortableRefs(optionalList(frontmatter, "wasm_component_refs", filePath), "wasm_component_refs", filePath);
+            validatePortableRefs(optionalList(frontmatter, "runtime_image_refs", filePath), "runtime_image_refs", filePath);
+            validatePortableRefs(optionalList(frontmatter, "subagent_refs", filePath), "subagent_refs", filePath);
+            validateFieldDescriptors(expectList(frontmatter, "inputs", filePath), "inputs", filePath);
+            validateFieldDescriptors(expectList(frontmatter, "outputs", filePath), "outputs", filePath);
+            expectBoolean(frontmatter, "receipt_required", filePath);
+            break;
+        }
+        case "work_order": {
+            const workId = expectString(frontmatter, "work_id", filePath);
+            requirePortableId(workId, "work_id", filePath);
+            const workVersion = expectString(frontmatter, "work_version", filePath);
+            requireSemver(workVersion, "work_version", filePath);
+            const requester = expectString(frontmatter, "requester", filePath);
+            requirePortableId(requester, "requester", filePath);
+            const orderStatus = expectString(frontmatter, "order_status", filePath);
+            requireEnum(orderStatus, "order_status", ORDER_STATUS_VALUES, filePath);
+            optionalString(frontmatter, "request_ref", filePath);
+            break;
+        }
+        case "receipt": {
+            const workOrderId = expectString(frontmatter, "work_order_id", filePath);
+            requirePortableId(workOrderId, "work_order_id", filePath);
+            const receiptStatus = expectString(frontmatter, "receipt_status", filePath);
+            requireEnum(receiptStatus, "receipt_status", RECEIPT_STATUS_VALUES, filePath);
+            const outcome = expectString(frontmatter, "outcome", filePath);
+            requireEnum(outcome, "outcome", OUTCOME_VALUES, filePath);
+            optionalString(frontmatter, "cost_ref", filePath);
+            break;
+        }
+        case "feedback": {
+            const targetId = expectString(frontmatter, "target_id", filePath);
+            requirePortableId(targetId, "target_id", filePath);
+            const sentiment = expectString(frontmatter, "sentiment", filePath);
+            requireEnum(sentiment, "sentiment", SENTIMENT_VALUES, filePath);
+            const feedbackStatus = expectString(frontmatter, "feedback_status", filePath);
+            requireEnum(feedbackStatus, "feedback_status", FEEDBACK_STATUS_VALUES, filePath);
+            optionalString(frontmatter, "source_ref", filePath);
+            break;
+        }
+        case "dispute": {
+            const workOrderId = expectString(frontmatter, "work_order_id", filePath);
+            requirePortableId(workOrderId, "work_order_id", filePath);
+            const receiptId = expectString(frontmatter, "receipt_id", filePath);
+            requirePortableId(receiptId, "receipt_id", filePath);
+            const disputeStatus = expectString(frontmatter, "dispute_status", filePath);
+            requireEnum(disputeStatus, "dispute_status", DISPUTE_STATUS_VALUES, filePath);
+            const severity = expectString(frontmatter, "severity", filePath);
+            requireEnum(severity, "severity", SEVERITY_VALUES, filePath);
+            break;
+        }
+        case "proposal": {
+            const targetId = expectString(frontmatter, "target_id", filePath);
+            requirePortableId(targetId, "target_id", filePath);
+            const proposalStatus = expectString(frontmatter, "proposal_status", filePath);
+            requireEnum(proposalStatus, "proposal_status", PROPOSAL_STATUS_VALUES, filePath);
+            const proposalKind = expectString(frontmatter, "proposal_kind", filePath);
+            requireEnum(proposalKind, "proposal_kind", PROPOSAL_KIND_VALUES, filePath);
+            validatePortableRefs(optionalList(frontmatter, "evidence_refs", filePath), "evidence_refs", filePath);
+            break;
+        }
+    }
+}
+function extractAgentAttributes(type, frontmatter) {
+    if (!isAgentFileType(type)) {
+        return {};
+    }
+    const attributes = {};
+    for (const key of exports.AGENT_ATTRIBUTE_KEY_ORDER[type]) {
+        const value = frontmatter[key];
+        if (value !== undefined) {
+            attributes[key] = value;
+        }
+    }
+    return attributes;
+}

package/dist/graph/edges.js

@@ -5,12 +5,15 @@ const id_1 = require("../util/id");
 function formatError(filePath, key, message) {
     return new Error(`${filePath}: ${key} ${message}`);
 }
-function normalizeIdRef(value, filePath, key) {
+function normalizeIdRef(value, filePath, key, options) {
     const normalized = value.toLowerCase();
     if (normalized !== value) {
         throw formatError(filePath, key, "must be lowercase");
     }
-    if (!(0, id_1.isCanonicalIdRef)(normalized)) {
+    const valid = options.allowPortableRefs
+        ? (0, id_1.isPortableIdRef)(normalized)
+        : (0, id_1.isCanonicalIdRef)(normalized);
+    if (!valid) {
         throw formatError(filePath, key, `invalid id reference: ${value}`);
     }
     return normalized;
@@ -35,7 +38,7 @@ function readStringList(fm, key) {
     }
     return value;
 }
-function extractEdges(frontmatter, filePath) {
+function extractEdges(frontmatter, filePath, options = {}) {
     const epic = readString(frontmatter, "epic");
     const parent = readString(frontmatter, "parent");
     const prev = readString(frontmatter, "prev");
@@ -44,21 +47,21 @@ function extractEdges(frontmatter, filePath) {
     const blocked_by = readStringList(frontmatter, "blocked_by") ?? [];
     const blocks = readStringList(frontmatter, "blocks") ?? [];
     const edges = {
-        relates: relates.map((value) => normalizeIdRef(value, filePath, "relates")),
-        blocked_by: blocked_by.map((value) => normalizeIdRef(value, filePath, "blocked_by")),
-        blocks: blocks.map((value) => normalizeIdRef(value, filePath, "blocks")),
+        relates: relates.map((value) => normalizeIdRef(value, filePath, "relates", options)),
+        blocked_by: blocked_by.map((value) => normalizeIdRef(value, filePath, "blocked_by", options)),
+        blocks: blocks.map((value) => normalizeIdRef(value, filePath, "blocks", options)),
     };
     if (epic) {
-        edges.epic = normalizeIdRef(epic, filePath, "epic");
+        edges.epic = normalizeIdRef(epic, filePath, "epic", options);
     }
     if (parent) {
-        edges.parent = normalizeIdRef(parent, filePath, "parent");
+        edges.parent = normalizeIdRef(parent, filePath, "parent", options);
     }
     if (prev) {
-        edges.prev = normalizeIdRef(prev, filePath, "prev");
+        edges.prev = normalizeIdRef(prev, filePath, "prev", options);
     }
     if (next) {
-        edges.next = normalizeIdRef(next, filePath, "next");
+        edges.next = normalizeIdRef(next, filePath, "next", options);
     }
     return edges;
 }

package/dist/graph/frontmatter.js

@@ -15,6 +15,39 @@ exports.DEFAULT_FRONTMATTER_KEY_ORDER = [
     "prev",
     "next",
     "supersedes",
+    "version",
+    "role",
+    "runtime_mode",
+    "work_contracts",
+    "requested_capabilities",
+    "resource_profile",
+    "update_policy",
+    "agent_id",
+    "kind",
+    "pricing_model",
+    "required_capabilities",
+    "inputs",
+    "outputs",
+    "receipt_required",
+    "work_id",
+    "work_version",
+    "requester",
+    "order_status",
+    "request_ref",
+    "work_order_id",
+    "receipt_status",
+    "outcome",
+    "cost_ref",
+    "target_id",
+    "sentiment",
+    "feedback_status",
+    "source_ref",
+    "receipt_id",
+    "dispute_status",
+    "severity",
+    "proposal_status",
+    "proposal_kind",
+    "evidence_refs",
     "tags",
     "owners",
     "links",

package/dist/graph/indexer.js

@@ -82,6 +82,7 @@ function buildIndex(root, config, options = {}) {
                     refs: node.refs,
                     aliases: node.aliases,
                     skills: node.skills,
+                    attributes: node.attributes,
                     path: relPath,
                     edges: normalizedEdges,
                 };

package/dist/graph/node.js

@@ -4,13 +4,26 @@ exports.ALLOWED_TYPES = exports.DEC_TYPES = exports.WORK_TYPES = void 0;
 exports.parseNode = parseNode;
 const frontmatter_1 = require("./frontmatter");
 const edges_1 = require("./edges");
-const template_schema_1 = require("./template_schema");
-Object.defineProperty(exports, "ALLOWED_TYPES", { enumerable: true, get: function () { return template_schema_1.ALLOWED_TYPES; } });
-Object.defineProperty(exports, "DEC_TYPES", { enumerable: true, get: function () { return template_schema_1.DEC_TYPES; } });
-Object.defineProperty(exports, "WORK_TYPES", { enumerable: true, get: function () { return template_schema_1.WORK_TYPES; } });
+const agent_file_types_1 = require("./agent_file_types");
 const id_1 = require("../util/id");
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 const DEC_ID_RE = /^dec-[0-9]+$/;
+exports.WORK_TYPES = new Set(["epic", "feat", "task", "bug", "checkpoint", "test"]);
+exports.DEC_TYPES = new Set(["dec"]);
+exports.ALLOWED_TYPES = new Set([
+    "rule",
+    "prd",
+    "edd",
+    "dec",
+    "prop",
+    "epic",
+    "feat",
+    "task",
+    "bug",
+    "checkpoint",
+    "test",
+    ...agent_file_types_1.AGENT_FILE_TYPES,
+]);
 const DEC_STATUS = new Set(["proposed", "accepted", "rejected", "superseded"]);
 const SKILL_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 function formatError(filePath, message) {
@@ -72,6 +85,12 @@ function requireIdFormat(value, key, filePath) {
     }
     return value;
 }
+function requirePortableIdFormat(value, key, filePath) {
+    if (!(0, id_1.isPortableId)(value)) {
+        throw formatError(filePath, `${key} must be a lowercase portable id`);
+    }
+    return value;
+}
 function requireDate(value, key, filePath) {
     if (!DATE_RE.test(value)) {
         throw formatError(filePath, `${key} must be YYYY-MM-DD`);
@@ -88,12 +107,13 @@ function parsePriority(value, filePath, min, max) {
     }
     return parsed;
 }
-function normalizeIdList(values, key, filePath) {
+function normalizeIdList(values, key, filePath, allowPortableIds = false) {
     return values.map((value) => {
         if (value !== value.toLowerCase()) {
             throw formatError(filePath, `${key} entries must be lowercase`);
         }
-        if (!isValidId(value)) {
+        const valid = allowPortableIds ? (0, id_1.isPortableId)(value) : isValidId(value);
+        if (!valid) {
             throw formatError(filePath, `${key} entries must match <prefix>-<number> or reserved id`);
         }
         return value;
@@ -142,19 +162,24 @@ function validateTemplateKeys(frontmatter, schema, filePath) {
 function parseNode(content, filePath, options) {
     const { frontmatter, body } = (0, frontmatter_1.parseFrontmatter)(content, filePath);
     const type = requireLowercase(expectString(frontmatter, "type", filePath), "type", filePath);
-    if (!template_schema_1.ALLOWED_TYPES.has(type)) {
-        throw formatError(filePath, `type must be one of ${Array.from(template_schema_1.ALLOWED_TYPES).join(", ")}`);
+    if (!exports.ALLOWED_TYPES.has(type)) {
+        throw formatError(filePath, `type must be one of ${Array.from(exports.ALLOWED_TYPES).join(", ")}`);
     }
+    const isAgentType = (0, agent_file_types_1.isAgentFileType)(type);
     const schema = requireTemplateSchema(type, options.templateSchemas, filePath);
     validateTemplateKeys(frontmatter, schema, filePath);
-    const id = requireIdFormat(requireLowercase(expectString(frontmatter, "id", filePath), "id", filePath), "id", filePath);
+    (0, agent_file_types_1.validateAgentFrontmatter)(type, frontmatter, filePath);
+    const idValue = requireLowercase(expectString(frontmatter, "id", filePath), "id", filePath);
+    const id = isAgentType
+        ? requirePortableIdFormat(idValue, "id", filePath)
+        : requireIdFormat(idValue, "id", filePath);
     const title = expectString(frontmatter, "title", filePath);
     const created = requireDate(expectString(frontmatter, "created", filePath), "created", filePath);
     const updated = requireDate(expectString(frontmatter, "updated", filePath), "updated", filePath);
     const statusValue = optionalString(frontmatter, "status", filePath);
     let status = undefined;
     const workStatus = new Set(options.workStatusEnum.map((value) => value.toLowerCase()));
-    if (template_schema_1.WORK_TYPES.has(type)) {
+    if (exports.WORK_TYPES.has(type)) {
         if (!statusValue) {
             throw formatError(filePath, "status is required for work items");
         }
@@ -164,7 +189,7 @@ function parseNode(content, filePath, options) {
         }
         status = normalized;
     }
-    else if (template_schema_1.DEC_TYPES.has(type)) {
+    else if (exports.DEC_TYPES.has(type)) {
         if (!statusValue) {
             throw formatError(filePath, "status is required for decision records");
         }
@@ -180,7 +205,7 @@ function parseNode(content, filePath, options) {
     const priorityValue = optionalString(frontmatter, "priority", filePath);
     let priority = undefined;
     if (priorityValue !== undefined) {
-        if (!template_schema_1.WORK_TYPES.has(type)) {
+        if (!exports.WORK_TYPES.has(type)) {
             throw formatError(filePath, "priority is only allowed for work items");
         }
         priority = parsePriority(priorityValue, filePath, options.priorityMin, options.priorityMax);
@@ -189,17 +214,17 @@ function parseNode(content, filePath, options) {
     const owners = requireLowercaseList(optionalList(frontmatter, "owners", filePath), "owners", filePath);
     const links = optionalList(frontmatter, "links", filePath);
     const artifacts = optionalList(frontmatter, "artifacts", filePath);
-    const refs = normalizeIdList(optionalList(frontmatter, "refs", filePath), "refs", filePath);
+    const refs = normalizeIdList(optionalList(frontmatter, "refs", filePath), "refs", filePath, isAgentType);
     const aliases = requireLowercaseList(optionalList(frontmatter, "aliases", filePath), "aliases", filePath);
     const skillsRaw = optionalList(frontmatter, "skills", filePath);
     const skills = normalizeSkillList(skillsRaw, filePath);
-    if (skills.length > 0 && !template_schema_1.WORK_TYPES.has(type)) {
+    if (skills.length > 0 && !exports.WORK_TYPES.has(type)) {
         throw formatError(filePath, "skills is only allowed for work items");
     }
     normalizeIdList(optionalList(frontmatter, "scope", filePath), "scope", filePath);
     const supersedesValue = optionalString(frontmatter, "supersedes", filePath);
     if (supersedesValue !== undefined) {
-        if (!template_schema_1.DEC_TYPES.has(type)) {
+        if (!exports.DEC_TYPES.has(type)) {
             throw formatError(filePath, "supersedes is only allowed for decision records");
         }
         const normalized = requireLowercase(supersedesValue, "supersedes", filePath);
@@ -207,7 +232,8 @@ function parseNode(content, filePath, options) {
             throw formatError(filePath, "supersedes must be a dec-# id");
         }
     }
-    const edges = (0, edges_1.extractEdges)(frontmatter, filePath);
+    const edges = (0, edges_1.extractEdges)(frontmatter, filePath, { allowPortableRefs: isAgentType });
+    const attributes = (0, agent_file_types_1.extractAgentAttributes)(type, frontmatter);
     return {
         id,
         type,
@@ -224,6 +250,7 @@ function parseNode(content, filePath, options) {
         aliases,
         skills,
         edges,
+        attributes,
         body,
         frontmatter,
     };

package/dist/graph/skills_indexer.js

@@ -81,6 +81,13 @@ function extractOchatr(frontmatter) {
     }
     return extracted;
 }
+function stripPrefix(values, prefix) {
+    const stripped = {};
+    for (const [key, value] of Object.entries(values)) {
+        stripped[key.slice(prefix.length)] = value;
+    }
+    return stripped;
+}
 function hasDirectory(dirPath) {
     if (!fs_1.default.existsSync(dirPath)) {
         return false;
@@ -113,6 +120,11 @@ function buildSkillIndexEntry(root, slug, filePath) {
     const authors = toLowercaseList(optionalList(frontmatter, "authors", filePath));
     const links = optionalList(frontmatter, "links", filePath);
     const skillDir = path_1.default.dirname(filePath);
+    const ochatr = extractOchatr(frontmatter);
+    const extensions = {};
+    if (Object.keys(ochatr).length > 0) {
+        extensions.ochatr = stripPrefix(ochatr, "ochatr_");
+    }
     return {
         slug,
         id: `skill:${slug}`,
@@ -128,7 +140,8 @@ function buildSkillIndexEntry(root, slug, filePath) {
         path: path_1.default.relative(root, filePath),
         has_scripts: hasDirectory(path_1.default.join(skillDir, "scripts")),
         has_references: hasDirectory(path_1.default.join(skillDir, "references")),
-        ochatr: extractOchatr(frontmatter),
+        extensions,
+        ochatr,
     };
 }
 function buildSkillsIndex(root, config) {