@agentxm/client-core 0.19.2 → 0.20.0

package/dist/src/unstable/settings/schema.js

@@ -7,11 +7,12 @@
  */
 import * as Schema from "effect/Schema";
 import * as SchemaTransformation from "effect/SchemaTransformation";
-import { ConfigurableAgentIdSchema, EXTENSION_NAME_PATTERN } from "../extensions/common.js";
+import { ConfigurableAgentIdSchema, EXTENSION_NAME_PATTERN, FQN_PATTERN, } from "../extensions/common.js";
 import { FileInputValueSchema } from "../files/manifest-schema.js";
 import { HandleSchema } from "../extensions/handle.js";
 import { LibraryRefSchema } from "../libraries/index.js";
 import { LintConfigSchema } from "../lint/config.js";
+import { isWorkspaceSourceLocator } from "../sources/workspace.js";
 // -----------------------------------------------------------------------------
 // Source Host Config (array-based, discriminated on `type` field)
 // -----------------------------------------------------------------------------
@@ -21,13 +22,13 @@ import { LintConfigSchema } from "../lint/config.js";
  *
  * @experimental This API is unstable and may change without notice.
  */
-const SOURCE_NAME_PATTERN = /^[a-z0-9][a-z0-9.-]*$/;
+const SOURCE_NAME_PATTERN = /^(?!workspace$)[a-z0-9][a-z0-9.-]*$/;
 const SourceNameSchema = Schema.String.check(Schema.isPattern(SOURCE_NAME_PATTERN, {
-    message: "source name must start with a letter or digit and contain only lowercase alphanumeric characters, hyphens, and dots",
+    message: 'source name must start with a letter or digit, contain only lowercase alphanumeric characters, hyphens, and dots, and must not be reserved name "workspace"',
 })).annotate({
     identifier: "SourceName",
     title: "Source Name",
-    description: "A source host alias: lowercase letters, numbers, hyphens, and dots.",
+    description: 'A source host alias: lowercase letters, numbers, hyphens, and dots. The name "workspace" is reserved.',
     examples: ["github", "my-registry.dev"],
 });
 const sourceNameFieldSchema = SourceNameSchema.pipe(Schema.annotateKey({ messageMissingKey: "source name is required" }), Schema.annotate({
@@ -129,10 +130,6 @@ export const SourceHostConfigSchema = Schema.Union([
 const ExtensionMapKeySchema = Schema.String.check(Schema.isPattern(EXTENSION_NAME_PATTERN, {
     message: "Names must be max 64 chars, lowercase letters/numbers/hyphens, not starting or ending with hyphen.",
 }));
-const authoredFieldSchema = Schema.optionalKey(Schema.Boolean.annotate({
-    description: "Set to true to mark this entry as authored locally in this workspace — for extensions you edit here. AXM treats authored entries as locally owned: it preserves their files on uninstall, keeps the local source instead of repointing to the registry on update, and re-resolves them from the local managed copy on enable. Omit otherwise — false is the default and should not be written explicitly.",
-    default: false,
-}));
 const enabledFieldSchema = Schema.optionalKey(Schema.Boolean.annotate({
     description: "Set to false to disable this entry. Omit otherwise — true is the default and should not be written explicitly.",
     default: true,
@@ -145,6 +142,26 @@ const entrySourceFieldSchema = (label, fqnType) => Schema.NonEmptyString.pipe(Sc
         "./extensions/code-review",
     ],
 }));
+const workspaceEntriesMatch = (pluralType) => Schema.makeFilter((entries) => {
+    for (const [entryName, entry] of Object.entries(entries)) {
+        if (!isWorkspaceSourceLocator(entry.source))
+            continue;
+        const fqn = entry.source.slice("workspace:".length);
+        const match = FQN_PATTERN.exec(fqn);
+        if (match === null) {
+            return `Workspace source "${entry.source}" must be workspace:@owner/<plural-type>/<name> without a version`;
+        }
+        const sourceType = match[2];
+        const sourceName = match[3];
+        if (sourceType !== pluralType) {
+            return `Workspace source "${entry.source}" has type "${sourceType ?? ""}", but this settings section requires "${pluralType}"`;
+        }
+        if (sourceName !== entryName) {
+            return `Workspace source "${entry.source}" has name "${sourceName ?? ""}", but the settings key is "${entryName}"`;
+        }
+    }
+    return undefined;
+});
 const McpServerEnvSchema = Schema.Union([
     Schema.Record(Schema.String, Schema.String),
     Schema.Array(Schema.String),
@@ -228,25 +245,21 @@ const compactOrVerboseEntry = (objectSchema, canonicalSchema, transformation, an
 const EnabledEntryCanonicalSchema = Schema.Struct({
     source: Schema.String,
     enabled: Schema.Boolean,
-    authored: Schema.Boolean,
 });
 const decodeEnabledEntry = (entry) => typeof entry === "string"
-    ? { source: entry, enabled: true, authored: false }
+    ? { source: entry, enabled: true }
     : {
         source: entry.source,
         enabled: entry.enabled ?? true,
-        authored: entry.authored ?? false,
     };
 const encodeEnabledEntry = (entry) => {
-    if (entry.enabled && !entry.authored)
+    if (entry.enabled)
         return entry.source;
     const obj = {
         source: entry.source,
     };
     if (!entry.enabled)
         obj.enabled = false;
-    if (entry.authored)
-        obj.authored = true;
     return obj;
 };
 const enabledEntryTransformation = {
@@ -262,17 +275,15 @@ const compactEnabledEntry = (objectSchema, annotations) => compactOrVerboseEntry
 export const SkillEntryObjectSchema = Schema.Struct({
     source: entrySourceFieldSchema("skill", "skills"),
     enabled: enabledFieldSchema,
-    authored: authoredFieldSchema,
 }).annotate({
     title: "Skill Entry Object",
-    description: "A skill entry with source and optional enabled/authored flags.",
+    description: "A skill entry with source and an optional enabled flag.",
 });
 /**
- * Union of skill entry forms: plain source string or object with source + enabled + authored.
+ * Union of skill entry forms: plain source string or object with source + enabled.
  *
- * Decodes to canonical `{ source, enabled, authored }` form; encodes back to
- * the most compact JSON representation (plain string when enabled and not
- * authored, object otherwise).
+ * Decodes to canonical `{ source, enabled }` form; encodes back to the most
+ * compact JSON representation.
  *
  * @experimental This API is unstable and may change without notice.
  */
@@ -297,7 +308,10 @@ export const SkillEntrySchema = compactEnabledEntry(SkillEntryObjectSchema, {
  *
  * @experimental This API is unstable and may change without notice.
  */
-export const SkillsMapSchema = Schema.Record(ExtensionMapKeySchema, SkillEntrySchema).annotate({
+export const SkillsMapSchema = Schema.Record(Schema.String, SkillEntrySchema)
+    .check(Schema.isPropertyNames(ExtensionMapKeySchema))
+    .check(workspaceEntriesMatch("skills"))
+    .annotate({
     identifier: "SkillsMap",
     title: "Skills Map",
     description: "A map of skill names to skill entries.",
@@ -310,17 +324,15 @@ export const SkillsMapSchema = Schema.Record(ExtensionMapKeySchema, SkillEntrySc
 export const CommandEntryObjectSchema = Schema.Struct({
     source: entrySourceFieldSchema("command", "commands"),
     enabled: enabledFieldSchema,
-    authored: authoredFieldSchema,
 }).annotate({
     title: "Command Entry Object",
-    description: "A command entry with source and optional enabled/authored flags.",
+    description: "A command entry with source and an optional enabled flag.",
 });
 /**
- * Union of command entry forms: plain source string or object with source + enabled + authored.
+ * Union of command entry forms: plain source string or object with source + enabled.
  *
- * Decodes to canonical `{ source, enabled, authored }` form; encodes back to
- * the most compact JSON representation (plain string when enabled and not
- * authored, object otherwise).
+ * Decodes to canonical `{ source, enabled }` form; encodes back to the most
+ * compact JSON representation.
  *
  * @experimental This API is unstable and may change without notice.
  */
@@ -345,7 +357,10 @@ export const CommandEntrySchema = compactEnabledEntry(CommandEntryObjectSchema,
  *
  * @experimental This API is unstable and may change without notice.
  */
-export const CommandsMapSchema = Schema.Record(ExtensionMapKeySchema, CommandEntrySchema).annotate({
+export const CommandsMapSchema = Schema.Record(Schema.String, CommandEntrySchema)
+    .check(Schema.isPropertyNames(ExtensionMapKeySchema))
+    .check(workspaceEntriesMatch("commands"))
+    .annotate({
     identifier: "CommandsMap",
     title: "Commands Map",
     description: "A map of command names to command entries.",
@@ -361,7 +376,6 @@ export const CommandsMapSchema = Schema.Record(ExtensionMapKeySchema, CommandEnt
 export const FilesEntryObjectSchema = Schema.Struct({
     source: entrySourceFieldSchema("Context Files package", "files"),
     enabled: enabledFieldSchema,
-    authored: authoredFieldSchema,
     inputs: Schema.optionalKey(FileInputValuesMapSchema),
 }).annotate({
     title: "Files Entry Object",
@@ -370,7 +384,7 @@ export const FilesEntryObjectSchema = Schema.Struct({
 /**
  * Union of Context Files package entry forms: plain source string or object with source, flags, and inputs.
  *
- * Decodes to canonical `{ source, enabled, authored, inputs }` form; encodes
+ * Decodes to canonical `{ source, enabled, inputs }` form; encodes
  * back to a plain source string when all metadata is default and no inputs are
  * set.
  *
@@ -379,26 +393,22 @@ export const FilesEntryObjectSchema = Schema.Struct({
 export const FilesEntrySchema = compactOrVerboseEntry(FilesEntryObjectSchema, Schema.Struct({
     source: Schema.String,
     enabled: Schema.Boolean,
-    authored: Schema.Boolean,
     inputs: FileInputValuesMapSchema,
 }), {
     decode: (entry) => typeof entry === "string"
-        ? { source: entry, enabled: true, authored: false, inputs: {} }
+        ? { source: entry, enabled: true, inputs: {} }
         : {
             source: entry.source,
             enabled: entry.enabled ?? true,
-            authored: entry.authored ?? false,
             inputs: entry.inputs ?? {},
         },
     encode: (entry) => {
         const hasInputs = Object.keys(entry.inputs).length > 0;
-        if (entry.enabled && !entry.authored && !hasInputs)
+        if (entry.enabled && !hasInputs)
             return entry.source;
         const obj = { source: entry.source };
         if (!entry.enabled)
             obj.enabled = false;
-        if (entry.authored)
-            obj.authored = true;
         if (hasInputs)
             obj.inputs = entry.inputs;
         return obj;
@@ -420,7 +430,10 @@ export const FilesEntrySchema = compactOrVerboseEntry(FilesEntryObjectSchema, Sc
  *
  * @experimental This API is unstable and may change without notice.
  */
-export const FilesMapSchema = Schema.Record(ExtensionMapKeySchema, FilesEntrySchema).annotate({
+export const FilesMapSchema = Schema.Record(Schema.String, FilesEntrySchema)
+    .check(Schema.isPropertyNames(ExtensionMapKeySchema))
+    .check(workspaceEntriesMatch("files"))
+    .annotate({
     identifier: "FilesMap",
     title: "Files Map",
     description: "A map of Context Files package names to Context Files package entries.",
@@ -436,13 +449,12 @@ export const FilesMapSchema = Schema.Record(ExtensionMapKeySchema, FilesEntrySch
 export const RuleEntryObjectSchema = Schema.Struct({
     source: entrySourceFieldSchema("rule", "rules"),
     enabled: enabledFieldSchema,
-    authored: authoredFieldSchema,
 }).annotate({
     title: "Rule Entry Object",
-    description: "A rule entry with source and optional enabled/authored flags.",
+    description: "A rule entry with source and an optional enabled flag.",
 });
 /**
- * Union of rule entry forms: plain source string or object with source + enabled + authored.
+ * Union of rule entry forms: plain source string or object with source + enabled.
  *
  * @experimental This API is unstable and may change without notice.
  */
@@ -460,7 +472,10 @@ export const RuleEntrySchema = compactEnabledEntry(RuleEntryObjectSchema, {
  *
  * @experimental This API is unstable and may change without notice.
  */
-export const RulesMapSchema = Schema.Record(ExtensionMapKeySchema, RuleEntrySchema).annotate({
+export const RulesMapSchema = Schema.Record(Schema.String, RuleEntrySchema)
+    .check(Schema.isPropertyNames(ExtensionMapKeySchema))
+    .check(workspaceEntriesMatch("rules"))
+    .annotate({
     identifier: "RulesMap",
     title: "Rules Map",
     description: "A map of rule names to rule entries.",
@@ -476,13 +491,12 @@ export const RulesMapSchema = Schema.Record(ExtensionMapKeySchema, RuleEntrySche
 export const HookEntryObjectSchema = Schema.Struct({
     source: entrySourceFieldSchema("hook", "hooks"),
     enabled: enabledFieldSchema,
-    authored: authoredFieldSchema,
 }).annotate({
     title: "Hook Entry Object",
-    description: "A hook entry with source and optional enabled/authored flags.",
+    description: "A hook entry with source and an optional enabled flag.",
 });
 /**
- * Union of hook entry forms: plain source string or object with source + enabled + authored.
+ * Union of hook entry forms: plain source string or object with source + enabled.
  *
  * @experimental This API is unstable and may change without notice.
  */
@@ -500,7 +514,10 @@ export const HookEntrySchema = compactEnabledEntry(HookEntryObjectSchema, {
  *
  * @experimental This API is unstable and may change without notice.
  */
-export const HooksMapSchema = Schema.Record(ExtensionMapKeySchema, HookEntrySchema).annotate({
+export const HooksMapSchema = Schema.Record(Schema.String, HookEntrySchema)
+    .check(Schema.isPropertyNames(ExtensionMapKeySchema))
+    .check(workspaceEntriesMatch("hooks"))
+    .annotate({
     identifier: "HooksMap",
     title: "Hooks Map",
     description: "A map of hook names to hook entries.",
@@ -516,11 +533,10 @@ export const HooksMapSchema = Schema.Record(ExtensionMapKeySchema, HookEntrySche
 export const McpServerEntryObjectSchema = Schema.Struct({
     source: entrySourceFieldSchema("MCP server", "mcps"),
     enabled: enabledFieldSchema,
-    authored: authoredFieldSchema,
     env: Schema.optionalKey(McpServerEnvSchema),
 }).annotate({
     title: "MCP Server Entry Object",
-    description: "An MCP server entry with source and optional enabled/authored/env fields.",
+    description: "An MCP server entry with source and optional enabled/env fields.",
 });
 const McpServerVerboseEntryObjectSchema = Schema.Struct({
     source: Schema.optionalKey(entrySourceFieldSchema("MCP server", "mcps")),
@@ -540,14 +556,13 @@ const McpServerVerboseEntryObjectSchema = Schema.Struct({
         description: "HTTP headers for a remote MCP server. Prefer ${VAR} references for secrets.",
     })),
     enabled: enabledFieldSchema,
-    authored: authoredFieldSchema,
     env: Schema.optionalKey(McpServerEnvSchema),
 }).pipe(Schema.check(Schema.makeFilter((entry) => validateMcpTransportExclusivity(entry))));
 /**
- * Union of MCP server entry forms: plain source string or object with source + enabled + authored + env.
+ * Union of MCP server entry forms: plain source string or object with source + enabled + env.
  *
- * Decodes to canonical `{ source, enabled, authored, env }` form; encodes back to the most
- * compact JSON representation (plain string when enabled, not authored, and env is empty).
+ * Decodes to canonical `{ source, enabled, env }` form; encodes back to the most
+ * compact JSON representation.
  *
  * @experimental This API is unstable and may change without notice.
  */
@@ -558,11 +573,10 @@ export const McpServerEntrySchema = compactOrVerboseEntry(McpServerVerboseEntryO
     url: Schema.optional(Schema.String),
     headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
     enabled: Schema.Boolean,
-    authored: Schema.Boolean,
     env: Schema.Record(Schema.String, Schema.String),
 }), {
     decode: (entry) => typeof entry === "string"
-        ? { source: entry, enabled: true, authored: false, env: {} }
+        ? { source: entry, enabled: true, env: {} }
         : {
             source: "source" in entry && entry.source !== undefined ? entry.source : "inline",
             ...("command" in entry && entry.command !== undefined
@@ -574,14 +588,10 @@ export const McpServerEntrySchema = compactOrVerboseEntry(McpServerVerboseEntryO
                 ? { headers: entry.headers }
                 : {}),
             enabled: entry.enabled ?? true,
-            authored: entry.authored ?? false,
             env: decodeMcpEnv(entry.env),
         },
     encode: (entry) => {
-        if (entry.source !== "inline" &&
-            entry.enabled &&
-            !entry.authored &&
-            Object.keys(entry.env).length === 0) {
+        if (entry.source !== "inline" && entry.enabled && Object.keys(entry.env).length === 0) {
             return entry.source;
         }
         const obj = {};
@@ -598,15 +608,12 @@ export const McpServerEntrySchema = compactOrVerboseEntry(McpServerVerboseEntryO
         }
         if (!entry.enabled)
             obj.enabled = false;
-        if (entry.authored)
-            obj.authored = true;
         if (Object.keys(entry.env).length > 0)
             obj.env = entry.env;
         if (entry.source !== "inline") {
             return {
                 source: entry.source,
                 ...(obj.enabled === undefined ? {} : { enabled: obj.enabled }),
-                ...(obj.authored === undefined ? {} : { authored: obj.authored }),
                 ...(obj.env === undefined ? {} : { env: obj.env }),
             };
         }
@@ -615,7 +622,6 @@ export const McpServerEntrySchema = compactOrVerboseEntry(McpServerVerboseEntryO
                 command: entry.command,
                 ...(obj.args === undefined ? {} : { args: obj.args }),
                 ...(obj.enabled === undefined ? {} : { enabled: obj.enabled }),
-                ...(obj.authored === undefined ? {} : { authored: obj.authored }),
                 ...(obj.env === undefined ? {} : { env: obj.env }),
             };
         }
@@ -623,7 +629,6 @@ export const McpServerEntrySchema = compactOrVerboseEntry(McpServerVerboseEntryO
             url: entry.url ?? "",
             ...(obj.headers === undefined ? {} : { headers: obj.headers }),
             ...(obj.enabled === undefined ? {} : { enabled: obj.enabled }),
-            ...(obj.authored === undefined ? {} : { authored: obj.authored }),
             ...(obj.env === undefined ? {} : { env: obj.env }),
         };
     },
@@ -645,7 +650,10 @@ export const McpServerEntrySchema = compactOrVerboseEntry(McpServerVerboseEntryO
  *
  * @experimental This API is unstable and may change without notice.
  */
-export const McpServersMapSchema = Schema.Record(ExtensionMapKeySchema, McpServerEntrySchema).annotate({
+export const McpServersMapSchema = Schema.Record(Schema.String, McpServerEntrySchema)
+    .check(Schema.isPropertyNames(ExtensionMapKeySchema))
+    .check(workspaceEntriesMatch("mcps"))
+    .annotate({
     identifier: "McpServersMap",
     title: "MCP Servers Map",
     description: "A map of MCP server names to MCP server entries.",
@@ -661,17 +669,15 @@ export const McpServersMapSchema = Schema.Record(ExtensionMapKeySchema, McpServe
 export const SubagentEntryObjectSchema = Schema.Struct({
     source: entrySourceFieldSchema("subagent", "subagents"),
     enabled: enabledFieldSchema,
-    authored: authoredFieldSchema,
 }).annotate({
     title: "Subagent Entry Object",
-    description: "A subagent entry with source and optional enabled/authored flags.",
+    description: "A subagent entry with source and an optional enabled flag.",
 });
 /**
- * Union of subagent entry forms: plain source string or object with source + enabled + authored.
+ * Union of subagent entry forms: plain source string or object with source + enabled.
  *
- * Decodes to canonical `{ source, enabled, authored }` form; encodes back to
- * the most compact JSON representation (plain string when enabled and not
- * authored, object otherwise).
+ * Decodes to canonical `{ source, enabled }` form; encodes back to the most
+ * compact JSON representation.
  *
  * @experimental This API is unstable and may change without notice.
  */
@@ -696,7 +702,10 @@ export const SubagentEntrySchema = compactEnabledEntry(SubagentEntryObjectSchema
  *
  * @experimental This API is unstable and may change without notice.
  */
-export const SubagentsMapSchema = Schema.Record(ExtensionMapKeySchema, SubagentEntrySchema).annotate({
+export const SubagentsMapSchema = Schema.Record(Schema.String, SubagentEntrySchema)
+    .check(Schema.isPropertyNames(ExtensionMapKeySchema))
+    .check(workspaceEntriesMatch("subagents"))
+    .annotate({
     identifier: "SubagentsMap",
     title: "Subagents Map",
     description: "A map of subagent names to subagent entries.",
@@ -711,35 +720,27 @@ export const SubagentsMapSchema = Schema.Record(ExtensionMapKeySchema, SubagentE
  */
 export const PackEntryObjectSchema = Schema.Struct({
     source: entrySourceFieldSchema("pack", "packs"),
-    authored: authoredFieldSchema,
 }).annotate({
     title: "Pack Entry Object",
-    description: "A pack entry with source and optional authored flag.",
+    description: "A pack entry with a source.",
 });
 /**
- * Union of pack entry forms: plain source string or object with source + authored.
+ * Union of pack entry forms: plain source string or object with source.
  *
- * Decodes to canonical `{ source, authored }` form; encodes back to the most
- * compact JSON representation (plain string when not authored, object otherwise).
+ * Decodes to canonical `{ source }` form and encodes back to a source string.
  *
  * @experimental This API is unstable and may change without notice.
  */
 export const PackEntrySchema = compactOrVerboseEntry(PackEntryObjectSchema, Schema.Struct({
     source: Schema.String,
-    authored: Schema.Boolean,
 }), {
-    decode: (entry) => typeof entry === "string"
-        ? { source: entry, authored: false }
-        : { source: entry.source, authored: entry.authored ?? false },
-    encode: (entry) => entry.authored ? { source: entry.source, authored: true } : entry.source,
+    decode: (entry) => typeof entry === "string" ? { source: entry } : { source: entry.source },
+    encode: (entry) => entry.source,
 }, {
     identifier: "PackEntry",
     title: "Pack Entry",
-    description: "A pack entry: a source string, or an object with source plus optional authored flag.",
-    examples: [
-        "@acme/packs/typescript@^1.0.0",
-        { source: "github:acme/agent-extensions", authored: true },
-    ],
+    description: "A pack entry: a source string, or an object with a source.",
+    examples: ["@acme/packs/typescript@^1.0.0"],
 });
 /**
  * Packs map - maps pack names to pack entries.
@@ -753,7 +754,10 @@ export const PackEntrySchema = compactOrVerboseEntry(PackEntryObjectSchema, Sche
  *
  * @experimental This API is unstable and may change without notice.
  */
-export const PacksMapSchema = Schema.Record(ExtensionMapKeySchema, PackEntrySchema).annotate({
+export const PacksMapSchema = Schema.Record(Schema.String, PackEntrySchema)
+    .check(Schema.isPropertyNames(ExtensionMapKeySchema))
+    .check(workspaceEntriesMatch("packs"))
+    .annotate({
     identifier: "PacksMap",
     title: "Packs Map",
     description: "A map of pack names to pack entries.",
@@ -772,38 +776,33 @@ export const LibraryEntryObjectSchema = Schema.Struct({
         examples: ["@acme/libraries/frontend"],
     })),
     enabled: enabledFieldSchema,
-    authored: authoredFieldSchema,
 }).annotate({
     title: "Library Entry Object",
-    description: "A Library subscription entry with source and optional enabled/authored flags.",
+    description: "A Library subscription entry with source and an optional enabled flag.",
 });
 /**
- * Union of Library entry forms: plain Library ref or object with source + enabled + authored.
+ * Union of Library entry forms: plain Library ref or object with source + enabled.
  *
  * @experimental This API is unstable and may change without notice.
  */
 export const LibraryEntrySchema = compactOrVerboseEntry(LibraryEntryObjectSchema, Schema.Struct({
     source: LibraryRefSchema,
     enabled: Schema.Boolean,
-    authored: Schema.Boolean,
 }), {
     decode: (entry) => typeof entry === "string"
-        ? { source: entry, enabled: true, authored: false }
+        ? { source: entry, enabled: true }
         : {
             source: entry.source,
             enabled: entry.enabled ?? true,
-            authored: entry.authored ?? false,
         },
     encode: (entry) => {
-        if (entry.enabled && !entry.authored)
+        if (entry.enabled)
             return entry.source;
         const obj = {
             source: entry.source,
         };
         if (!entry.enabled)
             obj.enabled = false;
-        if (entry.authored)
-            obj.authored = true;
         return obj;
     },
 }, {
@@ -817,7 +816,9 @@ export const LibraryEntrySchema = compactOrVerboseEntry(LibraryEntryObjectSchema
  *
  * @experimental This API is unstable and may change without notice.
  */
-export const LibrariesMapSchema = Schema.Record(ExtensionMapKeySchema, LibraryEntrySchema).annotate({
+export const LibrariesMapSchema = Schema.Record(Schema.String, LibraryEntrySchema)
+    .check(Schema.isPropertyNames(ExtensionMapKeySchema))
+    .annotate({
     identifier: "LibrariesMap",
     title: "Libraries Map",
     description: "A map of Library subscription names to Library refs.",
@@ -1040,43 +1041,43 @@ export const SettingsSchema = Schema.Struct({
         description: "Scalar workspace variables available to Context Files templates.",
     })),
     skills: Schema.optionalKey(Schema.Union([SkillsMapSchema]).annotate({
-        description: "Your installed skills, keyed by workspace skill name. Prefer plain source strings; use the object form only to set `enabled: false` or `authored: true`, and never write `enabled: true` or `authored: false` explicitly.",
+        description: "Your installed skills, keyed by workspace skill name. Prefer plain source strings; use the object form only to set `enabled: false`.",
     })),
     skillsConfig: Schema.optionalKey(Schema.Union([SkillsConfigSchema]).annotate({
         description: "Feature-level options for skill management.",
     })),
     commands: Schema.optionalKey(Schema.Union([CommandsMapSchema]).annotate({
-        description: "Your installed commands, keyed by workspace command name. Prefer plain source strings; use the object form only to set `enabled: false` or `authored: true`, and never write `enabled: true` or `authored: false` explicitly.",
+        description: "Your installed commands, keyed by workspace command name. Prefer plain source strings; use the object form only to set `enabled: false`.",
     })),
     commandsConfig: Schema.optionalKey(Schema.Union([CommandsConfigSchema]).annotate({
         description: "Feature-level options for command management.",
     })),
     files: Schema.optionalKey(Schema.Union([FilesMapSchema]).annotate({
-        description: "Your installed Context Files packages, keyed by workspace package name. Prefer plain source strings; use the object form only to set `enabled: false`, `authored: true`, or scalar `inputs`.",
+        description: "Your installed Context Files packages, keyed by workspace package name. Prefer plain source strings; use the object form only to set `enabled: false` or scalar `inputs`.",
     })),
     rules: Schema.optionalKey(Schema.Union([RulesMapSchema]).annotate({
-        description: "Your installed rules, keyed by workspace rule name. Prefer plain source strings; use the object form only to set `enabled: false` or `authored: true`.",
+        description: "Your installed rules, keyed by workspace rule name. Prefer plain source strings; use the object form only to set `enabled: false`.",
     })),
     hooks: Schema.optionalKey(Schema.Union([HooksMapSchema]).annotate({
-        description: "Your installed hooks, keyed by workspace hook name. Prefer plain source strings; use the object form only to set `enabled: false` or `authored: true`.",
+        description: "Your installed hooks, keyed by workspace hook name. Prefer plain source strings; use the object form only to set `enabled: false`.",
     })),
     subagents: Schema.optionalKey(Schema.Union([SubagentsMapSchema]).annotate({
-        description: "Your installed subagents, keyed by workspace subagent name. Prefer plain source strings; use the object form only to set `enabled: false` or `authored: true`, and never write `enabled: true` or `authored: false` explicitly.",
+        description: "Your installed subagents, keyed by workspace subagent name. Prefer plain source strings; use the object form only to set `enabled: false`.",
     })),
     subagentsConfig: Schema.optionalKey(Schema.Union([SubagentsConfigSchema]).annotate({
         description: "Feature-level options for subagent management.",
     })),
     packs: Schema.optionalKey(Schema.Union([PacksMapSchema]).annotate({
-        description: "Your installed packs, keyed by workspace pack name. Prefer plain source strings; use the object form only to set `authored: true`, and never write `authored: false` explicitly. Pack entries do not support `enabled` yet.",
+        description: "Your installed packs, keyed by workspace pack name. Pack entries do not support `enabled` yet.",
     })),
     packsConfig: Schema.optionalKey(Schema.Union([PacksConfigSchema]).annotate({
         description: "Feature-level options for pack management.",
     })),
     libraries: Schema.optionalKey(Schema.Union([LibrariesMapSchema]).annotate({
-        description: "Your Library subscriptions, keyed by workspace subscription name. Prefer plain Library refs; use the object form only to set `enabled: false` or `authored: true`. Libraries are always latest and do not accept version suffixes.",
+        description: "Your Library subscriptions, keyed by workspace subscription name. Prefer plain Library refs; use the object form only to set `enabled: false`. Libraries are always latest and do not accept version suffixes.",
     })),
     mcpServers: Schema.optionalKey(Schema.Union([McpServersMapSchema]).annotate({
-        description: "Your installed MCP servers, keyed by workspace MCP server name. Prefer plain source strings; use the object form only to set `enabled: false`, `authored: true`, or persisted `env` values.",
+        description: "Your installed MCP servers, keyed by workspace MCP server name. Prefer plain source strings; use the object form only to set `enabled: false` or persisted `env` values.",
     })),
     mcpServersConfig: Schema.optionalKey(Schema.Union([McpServersConfigSchema]).annotate({
         description: "Feature-level options for MCP server management.",
@@ -1092,7 +1093,7 @@ export const SettingsSchema = Schema.Struct({
     // them in the encoded (compact) form so agents see the preferred shape:
     // plain source strings, with the object form reserved for non-default flags.
     // Assertion needed: `.annotate()` types examples against the decoded
-    // canonical shape (where `enabled`/`authored` are required booleans), but
+    // canonical shape (where `enabled` is a required boolean), but
     // emitting that shape would teach agents to write the very defaults we want
     // them to omit.
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions