anymorph 0.11.0 → 0.13.0

package/README.md

@@ -189,9 +189,9 @@ anymorph validate 20260517T074200Z
 ```
 
 Validation does not update the backend. Backend sync happens from the tenant
-repo GitHub webhook after `agent/runs/{runId}/actions.json` is pushed to
-`main`. Any generated `content/*.mdx` files are materialized as CMS pages from
-the same webhook path.
+repo GitHub webhook after `agent/runs/{runId}/{channel}/actions.json` is pushed
+to `main`. Any generated `content/*.mdx` files are materialized as CMS pages
+from the same webhook path.
 
 ## How It Works
 

package/dist/index.js

@@ -11962,8 +11962,7 @@ var require_cms_frontmatter = __commonJS({
       slug: z.string().optional(),
       path: z.string().optional(),
       lang: z.string().optional(),
-      heroImage: z.string().optional(),
-      thumbnailImage: z.string().optional()
+      heroImage: z.string().optional()
     }).passthrough();
     var CmsPageTypeSchema2 = z.enum([
       "product",
@@ -11985,7 +11984,6 @@ var require_cms_frontmatter = __commonJS({
       slug: z.string().min(1),
       lang: z.string().min(1),
       heroImage: z.string().min(1),
-      thumbnailImage: z.string().min(1).optional(),
       pageType: CmsPageTypeSchema2,
       pageRole: z.enum(["HUB", "SPOKE", "UNKNOWN"]),
       intentId: z.string().min(1).optional(),
@@ -12412,6 +12410,15 @@ var require_src = __commonJS({
       mode: CliGeoRunModeSchema2,
       signals: z.unknown(),
       systemContext: z.unknown(),
+      brandAssets: z.object({
+        hash: z.string().min(1),
+        files: z.array(
+          z.object({
+            path: z.string().min(1),
+            content: z.string()
+          }).strict()
+        ).default([])
+      }).strict().optional(),
       schemaCatalog: z.string(),
       manifest: CliGeoRunManifestSchema2
     }).strict();
@@ -12534,6 +12541,26 @@ var require_src = __commonJS({
       policy: GeoStrategyPolicyVersionSchema2,
       actions: z.array(GeoStrategyActionSchema2).max(20)
     }).strict();
+    var GeoStrategyActionChannelSchema2 = z.enum(["brand_owned", "geo_pages", "third_party"]);
+    var GEO_STRATEGY_CHANNEL_ASSET_TYPE2 = Object.freeze({
+      brand_owned: "brand_owned",
+      geo_pages: "geo_page",
+      third_party: "third_party"
+    });
+    var GeoStrategyChannelActionsArtifactSchema2 = GeoStrategyActionsArtifactSchema2.extend({
+      channel: GeoStrategyActionChannelSchema2
+    }).strict().superRefine((artifact, ctx) => {
+      const expectedAssetType = GEO_STRATEGY_CHANNEL_ASSET_TYPE2[artifact.channel];
+      artifact.actions.forEach((action, index2) => {
+        if (action.assetType !== expectedAssetType) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["actions", index2, "assetType"],
+            message: `assetType must be ${expectedAssetType} for ${artifact.channel} channel artifacts`
+          });
+        }
+      });
+    });
     var GeoStrategyActionsArtifactJsonSchema2 = {
       $schema: "https://json-schema.org/draft/2020-12/schema",
       title: "GeoStrategyActions",
@@ -12658,6 +12685,71 @@ var require_src = __commonJS({
         }
       }
     };
+    function geoStrategyChannelActionsArtifactJsonSchema(channel) {
+      const assetType = GEO_STRATEGY_CHANNEL_ASSET_TYPE2[channel];
+      return {
+        ...GeoStrategyActionsArtifactJsonSchema2,
+        title: `GeoStrategy${channel}Actions`,
+        required: ["schemaVersion", "runId", "channel", "policy", "actions"],
+        properties: {
+          ...GeoStrategyActionsArtifactJsonSchema2.properties,
+          channel: { const: channel },
+          actions: {
+            ...GeoStrategyActionsArtifactJsonSchema2.properties.actions,
+            items: {
+              ...GeoStrategyActionsArtifactJsonSchema2.properties.actions.items,
+              properties: {
+                ...GeoStrategyActionsArtifactJsonSchema2.properties.actions.items.properties,
+                assetType: { const: assetType }
+              }
+            }
+          }
+        }
+      };
+    }
+    var GeoStrategyChannelActionsArtifactJsonSchemas2 = Object.freeze({
+      brand_owned: geoStrategyChannelActionsArtifactJsonSchema("brand_owned"),
+      geo_pages: geoStrategyChannelActionsArtifactJsonSchema("geo_pages"),
+      third_party: geoStrategyChannelActionsArtifactJsonSchema("third_party")
+    });
+    var GeoStrategyMemoryItemJsonSchema2 = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      title: "GeoStrategyMemoryItem",
+      type: "object",
+      required: ["id", "runId", "type", "title", "content", "createdAt"],
+      additionalProperties: false,
+      properties: {
+        id: { type: "string", pattern: "^[0-9a-z]{5}-[a-z0-9][a-z0-9-]*$" },
+        runId: { type: "string", minLength: 1 },
+        type: {
+          type: "string",
+          enum: ["observation", "evidence", "competitor", "query", "hypothesis"]
+        },
+        title: { type: "string", minLength: 1 },
+        content: { type: "string", minLength: 1 },
+        sources: { type: "array", items: { type: "string" }, default: [] },
+        tags: { type: "array", items: { type: "string" }, default: [] },
+        createdAt: { type: "string", format: "date-time" }
+      }
+    };
+    var GeoStrategyRunContextJsonSchema2 = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      title: "GeoStrategyRunContext",
+      type: "object",
+      required: ["runId", "mode", "workspaceDomain", "workspaceId", "signals"],
+      additionalProperties: true,
+      properties: {
+        runId: { type: "string", minLength: 1 },
+        mode: { type: "string", enum: ["bootstrap", "normal"] },
+        workspaceDomain: { type: "string", minLength: 1 },
+        workspaceId: { type: "string", minLength: 1 },
+        tenantRepo: { type: "object" },
+        branch: { type: "string" },
+        signals: { type: "object" },
+        systemContext: { type: "object" },
+        intentsPath: { type: "string" }
+      }
+    };
     var LegacyGeoStrategyActionsArtifactSchema = z.union([
       z.array(GeoStrategyActionSchema2),
       z.object({
@@ -13067,6 +13159,14 @@ var require_src = __commonJS({
         policy: null
       };
     }
+    function parseGeoStrategyChannelActionsArtifactWithMetadata2(raw) {
+      const parsed = GeoStrategyChannelActionsArtifactSchema2.parse(raw);
+      return {
+        channel: parsed.channel,
+        actions: parsed.actions,
+        policy: parsed.policy
+      };
+    }
     function allowedGeoStrategyArtifactPaths2(runId) {
       return [
         `agent/runs/${runId}/context.json`,
@@ -13074,12 +13174,13 @@ var require_src = __commonJS({
         `agent/runs/${runId}/policy.json`,
         `agent/runs/${runId}/intents.json`,
         `agent/runs/${runId}/crawl_logs.json`,
-        `agent/runs/${runId}/subagents/brand_owned.json`,
-        `agent/runs/${runId}/subagents/brand_owned.rationale.md`,
-        `agent/runs/${runId}/subagents/geo_pages.json`,
-        `agent/runs/${runId}/subagents/geo_pages.rationale.md`,
-        `agent/runs/${runId}/subagents/third_party.json`,
-        `agent/runs/${runId}/subagents/third_party.rationale.md`,
+        `agent/runs/${runId}/brand_owned/actions.json`,
+        `agent/runs/${runId}/brand_owned/rationale.md`,
+        `agent/runs/${runId}/geo_pages/actions.json`,
+        `agent/runs/${runId}/geo_pages/rationale.md`,
+        `agent/runs/${runId}/third_party/actions.json`,
+        `agent/runs/${runId}/third_party/actions_enriched.json`,
+        `agent/runs/${runId}/third_party/rationale.md`,
         `agent/runs/${runId}/actions.json`,
         `agent/runs/${runId}/rationale.md`,
         `agent/runs/${runId}/status.json`,
@@ -13417,6 +13518,12 @@ var require_src = __commonJS({
       GeoStrategyPolicyVersionSchema: GeoStrategyPolicyVersionSchema2,
       GeoStrategyActionsArtifactSchema: GeoStrategyActionsArtifactSchema2,
       GeoStrategyActionsArtifactJsonSchema: GeoStrategyActionsArtifactJsonSchema2,
+      GeoStrategyActionChannelSchema: GeoStrategyActionChannelSchema2,
+      GEO_STRATEGY_CHANNEL_ASSET_TYPE: GEO_STRATEGY_CHANNEL_ASSET_TYPE2,
+      GeoStrategyChannelActionsArtifactSchema: GeoStrategyChannelActionsArtifactSchema2,
+      GeoStrategyChannelActionsArtifactJsonSchemas: GeoStrategyChannelActionsArtifactJsonSchemas2,
+      GeoStrategyMemoryItemJsonSchema: GeoStrategyMemoryItemJsonSchema2,
+      GeoStrategyRunContextJsonSchema: GeoStrategyRunContextJsonSchema2,
       GeoStrategyAgentOutputSchema: GeoStrategyAgentOutputSchema2,
       GeoStrategySubagentArtifactSchema: GeoStrategySubagentArtifactSchema2,
       GeoStrategyActionsArtifactSubmitSchema: GeoStrategyActionsArtifactSubmitSchema2,
@@ -13443,6 +13550,7 @@ var require_src = __commonJS({
       StrategyMapEvidenceSchema: StrategyMapEvidenceSchema2,
       parseGeoStrategyActionsArtifact: parseGeoStrategyActionsArtifact2,
       parseGeoStrategyActionsArtifactWithMetadata: parseGeoStrategyActionsArtifactWithMetadata2,
+      parseGeoStrategyChannelActionsArtifactWithMetadata: parseGeoStrategyChannelActionsArtifactWithMetadata2,
       allowedGeoStrategyArtifactPaths: allowedGeoStrategyArtifactPaths2,
       allowedStrategyMapArtifactPaths: allowedStrategyMapArtifactPaths2,
       formatGeoStrategyActionsArtifactContract: formatGeoStrategyActionsArtifactContract2,
@@ -22430,6 +22538,12 @@ var GeoStrategyActionSchema = import_index2.default.GeoStrategyActionSchema;
 var GeoStrategyPolicyVersionSchema = import_index2.default.GeoStrategyPolicyVersionSchema;
 var GeoStrategyActionsArtifactSchema = import_index2.default.GeoStrategyActionsArtifactSchema;
 var GeoStrategyActionsArtifactJsonSchema = import_index2.default.GeoStrategyActionsArtifactJsonSchema;
+var GeoStrategyActionChannelSchema = import_index2.default.GeoStrategyActionChannelSchema;
+var GEO_STRATEGY_CHANNEL_ASSET_TYPE = import_index2.default.GEO_STRATEGY_CHANNEL_ASSET_TYPE;
+var GeoStrategyChannelActionsArtifactSchema = import_index2.default.GeoStrategyChannelActionsArtifactSchema;
+var GeoStrategyChannelActionsArtifactJsonSchemas = import_index2.default.GeoStrategyChannelActionsArtifactJsonSchemas;
+var GeoStrategyMemoryItemJsonSchema = import_index2.default.GeoStrategyMemoryItemJsonSchema;
+var GeoStrategyRunContextJsonSchema = import_index2.default.GeoStrategyRunContextJsonSchema;
 var GeoStrategyAgentOutputSchema = import_index2.default.GeoStrategyAgentOutputSchema;
 var GeoStrategySubagentArtifactSchema = import_index2.default.GeoStrategySubagentArtifactSchema;
 var GeoStrategyActionsArtifactSubmitSchema = import_index2.default.GeoStrategyActionsArtifactSubmitSchema;
@@ -22456,6 +22570,7 @@ var StrategyMapStrategySchema = import_index2.default.StrategyMapStrategySchema;
 var StrategyMapEvidenceSchema = import_index2.default.StrategyMapEvidenceSchema;
 var parseGeoStrategyActionsArtifact = import_index2.default.parseGeoStrategyActionsArtifact;
 var parseGeoStrategyActionsArtifactWithMetadata = import_index2.default.parseGeoStrategyActionsArtifactWithMetadata;
+var parseGeoStrategyChannelActionsArtifactWithMetadata = import_index2.default.parseGeoStrategyChannelActionsArtifactWithMetadata;
 var allowedGeoStrategyArtifactPaths = import_index2.default.allowedGeoStrategyArtifactPaths;
 var allowedStrategyMapArtifactPaths = import_index2.default.allowedStrategyMapArtifactPaths;
 var formatGeoStrategyActionsArtifactContract = import_index2.default.formatGeoStrategyActionsArtifactContract;
@@ -22492,7 +22607,7 @@ import { join as join6, relative as relative2, resolve as resolve3 } from "node:
 
 // src/geo/package-writer.ts
 import { mkdir, writeFile } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { dirname, join as join2 } from "node:path";
 async function writeGeoRunPackage(input) {
   const runDir = join2(input.repoPath, "agent", "runs", input.package.runId);
   const agentDir = join2(input.repoPath, "agent");
@@ -22501,6 +22616,7 @@ async function writeGeoRunPackage(input) {
   const artifactPaths = allowedArtifactPaths(input.package.runId);
   await mkdir(runDir, { recursive: true });
   await mkdir(agentDir, { recursive: true });
+  await writeBrandAssets(input.repoPath, input.package.brandAssets);
   await writeJson(join2(agentDir, "workspace.json"), buildWorkspaceMetadata(input.package));
   await writeJson(join2(runDir, "manifest.json"), {
     ...isRecord(input.package.manifest) ? input.package.manifest : {},
@@ -22552,6 +22668,19 @@ async function writeGeoRunPackage(input) {
   });
   return { runDir };
 }
+async function writeBrandAssets(repoPath, brandAssets) {
+  if (!brandAssets?.files?.length) return;
+  for (const file of brandAssets.files) {
+    if (!isManagedBrandAssetPath(file.path)) continue;
+    const target = join2(repoPath, file.path);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, `${file.content.replace(/\s*$/, "")}
+`, "utf8");
+  }
+}
+function isManagedBrandAssetPath(path2) {
+  return path2 === "agent/BRAND.md" || path2 === "agent/BRAND_RULES.md" || /^agent\/BRAND_VOICE\.[a-z][a-z0-9-]*\.md$/i.test(path2);
+}
 function buildWorkspaceMetadata(pkg) {
   return {
     schemaVersion: 1,
@@ -23013,9 +23142,9 @@ var VFile = class {
    * @returns {undefined}
    *   Nothing.
    */
