anymorph 0.2.5 → 0.4.0

package/dist/skillpacks/geo/skills/geo-page-writer/references/validation.md

@@ -0,0 +1,59 @@
+# Validation
+
+Validation has two owners:
+
+- The agent owns brand and fact validation.
+- `check-page-mdx.mjs` owns deterministic MDX static validation.
+
+## Brand Validation
+
+Before running the script, review the MDX against the source pack and tenant
+brand context.
+
+Check:
+
+- Tone matches the brand guidance.
+- Blocklisted phrases are absent.
+- Required positioning is represented.
+- "Must avoid" claims or angles are not used.
+- The brand role is honest and not forced into unrelated claims.
+- Competitive comparisons are measured and sourced.
+
+If unsure, soften the claim or remove it.
+
+## Fact Validation
+
+Every concrete factual claim must be supported by the source pack or existing
+tenant/product data.
+
+Remove or soften:
+
+- numbers not present in sources
+- dates not present in sources
+- "best", "#1", "first", "only", "guaranteed", or "clinically proven" without
+  direct evidence
+- product efficacy claims without product/KB/source support
+- competitor comparisons without a source for both sides
+- exact quotes not present verbatim in a source
+
+Use hedged language when evidence is directional but not conclusive.
+
+## MDX Static Validation
+
+Run:
+
+```bash
+node .agents/skills/geo-page-writer/scripts/check-page-mdx.mjs \
+  --file <path/to/page.mdx> \
+  --sources agent/page-writer/<runId>/<actionId>/sources/source-pack.json
+```
+
+The checker validates:
+
+- frontmatter presence
+- MDX/JSX parse when a compiler is available
+- import and component allowlists
+- image URL provenance
+- link and CTA URL shape
+
+Fix all errors. Review warnings before committing.

package/dist/skillpacks/geo/skills/geo-page-writer/references/writing.md

@@ -0,0 +1,55 @@
+# Writing
+
+Write the actual MDX directly. Do not use a writing script.
+
+## Page Shape
+
+The page should be useful to a human reader and easy for AI engines to cite.
+
+Use:
+
+- Answer-first opening.
+- Clear H2 sections that each answer one question.
+- Self-contained paragraphs with explicit entities.
+- Specific product, process, or methodology details when sourced.
+- Tables or lists only when they improve comparison or extraction.
+
+Avoid:
+
+- Generic SEO filler.
+- Keyword stuffing.
+- Unsupported rankings or superlatives.
+- Fake quotes, fake studies, fake customers, or invented numbers.
+- Images that are merely decorative when product/source evidence is needed.
+
+## Frontmatter
+
+Include the tenant's expected MDX frontmatter fields. At minimum:
+
+- `title`
+- `description`
+- `lang`
+
+Include `heroImage` only when the URL is from the source pack, product catalog,
+or an existing tenant asset.
+
+## Components
+
+Use only components already supported by the tenant CMS renderer. Prefer plain
+MDX when unsure.
+
+For commerce/product pages:
+
+- Only mention products present in the source pack or product context.
+- Use product image, price, URL, and title verbatim.
+- Do not compute discounts or localize prices yourself.
+
+## CTA
+
+Use CTA URLs from tenant inputs or existing safe routes. Do not invent checkout,
+demo, pricing, or contact URLs.
+
+## Images
+
+Use image URLs verbatim. Add useful alt text. Do not crop product imagery in a
+way that hides packaging, texture, label, or use context.

