@yansirplus/cli 0.5.17 → 0.5.19

package/dist/build/agent-authoring/manifest-compiler.js

@@ -4,10 +4,24 @@ import { isAuthorityRef } from "@yansirplus/core/effect-claim";
 import { isMaterialRef } from "@yansirplus/core/material-ref";
 import { BUILTIN_HANDLER_KINDS } from "@yansirplus/core/runtime-protocol";
 import { WORKSPACE_TOOL_DEFAULT_DECLARATIONS, } from "@yansirplus/runtime";
-import { AUTHORING_DEFAULTS_VERSION, digestText, findFunctionPath, hasFunction, isNonEmptyString, isRecord, isWorkspaceToolName, } from "./shared.js";
+import { cronMinuteExpression } from "@yansirplus/runtime/schedule";
+import { AUTHORING_DEFAULTS_VERSION, digestText, findFunctionPath, GENERATED_LOAD_SKILL_TOOL_NAME, GENERATED_READ_SKILL_FILE_TOOL_NAME, hasFunction, isNonEmptyString, isRecord, isWorkspaceToolName, } from "./shared.js";
+const SKILL_DESCRIPTION_MAX_BYTES = 240;
+const SKILL_BODY_MAX_BYTES = 131_072;
+const SKILL_SUPPORT_FILE_MAX_BYTES = 65_536;
+const SKILL_SUPPORT_FILES_MAX_COUNT = 64;
+const SKILL_SUPPORT_PACKAGE_MAX_BYTES = 262_144;
+const skillNamePattern = /^[a-z][a-z0-9_-]{0,63}$/u;
+const channelNamePattern = /^[a-z][a-z0-9_-]{0,63}$/u;
+const workflowNamePattern = /^[a-z][a-z0-9_-]{0,63}$/u;
+const scheduleSlugPattern = /^[a-z][a-z0-9_-]{0,63}$/u;
+const instructionFragmentIdPattern = /^[a-z][a-z0-9_-]{0,63}$/u;
+const dynamicResolverIdPattern = /^[a-z][a-z0-9_-]{0,63}$/u;
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder("utf-8", { fatal: true });
 const defaultOrigin = (factKey) => `default:${AUTHORING_DEFAULTS_VERSION}#${factKey}`;
 export const workspaceManifestMacroOrigin = (factKey) => `macro(workspace@1)#${factKey}`;
-const authoredPath = (path) => (path.startsWith("agent/") ? path : `agent/${path}`);
+const authoredPath = (path) => path.startsWith("workflows/") ? path : `agent/${path}`;
 const authorOrigin = (path, pointer) => `author:${authoredPath(path)}#${pointer}`;
 const pathOrigin = (path) => `path:${authoredPath(path)}`;
 const isManifestMapId = (value) => value.length > 0 && !value.includes("/") && value !== "." && value !== "..";
@@ -28,6 +42,60 @@ const parseStringField = (state, path, field, value) => {
     }
     return value;
 };
+const utf8ByteLength = (value) => textEncoder.encode(value).length;
+const isSkillName = (value) => skillNamePattern.test(value);
+const isChannelName = (value) => channelNamePattern.test(value);
+const isWorkflowName = (value) => workflowNamePattern.test(value);
+const isScheduleSlug = (value) => scheduleSlugPattern.test(value);
+const isInstructionFragmentId = (value) => instructionFragmentIdPattern.test(value);
+const isDynamicResolverId = (value) => dynamicResolverIdPattern.test(value);
+const decodeUtf8Bytes = (state, path, field, bytes) => {
+    try {
+        return textDecoder.decode(bytes);
+    }
+    catch {
+        invalidAuthoredValue(state, path, field, "utf8_required");
+        return null;
+    }
+};
+const assertNoNulText = (state, path, field, text) => {
+    if (!text.includes("\0"))
+        return true;
+    invalidAuthoredValue(state, path, field, "nul_byte_forbidden");
+    return false;
+};
+const assertRegularAuthoredSource = (state, path, sourceKind) => {
+    const kind = sourceKind ?? "regular";
+    if (kind === "regular")
+        return true;
+    state.issues.push({
+        kind: "unsupported_path",
+        path,
+        reason: kind === "symlink" ? "symlink_forbidden" : "regular_file_required",
+    });
+    return false;
+};
+const parseSkillFrontmatterStringField = (state, path, field, value) => {
+    const parsed = parseStringField(state, path, field, value);
+    if (parsed === null)
+        return null;
+    const trimmed = parsed.trim();
+    if (trimmed.length === 0) {
+        invalidAuthoredValue(state, path, field, "non_empty_string_required");
+        return null;
+    }
+    return trimmed;
+};
+const parseSkillDescriptionField = (state, path, value) => {
+    const description = parseSkillFrontmatterStringField(state, path, "/frontmatter/description", value);
+    if (description === null)
+        return null;
+    if (utf8ByteLength(description) > SKILL_DESCRIPTION_MAX_BYTES) {
+        invalidAuthoredValue(state, path, "/frontmatter/description", "skill_description_too_large");
+        return null;
+    }
+    return description;
+};
 const parseOptionalStringField = (state, path, field, value) => {
     if (value === undefined)
         return undefined;
@@ -133,7 +201,25 @@ const parseOutputSchema = (state, path, value) => {
         fingerprint: value.fingerprint,
     };
 };