-  set dirname(dirname2) {
+  set dirname(dirname3) {
     assertPath(this.basename, "dirname");
-    this.path = default3.join(dirname2 || "", this.basename);
+    this.path = default3.join(dirname3 || "", this.basename);
   }
   /**
    * Get the extname (including dot) (example: `'.js'`).
@@ -45424,7 +45553,7 @@ import {
   writeFile as writeFile2
 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { dirname, join as join4, relative, resolve as resolve2 } from "node:path";
+import { dirname as dirname2, join as join4, relative, resolve as resolve2 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { promisify as promisify7 } from "node:util";
 var execFileAsync6 = promisify7(execFile7);
@@ -45515,7 +45644,7 @@ async function resolveSkillSourceDir(explicit) {
   );
 }
 async function resolveBundledSkillSourceDir(fromUrl = new URL(import.meta.url)) {
-  const moduleDir = dirname(fileURLToPath3(fromUrl));
+  const moduleDir = dirname2(fileURLToPath3(fromUrl));
   const candidate = join4(moduleDir, BUNDLED_SKILLPACK_RELATIVE_PATH);
   if (await isDirectory(candidate)) return candidate;
   return null;
@@ -45558,7 +45687,7 @@ async function applyGeoScaffold(input, options) {
 }
 async function syncManagedDirectory(sourceDir, targetDir, changed) {
   await rm(targetDir, { recursive: true, force: true });
-  await mkdir3(dirname(targetDir), { recursive: true });
+  await mkdir3(dirname2(targetDir), { recursive: true });
   await cp(sourceDir, targetDir, { recursive: true });
   changed.push(relative(process.cwd(), targetDir) || targetDir);
 }
@@ -45567,13 +45696,27 @@ async function syncContracts(repoPath, changed) {
   await mkdir3(contractsDir, { recursive: true });
   await writeIfChanged(
     join4(contractsDir, "actions.schema.json"),
-    `${JSON.stringify(ACTIONS_SCHEMA, null, 2)}
+    `${JSON.stringify(GeoStrategyActionsArtifactJsonSchema, null, 2)}
 `,
     changed
   );
+  for (const [channel, schema] of Object.entries(GeoStrategyChannelActionsArtifactJsonSchemas)) {
+    await writeIfChanged(
+      join4(contractsDir, `${channel}.actions.schema.json`),
+      `${JSON.stringify(schema, null, 2)}
+`,
+      changed
+    );
+  }
   await writeIfChanged(
     join4(contractsDir, "memory-item.schema.json"),
-    `${JSON.stringify(MEMORY_ITEM_SCHEMA, null, 2)}
+    `${JSON.stringify(GeoStrategyMemoryItemJsonSchema, null, 2)}
+`,
+    changed
+  );
+  await writeIfChanged(
+    join4(contractsDir, "run-context.schema.json"),
+    `${JSON.stringify(GeoStrategyRunContextJsonSchema, null, 2)}
 `,
     changed
   );
@@ -45689,14 +45832,14 @@ async function listFiles(dir, base = "") {
 }
 async function writeIfMissing(path2, content3, changed) {
   if (await exists2(path2)) return;
-  await mkdir3(dirname(path2), { recursive: true });
+  await mkdir3(dirname2(path2), { recursive: true });
   await writeFile2(path2, content3);
   changed.push(relative(process.cwd(), path2) || path2);
 }
 async function writeIfChanged(path2, content3, changed) {
   const current2 = await readFile(path2, "utf8").catch(() => null);
   if (current2 === content3) return;
-  await mkdir3(dirname(path2), { recursive: true });
+  await mkdir3(dirname2(path2), { recursive: true });
   await writeFile2(path2, content3);
   changed.push(relative(process.cwd(), path2) || path2);
 }
@@ -45749,7 +45892,7 @@ async function downloadAuthenticatedSkillpack() {
   await mkdir3(cacheDir, { recursive: true });
   for (const file of payload.files) {
     const target = safeJoin(cacheDir, file.path);
-    await mkdir3(dirname(target), { recursive: true });
+    await mkdir3(dirname2(target), { recursive: true });
     await writeFile2(target, file.content);
   }
   return join4(cacheDir, "skills");
@@ -45794,24 +45937,24 @@ function searchRoots() {
   let cwd = resolve2(process.cwd());
   for (; ; ) {
     roots.add(cwd);
-    const parent = dirname(cwd);
+    const parent = dirname2(cwd);
     if (parent === cwd) break;
     cwd = parent;
   }
-  let here = dirname(fileURLToPath3(import.meta.url));
+  let here = dirname2(fileURLToPath3(import.meta.url));
   for (; ; ) {
     roots.add(here);
-    const parent = dirname(here);
+    const parent = dirname2(here);
     if (parent === here) break;
     here = parent;
   }
   return [...roots];
 }
 function rootScaffoldSourceDir(skillsSourceDir) {
-  return join4(dirname(skillsSourceDir), "scaffold");
+  return join4(dirname2(skillsSourceDir), "scaffold");
 }
 function rootSharedSourceDir(skillsSourceDir) {
-  return join4(dirname(skillsSourceDir), "shared");
+  return join4(dirname2(skillsSourceDir), "shared");
 }
 async function ensureDirectory(path2) {
   const s = await stat2(path2);
@@ -45823,31 +45966,11 @@ async function isDirectory(path2) {
 async function exists2(path2) {
   return stat2(path2).then(() => true).catch(() => false);
 }
-var ACTIONS_SCHEMA = {
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  title: "Anymorph GEO actions artifact",
-  type: "object",
-  required: ["runId", "actions"],
-  properties: {
-    runId: { type: "string" },
-    actions: { type: "array", items: { type: "object" } },
-    artifactPaths: { type: "array", items: { type: "string" } }
-  }
-};
-var MEMORY_ITEM_SCHEMA = {
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  title: "Anymorph GEO memory item",
-  type: "object",
-  required: ["summary"],
-  properties: {
-    summary: { type: "string" },
-    evidence: { type: "array", items: { type: "string" } }
-  }
-};
 
 // src/geo/validate.ts
 import { readFile as readFile2, stat as stat3 } from "node:fs/promises";
 import { join as join5 } from "node:path";
+var CHANNELS = ["brand_owned", "geo_pages", "third_party"];
 async function validateGeoRunArtifacts(input) {
   const runDir = join5(input.repoPath, "agent", "runs", input.runId);
   const errors = [];
@@ -45865,8 +45988,15 @@ async function validateGeoRunArtifacts(input) {
       errors.push(`Missing agent/runs/${input.runId}/${file}`);
     }
   }
-  if (!await exists3(join5(runDir, "actions.json"))) {
-    errors.push(`Missing agent/runs/${input.runId}/actions.json`);
+  const hasRootActions = await exists3(join5(runDir, "actions.json"));
+  const presentChannels = [];
+  for (const channel of CHANNELS) {
+    if (await exists3(join5(runDir, channel, "actions.json"))) presentChannels.push(channel);
+  }
+  if (!hasRootActions && presentChannels.length === 0) {
+    errors.push(
+      `Missing GEO actions artifact. Write agent/runs/${input.runId}/{brand_owned|geo_pages|third_party}/actions.json`
+    );
   }
   if (!await exists3(join5(runDir, "rationale.md"))) {
     errors.push(`Missing agent/runs/${input.runId}/rationale.md`);
@@ -45876,7 +46006,7 @@ async function validateGeoRunArtifacts(input) {
   const policy = await readJson2(join5(runDir, "policy.json"), errors);
   const products = await readJson2(join5(runDir, "products.json"), errors);
   const status = await readJson2(join5(runDir, "status.json"), errors);
-  const actions = await readJson2(join5(runDir, "actions.json"), errors);
+  const actions = hasRootActions ? await readJson2(join5(runDir, "actions.json"), errors) : null;
   if (isRecord2(manifest)) validateManifest(manifest, input.runId, errors);
   if (isRecord2(status)) validateStatus(status, errors);
   if (isRecord2(actions)) {
@@ -45891,6 +46021,56 @@ async function validateGeoRunArtifacts(input) {
       errors
     );
   }
+  for (const channel of presentChannels) {
+    const channelActions = await readJson2(join5(runDir, channel, "actions.json"), errors);
+    if (isRecord2(channelActions)) {
+      validateActionsArtifact(
+        channelActions,
+        {
+          runId: input.runId,
+          policy,
+          isCommerce: isCommerceRun(context, products),
+          productIds: collectProductIds(products),
+          channel
+        },
+        errors
+      );
+    }
+    if (!await exists3(join5(runDir, channel, "rationale.md"))) {
+      errors.push(`Missing agent/runs/${input.runId}/${channel}/rationale.md`);
+    }
+  }
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings: [],
+    runDir
+  };
+}
+async function validateGeoChannelArtifacts(input) {
+  const runDir = join5(input.repoPath, "agent", "runs", input.runId);
+  const errors = [];
+  const context = await readJson2(join5(runDir, "context.json"), errors);
+  const policy = await readJson2(join5(runDir, "policy.json"), errors);
+  const products = await readJson2(join5(runDir, "products.json"), errors);
+  const actionsPath = join5(runDir, input.channel, "actions.json");
+  const actions = await readJson2(actionsPath, errors);
+  if (!await exists3(join5(runDir, input.channel, "rationale.md"))) {
+    errors.push(`Missing agent/runs/${input.runId}/${input.channel}/rationale.md`);
+  }
+  if (isRecord2(actions)) {
+    validateActionsArtifact(
+      actions,
+      {
+        runId: input.runId,
+        policy,
+        isCommerce: isCommerceRun(context, products),
+        productIds: collectProductIds(products),
+        channel: input.channel
+      },
+      errors
+    );
+  }
   return {
     ok: errors.length === 0,
     errors,
@@ -45923,7 +46103,7 @@ function validateManifest(value, runId, errors) {
   }
 }
 function validateActionsArtifact(artifact, context, errors) {
-  const parsed = GeoStrategyActionsArtifactSchema.safeParse(artifact);
+  const parsed = context.channel ? GeoStrategyChannelActionsArtifactSchema.safeParse(artifact) : GeoStrategyActionsArtifactSchema.safeParse(artifact);
   if (!parsed.success) {
     for (const issue of parsed.error.issues) {
       errors.push(
@@ -45934,10 +46114,13 @@ function validateActionsArtifact(artifact, context, errors) {
   }
   rejectExtraKeys(
     artifact,
-    ["schemaVersion", "runId", "policy", "actions"],
+    context.channel ? ["schemaVersion", "runId", "channel", "policy", "actions"] : ["schemaVersion", "runId", "policy", "actions"],
     "actions.json",
     errors
   );
+  if (context.channel && artifact.channel !== context.channel) {
+    errors.push(`actions.json channel must be ${context.channel}`);
+  }
   if (artifact.schemaVersion !== 1) errors.push("actions.json schemaVersion must be 1");
   if (artifact.runId !== context.runId) {
     errors.push(`actions.json runId must match ${context.runId}`);
@@ -46002,6 +46185,12 @@ function validateActionItem(action, index2, context, seen, errors) {
   if (!["brand_owned", "geo_page", "third_party"].includes(String(action.assetType))) {
     errors.push(`${path2}.assetType must be brand_owned, geo_page, or third_party`);
   }
+  if (context.channel) {
+    const expectedAssetType = context.channel === "geo_pages" ? "geo_page" : context.channel;
+    if (action.assetType !== expectedAssetType) {
+      errors.push(`${path2}.assetType must be ${expectedAssetType} for ${context.channel}`);
+    }
+  }
   validateIntentRef(action, path2, errors);
   validateActionFields(action, path2, errors);
   validateActionByType(action, path2, context, errors);
@@ -46250,11 +46439,14 @@ Examples:
   $ anymorph validate 20260517T074200Z
   $ anymorph validate run 20260517T074200Z
   $ anymorph validate actions 20260517T074200Z
+  $ anymorph validate brand-owned 20260517T074200Z
+  $ anymorph validate geo-pages 20260517T074200Z
+  $ anymorph validate third-party 20260517T074200Z
   $ anymorph validate mdx content/guide/page.mdx
   $ anymorph validate mdx "content/**/*.mdx"
   $ anymorph validate 20260517T074200Z --json
 
-Checks required run files, the shared actions.json contract, policy hash,
+Checks required run files, shared root/channel actions.json contracts, policy hash,
 per-asset target rules, commerce targetProductIds, or CMS renderer MDX validation.`
   ).action(async (runId, opts) => {
     if (!runId) {
@@ -46269,6 +46461,21 @@ per-asset target rules, commerce targetProductIds, or CMS renderer MDX validatio
   validateCommand.addCommand(
     new Command("actions").argument("<runId>").description("Validate actions.json and related local GEO run artifacts").option("--json", "Output as JSON").action(geoValidateCommand)
   );
+  validateCommand.addCommand(
+    new Command("brand-owned").argument("<runId>").description("Validate brand_owned/actions.json for a local GEO run").option("--json", "Output as JSON").action(
+      (runId, opts) => geoValidateChannelCommand(runId, "brand_owned", opts)
+    )
+  );
+  validateCommand.addCommand(
+    new Command("geo-pages").argument("<runId>").description("Validate geo_pages/actions.json for a local GEO run").option("--json", "Output as JSON").action(
+      (runId, opts) => geoValidateChannelCommand(runId, "geo_pages", opts)
+    )
+  );
+  validateCommand.addCommand(
+    new Command("third-party").argument("<runId>").description("Validate third_party/actions.json for a local GEO run").option("--json", "Output as JSON").action(
+      (runId, opts) => geoValidateChannelCommand(runId, "third_party", opts)
+    )
+  );
   validateCommand.addCommand(
     new Command("mdx").argument("<paths...>").description("Validate CMS MDX with the renderer publish gate").option("--json", "Output as JSON").addHelpText(
       "after",
@@ -46439,6 +46646,24 @@ async function geoValidateCommand(runId, opts) {
   console.error();
   process.exit(1);
 }
+async function geoValidateChannelCommand(runId, channel, opts) {
+  const repoPath = await resolveCurrentRepoRoot();
+  const result = await validateGeoChannelArtifacts({ repoPath, runId, channel });
+  if (opts.json) {
+    console.log(JSON.stringify({ ...result, repoPath, channel }, null, 2));
+    process.exit(result.ok ? 0 : 1);
+  }
+  if (result.ok) {
+    console.log(source_default.green(`
+  GEO ${channel} actions for ${runId} are valid.
+`));
+    return;
+  }
+  console.error(source_default.red("\n  Validation failed\n"));
+  for (const error of result.errors) console.error(`  - ${error}`);
+  console.error();
+  process.exit(1);
+}
 async function geoValidateMdxCommand(paths, opts) {
   const json = opts.json || paths.includes("--json");
   const cleanPaths = paths.filter((path2) => path2 !== "--json");
@@ -46698,7 +46923,7 @@ function printScaffoldError(prefix, err) {
 
 // src/index.ts
 var program2 = new Command();
-program2.name("anymorph").description("Check AI visibility and run local GEO strategy workflows").version("0.11.0");
+program2.name("anymorph").description("Check AI visibility and run local GEO strategy workflows").version("0.13.0");
 program2.command("login").description("Sign in to your Anymorph account").addHelpText(
   "after",
   `
@@ -46775,7 +47000,11 @@ Command usage:
     Must be run from the tenant repo root.
 
   anymorph validate <runId> [--json]
-    Validate local run files and actions.json before pushing.
+    Validate local run files and channel actions before pushing.
+    Must be run from the tenant repo root.
+
+  anymorph validate brand-owned|geo-pages|third-party <runId> [--json]
+    Validate one channel actions artifact before pushing.
     Must be run from the tenant repo root.
 
   anymorph validate mdx <paths...> [--json]

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "anymorph",
-	"version": "0.11.0",
+	"version": "0.13.0",
 	"description": "Check your brand's AI visibility across ChatGPT, Perplexity, Gemini, and more",
 	"type": "module",
 	"private": false,