package/dist/skillpacks/geo/skills/geo-page-writer/scripts/check-page-mdx.mjs

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const args = parseArgs(process.argv.slice(2));
+
+try {
+	const result = await check(args);
+	console.log(JSON.stringify(result, null, 2));
+	process.exit(result.ok ? 0 : 1);
+} catch (err) {
+	const message = err instanceof Error ? err.message : String(err);
+	console.error(message);
+	process.exit(1);
+}
+
+function parseArgs(argv) {
+	const out = {};
+	for (let i = 0; i < argv.length; i += 1) {
+		const arg = argv[i];
+		if (arg === "--file") out.file = requireValue(argv, ++i, arg);
+		else if (arg === "--sources") out.sources = requireValue(argv, ++i, arg);
+		else if (arg === "--out") out.out = requireValue(argv, ++i, arg);
+		else throw new Error(`Unknown argument: ${arg}`);
+	}
+	return out;
+}
+
+function requireValue(argv, index, flag) {
+	const value = argv[index];
+	if (!value || value.startsWith("--")) throw new Error(`${flag} requires a value`);
+	return value;
+}
+
+async function check(input) {
+	const file = required(input.file, "--file");
+	const sourcePath = input.sources;
+	const mdxPath = resolve(file);
+	const mdx = await readFile(mdxPath, "utf8");
+	const sourcePack = sourcePath ? JSON.parse(await readFile(resolve(sourcePath), "utf8")) : null;
+	const errors = [];
+	const warnings = [];
+	const frontmatter = parseFrontmatter(mdx, errors);
+	checkFrontmatter(frontmatter, errors);
+	checkImports(mdx, errors, warnings);
+	checkComponents(mdx, errors);
+	checkLinks(mdx, warnings);
+	checkImages(mdx, sourcePack, warnings);
+	await checkMdxCompile(mdx, errors, warnings);
+	const result = {
+		ok: errors.length === 0,
+		file: mdxPath,
+		checkedAt: new Date().toISOString(),
+		errors,
+		warnings,
+	};
+	if (input.out) {
+		const outPath = isAbsolute(input.out) ? input.out : resolve(input.out);
+		await mkdir(dirname(outPath), { recursive: true });
+		await writeFile(outPath, `${JSON.stringify(result, null, 2)}\n`);
+	}
+	return result;
+}
+
+function parseFrontmatter(mdx, errors) {
+	if (!mdx.startsWith("---\n")) {
+		errors.push("frontmatter: file must start with YAML frontmatter");
+		return {};
+	}
+	const end = mdx.indexOf("\n---", 4);
+	if (end === -1) {
+		errors.push("frontmatter: closing --- not found");
+		return {};
+	}
+	const raw = mdx.slice(4, end).trim();
+	const data = {};
+	for (const line of raw.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const match = trimmed.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+		if (!match) continue;
+		data[match[1]] = unquote(match[2]);
+	}
+	return data;
+}
+
+function unquote(value) {
+	const trimmed = value.trim();
+	if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+		return trimmed.slice(1, -1);
+	}
+	return trimmed;
+}
+
+function checkFrontmatter(frontmatter, errors) {
+	for (const field of ["title", "description", "lang"]) {
+		if (!frontmatter[field]) errors.push(`frontmatter: ${field} is required`);
+	}
+	if (frontmatter.heroImage && !isHttpUrl(frontmatter.heroImage) && !frontmatter.heroImage.startsWith("/")) {
+		errors.push("frontmatter: heroImage must be an absolute http(s) URL or root-relative path");
+	}
+}
+
+const ALLOWED_IMPORTS = new Set([
+	"@/components/mdx",
+	"@/components/cms",
+	"@/components/content",
+]);
+
+function checkImports(mdx, errors, warnings) {
+	const imports = [...mdx.matchAll(/^\s*import\s+[^'"]+['"]([^'"]+)['"];?\s*$/gm)].map((m) => m[1]);
+	for (const specifier of imports) {
+		if (![...ALLOWED_IMPORTS].some((allowed) => specifier.startsWith(allowed))) {
+			errors.push(`import: unsupported import "${specifier}"`);
+		}
+	}
+}
+
+const ALLOWED_COMPONENTS = new Set([
+	"ArticleHeader",
+	"Callout",
+	"CTA",
+	"FAQ",
+	"Image",
+	"ImageGrid",
+	"ProductCard",
+	"RelatedContent",
+	"Table",
+]);
+
+function checkComponents(mdx, errors) {
+	const tags = [...mdx.matchAll(/<([A-Z][A-Za-z0-9.]*)\b/g)].map((m) => m[1].split(".")[0]);
+	for (const tag of new Set(tags)) {
+		if (!ALLOWED_COMPONENTS.has(tag)) errors.push(`component: unsupported component <${tag}>`);
+	}
+}
+
+function checkLinks(mdx, warnings) {
+	const markdownLinks = [...mdx.matchAll(/\[[^\]]+\]\(([^)]+)\)/g)].map((m) => m[1]);
+	const hrefs = [...mdx.matchAll(/\bhref=["']([^"']+)["']/g)].map((m) => m[1]);
+	for (const url of [...markdownLinks, ...hrefs]) {
+		if (url.startsWith("#") || url.startsWith("/") || isHttpUrl(url) || url.startsWith("mailto:") || url.startsWith("tel:")) continue;
+		warnings.push(`link: review non-standard URL "${url}"`);
+	}
+}
+
+function checkImages(mdx, sourcePack, warnings) {
+	const urls = [
+		...[...mdx.matchAll(/!\[[^\]]*\]\(([^)]+)\)/g)].map((m) => m[1]),
+		...[...mdx.matchAll(/\bsrc=["']([^"']+)["']/g)].map((m) => m[1]),
+		...[...mdx.matchAll(/\bimage=["']([^"']+)["']/g)].map((m) => m[1]),
+		...[...mdx.matchAll(/\bheroImage:\s*["']?([^"'\n]+)["']?/g)].map((m) => m[1].trim()),
+	].filter((url) => isHttpUrl(url));
+	const allowed = collectAllowedImageUrls(sourcePack);
+	for (const url of new Set(urls)) {
+		if (allowed.size > 0 && !allowed.has(url)) {
+			warnings.push(`image: "${url}" is not present in source-pack image results`);
+		}
+	}
+}
+
+function collectAllowedImageUrls(sourcePack) {
+	const urls = new Set();
+	const add = (value) => {
+		if (typeof value === "string" && isHttpUrl(value)) urls.add(value);
+	};
+	const walk = (value) => {
+		if (Array.isArray(value)) return value.forEach(walk);
+		if (!value || typeof value !== "object") return;
+		for (const [key, child] of Object.entries(value)) {
+			if (/^(url|imageUrl|src|heroImage)$/i.test(key)) add(child);
+			walk(child);
+		}
+	};
+	walk(sourcePack?.images);
+	walk(sourcePack?.imageResults);
+	walk(sourcePack?.action?.target);
+	return urls;
+}
+
+async function checkMdxCompile(mdx, errors, warnings) {
+	try {
+		const mod = await import("@mdx-js/mdx");
+		await mod.compile(mdx, { jsx: true, development: false });
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		if (message.includes("Cannot find package '@mdx-js/mdx'")) {
+			warnings.push("mdx: @mdx-js/mdx is not installed in this repo; skipped compiler parse check");
+			checkBalancedBraces(mdx, warnings);
+			return;
+		}
+		errors.push(`mdx: compile failed: ${message}`);
+	}
+}
+
+function checkBalancedBraces(mdx, warnings) {
+	const opens = (mdx.match(/{/g) ?? []).length;
+	const closes = (mdx.match(/}/g) ?? []).length;
+	if (opens !== closes) warnings.push(`mdx: brace count differs ({=${opens}, }=${closes}); review JSX expressions`);
+}
+
+function isHttpUrl(value) {
+	return /^https?:\/\//i.test(value);
+}
+
+function required(value, name) {
+	if (!value) throw new Error(`${name} is required`);
+	return value;
+}

package/dist/skillpacks/geo/skills/geo-page-writer/scripts/collect-page-sources.mjs

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+const CONFIG_DIR = join(homedir(), ".anymorph");
+const CRED_FILE = join(CONFIG_DIR, "credentials.json");
+
+const command = process.argv[2];
+const args = parseArgs(process.argv.slice(3));
+
+try {
+	const result = await run(command, args);
+	if (result !== undefined) console.log(JSON.stringify(result, null, 2));
+	if (result && result.ok === false) process.exitCode = 1;
+} catch (err) {
+	const message = err instanceof Error ? err.message : String(err);
+	console.error(message);
+	process.exit(1);
+}
+
+async function run(mode, input) {
+	if (mode === "exa") return collectExa(input);
+	if (mode === "kb") return collectKb(input);
+	if (mode === "images") return collectImages(input);
+	if (mode === "all") return collectAll(input);
+	throw new Error("Usage: collect-page-sources.mjs <exa|kb|images|all> --run-id <id> --action-id <id> --workspace <id-or-domain> [--repo .] [--query text]");
+}
+
+function parseArgs(argv) {
+	const out = { repo: ".", limit: "10", imageLimit: "10" };
+	for (let i = 0; i < argv.length; i += 1) {
+		const arg = argv[i];
+		if (arg === "--repo") out.repo = requireValue(argv, ++i, arg);
+		else if (arg === "--run-id") out.runId = requireValue(argv, ++i, arg);
+		else if (arg === "--action-id") out.actionId = requireValue(argv, ++i, arg);
+		else if (arg === "--workspace") out.workspace = requireValue(argv, ++i, arg);
+		else if (arg === "--query") out.query = requireValue(argv, ++i, arg);
+		else if (arg === "--limit") out.limit = requireValue(argv, ++i, arg);
+		else if (arg === "--image-limit") out.imageLimit = requireValue(argv, ++i, arg);
+		else if (arg === "--type") out.type = requireValue(argv, ++i, arg);
+		else throw new Error(`Unknown argument: ${arg}`);
+	}
+	return out;
+}
+
+function requireValue(argv, index, flag) {
+	const value = argv[index];
+	if (!value || value.startsWith("--")) throw new Error(`${flag} requires a value`);
+	return value;
+}
+
+async function collectAll(input) {
+	const results = { exa: null, kb: null, images: null, failures: [] };
+	for (const [key, fn] of [
+		["exa", collectExa],
+		["kb", collectKb],
+		["images", collectImages],
+	]) {
+		try {
+			results[key] = await fn({ ...input, quiet: true });
+		} catch (err) {
+			results.failures.push({ source: key, error: err instanceof Error ? err.message : String(err) });
+		}
+	}
+	const ctx = await loadContext(input);
+	const sourcesDir = await ensureSourcesDir(ctx);
+	const sourcePack = {
+		schemaVersion: 1,
+		runId: ctx.runId,
+		actionId: ctx.actionId,
+		workspace: ctx.workspace,
+		query: ctx.query,
+		action: ctx.action,
+		generatedAt: new Date().toISOString(),
+		exa: results.exa?.summary ?? null,
+		exaSources: results.exa?.sources ?? [],
+		kb: results.kb?.summary ?? null,
+		kbResults: results.kb?.results ?? [],
+		images: results.images?.summary ?? null,
+		imageResults: results.images?.results ?? [],
+		failures: results.failures,
+	};
+	await writeJson(join(sourcesDir, "source-pack.json"), sourcePack);
+	return { ok: results.failures.length === 0, dir: sourcesDir, sourcePack: join(sourcesDir, "source-pack.json"), failures: results.failures };
+}
+
+async function collectExa(input) {
+	const apiKey = process.env.EXA_API_KEY;
+	if (!apiKey) throw new Error("EXA_API_KEY is required for Exa Deep Search");
+	const ctx = await loadContext(input);
+	const sourcesDir = await ensureSourcesDir(ctx);
+	const body = {
+		query: buildResearchPrompt(ctx),
+		type: input.type ?? "deep-reasoning",
+		contents: { highlights: true, summary: true },
+	};
+	const res = await fetch("https://api.exa.ai/search", {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			"x-api-key": apiKey,
+		},
+		body: JSON.stringify(body),
+	});
+	const text = await res.text();
+	if (!res.ok) throw new Error(`Exa search failed (${res.status}): ${text.slice(0, 1000)}`);
+	const data = JSON.parse(text);
+	const markdown = renderExaMarkdown(ctx, data);
+	await writeFile(join(sourcesDir, "exa-research.md"), markdown);
+	await writeJson(join(sourcesDir, "exa-response.json"), data);
+	const summary = {
+		type: body.type,
+		resultCount: Array.isArray(data.results) ? data.results.length : 0,
+		hasOutput: Boolean(data.output),
+		costDollars: data.costDollars ?? null,
+	};
+	return {
+		ok: true,
+		dir: sourcesDir,
+		summary,
+		sources: (data.results ?? []).map((item) => ({
+			title: item.title ?? null,
+			url: item.url ?? null,
+			publishedDate: item.publishedDate ?? null,
+		})),
+	};
+}
+
+async function collectKb(input) {
+	const ctx = await loadContext(input);
+	const workspaceId = await resolveWorkspaceId(ctx.workspace);
+	const sourcesDir = await ensureSourcesDir(ctx);
+	const params = new URLSearchParams({ query: ctx.query });
+	const data = await backendJson("GET", `/api/workspaces/${encodeURIComponent(workspaceId)}/knowledge-base/search?${params}`);
+	await writeJson(join(sourcesDir, "kb-results.json"), data);
+	const summary = {
+		workspaceId,
+		resultCount: Array.isArray(data.results) ? data.results.length : 0,
+	};
+	return { ok: true, dir: sourcesDir, summary, results: data.results ?? [] };
+}
+
+async function collectImages(input) {
+	const ctx = await loadContext(input);
+	const workspaceId = await resolveWorkspaceId(ctx.workspace);
+	const sourcesDir = await ensureSourcesDir(ctx);
+	const params = new URLSearchParams({
+		q: ctx.query,
+		topK: String(Number(input.imageLimit ?? input.limit ?? 10)),
+	});
+	const data = await backendJson("GET", `/api/workspaces/${encodeURIComponent(workspaceId)}/image-assets/search?${params}`);
+	await writeJson(join(sourcesDir, "image-results.json"), data);
+	const rows = Array.isArray(data.results) ? data.results : Array.isArray(data.items) ? data.items : [];
+	const summary = { workspaceId, resultCount: rows.length };
+	return { ok: true, dir: sourcesDir, summary, results: rows };
+}
+
+async function loadContext(input) {
+	const repo = resolve(input.repo ?? ".");
+	const runId = required(input.runId, "--run-id");
+	const actionId = required(input.actionId, "--action-id");
+	const runDir = join(repo, "agent", "runs", runId);
+	const actions = await readJson(join(runDir, "actions.json"));
+	const context = await readJson(join(runDir, "context.json")).catch(() => null);
+	const action = actions.actions?.find((item) => item.id === actionId);
+	if (!action) throw new Error(`Action ${actionId} not found in agent/runs/${runId}/actions.json`);
+	if (action.assetType !== "geo_page") throw new Error(`Action ${actionId} is ${action.assetType}; geo-page-writer only supports geo_page actions`);
+	const workspace = input.workspace ?? context?.workspaceId ?? context?.workspaceDomain;
+	if (!workspace) throw new Error("--workspace is required when run context does not include workspaceId/workspaceDomain");
+	const query = input.query ?? buildDefaultQuery(action, context);
+	return { repo, runId, actionId, runDir, action, context, workspace, query };
+}
+
+function buildDefaultQuery(action, context) {
+	const target = action.target ?? {};
+	return [
+		target.title,
+		action.objective,
+		action.changeBrief,
+		action.reason,
+		Array.isArray(target.queryCluster) ? target.queryCluster.join(", ") : "",
+		context?.workspaceDomain ? `brand domain: ${context.workspaceDomain}` : "",
+	]
+		.filter(Boolean)
+		.join("\n");
+}
+
+function buildResearchPrompt(ctx) {
+	return [
+		"Research this GEO page before MDX writing.",
+		"Return concise findings, source URLs, caveats, and claims that are safe to cite.",
+		"",
+		`Workspace: ${ctx.workspace}`,
+		`Run: ${ctx.runId}`,
+		`Action: ${ctx.actionId}`,
+		`Objective: ${ctx.action.objective}`,
+		`Reason: ${ctx.action.reason}`,
+		`Brief: ${ctx.action.changeBrief}`,
+		`Expected outcome: ${ctx.action.expectedOutcome}`,
+		"",
+		`Research query:\n${ctx.query}`,
+	].join("\n");
+}
+
+function renderExaMarkdown(ctx, data) {
+	const lines = [
+		`# Exa Research: ${ctx.action.target?.title ?? ctx.action.objective}`,
+		"",
+		`Run: ${ctx.runId}`,
+		`Action: ${ctx.actionId}`,
+		`Generated: ${new Date().toISOString()}`,
+		"",
+		"## Synthesized Output",
+		"",
+		renderOutputContent(data.output?.content),
+		"",
+		"## Grounding",
+		"",
+		...(Array.isArray(data.output?.grounding)
+			? data.output.grounding.map((item) => `- ${item.field ?? "output"}: ${(item.citations ?? []).map((c) => `${c.title ?? c.url} (${c.url})`).join("; ")}${item.confidence ? ` [${item.confidence}]` : ""}`)
+			: ["- none"]),
+		"",
+		"## Results",
+		"",
+		...(Array.isArray(data.results)
+			? data.results.map((item) => `- ${item.title ?? item.url}\n  ${item.url}\n  ${(item.highlights ?? []).slice(0, 3).join("\n  ") || item.summary || ""}`)
+			: ["- none"]),
+	];
+	return `${lines.join("\n")}\n`;
+}
+
+function renderOutputContent(value) {
+	if (value == null) return "_No synthesized output returned._";
+	if (typeof value === "string") return value;
+	return `\`\`\`json\n${JSON.stringify(value, null, 2)}\n\`\`\``;
+}
+
+async function ensureSourcesDir(ctx) {
+	const dir = join(ctx.repo, "agent", "page-writer", ctx.runId, ctx.actionId, "sources");
+	await mkdir(dir, { recursive: true });
+	return dir;
+}
+
+async function readJson(path) {
+	return JSON.parse(await readFile(path, "utf8"));
+}
+
+async function writeJson(path, value) {
+	await writeFile(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+async function backendJson(method, path) {
+	const res = await backendRequest(method, path);
+	const text = await res.text();
+	if (!res.ok) throw new Error(`${method} ${path} failed (${res.status}): ${text.slice(0, 1000) || res.statusText}`);
+	return text ? JSON.parse(text) : {};
+}
+
+async function backendRequest(method, path) {
+	const baseUrl = getApiUrl();
+	const headers = { "Content-Type": "application/json" };
+	const internal = process.env.ANYMORPH_INTERNAL_API_KEY || process.env.AGENT_INTERNAL_API_KEY || process.env.CRON_SECRET;
+	if (internal) headers.Authorization = `Bearer ${internal}`;
+	else if (process.env.ANYMORPH_ACCESS_TOKEN) headers.Authorization = `Bearer ${process.env.ANYMORPH_ACCESS_TOKEN}`;
+	else {
+		const creds = readCredentials();
+		if (creds?.access_token) headers.Authorization = `Bearer ${creds.access_token}`;
+	}
+	if (!headers.Authorization) throw new Error("No backend credential found. Run `anymorph login` or set ANYMORPH_ACCESS_TOKEN/ANYMORPH_INTERNAL_API_KEY.");
+	return fetch(`${baseUrl}${path}`, { method, headers });
+}
+
+async function resolveWorkspaceId(workspace) {
+	if (/^(ws_|workspace_|[a-z0-9]{20,})/i.test(workspace)) return workspace;
+	try {
+		const payload = await backendJson("GET", "/api/cli/status");
+		const match = (payload.workspaces ?? []).find((item) => item.id === workspace || item.domain === workspace || item.domain === String(workspace).replace(/^www\./, ""));
+		return match?.id ?? workspace;
+	} catch {
+		return workspace;
+	}
+}
+
+function readCredentials() {
+	if (!existsSync(CRED_FILE)) return null;
+	try {
+		return JSON.parse(readFileSync(CRED_FILE, "utf8"));
+	} catch {
+		return null;
+	}
+}
+
+function getApiUrl() {
+	const creds = readCredentials();
+	return creds?.api_url ?? process.env.ANYMORPH_API_URL ?? "https://api.anymorph.ai";
+}
+
+function required(value, name) {
+	if (!value) throw new Error(`${name} is required`);
+	return value;
+}

package/dist/skillpacks/geo/skills/geo-pages-diagnosis/SKILL.md

@@ -32,7 +32,7 @@ Read these references before producing proposals:
 - `references/diagnosis-contract.md` for the exact runtime diagnosis contract and artifact submission shape.
 
 1. Read shared run context and the GEO page candidate slice.
-2. Use `list_geo_strategy_candidates` before broad SQL.
+2. Use `list_geo_page_candidates` before broad SQL.
 3. Use `get_geo_intent_diagnostic` for weak intents and generated-page gaps.
 4. Use page visibility, page insights, content, source, and products only when needed.
 5. For commerce create actions, use product evidence before proposing product-linked pages.