diff --git a/.agents/skills/frontend-aeo-wiki/SKILL.md b/.agents/skills/frontend-aeo-wiki/SKILL.md
new file mode 100644
index 00000000..0f833b0b
--- /dev/null
+++ b/.agents/skills/frontend-aeo-wiki/SKILL.md
@@ -0,0 +1,77 @@
+---
+name: frontend-aeo-wiki
+description: Generate AEO wiki and answer-page drafts from the user-visible surface of a frontend repository, especially Next.js App Router apps. Use when turning frontend routes, pages, metadata, UI copy, README, or public docs into Kinic Wiki Markdown and /answers Markdown.
+---
+
+# Frontend AEO Wiki
+
+Use this skill when a frontend repository should become an AI-search-ready public wiki.
+
+## Scope
+
+Only document user-visible product behavior.
+
+Include:
+
+- Next.js App Router pages and layouts
+- route metadata and page titles
+- UI copy visible in components used by public pages
+- README and public docs
+- public API behavior only when surfaced in UI or public docs
+
+Exclude:
+
+- database schemas
+- backend-only code and internal clients
+- tests, fixtures, generated files, build scripts
+- secrets, environment values, private config
+- hidden admin surfaces
+- claims about pricing, security, compliance, performance, competitors, or roadmap unless explicitly present in visible UI, metadata, README, or public docs
+
+## Workflow
+
+1. Detect the frontend framework. For now, support Next.js App Router first.
+2. Build a source pack from visible routes, layouts, metadata, README, and docs.
+3. Generate concise Wiki Markdown:
+   - `/Wiki/product/overview.md`
+   - `/Wiki/product/screens.md`
+   - `/Wiki/product/features.md`
+   - `/Wiki/product/faq.md`
+4. Generate AEO answer Markdown under `/Wiki/aeo/...`.
+5. Every answer must include frontmatter with `title`, `description`, `answer_summary`, `updated`, `index: true`, `entities`, and `sources`.
+6. Every answer body must cite repo-relative source paths.
+7. Reject or omit unsupported claims instead of inventing product promises.
+
+## Answer Contract
+
+Use this frontmatter shape:
+
+```md
+---
+title: What is Example?
+description: Example helps users understand the visible product value.
+answer_summary: Example provides the visible product experience described in the frontend.
+updated: 2026-05-07
+index: true
+entities:
+  - Example
+sources:
+  - README.md
+  - app/page.tsx
+---
+```
+
+The body should be short, factual, and grounded in `sources`.
+
+## Validation
+
+Before publishing, ensure:
+
+- slugs are unique
+- required frontmatter exists
+- `sources` is non-empty
+- Markdown parses
+- no secret patterns appear
+- no unsupported claim category appears without a visible source
+
+If validation fails, do not publish generated pages.
diff --git a/crates/vfs_cli_app/src/aeo_generate/collect.rs b/crates/vfs_cli_app/src/aeo_generate/collect.rs
new file mode 100644
index 00000000..ac317561
--- /dev/null
+++ b/crates/vfs_cli_app/src/aeo_generate/collect.rs
@@ -0,0 +1,172 @@
+// Where: crates/vfs_cli_app/src/aeo_generate/collect.rs
+// What: Collect and validate user-visible frontend source paths.
+// Why: AEO generation must ignore implementation-only repository content.
+
+use crate::aeo_generate::types::{SourceEntry, SourceKind, ValidationReport};
+use anyhow::Result;
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::Path;
+
+const MAX_SOURCE_BYTES: u64 = 512 * 1024;
+
+pub fn collect_frontend_sources(repo: &Path) -> Result<Vec<SourceEntry>> {
+    let mut sources = BTreeMap::<String, SourceKind>::new();
+    let readme = repo.join("README.md");
+    if readme.is_file() {
+        sources.insert("README.md".to_string(), SourceKind::Readme);
+    }
+    collect_docs(repo, repo, &mut sources)?;
+    collect_next_app(repo, repo, &mut sources)?;
+    Ok(sources
+        .into_iter()
+        .map(|(path, kind)| SourceEntry { path, kind })
+        .collect())
+}
+
+pub fn validate_source_pack(sources: &[SourceEntry], repo: &Path) -> ValidationReport {
+    let mut report = ValidationReport {
+        passed: true,
+        errors: Vec::new(),
+        warnings: Vec::new(),
+    };
+    if !sources
+        .iter()
+        .any(|source| source.kind == SourceKind::NextAppPage)
+    {
+        report
+            .errors
+            .push("missing Next.js App Router page source".to_string());
+    }
+    if sources.is_empty() {
+        report
+            .errors
+            .push("no frontend AEO sources found".to_string());
+    }
+    for source in sources {
+        let path = repo.join(&source.path);
+        if let Ok(content) = fs::read_to_string(path)
+            && contains_secret_pattern(&content)
+        {
+            report
+                .errors
+                .push(format!("secret-like pattern found in {}", source.path));
+        }
+    }
+    report.passed = report.errors.is_empty();
+    report
+}
+
+fn collect_docs(
+    repo: &Path,
+    root: &Path,
+    sources: &mut BTreeMap<String, SourceKind>,
+) -> Result<()> {
+    let docs = repo.join("docs");
+    if !docs.is_dir() {
+        return Ok(());
+    }
+    collect_files(
+        &docs,
+        root,
+        sources,
+        |relative| relative.ends_with(".md") || relative.ends_with(".mdx"),
+        SourceKind::PublicDoc,
+    )
+}
+
+fn collect_next_app(
+    repo: &Path,
+    root: &Path,
+    sources: &mut BTreeMap<String, SourceKind>,
+) -> Result<()> {
+    let app = repo.join("app");
+    if !app.is_dir() {
+        return Ok(());
+    }
+    collect_files(
+        &app,
+        root,
+        sources,
+        |relative| {
+            (relative.ends_with("/page.tsx") || relative == "app/page.tsx")
+                || (relative.ends_with("/layout.tsx") || relative == "app/layout.tsx")
+        },
+        SourceKind::NextAppPage,
+    )?;
+    for (path, kind) in sources.iter_mut() {
+        if path.ends_with("/layout.tsx") || path == "app/layout.tsx" {
+            *kind = SourceKind::NextAppLayout;
+        }
+    }
+    Ok(())
+}
+
+fn collect_files(
+    dir: &Path,
+    root: &Path,
+    sources: &mut BTreeMap<String, SourceKind>,
+    include: impl Fn(&str) -> bool + Copy,
+    kind: SourceKind,
+) -> Result<()> {
+    for entry in fs::read_dir(dir)? {
+        let entry = entry?;
+        let path = entry.path();
+        let file_name = entry.file_name();
+        let file_name = file_name.to_string_lossy();
+        if should_skip_name(&file_name) {
+            continue;
+        }
+        if path.is_dir() {
+            collect_files(&path, root, sources, include, kind)?;
+            continue;
+        }
+        if !path.is_file() || path.metadata()?.len() > MAX_SOURCE_BYTES {
+            continue;
+        }
+        let relative = repo_relative(root, &path)?;
+        if include(&relative) && !is_hidden_admin_surface(&relative) {
+            sources.insert(relative, kind);
+        }
+    }
+    Ok(())
+}
+
+fn should_skip_name(name: &str) -> bool {
+    name.starts_with('.')
+        || matches!(
+            name,
+            "node_modules"
+                | "target"
+                | ".next"
+                | "dist"
+                | "build"
+                | "coverage"
+                | "__tests__"
+                | "tests"
+                | "fixtures"
+        )
+}
+
+fn is_hidden_admin_surface(relative: &str) -> bool {
+    relative
+        .split('/')
+        .any(|segment| segment == "admin" || segment == "(admin)" || segment.starts_with("_"))
+}
+
+fn repo_relative(root: &Path, path: &Path) -> Result<String> {
+    Ok(path
+        .strip_prefix(root)?
+        .components()
+        .map(|component| component.as_os_str().to_string_lossy())
+        .collect::<Vec<_>>()
+        .join("/"))
+}
+
+fn contains_secret_pattern(content: &str) -> bool {
+    content.contains("-----BEGIN PRIVATE KEY-----")
+        || content.contains("sk-")
+        || content.contains("AKIA")
+        || content.contains("SECRET_KEY=")
+        || content.contains("NEXT_PUBLIC_") && content.contains("PRIVATE")
+}
diff --git a/crates/vfs_cli_app/src/aeo_generate/mod.rs b/crates/vfs_cli_app/src/aeo_generate/mod.rs
new file mode 100644
index 00000000..35bf87b4
--- /dev/null
+++ b/crates/vfs_cli_app/src/aeo_generate/mod.rs
@@ -0,0 +1,176 @@
+// Where: crates/vfs_cli_app/src/aeo_generate/mod.rs
+// What: Local dry-run generator for frontend-surface AEO wiki artifacts.
+// Why: Repo push automation needs deterministic artifacts before server-side LLM publish exists.
+
+mod collect;
+mod output;
+mod types;
+
+pub use types::{AeoGenerateArgs, AeoGenerationReport};
+
+use anyhow::{Context, Result, bail};
+use collect::{collect_frontend_sources, validate_source_pack};
+use output::{build_manifest, build_outputs, slugify, write_outputs};
+use std::fs;
+
+pub fn run_aeo_generate(args: AeoGenerateArgs) -> Result<AeoGenerationReport> {
+    let repo = args
+        .repo
+        .canonicalize()
+        .with_context(|| format!("repo path does not exist: {}", args.repo.display()))?;
+    if !repo.is_dir() {
+        bail!("repo path is not a directory: {}", repo.display());
+    }
+    let project_name = args.project_name.trim();
+    if project_name.is_empty() {
+        bail!("project name must not be empty");
+    }
+    let project_slug = slugify(project_name);
+    if project_slug.is_empty() {
+        bail!("project name must contain at least one alphanumeric character");
+    }
+
+    let sources = collect_frontend_sources(&repo)?;
+    let validation = validate_source_pack(&sources, &repo);
+    let outputs = build_outputs(project_name, &project_slug, &sources);
+
+    fs::create_dir_all(args.out.join("wiki"))?;
+    fs::create_dir_all(args.out.join("answers"))?;
+    write_outputs(&args.out, project_name, &project_slug, &outputs)?;
+
+    let manifest = build_manifest(project_name, &project_slug, &outputs);
+    fs::write(
+        args.out.join("manifest.json"),
+        serde_json::to_string_pretty(&manifest)? + "\n",
+    )?;
+    fs::write(
+        args.out.join("validation.json"),
+        serde_json::to_string_pretty(&validation)? + "\n",
+    )?;
+
+    Ok(AeoGenerationReport {
+        project_name: project_name.to_string(),
+        project_slug,
+        framework: "nextjs_app_router".to_string(),
+        sources,
+        outputs,
+        validation,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{AeoGenerateArgs, run_aeo_generate};
+    use crate::aeo_generate::types::SourceKind;
+    use std::fs;
+    use tempfile::tempdir;
+
+    #[test]
+    fn next_app_router_fixture_generates_expected_artifacts() {
+        let dir = tempdir().expect("tempdir should exist");
+        let repo = dir.path().join("repo");
+        fs::create_dir_all(repo.join("app/features")).expect("dirs should write");
+        fs::create_dir_all(repo.join("docs")).expect("docs should write");
+        fs::write(repo.join("README.md"), "# Demo\nVisible product.").expect("readme should write");
+        fs::write(
+            repo.join("app/page.tsx"),
+            "export default function Page(){return <main>Demo home</main>}",
+        )
+        .expect("page should write");
+        fs::write(
+            repo.join("app/features/page.tsx"),
+            "export default function Page(){return <main>Features</main>}",
+        )
+        .expect("feature page should write");
+        fs::write(repo.join("docs/public.md"), "# Public docs").expect("doc should write");
+
+        let out = dir.path().join("out");
+        let report = run_aeo_generate(AeoGenerateArgs {
+            repo,
+            out: out.clone(),
+            project_name: "Demo App".to_string(),
+        })
+        .expect("generation should pass");
+
+        assert!(report.validation.passed);
+        assert!(out.join("wiki/overview.md").is_file());
+        assert!(out.join("answers/what-is-demo-app.md").is_file());
+        assert!(out.join("manifest.json").is_file());
+        assert!(
+            report
+                .sources
+                .iter()
+                .any(|source| source.path == "app/page.tsx"
+                    && source.kind == SourceKind::NextAppPage)
+        );
+        assert!(
+            report
+                .sources
+                .iter()
+                .any(|source| source.path == "docs/public.md"
+                    && source.kind == SourceKind::PublicDoc)
+        );
+    }
+
+    #[test]
+    fn generator_excludes_backend_tests_hidden_admin_and_env_files() {
+        let dir = tempdir().expect("tempdir should exist");
+        let repo = dir.path().join("repo");
+        fs::create_dir_all(repo.join("app/admin")).expect("admin dirs should write");
+        fs::create_dir_all(repo.join("app")).expect("app dirs should write");
+        fs::create_dir_all(repo.join("tests")).expect("tests dirs should write");
+        fs::write(
+            repo.join("app/page.tsx"),
+            "export default function Page(){return null}",
+        )
+        .expect("page should write");
+        fs::write(
+            repo.join("app/admin/page.tsx"),
+            "export default function Page(){return null}",
+        )
+        .expect("admin page should write");
+        fs::write(repo.join("tests/page.test.tsx"), "test('x',()=>{})").expect("test should write");
+        fs::write(repo.join(".env"), "SECRET_KEY=value").expect("env should write");
+
+        let report = run_aeo_generate(AeoGenerateArgs {
+            repo,
+            out: dir.path().join("out"),
+            project_name: "Demo".to_string(),
+        })
+        .expect("generation should pass");
+
+        let paths = report
+            .sources
+            .iter()
+            .map(|source| source.path.as_str())
+            .collect::<Vec<_>>();
+        assert!(paths.contains(&"app/page.tsx"));
+        assert!(!paths.contains(&"app/admin/page.tsx"));
+        assert!(!paths.contains(&"tests/page.test.tsx"));
+        assert!(!paths.contains(&".env"));
+    }
+
+    #[test]
+    fn missing_page_source_fails_validation() {
+        let dir = tempdir().expect("tempdir should exist");
+        let repo = dir.path().join("repo");
+        fs::create_dir_all(&repo).expect("repo should write");
+        fs::write(repo.join("README.md"), "# Demo").expect("readme should write");
+
+        let report = run_aeo_generate(AeoGenerateArgs {
+            repo,
+            out: dir.path().join("out"),
+            project_name: "Demo".to_string(),
+        })
+        .expect("generation should produce validation report");
+
+        assert!(!report.validation.passed);
+        assert!(
+            report
+                .validation
+                .errors
+                .iter()
+                .any(|error| error.contains("missing Next.js App Router page source"))
+        );
+    }
+}
diff --git a/crates/vfs_cli_app/src/aeo_generate/output.rs b/crates/vfs_cli_app/src/aeo_generate/output.rs
new file mode 100644
index 00000000..c5b5e136
--- /dev/null
+++ b/crates/vfs_cli_app/src/aeo_generate/output.rs
@@ -0,0 +1,202 @@
+// Where: crates/vfs_cli_app/src/aeo_generate/output.rs
+// What: Build and write frontend AEO dry-run artifacts.
+// Why: Generated files need a stable shape for future publish automation.
+
+use crate::aeo_generate::types::{
+    GeneratedOutput, GeneratedOutputKind, Manifest, ManifestAnswer, ManifestWikiPage, SourceEntry,
+};
+use anyhow::{Result, anyhow};
+use std::collections::BTreeSet;
+use std::fs;
+use std::path::Path;
+
+pub fn build_outputs(
+    project_name: &str,
+    project_slug: &str,
+    sources: &[SourceEntry],
+) -> Vec<GeneratedOutput> {
+    let source_paths = sources
+        .iter()
+        .map(|source| source.path.clone())
+        .collect::<Vec<_>>();
+    let wiki_pages = [
+        ("wiki/overview.md", "Product overview"),
+        ("wiki/screens.md", "Visible screens"),
+        ("wiki/features.md", "Visible features"),
+        ("wiki/faq.md", "Product FAQ"),
+    ];
+    let answers = [
+        (
+            format!("answers/what-is-{project_slug}.md"),
+            format!("what-is-{project_slug}"),
+            format!("What is {project_name}?"),
+        ),
+        (
+            format!("answers/how-does-{project_slug}-work.md"),
+            format!("how-does-{project_slug}-work"),
+            format!("How does {project_name} work?"),
+        ),
+        (
+            format!("answers/{project_slug}-features.md"),
+            format!("{project_slug}-features"),
+            format!("{project_name} features"),
+        ),
+    ];
+    wiki_pages
+        .into_iter()
+        .map(|(path, title)| GeneratedOutput {
+            kind: GeneratedOutputKind::Wiki,
+            path: path.to_string(),
+            slug: None,
+            title: title.to_string(),
+            sources: source_paths.clone(),
+        })
+        .chain(
+            answers
+                .into_iter()
+                .map(|(path, slug, title)| GeneratedOutput {
+                    kind: GeneratedOutputKind::Answer,
+                    path,
+                    slug: Some(slug),
+                    title,
+                    sources: source_paths.clone(),
+                }),
+        )
+        .collect()
+}
+
+pub fn write_outputs(
+    out: &Path,
+    project_name: &str,
+    project_slug: &str,
+    outputs: &[GeneratedOutput],
+) -> Result<()> {
+    let duplicate_slugs = duplicate_slugs(outputs);
+    if !duplicate_slugs.is_empty() {
+        return Err(anyhow!("duplicate generated slugs: {:?}", duplicate_slugs));
+    }
+    for output in outputs {
+        let path = out.join(&output.path);
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        let content = match output.kind {
+            GeneratedOutputKind::Wiki => wiki_markdown(project_name, output),
+            GeneratedOutputKind::Answer => answer_markdown(project_name, project_slug, output),
+        };
+        fs::write(path, content)?;
+    }
+    Ok(())
+}
+
+pub fn build_manifest(
+    project_name: &str,
+    project_slug: &str,
+    outputs: &[GeneratedOutput],
+) -> Manifest {
+    Manifest {
+        project_name: project_name.to_string(),
+        project_slug: project_slug.to_string(),
+        framework: "nextjs_app_router".to_string(),
+        answers: outputs
+            .iter()
+            .filter(|output| output.kind == GeneratedOutputKind::Answer)
+            .map(|output| ManifestAnswer {
+                slug: output.slug.clone().expect("answer output should have slug"),
+                title: output.title.clone(),
+                path: output.path.clone(),
+                sources: output.sources.clone(),
+            })
+            .collect(),
+        wiki_pages: outputs
+            .iter()
+            .filter(|output| output.kind == GeneratedOutputKind::Wiki)
+            .map(|output| ManifestWikiPage {
+                title: output.title.clone(),
+                path: output.path.clone(),
+                sources: output.sources.clone(),
+            })
+            .collect(),
+    }
+}
+
+pub fn slugify(value: &str) -> String {
+    let mut slug = String::new();
+    let mut last_dash = false;
+    for ch in value.chars() {
+        if ch.is_ascii_alphanumeric() {
+            slug.push(ch.to_ascii_lowercase());
+            last_dash = false;
+        } else if !last_dash && !slug.is_empty() {
+            slug.push('-');
+            last_dash = true;
+        }
+    }
+    if slug.ends_with('-') {
+        slug.pop();
+    }
+    slug
+}
+
+fn duplicate_slugs(outputs: &[GeneratedOutput]) -> Vec<String> {
+    let mut seen = BTreeSet::new();
+    let mut duplicates = BTreeSet::new();
+    for slug in outputs.iter().filter_map(|output| output.slug.as_ref()) {
+        if !seen.insert(slug.clone()) {
+            duplicates.insert(slug.clone());
+        }
+    }
+    duplicates.into_iter().collect()
+}
+
+fn wiki_markdown(project_name: &str, output: &GeneratedOutput) -> String {
+    format!(
+        "# {}\n\n{} is described from user-visible frontend sources.\n\n## Sources\n{}\n",
+        output.title,
+        project_name,
+        markdown_source_list(&output.sources)
+    )
+}
+
+fn answer_markdown(project_name: &str, project_slug: &str, output: &GeneratedOutput) -> String {
+    let slug = output
+        .slug
+        .as_deref()
+        .expect("answer output should have slug");
+    let subject = if slug == format!("what-is-{project_slug}") {
+        project_name.to_string()
+    } else {
+        format!("{project_name} ({slug})")
+    };
+    format!(
+        "---\ntitle: {}\ndescription: {} answer page generated from visible frontend sources.\nanswer_summary: {} is summarized from visible frontend sources.\nupdated: 2026-05-07\nindex: true\nentities:\n  - {}\nsources:\n{}\n---\n\n# {}\n\n{} is represented here using only user-visible frontend sources.\n\n## Sources\n{}\n",
+        output.title,
+        project_name,
+        project_name,
+        project_name,
+        frontmatter_source_list(&output.sources),
+        output.title,
+        subject,
+        markdown_source_list(&output.sources)
+    )
+}
+
+fn frontmatter_source_list(sources: &[String]) -> String {
+    sources
+        .iter()
+        .map(|source| format!("  - {source}"))
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+fn markdown_source_list(sources: &[String]) -> String {
+    if sources.is_empty() {
+        return "- No source paths found.\n".to_string();
+    }
+    sources
+        .iter()
+        .map(|source| format!("- `{source}`"))
+        .collect::<Vec<_>>()
+        .join("\n")
+        + "\n"
+}
diff --git a/crates/vfs_cli_app/src/aeo_generate/types.rs b/crates/vfs_cli_app/src/aeo_generate/types.rs
new file mode 100644
index 00000000..f674d583
--- /dev/null
+++ b/crates/vfs_cli_app/src/aeo_generate/types.rs
@@ -0,0 +1,85 @@
+// Where: crates/vfs_cli_app/src/aeo_generate/types.rs
+// What: Shared data contracts for frontend AEO dry-run generation.
+// Why: Manifest, validation, and CLI output need stable structured shapes.
+
+use serde::Serialize;
+use std::path::PathBuf;
+
+#[derive(Debug, Clone)]
+pub struct AeoGenerateArgs {
+    pub repo: PathBuf,
+    pub out: PathBuf,
+    pub project_name: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct AeoGenerationReport {
+    pub project_name: String,
+    pub project_slug: String,
+    pub framework: String,
+    pub sources: Vec<SourceEntry>,
+    pub outputs: Vec<GeneratedOutput>,
+    pub validation: ValidationReport,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct SourceEntry {
+    pub path: String,
+    pub kind: SourceKind,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum SourceKind {
+    Readme,
+    PublicDoc,
+    NextAppPage,
+    NextAppLayout,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct GeneratedOutput {
+    pub kind: GeneratedOutputKind,
+    pub path: String,
+    pub slug: Option<String>,
+    pub title: String,
+    pub sources: Vec<String>,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum GeneratedOutputKind {
+    Wiki,
+    Answer,
+}
+
+#[derive(Debug, Clone, Serialize, Default)]
+pub struct ValidationReport {
+    pub passed: bool,
+    pub errors: Vec<String>,
+    pub warnings: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct Manifest {
+    pub project_name: String,
+    pub project_slug: String,
+    pub framework: String,
+    pub answers: Vec<ManifestAnswer>,
+    pub wiki_pages: Vec<ManifestWikiPage>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct ManifestAnswer {
+    pub slug: String,
+    pub title: String,
+    pub path: String,
+    pub sources: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct ManifestWikiPage {
+    pub title: String,
+    pub path: String,
+    pub sources: Vec<String>,
+}
diff --git a/crates/vfs_cli_app/src/cli.rs b/crates/vfs_cli_app/src/cli.rs
index 87398fda..a87c1c2c 100644
--- a/crates/vfs_cli_app/src/cli.rs
+++ b/crates/vfs_cli_app/src/cli.rs
@@ -256,6 +256,14 @@ pub enum Command {
         #[arg(long, default_value = DEFAULT_MIRROR_ROOT)]
         mirror_root: String,
     },
+    AeoGenerate {
+        #[arg(long)]
+        repo: PathBuf,
+        #[arg(long)]
+        out: PathBuf,
+        #[arg(long)]
+        project_name: String,
+    },
 }
 
 impl Command {
@@ -515,4 +523,29 @@ mod tests {
         assert_eq!(limit, 9);
         assert!(!json);
     }
+
+    #[test]
+    fn main_cli_parses_aeo_generate_command() {
+        let cli = Cli::parse_from([
+            "vfs-cli",
+            "aeo-generate",
+            "--repo",
+            ".",
+            "--out",
+            "/tmp/aeo",
+            "--project-name",
+            "Demo App",
+        ]);
+        let Command::AeoGenerate {
+            repo,
+            out,
+            project_name,
+        } = cli.command
+        else {
+            panic!("expected aeo-generate command");
+        };
+        assert_eq!(repo, std::path::PathBuf::from("."));
+        assert_eq!(out, std::path::PathBuf::from("/tmp/aeo"));
+        assert_eq!(project_name, "Demo App");
+    }
 }
diff --git a/crates/vfs_cli_app/src/lib.rs b/crates/vfs_cli_app/src/lib.rs
index 660c227b..95f92692 100644
--- a/crates/vfs_cli_app/src/lib.rs
+++ b/crates/vfs_cli_app/src/lib.rs
@@ -1,6 +1,7 @@
 // Where: crates/vfs_cli_app/src/lib.rs
 // What: Agent-facing CLI library for FS-first remote operations and local mirrors.
 // Why: The CLI now talks to the canister using node-oriented APIs and mirrors paths directly.
+pub mod aeo_generate;
 #[cfg(test)]
 mod agent_tools_tests;
 pub mod beam_bench;
diff --git a/crates/vfs_cli_app/src/main.rs b/crates/vfs_cli_app/src/main.rs
index 2f38a38c..904b0144 100644
--- a/crates/vfs_cli_app/src/main.rs
+++ b/crates/vfs_cli_app/src/main.rs
@@ -4,13 +4,29 @@
 use anyhow::Result;
 use clap::Parser;
 use vfs_cli::connection::resolve_connection;
+use vfs_cli_app::aeo_generate::{AeoGenerateArgs, run_aeo_generate};
 use vfs_cli_app::cli::Cli;
+use vfs_cli_app::cli::Command;
 use vfs_cli_app::commands::run_command;
 use vfs_client::CanisterVfsClient;
 
 #[tokio::main]
 async fn main() -> Result<()> {
     let cli = Cli::parse();
+    if let Command::AeoGenerate {
+        repo,
+        out,
+        project_name,
+    } = &cli.command
+    {
+        let report = run_aeo_generate(AeoGenerateArgs {
+            repo: repo.clone(),
+            out: out.clone(),
+            project_name: project_name.clone(),
+        })?;
+        println!("{}", serde_json::to_string_pretty(&report)?);
+        return Ok(());
+    }
     let connection = resolve_connection(cli.connection.local, cli.connection.canister_id.clone())?;
     let client = CanisterVfsClient::new(&connection.replica_host, &connection.canister_id).await?;
     run_command(&client, cli).await
diff --git a/docs/internal/FRONTEND_AEO_WIKI.md b/docs/internal/FRONTEND_AEO_WIKI.md
new file mode 100644
index 00000000..bf93cbb2
--- /dev/null
+++ b/docs/internal/FRONTEND_AEO_WIKI.md
@@ -0,0 +1,71 @@
+# Frontend AEO Wiki
+
+Frontend AEO Wiki turns the user-visible surface of a frontend repo into Kinic Wiki pages and AEO answer pages.
+
+## Product Flow
+
+1. Developer connects a GitHub repository.
+2. Developer pushes to `main`.
+3. Kinic receives a push webhook.
+4. Kinic analyzes the frontend surface.
+5. Kinic-side LLM generation creates public Wiki and AEO answer drafts.
+6. Mechanical validation gates publish.
+7. Kinic publishes updated `/answers`, `sitemap.xml`, and `llms.txt`.
+
+The target experience is Vercel-like: connect a repo, push to `main`, and let Kinic keep the AI-search-ready public knowledge layer current.
+
+## Frontend Surface
+
+MVP source inputs:
+
+- Next.js App Router `app/**/page.tsx`
+- Next.js App Router `app/**/layout.tsx`
+- route metadata and visible UI copy
+- root `README.md`
+- public docs under `docs/**`
+
+Excluded inputs:
+
+- database schemas
+- backend-only helpers and internal API clients
+- tests and fixtures
+- generated files and build scripts
+- secrets, environment values, and private config
+- hidden admin surfaces
+
+Generated content must not claim pricing, security, compliance, performance, competitor superiority, or roadmap details unless the claim is explicit in visible UI, metadata, README, or public docs.
+
+## Generated Output
+
+Local dry-run output uses this shape:
+
+```text
+wiki/overview.md
+wiki/screens.md
+wiki/features.md
+wiki/faq.md
+answers/what-is-<project>.md
+answers/how-does-<project>-work.md
+answers/<project>-features.md
+manifest.json
+validation.json
+```
+
+Answer pages use the existing AEO frontmatter contract plus `sources`.
+
+## Publish Contract
+
+The current MVP only generates local artifacts. A later publish step can consume `manifest.json` to update Kinic Wiki nodes and derive `AeoPageConfig` allowlist entries.
+
+Publish must pass mechanical validation:
+
+- required frontmatter exists
+- slug values are unique
+- source paths are present
+- Markdown parses
+- no secret patterns are present
+- generated claims are grounded in visible frontend or public docs
+- `/w/*` remains `noindex`
+- only `/answers/*` appears in `sitemap.xml` and `llms.txt`
+
+If validation fails, Kinic keeps the previous published version and stores the failed generation report.
diff --git a/docs/internal/aeo-publish-mvp/README.md b/docs/internal/aeo-publish-mvp/README.md
new file mode 100644
index 00000000..9304b51b
--- /dev/null
+++ b/docs/internal/aeo-publish-mvp/README.md
@@ -0,0 +1,14 @@
+# AEO Publish MVP Investor Diagrams
+
+投資家向けに AEO Publish MVP の概念を説明する図を置く。
+
+## 推奨順序
+
+1. ![Search shift](search-shift.png)
+   検索導線が「ページ訪問」から「AI回答」へ移る市場変化を示す。
+
+2. ![Sitemap, llms.txt, and answers](sitemap-llms-answers.png)
+   `sitemap.xml`、`llms.txt`、`/answers/<slug>` の役割差を示す。
+
+3. ![AEO publish MVP flow](aeo-publish-mvp-flow.png)
+   Kinic Wiki Canister から AI 検索に引用されるまでの公開フローを示す。
diff --git a/docs/internal/aeo-publish-mvp/aeo-publish-mvp-flow.png b/docs/internal/aeo-publish-mvp/aeo-publish-mvp-flow.png
new file mode 100644
index 00000000..0c48bfad
Binary files /dev/null and b/docs/internal/aeo-publish-mvp/aeo-publish-mvp-flow.png differ
diff --git a/docs/internal/aeo-publish-mvp/search-shift.png b/docs/internal/aeo-publish-mvp/search-shift.png
new file mode 100644
index 00000000..d73aef6c
Binary files /dev/null and b/docs/internal/aeo-publish-mvp/search-shift.png differ
diff --git a/docs/internal/aeo-publish-mvp/sitemap-llms-answers.png b/docs/internal/aeo-publish-mvp/sitemap-llms-answers.png
new file mode 100644
index 00000000..f6c78800
Binary files /dev/null and b/docs/internal/aeo-publish-mvp/sitemap-llms-answers.png differ
diff --git a/wikibrowser/README.md b/wikibrowser/README.md
index d3441516..4873888e 100644
--- a/wikibrowser/README.md
+++ b/wikibrowser/README.md
@@ -128,6 +128,45 @@ The app is public read-only and accepts database IDs for the fixed canister. The
 Canister unreachable / API failures are shown as browser errors and are not treated as not-found states.
 The `/<database-id>/...` and `/dashboard/<database-id>` URLs are App Router dynamic routes. Read and authenticated calls go directly from the browser to the configured IC gateway.
 
+## AEO Publish MVP
+
+`/answers/<slug>` serves allowlisted AI-readable public memory pages. These pages run on the Next server with ISR and read Markdown from the configured Kinic Wiki canister.
+The published answer page is rendered from canonical Markdown so crawlers can read stable answer HTML.
+This MVP is Kinic's first AEO publish layer: question demand informs which allowlisted answer pages are added next, and the answer asset set expands without exposing arbitrary database browser routes.
+
+Environment:
+
+```bash
+KINIC_AEO_CANISTER_ID=<mainnet-wiki-canister-id>
+NEXT_PUBLIC_SITE_URL=https://kinic.xyz
+```
+
+Rules:
+
+- `/answers/*` is indexable and rendered with the page body in the initial HTML.
+- `/<database-id>/*` remains the arbitrary database browser and is marked `noindex`.
+- `sitemap.xml` only lists `/answers/*`.
+- `robots.txt` allows `OAI-SearchBot` and blocks arbitrary browser routes.
+- The service boundary is the AEO page allowlist, `sitemap.xml`, `llms.txt`, `robots.txt`, and JSON-LD generated from `AeoPageConfig`.
+
+AEO Markdown must include limited frontmatter:
+
+```md
+---
+title: What is Kinic?
+description: Kinic is an AI memory for important information.
+answer_summary: Kinic helps people browse and access important information in one organized place.
+updated: 2026-05-07
+index: true
+entities:
+  - Kinic
+  - AI memory
+sources:
+  - README.md
+  - app/page.tsx
+---
+```
+
 ## Troubleshooting
 
 - Local canister not found: `NEXT_PUBLIC_KINIC_WIKI_CANISTER_ID` does not exist on `NEXT_PUBLIC_WIKI_IC_HOST`. For `http://127.0.0.1:8000`, start the local replica / icp local network and deploy the wiki canister into that state.
@@ -145,10 +184,10 @@ Cloudflare settings:
 - Root Directory: `wikibrowser`
 - Install Command: `pnpm install --frozen-lockfile`
 - Build Command: `pnpm deploy`
-- Build Variables: `NEXT_PUBLIC_WIKI_IC_HOST=https://icp0.io` and `NEXT_PUBLIC_KINIC_WIKI_CANISTER_ID=<mainnet-wiki-canister-id>` for Preview and Production
+- Build Variables: `NEXT_PUBLIC_WIKI_IC_HOST=https://icp0.io`, `NEXT_PUBLIC_KINIC_WIKI_CANISTER_ID=<mainnet-wiki-canister-id>`, `KINIC_AEO_CANISTER_ID=<mainnet-wiki-canister-id>`, and `NEXT_PUBLIC_SITE_URL=<canonical-origin>` for Preview and Production
 - Runtime: Cloudflare Workers via `@opennextjs/cloudflare`
 
-Both variables are public browser bundle values. Set them as Cloudflare build variables, not only runtime Worker variables, because Next.js inlines `NEXT_PUBLIC_*` values into the client bundle during build.
+Set `NEXT_PUBLIC_*` values as Cloudflare build variables, not only runtime Worker variables, because Next.js inlines them into the client bundle during build.
 
 CLI deploy from this directory:
 
diff --git a/wikibrowser/app/[databaseId]/[[...segments]]/page.tsx b/wikibrowser/app/[databaseId]/[[...segments]]/page.tsx
index 30682ace..1987c7b1 100644
--- a/wikibrowser/app/[databaseId]/[[...segments]]/page.tsx
+++ b/wikibrowser/app/[databaseId]/[[...segments]]/page.tsx
@@ -1,6 +1,14 @@
 import { Suspense } from "react";
+import type { Metadata } from "next";
 import { WikiBrowser } from "@/components/wiki-browser";
 
+export const metadata: Metadata = {
+  robots: {
+    index: false,
+    follow: false
+  }
+};
+
 export default function WikiDatabasePage() {
   return (
     <Suspense fallback={<div className="min-h-screen bg-canvas" />}>
diff --git a/wikibrowser/app/answers/[slug]/page.tsx b/wikibrowser/app/answers/[slug]/page.tsx
new file mode 100644
index 00000000..dcacd154
--- /dev/null
+++ b/wikibrowser/app/answers/[slug]/page.tsx
@@ -0,0 +1,62 @@
+import type { Metadata } from "next";
+import { notFound } from "next/navigation";
+import { AeoArticle } from "@/components/aeo-article";
+import { absoluteUrl } from "@/lib/aeo/site";
+import { loadAeoPage } from "@/lib/aeo/load-page";
+
+export const runtime = "nodejs";
+export const revalidate = 3600;
+
+type PageProps = {
+  params: Promise<{
+    slug: string;
+  }>;
+};
+
+export async function generateMetadata({ params }: PageProps): Promise<Metadata> {
+  const { slug } = await params;
+  const page = await loadAeoPage(slug);
+  if (!page) {
+    return {};
+  }
+  const canonicalPath = page.parsed.frontmatter.canonical ?? page.config.canonicalPath;
+  const url = absoluteUrl(canonicalPath);
+  return {
+    title: page.parsed.frontmatter.title,
+    description: page.parsed.frontmatter.description,
+    alternates: {
+      canonical: url
+    },
+    openGraph: {
+      type: "article",
+      title: page.parsed.frontmatter.title,
+      description: page.parsed.frontmatter.description,
+      url,
+      locale: page.config.locale
+    }
+  };
+}
+
+export default async function AnswerPage({ params }: PageProps) {
+  const { slug } = await params;
+  const page = await loadAeoPage(slug);
+  if (!page) {
+    notFound();
+  }
+  const canonicalPath = page.parsed.frontmatter.canonical ?? page.config.canonicalPath;
+  const jsonLd = {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    headline: page.parsed.frontmatter.title,
+    description: page.parsed.frontmatter.description,
+    dateModified: page.parsed.frontmatter.updated,
+    mainEntityOfPage: absoluteUrl(canonicalPath),
+    about: page.parsed.frontmatter.entities
+  };
+  return (
+    <>
+      <script type="application/ld+json" dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }} />
+      <AeoArticle page={page} />
+    </>
+  );
+}
diff --git a/wikibrowser/app/llms.txt/route.ts b/wikibrowser/app/llms.txt/route.ts
new file mode 100644
index 00000000..88e8b038
--- /dev/null
+++ b/wikibrowser/app/llms.txt/route.ts
@@ -0,0 +1,16 @@
+import { listAeoPageLinks } from "@/lib/aeo/pages";
+import { absoluteUrl } from "@/lib/aeo/site";
+
+export const runtime = "nodejs";
+export const revalidate = 86400;
+
+export function GET() {
+  const links = listAeoPageLinks()
+    .map((page) => `- ${page.title}: ${absoluteUrl(page.path)}`)
+    .join("\n");
+  return new Response(`# Kinic\n\nKinic is an AI memory for browsing and accessing important information in one organized place.\n\n## Key pages\n\n${links}\n`, {
+    headers: {
+      "Content-Type": "text/plain; charset=utf-8"
+    }
+  });
+}
diff --git a/wikibrowser/app/robots.ts b/wikibrowser/app/robots.ts
new file mode 100644
index 00000000..870b837d
--- /dev/null
+++ b/wikibrowser/app/robots.ts
@@ -0,0 +1,26 @@
+import type { MetadataRoute } from "next";
+import { siteUrl } from "@/lib/aeo/site";
+
+export default function robots(): MetadataRoute.Robots {
+  return {
+    rules: [
+      {
+        userAgent: "OAI-SearchBot",
+        allow: ["/answers/", "/llms.txt", "/sitemap.xml"],
+        disallow: ["/"]
+      },
+      {
+        userAgent: "GPTBot",
+        allow: ["/answers/", "/llms.txt", "/sitemap.xml"],
+        disallow: ["/"]
+      },
+      {
+        userAgent: "*",
+        allow: ["/answers/", "/llms.txt", "/sitemap.xml"],
+        disallow: ["/"]
+      }
+    ],
+    sitemap: `${siteUrl()}/sitemap.xml`,
+    host: siteUrl()
+  };
+}
diff --git a/wikibrowser/app/sitemap.ts b/wikibrowser/app/sitemap.ts
new file mode 100644
index 00000000..1bfe602e
--- /dev/null
+++ b/wikibrowser/app/sitemap.ts
@@ -0,0 +1,11 @@
+import type { MetadataRoute } from "next";
+import { listAeoPages } from "@/lib/aeo/pages";
+import { absoluteUrl } from "@/lib/aeo/site";
+
+export default function sitemap(): MetadataRoute.Sitemap {
+  return listAeoPages().map((page) => ({
+    url: absoluteUrl(page.canonicalPath),
+    changeFrequency: "weekly",
+    priority: 0.8
+  }));
+}
diff --git a/wikibrowser/components/aeo-article.tsx b/wikibrowser/components/aeo-article.tsx
new file mode 100644
index 00000000..9a1a4b6f
--- /dev/null
+++ b/wikibrowser/components/aeo-article.tsx
@@ -0,0 +1,51 @@
+// Where: wikibrowser/components/aeo-article.tsx
+// What: Server-rendered article view for AEO answer pages.
+// Why: AI and search crawlers need the answer body in the initial HTML.
+
+import Link from "next/link";
+import ReactMarkdown from "react-markdown";
+import remarkGfm from "remark-gfm";
+import { hrefForMarkdownLink } from "@/lib/paths";
+import type { LoadedAeoPage } from "@/lib/aeo/load-page";
+
+export function AeoArticle({ page }: { page: LoadedAeoPage }) {
+  const { config, parsed } = page;
+  const canonical = parsed.frontmatter.canonical ?? config.canonicalPath;
+  return (
+    <main className="min-h-screen bg-[#faf8f3] px-5 py-8 text-[#18212f] md:px-8 md:py-12">
+      <article className="mx-auto max-w-3xl">
+        <p className="font-mono text-xs uppercase text-[#667085]">Kinic public memory</p>
+        <h1 className="mt-3 text-4xl font-semibold leading-tight md:text-5xl">{parsed.frontmatter.title}</h1>
+        <p className="mt-5 text-xl leading-8 text-[#344054]">{parsed.frontmatter.answerSummary}</p>
+        <div className="mt-8 border-y border-[#ded7cb] py-4 text-sm text-[#667085]">
+          <p>Updated: {parsed.frontmatter.updated}</p>
+          <p className="mt-1">Canonical: {canonical}</p>
+        </div>
+        <div className="markdown-body mt-8">
+          <ReactMarkdown
+            remarkPlugins={[remarkGfm]}
+            components={{
+              a({ href, children, ...props }) {
+                const wikiHref = hrefForMarkdownLink(config.canisterId, config.databaseId, config.path, href);
+                if (!wikiHref) {
+                  return (
+                    <a href={href} {...props}>
+                      {children}
+                    </a>
+                  );
+                }
+                return (
+                  <Link href={wikiHref} {...props}>
+                    {children}
+                  </Link>
+                );
+              }
+            }}
+          >
+            {parsed.markdown}
+          </ReactMarkdown>
+        </div>
+      </article>
+    </main>
+  );
+}
diff --git a/wikibrowser/lib/aeo/load-page.ts b/wikibrowser/lib/aeo/load-page.ts
new file mode 100644
index 00000000..a108237d
--- /dev/null
+++ b/wikibrowser/lib/aeo/load-page.ts
@@ -0,0 +1,28 @@
+// Where: wikibrowser/lib/aeo/load-page.ts
+// What: Load allowlisted answer pages from a Kinic Wiki canister.
+// Why: AEO pages must embed canister-backed memory in server-rendered HTML.
+
+import { readNode } from "@/lib/vfs-client";
+import { getAeoPage, type AeoPageConfig } from "@/lib/aeo/pages";
+import { parseAeoMarkdown, type ParsedAeoMarkdown } from "@/lib/aeo/parse-markdown";
+
+export type LoadedAeoPage = {
+  config: AeoPageConfig;
+  parsed: ParsedAeoMarkdown;
+};
+
+export async function loadAeoPage(slug: string): Promise<LoadedAeoPage | null> {
+  const config = getAeoPage(slug);
+  if (!config || !config.canisterId) {
+    return null;
+  }
+  const node = await readNode(config.canisterId, config.databaseId, config.path);
+  if (!node || node.kind !== "file") {
+    return null;
+  }
+  const parsed = parseAeoMarkdown(node.content);
+  if (!parsed) {
+    return null;
+  }
+  return { config, parsed };
+}
diff --git a/wikibrowser/lib/aeo/pages.ts b/wikibrowser/lib/aeo/pages.ts
new file mode 100644
index 00000000..372f17fa
--- /dev/null
+++ b/wikibrowser/lib/aeo/pages.ts
@@ -0,0 +1,93 @@
+// Where: wikibrowser/lib/aeo/pages.ts
+// What: Kinic's allowlisted answer page targets for AI-readable public memory pages.
+// Why: The reusable AEO boundary is the page config, not arbitrary canister IDs or VFS paths.
+
+export type AeoPageConfig = {
+  slug: string;
+  canisterId: string;
+  databaseId: string;
+  path: string;
+  canonicalPath: string;
+  locale: string;
+};
+
+type AeoPageSeed = {
+  path: string;
+  title: string;
+};
+
+const DEFAULT_DATABASE_ID = "default";
+const DEFAULT_LOCALE = "en";
+const aeoCanisterId = process.env.KINIC_AEO_CANISTER_ID ?? "";
+
+const PAGE_SEEDS: Record<string, AeoPageSeed> = {
+  "what-is-kinic": {
+    path: "/Wiki/aeo/what-is-kinic.md",
+    title: "What is Kinic?"
+  },
+  "what-is-ai-memory": {
+    path: "/Wiki/aeo/what-is-ai-memory.md",
+    title: "What is AI memory?"
+  },
+  "personal-ai-memory": {
+    path: "/Wiki/aeo/personal-ai-memory.md",
+    title: "What is personal AI memory?"
+  },
+  "public-memory": {
+    path: "/Wiki/aeo/public-memory.md",
+    title: "What is public memory?"
+  },
+  "read-only-memory": {
+    path: "/Wiki/aeo/read-only-memory.md",
+    title: "What is read-only memory?"
+  },
+  "chatgpt-memory-app": {
+    path: "/Wiki/aeo/chatgpt-memory-app.md",
+    title: "What is a ChatGPT memory app?"
+  },
+  "kinic-vs-bookmarks": {
+    path: "/Wiki/comparisons/kinic-vs-bookmarks.md",
+    title: "Kinic vs bookmarks"
+  },
+  "kinic-vs-notion": {
+    path: "/Wiki/comparisons/kinic-vs-notion.md",
+    title: "Kinic vs Notion"
+  },
+  "ai-memory-for-research": {
+    path: "/Wiki/aeo/ai-memory-for-research.md",
+    title: "AI memory for research"
+  },
+  "ai-memory-for-developers": {
+    path: "/Wiki/aeo/ai-memory-for-developers.md",
+    title: "AI memory for developers"
+  }
+};
+
+export const AEO_PAGES: Record<string, AeoPageConfig> = Object.fromEntries(
+  Object.entries(PAGE_SEEDS).map(([slug, seed]) => [
+    slug,
+    {
+      slug,
+      canisterId: aeoCanisterId,
+      databaseId: DEFAULT_DATABASE_ID,
+      path: seed.path,
+      canonicalPath: `/answers/${slug}`,
+      locale: DEFAULT_LOCALE
+    }
+  ])
+);
+
+export function getAeoPage(slug: string): AeoPageConfig | null {
+  return AEO_PAGES[slug] ?? null;
+}
+
+export function listAeoPages(): AeoPageConfig[] {
+  return Object.values(AEO_PAGES);
+}
+
+export function listAeoPageLinks(): { title: string; path: string }[] {
+  return Object.entries(PAGE_SEEDS).map(([slug, seed]) => ({
+    title: seed.title,
+    path: `/answers/${slug}`
+  }));
+}
diff --git a/wikibrowser/lib/aeo/parse-markdown.ts b/wikibrowser/lib/aeo/parse-markdown.ts
new file mode 100644
index 00000000..ab4432c5
--- /dev/null
+++ b/wikibrowser/lib/aeo/parse-markdown.ts
@@ -0,0 +1,123 @@
+// Where: wikibrowser/lib/aeo/parse-markdown.ts
+// What: Parse the limited AEO frontmatter contract and Markdown body.
+// Why: MVP avoids a new YAML dependency while enforcing indexed page quality.
+
+export type AeoFrontmatter = {
+  title: string;
+  description: string;
+  answerSummary: string;
+  updated: string;
+  index: true;
+  canonical: string | null;
+  entities: string[];
+  sources: string[];
+};
+
+export type ParsedAeoMarkdown = {
+  frontmatter: AeoFrontmatter;
+  markdown: string;
+};
+
+type RawFrontmatter = {
+  title?: string;
+  description?: string;
+  answer_summary?: string;
+  updated?: string;
+  index?: string;
+  canonical?: string;
+  entities?: string[];
+  sources?: string[];
+};
+
+export function parseAeoMarkdown(content: string): ParsedAeoMarkdown | null {
+  if (!content.startsWith("---\n")) {
+    return null;
+  }
+  const endIndex = content.indexOf("\n---\n", 4);
+  if (endIndex === -1) {
+    return null;
+  }
+  const raw = parseFrontmatterBlock(content.slice(4, endIndex));
+  const frontmatter = normalizeFrontmatter(raw);
+  if (!frontmatter) {
+    return null;
+  }
+  return {
+    frontmatter,
+    markdown: content.slice(endIndex + "\n---\n".length).trim()
+  };
+}
+
+function parseFrontmatterBlock(block: string): RawFrontmatter {
+  const raw: RawFrontmatter = {};
+  let listKey: "entities" | "sources" | null = null;
+  for (const line of block.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    if (listKey && trimmed.startsWith("- ")) {
+      raw[listKey] = [...(raw[listKey] ?? []), unquote(trimmed.slice(2).trim())];
+      continue;
+    }
+    listKey = null;
+    const separator = trimmed.indexOf(":");
+    if (separator === -1) {
+      continue;
+    }
+    const key = trimmed.slice(0, separator).trim();
+    const value = trimmed.slice(separator + 1).trim();
+    if ((key === "entities" || key === "sources") && value === "") {
+      raw[key] = [];
+      listKey = key;
+      continue;
+    }
+    assignScalar(raw, key, unquote(value));
+  }
+  return raw;
+}
+
+function assignScalar(raw: RawFrontmatter, key: string, value: string): void {
+  if (key === "title") {
+    raw.title = value;
+  } else if (key === "description") {
+    raw.description = value;
+  } else if (key === "answer_summary") {
+    raw.answer_summary = value;
+  } else if (key === "updated") {
+    raw.updated = value;
+  } else if (key === "index") {
+    raw.index = value;
+  } else if (key === "canonical") {
+    raw.canonical = value;
+  }
+}
+
+function normalizeFrontmatter(raw: RawFrontmatter): AeoFrontmatter | null {
+  if (!raw.title || !raw.description || !raw.answer_summary || !raw.updated) {
+    return null;
+  }
+  if (raw.index !== "true") {
+    return null;
+  }
+  return {
+    title: raw.title,
+    description: raw.description,
+    answerSummary: raw.answer_summary,
+    updated: raw.updated,
+    index: true,
+    canonical: raw.canonical ?? null,
+    entities: raw.entities ?? [],
+    sources: raw.sources ?? []
+  };
+}
+
+function unquote(value: string): string {
+  if (value.length >= 2 && value.startsWith("\"") && value.endsWith("\"")) {
+    return value.slice(1, -1);
+  }
+  if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
diff --git a/wikibrowser/lib/aeo/site.ts b/wikibrowser/lib/aeo/site.ts
new file mode 100644
index 00000000..f2ed7e4c
--- /dev/null
+++ b/wikibrowser/lib/aeo/site.ts
@@ -0,0 +1,25 @@
+// Where: wikibrowser/lib/aeo/site.ts
+// What: Public URL helpers for metadata, sitemap, robots, and llms.txt.
+// Why: Canonical generation must be centralized across server routes.
+
+const LOCAL_SITE_URL = "http://localhost:3000";
+
+export function siteUrl(): string {
+  const explicitUrl = process.env.NEXT_PUBLIC_SITE_URL;
+  if (explicitUrl) {
+    return normalizeOrigin(explicitUrl);
+  }
+  const vercelUrl = process.env.VERCEL_URL;
+  if (vercelUrl) {
+    return normalizeOrigin(`https://${vercelUrl}`);
+  }
+  return LOCAL_SITE_URL;
+}
+
+export function absoluteUrl(path: string): string {
+  return new URL(path, siteUrl()).toString();
+}
+
+function normalizeOrigin(origin: string): string {
+  return origin.endsWith("/") ? origin.slice(0, -1) : origin;
+}
diff --git a/wikibrowser/package.json b/wikibrowser/package.json
index 2bdef33f..7a0c094b 100644
--- a/wikibrowser/package.json
+++ b/wikibrowser/package.json
@@ -9,7 +9,7 @@
     "smoke": "node scripts/smoke-ui.mjs",
     "smoke:errors": "node scripts/smoke-errors.mjs",
     "smoke:public": "node scripts/smoke-public.mjs",
-    "test": "node scripts/check-candid-drift.mjs && node scripts/check-paths.mjs && node scripts/check-ui-helpers.mjs && node scripts/check-api-errors.mjs && node scripts/check-smoke-url.mjs && node scripts/check-dashboard.mjs",
+    "test": "node scripts/check-candid-drift.mjs && node scripts/check-paths.mjs && node scripts/check-ui-helpers.mjs && node scripts/check-api-errors.mjs && node scripts/check-smoke-url.mjs && node scripts/check-dashboard.mjs && node scripts/check-aeo.mjs && node scripts/check-aeo-parser.mjs && node scripts/check-frontend-aeo-skill.mjs",
     "typecheck": "next typegen && tsc --noEmit",
     "build:worker": "opennextjs-cloudflare build",
     "preview": "opennextjs-cloudflare build && opennextjs-cloudflare preview",
diff --git a/wikibrowser/scripts/check-aeo-parser.mjs b/wikibrowser/scripts/check-aeo-parser.mjs
new file mode 100644
index 00000000..a5765b9b
--- /dev/null
+++ b/wikibrowser/scripts/check-aeo-parser.mjs
@@ -0,0 +1,79 @@
+// Where: wikibrowser/scripts/check-aeo-parser.mjs
+// What: Runtime contract checks for AEO Markdown parsing.
+// Why: Existing canister Markdown may lack generator-only fields such as sources.
+
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import vm from "node:vm";
+import ts from "typescript";
+
+const require = createRequire(import.meta.url);
+const root = process.cwd();
+const sourcePath = path.join(root, "lib/aeo/parse-markdown.ts");
+const source = fs.readFileSync(sourcePath, "utf8");
+const compiled = ts.transpileModule(source, {
+  compilerOptions: {
+    module: ts.ModuleKind.CommonJS,
+    target: ts.ScriptTarget.ES2022
+  }
+});
+
+const module = { exports: {} };
+vm.runInNewContext(compiled.outputText, {
+  exports: module.exports,
+  module,
+  require
+});
+
+const { parseAeoMarkdown } = module.exports;
+
+function markdown(frontmatter) {
+  return `---\n${frontmatter.trim()}\n---\n\nBody`;
+}
+
+const withSources = parseAeoMarkdown(
+  markdown(`
+title: What is Kinic?
+description: Kinic publishes public memory answers.
+answer_summary: Kinic publishes answer pages.
+updated: 2026-05-07
+index: true
+entities:
+  - Kinic
+sources:
+  - README.md
+  - app/page.tsx
+`)
+);
+
+assert.equal(withSources.frontmatter.sources.length, 2);
+assert.equal(
+  JSON.stringify(withSources.frontmatter.sources),
+  JSON.stringify(["README.md", "app/page.tsx"])
+);
+
+const withoutSources = parseAeoMarkdown(
+  markdown(`
+title: What is Kinic?
+description: Kinic publishes public memory answers.
+answer_summary: Kinic publishes answer pages.
+updated: 2026-05-07
+index: true
+`)
+);
+
+assert.equal(JSON.stringify(withoutSources.frontmatter.sources), JSON.stringify([]));
+
+for (const invalid of [
+  "description: Missing title\nanswer_summary: Summary\nupdated: 2026-05-07\nindex: true",
+  "title: Missing description\nanswer_summary: Summary\nupdated: 2026-05-07\nindex: true",
+  "title: Missing summary\ndescription: Description\nupdated: 2026-05-07\nindex: true",
+  "title: Missing updated\ndescription: Description\nanswer_summary: Summary\nindex: true",
+  "title: Not indexed\ndescription: Description\nanswer_summary: Summary\nupdated: 2026-05-07\nindex: false"
+]) {
+  assert.equal(parseAeoMarkdown(markdown(invalid)), null);
+}
+
+console.log("AEO parser checks passed");
diff --git a/wikibrowser/scripts/check-aeo.mjs b/wikibrowser/scripts/check-aeo.mjs
new file mode 100644
index 00000000..dacfda9a
--- /dev/null
+++ b/wikibrowser/scripts/check-aeo.mjs
@@ -0,0 +1,86 @@
+// Where: wikibrowser/scripts/check-aeo.mjs
+// What: Static checks for the AEO publish MVP.
+// Why: Route generation must stay allowlisted and crawler-safe.
+
+import fs from "node:fs";
+import path from "node:path";
+
+const root = process.cwd();
+const pagesSource = fs.readFileSync(path.join(root, "lib/aeo/pages.ts"), "utf8");
+const sitemapSource = fs.readFileSync(path.join(root, "app/sitemap.ts"), "utf8");
+const robotsSource = fs.readFileSync(path.join(root, "app/robots.ts"), "utf8");
+const configSource = fs.readFileSync(path.join(root, "next.config.ts"), "utf8");
+const parserSource = fs.readFileSync(path.join(root, "lib/aeo/parse-markdown.ts"), "utf8");
+
+const failures = [];
+
+for (const slug of [
+  "what-is-kinic",
+  "what-is-ai-memory",
+  "personal-ai-memory",
+  "public-memory",
+  "read-only-memory",
+  "chatgpt-memory-app",
+  "kinic-vs-bookmarks",
+  "kinic-vs-notion",
+  "ai-memory-for-research",
+  "ai-memory-for-developers"
+]) {
+  if (!pagesSource.includes(`"${slug}"`)) {
+    failures.push(`missing AEO slug: ${slug}`);
+  }
+}
+
+if (!pagesSource.includes("KINIC_AEO_CANISTER_ID")) {
+  failures.push("AEO canister id is not environment-backed");
+}
+if (!pagesSource.includes("canonicalPath: `/answers/${slug}`")) {
+  failures.push("AEO canonical paths must derive from allowlisted slugs");
+}
+if (pagesSource.includes("[canisterId]") || pagesSource.includes(":canister")) {
+  failures.push("AEO pages must not expose arbitrary canister route params");
+}
+if (!sitemapSource.includes("listAeoPages")) {
+  failures.push("sitemap must use the AEO allowlist");
+}
+if (sitemapSource.includes("/w/") || sitemapSource.includes("/dashboard/")) {
+  failures.push("sitemap must not include browser routes");
+}
+if (!robotsSource.includes("OAI-SearchBot")) {
+  failures.push("robots.txt must include OAI-SearchBot policy");
+}
+if (!robotsSource.includes('disallow: ["/"]')) {
+  failures.push("robots.txt must disallow arbitrary browser routes");
+}
+if (configSource.includes("output: \"export\"")) {
+  failures.push("next.config.ts must not use static export");
+}
+for (const field of ["title", "description", "answer_summary", "updated", "index", "sources"]) {
+  if (!parserSource.includes(field)) {
+    failures.push(`frontmatter parser does not handle ${field}`);
+  }
+}
+if (!parserSource.includes("sources: raw.sources ?? []")) {
+  failures.push("frontmatter parser must default missing sources to []");
+}
+if (parserSource.includes("!raw.sources || raw.sources.length === 0")) {
+  failures.push("frontmatter parser must not reject legacy AEO Markdown without sources");
+}
+for (const requiredFragment of [
+  "!raw.title",
+  "!raw.description",
+  "!raw.answer_summary",
+  "!raw.updated",
+  'raw.index !== "true"'
+]) {
+  if (!parserSource.includes(requiredFragment)) {
+    failures.push(`frontmatter parser must still require ${requiredFragment}`);
+  }
+}
+
+if (failures.length > 0) {
+  console.error(failures.join("\n"));
+  process.exit(1);
+}
+
+console.log("AEO checks passed");
diff --git a/wikibrowser/scripts/check-frontend-aeo-skill.mjs b/wikibrowser/scripts/check-frontend-aeo-skill.mjs
new file mode 100644
index 00000000..53fee684
--- /dev/null
+++ b/wikibrowser/scripts/check-frontend-aeo-skill.mjs
@@ -0,0 +1,35 @@
+// Where: wikibrowser/scripts/check-frontend-aeo-skill.mjs
+// What: Static contract checks for the frontend-aeo-wiki skill.
+// Why: AEO generation must stay scoped to visible frontend sources.
+
+import fs from "node:fs";
+import path from "node:path";
+
+const root = path.resolve(process.cwd(), "..");
+const skillPath = path.join(root, ".agents/skills/frontend-aeo-wiki/SKILL.md");
+const source = fs.readFileSync(skillPath, "utf8");
+const failures = [];
+
+for (const required of [
+  "Next.js App Router",
+  "user-visible product behavior",
+  "README",
+  "public docs",
+  "backend-only code",
+  "secrets",
+  "hidden admin surfaces",
+  "sources",
+  "slugs are unique",
+  "required frontmatter"
+]) {
+  if (!source.includes(required)) {
+    failures.push(`frontend-aeo-wiki skill is missing: ${required}`);
+  }
+}
+
+if (failures.length > 0) {
+  console.error(failures.join("\n"));
+  process.exit(1);
+}
+
+console.log("Frontend AEO skill checks passed");