-const stripAgentPrefix = (path) => path.startsWith("agent/") ? path.slice("agent/".length) : path;
+const agentGrammarRoots = new Set([
+    "agent.json",
+    "channels",
+    "domains",
+    "instructions",
+    "instructions.md",
+    "interactions",
+    "materials",
+    "skills",
+    "schedules",
+    "tools",
+]);
+const stripAgentPrefix = (path) => {
+    if (!path.startsWith("agent/"))
+        return path;
+    const rest = path.slice("agent/".length);
+    const root = rest.split("/")[0] ?? "";
+    return agentGrammarRoots.has(root) ? rest : path;
+};
 const normalizePath = (path) => {
     if (path.length === 0 || path.startsWith("/") || path.includes("\\"))
         return null;
@@ -233,6 +319,12 @@ const toolAllowedFields = new Set([
     "effects",
     "receiptPolicy",
 ]);
+const dynamicResolverAllowedFields = new Set(["outputs", "id", "name"]);
+const dynamicOutputSlots = [
+    "tools",
+    "skills",
+    "instructions",
+];
 const domainAllowedFields = new Set(["bindingRef"]);
 const interactionAllowedFields = new Set(["bindingRef"]);
 const agentAllowedFields = new Set([
@@ -241,6 +333,7 @@ const agentAllowedFields = new Set([
     "scope",
     "effectAuthorityRef",
     "handlers",
+    "capabilities",
     "llmRoutes",
     "tools",
     "materials",
@@ -380,6 +473,9 @@ const recordAgentJson = (state, path, value) => {
         invalidAuthoredValue(state, path, "/effectAuthorityRef", "authority_ref_invalid");
     }
     const handlers = value.handlers === undefined ? undefined : parseHandlers(state, path, value.handlers);
+    const capabilities = value.capabilities === undefined
+        ? undefined
+        : parseRecordMap(state, path, "/capabilities", value.capabilities, (_capability, child) => parseBindingRefObject(state, path, "/capabilities", child));
     const llmRoutes = value.llmRoutes === undefined
         ? undefined
         : parseRecordMap(state, path, "/llmRoutes", value.llmRoutes, (_route, child) => parseBindingRefObject(state, path, "/llmRoutes", child));
@@ -421,6 +517,11 @@ const recordAgentJson = (state, path, value) => {
     }
     if (handlers !== undefined && handlers !== null)
         putAuthored(state, "/handlers", handlers, authorOrigin(path, "/handlers"));
+    if (capabilities !== undefined && capabilities !== null) {
+        for (const [capabilityId, ref] of Object.entries(capabilities)) {
+            putAuthored(state, `/capabilities/${capabilityId}/bindingRef`, ref.bindingRef, authorOrigin(path, `/capabilities/${capabilityId}/bindingRef`));
+        }
+    }
     if (llmRoutes !== undefined && llmRoutes !== null) {
         for (const [route, ref] of Object.entries(llmRoutes)) {
             putAuthored(state, `/llmRoutes/${route}/bindingRef`, ref.bindingRef, authorOrigin(path, `/llmRoutes/${route}/bindingRef`));
@@ -503,7 +604,236 @@ const recordJsonFile = (state, path, value) => {
             state.issues.push({ kind: "unsupported_path", path, reason: "json_path_not_in_grammar" });
     }
 };
-const recordMarkdownFile = (state, path, text) => {
+const skillIdentityForPath = (path) => {
+    const parts = path.split("/");
+    if (parts[0] !== "skills")
+        return null;
+    if (parts.length === 2 && parts[1]?.endsWith(".md")) {
+        const name = parts[1].slice(0, -".md".length);
+        return isSkillName(name) ? name : null;
+    }
+    if (parts.length === 3 && parts[2] === "SKILL.md") {
+        const name = parts[1] ?? "";
+        return isSkillName(name) ? name : null;
+    }
+    return null;
+};
+const isPackagedSkillPath = (skill) => skill.path === `agent/skills/${skill.name}/SKILL.md`;
+const skillSupportPathForPath = (path) => {
+    const parts = path.split("/");
+    if (parts[0] !== "skills" || parts.length < 4)
+        return null;
+    const skillName = parts[1] ?? "";
+    if (!isSkillName(skillName))
+        return null;
+    const root = parts[2];
+    if (root !== "references" && root !== "scripts")
+        return null;
+    return {
+        skillName,
+        packagePath: [root, ...parts.slice(3)].join("/"),
+    };
+};
+const instructionFragmentIdForPath = (path) => {
+    const parts = path.split("/");
+    if (parts.length !== 2 || parts[0] !== "instructions" || !parts[1]?.endsWith(".md")) {
+        return null;
+    }
+    const fragmentId = parts[1].slice(0, -".md".length);
+    return isInstructionFragmentId(fragmentId) ? fragmentId : null;
+};
+const dynamicResolverIdentityForPath = (path) => {
+    const parts = path.split("/");
+    if (parts.length !== 2 || !parts[1]?.endsWith(".dynamic.ts"))
+        return null;
+    const slot = parts[0];
+    if (slot !== "tools" && slot !== "skills" && slot !== "instructions")
+        return null;
+    const resolverId = parts[1].slice(0, -".dynamic.ts".length);
+    if (!isDynamicResolverId(resolverId))
+        return null;
+    return { slot, resolverId };
+};
+const stripYamlQuotes = (value) => {
+    if (((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) &&
+        value.length >= 2) {
+        return value.slice(1, -1);
+    }
+    return value;
+};
+const parseSkillFrontmatter = (state, path, text) => {
+    const normalized = text.replace(/\r\n?/gu, "\n");
+    const lines = normalized.split("\n");
+    if (lines[0]?.trim() !== "---") {
+        invalidAuthoredValue(state, path, "/frontmatter", "frontmatter_required");
+        return null;
+    }
+    const end = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+    if (end < 0) {
+        invalidAuthoredValue(state, path, "/frontmatter", "frontmatter_not_closed");
+        return null;
+    }
+    const issueCount = state.issues.length;
+    const fields = {};
+    for (let index = 1; index < end; index += 1) {
+        const line = lines[index]?.trim() ?? "";
+        if (line.length === 0)
+            continue;
+        const match = /^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/u.exec(line);
+        if (match === null) {
+            invalidAuthoredValue(state, path, `/frontmatter/${index}`, "frontmatter_line_invalid");
+            continue;
+        }
+        const [, key, rawValue] = match;
+        if (Object.prototype.hasOwnProperty.call(fields, key)) {
+            invalidAuthoredValue(state, path, `/frontmatter/${key}`, "frontmatter_field_duplicate");
+            continue;
+        }
+        fields[key] = stripYamlQuotes(rawValue.trim());
+    }
+    assertAllowedFields(state, path, fields, new Set(["name", "description"]));
+    const name = parseSkillFrontmatterStringField(state, path, "/frontmatter/name", fields.name);
+    const description = parseSkillDescriptionField(state, path, fields.description);
+    if (name === null || description === null || state.issues.length > issueCount)
+        return null;
+    return {
+        name,
+        description,
+        body: lines
+            .slice(end + 1)
+            .join("\n")
+            .replace(/^\n/u, "")
+            .replace(/\s+$/u, ""),
+    };
+};
+const recordInstructionFragmentFile = (state, path, fragmentId, text, sourceKind) => {
+    if (!assertRegularAuthoredSource(state, path, sourceKind))
+        return;
+    if (text.trim().length === 0) {
+        invalidAuthoredValue(state, path, "/body", "instruction_fragment_empty");
+        return;
+    }
+    if (!assertNoNulText(state, path, "/body", text))
+        return;
+    const existing = state.instructionFragments.get(fragmentId);
+    if (existing !== undefined) {
+        state.issues.push({
+            kind: "duplicate_instruction_fragment",
+            fragmentId,
+            path,
+            existingPath: existing.path,
+        });
+        return;
+    }
+    state.instructionFragments.set(fragmentId, {
+        fragmentId,
+        path: authoredPath(path),
+        digest: digestText(text),
+        text,
+        origin: pathOrigin(path),
+    });
+};
+const recordSkillFile = (state, path, expectedName, text, sourceKind) => {
+    if (!isSkillName(expectedName)) {
+        state.issues.push({ kind: "unsupported_path", path, reason: "skill_name_invalid" });
+        return;
+    }
+    if (!assertRegularAuthoredSource(state, path, sourceKind))
+        return;
+    const parsed = parseSkillFrontmatter(state, path, text);
+    if (parsed === null)
+        return;
+    if (!isSkillName(parsed.name)) {
+        invalidAuthoredValue(state, path, "/frontmatter/name", "skill_name_invalid");
+        return;
+    }
+    if (parsed.name !== expectedName) {
+        state.issues.push({
+            kind: "skill_identity_mismatch",
+            path,
+            expectedName,
+            actualName: parsed.name,
+        });
+        return;
+    }
+    if (utf8ByteLength(parsed.body) > SKILL_BODY_MAX_BYTES) {
+        invalidAuthoredValue(state, path, "/body", "skill_body_too_large");
+        return;
+    }
+    if (!assertNoNulText(state, path, "/body", parsed.body))
+        return;
+    const existing = state.skills.get(expectedName);
+    if (existing !== undefined) {
+        state.issues.push({
+            kind: "duplicate_skill",
+            name: expectedName,
+            path,
+            existingPath: existing.path,
+        });
+        return;
+    }
+    state.skills.set(expectedName, {
+        name: expectedName,
+        description: parsed.description,
+        path: authoredPath(path),
+        digest: digestText(parsed.body),
+        text: parsed.body,
+        files: [],
+    });
+};
+const recordSkillSupportFile = (state, path, supportPath, bytes, sourceKind) => {
+    if (!assertRegularAuthoredSource(state, path, sourceKind))
+        return;
+    if (bytes.byteLength > SKILL_SUPPORT_FILE_MAX_BYTES) {
+        invalidAuthoredValue(state, path, "/bytes", "skill_file_too_large");
+        return;
+    }
+    const files = state.skillSupportFiles.get(supportPath.skillName) ?? [];
+    if (files.length >= SKILL_SUPPORT_FILES_MAX_COUNT) {
+        invalidAuthoredValue(state, path, "/bytes", "skill_package_too_many_files");
+        return;
+    }
+    const currentBytes = state.skillSupportByteTotals.get(supportPath.skillName) ?? 0;
+    if (currentBytes + bytes.byteLength > SKILL_SUPPORT_PACKAGE_MAX_BYTES) {
+        invalidAuthoredValue(state, path, "/bytes", "skill_package_too_large");
+        return;
+    }
+    const text = decodeUtf8Bytes(state, path, "/bytes", bytes);
+    if (text === null || !assertNoNulText(state, path, "/bytes", text))
+        return;
+    files.push({
+        path: supportPath.packagePath,
+        digest: digestText(text),
+        bytes: bytes.byteLength,
+        text,
+    });
+    state.skillSupportFiles.set(supportPath.skillName, files);
+    state.skillSupportByteTotals.set(supportPath.skillName, currentBytes + bytes.byteLength);
+};
+const recordMarkdownFile = (state, path, text, sourceKind) => {
+    const skillName = skillIdentityForPath(path);
+    if (path.startsWith("skills/")) {
+        if (skillName === null) {
+            state.issues.push({ kind: "unsupported_path", path, reason: "skill_path_not_in_grammar" });
+            return;
+        }
+        recordSkillFile(state, path, skillName, text, sourceKind);
+        return;
+    }
+    if (path.startsWith("instructions/")) {
+        const fragmentId = instructionFragmentIdForPath(path);
+        if (fragmentId === null) {
+            state.issues.push({
+                kind: "unsupported_path",
+                path,
+                reason: "instruction_fragment_path_not_in_grammar",
+            });
+            return;
+        }
+        recordInstructionFragmentFile(state, path, fragmentId, text, sourceKind);
+        return;
+    }
     if (path !== "instructions.md") {
         state.issues.push({ kind: "unsupported_path", path, reason: "markdown_path_not_in_grammar" });
         return;
@@ -516,20 +846,225 @@ const recordMarkdownFile = (state, path, text) => {
     };
     putAuthored(state, "/instructions", instructions, pathOrigin(path));
 };
+const recordTextFile = (state, path, bytes, sourceKind) => {
+    const supportPath = skillSupportPathForPath(path);
+    if (supportPath === null) {
+        state.issues.push({ kind: "unsupported_path", path, reason: "text_path_not_in_grammar" });
+        return;
+    }
+    recordSkillSupportFile(state, path, supportPath, bytes, sourceKind);
+};
 const recordToolFile = (state, path, declaration) => {
     const parts = path.split("/");
     if (parts.length !== 2 || parts[0] !== "tools" || !parts[1]?.endsWith(".ts")) {
         state.issues.push({ kind: "unsupported_path", path, reason: "tool_path_not_in_grammar" });
         return;
     }
+    if (parts[1].endsWith(".dynamic.ts")) {
+        state.issues.push({ kind: "unsupported_path", path, reason: "dynamic_path_not_in_grammar" });
+        return;
+    }
     const toolId = parts[1].slice(0, -".ts".length);
     if (toolId.length === 0) {
         state.issues.push({ kind: "unsupported_path", path, reason: "empty_path_identity" });
         return;
     }
+    if (toolId === GENERATED_LOAD_SKILL_TOOL_NAME || toolId === GENERATED_READ_SKILL_FILE_TOOL_NAME) {
+        state.issues.push({ kind: "reserved_tool_name", path, toolId });
+        return;
+    }
     state.toolFilePaths.set(toolId, path);
     recordToolFacts(state, toolId, path, declaration ?? {}, (field) => authorOrigin(path, field));
 };
+const parseDynamicOutputs = (state, path, slot, value) => {
+    if (!isRecord(value)) {
+        invalidAuthoredValue(state, path, "/outputs", "object_required");
+        return null;
+    }
+    for (const outputSlot of Object.keys(value)) {
+        if (!dynamicOutputSlots.includes(outputSlot)) {
+            state.issues.push({ kind: "unknown_field", path, field: `/outputs/${outputSlot}` });
+            continue;
+        }
+        if (outputSlot !== slot) {
+            state.issues.push({
+                kind: "dynamic_resolver_cross_slot_output",
+                path,
+                slot,
+                outputSlot: outputSlot,
+            });
+        }
+    }
+    if (!Object.prototype.hasOwnProperty.call(value, slot)) {
+        invalidAuthoredValue(state, path, `/outputs/${slot}`, "dynamic_resolver_output_required");
+        return null;
+    }
+    return parseStringArrayField(state, path, `/outputs/${slot}`, value[slot]);
+};
+const recordDynamicResolverFile = (state, path, declaration, sourceKind) => {
+    const identity = dynamicResolverIdentityForPath(path);
+    if (identity === null) {
+        state.issues.push({ kind: "unsupported_path", path, reason: "dynamic_path_not_in_grammar" });
+        return;
+    }
+    if (!assertRegularAuthoredSource(state, path, sourceKind))
+        return;
+    if (!isRecord(declaration)) {
+        invalidAuthoredValue(state, path, "/", "dynamic_resolver_declaration_object_required");
+        return;
+    }
+    const localIssueCount = state.issues.length;
+    assertNoPathIdentityFields(state, path, declaration);
+    assertAllowedFields(state, path, declaration, dynamicResolverAllowedFields);
+    assertNoRuntimeFactFields(state, path, declaration);
+    const outputs = parseDynamicOutputs(state, path, identity.slot, declaration.outputs);
+    if (outputs === null || state.issues.length > localIssueCount)
+        return;
+    const key = `${identity.slot}/${identity.resolverId}`;
+    const existing = state.dynamicResolvers.get(key);
+    if (existing !== undefined) {
+        state.issues.push({
+            kind: "duplicate_dynamic_resolver",
+            slot: identity.slot,
+            resolverId: identity.resolverId,
+            path,
+            existingPath: existing.path,
+        });
+        return;
+    }
+    state.dynamicResolvers.set(key, {
+        resolverId: identity.resolverId,
+        slot: identity.slot,
+        path: authoredPath(path),
+        outputs,
+        origin: pathOrigin(path),
+    });
+};
+const recordChannelFile = (state, path, sourceKind) => {
+    const parts = path.split("/");
+    if (parts.length !== 2 || parts[0] !== "channels" || !parts[1]?.endsWith(".ts")) {
+        state.issues.push({ kind: "unsupported_path", path, reason: "channel_path_not_in_grammar" });
+        return;
+    }
+    const name = parts[1].slice(0, -".ts".length);
+    if (name.length === 0) {
+        state.issues.push({ kind: "unsupported_path", path, reason: "empty_path_identity" });
+        return;
+    }
+    if (!isChannelName(name)) {
+        state.issues.push({ kind: "unsupported_path", path, reason: "channel_name_invalid" });
+        return;
+    }
+    if (!assertRegularAuthoredSource(state, path, sourceKind))
+        return;
+    state.channels.set(name, {
+        name,
+        path: authoredPath(path),
+        origin: pathOrigin(path),
+    });
+};
+const recordWorkflowFile = (state, path, sourceKind) => {
+    const parts = path.split("/");
+    if (parts.length !== 2 || parts[0] !== "workflows" || !parts[1]?.endsWith(".ts")) {
+        state.issues.push({ kind: "unsupported_path", path, reason: "workflow_path_not_in_grammar" });
+        return;
+    }
+    const name = parts[1].slice(0, -".ts".length);
+    if (name.length === 0) {
+        state.issues.push({ kind: "unsupported_path", path, reason: "empty_path_identity" });
+        return;
+    }
+    if (!isWorkflowName(name)) {
+        state.issues.push({ kind: "unsupported_path", path, reason: "workflow_name_invalid" });
+        return;
+    }
+    if (!assertRegularAuthoredSource(state, path, sourceKind))
+        return;
+    state.workflows.set(name, {
+        name,
+        path: authoredPath(path),
+        origin: pathOrigin(path),
+    });
+};
+const scheduleAllowedFields = new Set(["cron", "handler", "id", "name", "kind"]);
+const scheduleIdFromPath = (state, path) => {
+    const parts = path.split("/");
+    if (parts.length < 2 || parts[0] !== "schedules" || !parts[parts.length - 1]?.endsWith(".ts")) {
+        state.issues.push({ kind: "unsupported_path", path, reason: "schedule_path_not_in_grammar" });
+        return null;
+    }
+    const slugs = [...parts.slice(1, -1), parts[parts.length - 1].slice(0, -".ts".length)];
+    if (slugs.some((slug) => slug.length === 0)) {
+        state.issues.push({ kind: "unsupported_path", path, reason: "empty_path_identity" });
+        return null;
+    }
+    if (slugs.includes("subagents")) {
+        state.issues.push({
+            kind: "unsupported_path",
+            path,
+            reason: "subagent_schedule_directory_forbidden",
+        });
+        return null;
+    }
+    const invalid = slugs.find((slug) => !isScheduleSlug(slug));
+    if (invalid !== undefined) {
+        state.issues.push({ kind: "unsupported_path", path, reason: "schedule_slug_invalid" });
+        return null;
+    }
+    return slugs.join("/");
+};
+const recordScheduleFile = (state, path, declaration, sourceKind) => {
+    const scheduleId = scheduleIdFromPath(state, path);
+    if (scheduleId === null)
+        return;
+    if (!assertRegularAuthoredSource(state, path, sourceKind))
+        return;
+    if (!isRecord(declaration)) {
+        invalidAuthoredValue(state, path, "/", "schedule_declaration_object_required");
+        return;
+    }
+    const declarationRecord = declaration;
+    const localIssueCount = state.issues.length;
+    assertNoPathIdentityFields(state, path, declarationRecord);
+    if (Object.prototype.hasOwnProperty.call(declarationRecord, "kind")) {
+        state.issues.push({ kind: "identity_field_forbidden", path, field: "kind" });
+    }
+    assertAllowedFields(state, path, declarationRecord, scheduleAllowedFields);
+    assertNoRuntimeFactFields(state, path, declarationRecord);
+    if (state.issues.length > localIssueCount)
+        return;
+    if (typeof declaration.cron !== "string") {
+        invalidAuthoredValue(state, path, "/cron", "cron_string_required");
+        return;
+    }
+    if (typeof declaration.handler !== "function") {
+        invalidAuthoredValue(state, path, "/handler", "schedule_handler_function_required");
+        return;
+    }
+    let cron;
+    try {
+        cron = cronMinuteExpression(declaration.cron);
+    }
+    catch {
+        invalidAuthoredValue(state, path, "/cron", "cron_minute_expression_invalid");
+        return;
+    }
+    if (state.schedules.has(scheduleId)) {
+        const existing = state.schedules.get(scheduleId);
+        state.issues.push({
+            kind: "duplicate_path",
+            path: authoredPath(path),
+            existingPath: existing?.path ?? authoredPath(path),
+        });
+        return;
+    }
+    state.schedules.set(scheduleId, {
+        scheduleId,
+        cron,
+        path: authoredPath(path),
+        origin: pathOrigin(path),
+    });
+};
 const applyDefaults = (state) => {
     putDefault(state, "/agentId", "agent");
     const agentId = state.facts.get("/agentId")?.value;
@@ -629,6 +1164,10 @@ const buildManifest = (state) => {
         const bindingRef = factValue(state, `/llmRoutes/${id}/bindingRef`);
         return bindingRef === undefined ? null : { bindingRef };
     });
+    const capabilities = collectRecord(state, "/capabilities/", (id) => {
+        const bindingRef = factValue(state, `/capabilities/${id}/bindingRef`);
+        return bindingRef === undefined ? null : { bindingRef };
+    });
     const tools = collectRecord(state, "/tools/", (id) => collectTool(state, id));
     const materials = collectRecord(state, "/materials/", (id) => factValue(state, `/materials/${id}`) ?? null);
     const executionDomains = collectRecord(state, "/executionDomains/", (id) => {
@@ -649,6 +1188,7 @@ const buildManifest = (state) => {
         handlers: factValue(state, "/handlers") ?? [],
         ...(version === undefined ? {} : { version }),
         ...(instructions === undefined ? {} : { instructions }),
+        ...(capabilities === undefined ? {} : { capabilities }),
         ...(llmRoutes === undefined ? {} : { llmRoutes }),
         ...(tools === undefined ? {} : { tools }),
         ...(materials === undefined ? {} : { materials }),
@@ -678,10 +1218,61 @@ const buildToolFilePaths = (state) => {
     }
     return paths;
 };
+const buildChannels = (state) => [...state.channels.values()].sort((left, right) => left.name.localeCompare(right.name));
+const buildWorkflows = (state) => [...state.workflows.values()].sort((left, right) => left.name.localeCompare(right.name));
+const buildSchedules = (state) => [...state.schedules.values()].sort((left, right) => left.scheduleId.localeCompare(right.scheduleId));
+const buildInstructionFragments = (state) => [...state.instructionFragments.values()].sort((left, right) => left.fragmentId.localeCompare(right.fragmentId));
+const buildDynamicResolvers = (state) => [...state.dynamicResolvers.values()].sort((left, right) => left.slot.localeCompare(right.slot) || left.resolverId.localeCompare(right.resolverId));
+const validateSkillSupportFiles = (state) => {
+    for (const [skillName, files] of state.skillSupportFiles.entries()) {
+        const skill = state.skills.get(skillName);
+        if (skill !== undefined && isPackagedSkillPath(skill))
+            continue;
+        for (const file of files) {
+            state.issues.push({
+                kind: "unsupported_path",
+                path: `skills/${skillName}/${file.path}`,
+                reason: "skill_support_requires_packaged_skill",
+            });
+        }
+    }
+};
+const dynamicResolverTargets = (state, slot) => {
+    switch (slot) {
+        case "tools":
+            return state.toolIds;
+        case "skills":
+            return new Set(state.skills.keys());
+        case "instructions":
+            return new Set(state.instructionFragments.keys());
+    }
+};
+const validateDynamicResolvers = (state) => {
+    for (const resolver of state.dynamicResolvers.values()) {
+        const targetIds = dynamicResolverTargets(state, resolver.slot);
+        for (const targetId of resolver.outputs) {
+            if (targetIds.has(targetId))
+                continue;
+            state.issues.push({
+                kind: "dynamic_resolver_unknown_target",
+                path: resolver.path,
+                slot: resolver.slot,
+                targetId,
+            });
+        }
+    }
+};
+const buildSkills = (state) => [...state.skills.values()]
+    .map((skill) => ({
+    ...skill,
+    files: [...(state.skillSupportFiles.get(skill.name) ?? [])].sort((left, right) => left.path.localeCompare(right.path)),
+}))
+    .sort((left, right) => left.name.localeCompare(right.name));
 /**
- * Compile an authored `agent/` tree into one normalized manifest plus
- * provenance. This is the app-author entrypoint; runtime facts and provider
- * material are rejected before they can become manifest truth.
+ * Compile authored `agent/` and `workflows/` roots into one normalized
+ * manifest plus authoring facts. This is the app-author entrypoint; runtime
+ * facts and provider material are rejected before they can become manifest
+ * truth.
  *
  * @agentosPrimitive primitive.agent-authoring.compileAgentTree
  * @agentosInvariant invariant.docs.agent-projection
@@ -695,6 +1286,14 @@ export const compileAgentTree = (tree) => {
         pathKeys: new Map(),
         toolIds: new Set(),
         toolFilePaths: new Map(),
+        channels: new Map(),
+        workflows: new Map(),
+        schedules: new Map(),
+        skills: new Map(),
+        skillSupportFiles: new Map(),
+        skillSupportByteTotals: new Map(),
+        instructionFragments: new Map(),
+        dynamicResolvers: new Map(),
         workspaceToolControls: new Map(),
     };
     for (const file of tree.files) {
@@ -703,7 +1302,10 @@ export const compileAgentTree = (tree) => {
             continue;
         switch (file.kind) {
             case "markdown":
-                recordMarkdownFile(state, path, file.text);
+                recordMarkdownFile(state, path, file.text, file.sourceKind);
+                break;
+            case "text":
+                recordTextFile(state, path, file.bytes, file.sourceKind);
                 break;
             case "json":
                 recordJsonFile(state, path, file.value);
@@ -711,8 +1313,22 @@ export const compileAgentTree = (tree) => {
             case "tool":
                 recordToolFile(state, path, file.declaration);
                 break;
+            case "dynamic":
+                recordDynamicResolverFile(state, path, file.declaration, file.sourceKind);
+                break;
+            case "channel":
+                recordChannelFile(state, path, file.sourceKind);
+                break;
+            case "workflow":
+                recordWorkflowFile(state, path, file.sourceKind);
+                break;
+            case "schedule":
+                recordScheduleFile(state, path, file.declaration, file.sourceKind);
+                break;
         }
     }
+    validateSkillSupportFiles(state);
+    validateDynamicResolvers(state);
     applyDefaults(state);
     enforceL0(state);
     if (state.issues.length > 0)
@@ -732,6 +1348,12 @@ export const compileAgentTree = (tree) => {
             provenance: buildProvenance(state),
             workspaceToolControls: buildWorkspaceToolControls(state),
             toolFilePaths: buildToolFilePaths(state),
+            channels: buildChannels(state),
+            workflows: buildWorkflows(state),
+            schedules: buildSchedules(state),
+            skills: buildSkills(state),
+            instructionFragments: buildInstructionFragments(state),
+            dynamicResolvers: buildDynamicResolvers(state),
         },
     };
 };