anymorph 0.2.0 → 0.2.1

package/README.md

@@ -27,6 +27,7 @@ anymorph check yourdomain.com
 anymorph workspaces
 
 # Prepare and validate local GEO strategy artifacts
+anymorph geo init --repo .
 anymorph geo prepare yourdomain.com
 anymorph geo validate 20260517T074200Z --repo .
 ```
@@ -122,12 +123,55 @@ repos under `~/.anymorph/repos/{domain}`. Use `--repo` to target an explicit
 local checkout.
 
 ```bash
+anymorph geo init --repo ~/works/yourdomain.com
 anymorph geo prepare yourdomain.com
 anymorph geo prepare yourdomain.com --repo ~/works/yourdomain.com
 ```
 
-This initializes `agent/runs/{runId}/manifest.json`, `context.json`, and
-`status.json`. The agent fills the content artifacts separately.
+`prepare` syncs the GEO scaffold first unless `--skip-scaffold` is passed. It
+then initializes `agent/runs/{runId}/manifest.json`, `context.json`,
+`intents.json`, `crawl_logs.json`, and `status.json`. The agent fills the
+content artifacts separately.
+
+### `anymorph geo init`
+
+Initialize a local tenant repo for GEO work.
+
+```bash
+anymorph geo init --repo .
+anymorph geo init --repo . --skills-source /path/to/anymorph-geo-skills/plugins/anymorph-geo/skills
+```
+
+This installs managed skills under `.claude/skills` and `.agents/skills`, writes
+`agent/contracts`, creates `agent/runs` and `agent/archive`, and creates missing
+memory files without overwriting existing `agent/BRAND.md`, `agent/STRATEGY.md`,
+or `agent/LEARNINGS.md`.
+
+### `anymorph geo sync`
+
+Sync managed GEO files without touching memory or run artifacts.
+
+```bash
+anymorph geo sync --repo .
+```
+
+### `anymorph geo doctor`
+
+Check whether the local scaffold still matches the installed skillpack.
+
+```bash
+anymorph geo doctor --repo .
+anymorph geo doctor --repo . --json
+```
+
+### `anymorph geo intents <runId>`
+
+Show the pre-fetched intent list for a local GEO strategy run.
+
+```bash
+anymorph geo intents 20260517T074200Z --repo .
+anymorph geo intents 20260517T074200Z --repo . --json
+```
 
 ### `anymorph geo validate <runId>`
 

package/dist/index.js

@@ -5430,14 +5430,14 @@ var baseOpen = async (options) => {
   }
   const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode > 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve2(subprocess);
+        resolve3(subprocess);
       });
     });
   }
@@ -7051,7 +7051,7 @@ async function loginCommand() {
   process.exit(1);
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 
 // src/lib/display.ts
@@ -7181,7 +7181,7 @@ async function checkCommand(domain, opts) {
   process.exit(1);
 }
 function sleep2(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 
 // src/commands/status.ts
@@ -7246,6 +7246,10 @@ async function workspacesCommand(opts) {
   console.log();
 }
 
+// src/commands/geo.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+
 // src/geo/package-writer.ts
 import { mkdir, writeFile } from "node:fs/promises";
 import { join as join2 } from "node:path";
@@ -7261,16 +7265,57 @@ async function writeGeoRunPackage(input) {
     branch: input.package.branch,
     execution: input.package.execution,
     mode: input.package.mode,
-    signals: input.package.signals,
+    signals: buildContextSignals(input.package.signals),
     systemContext: input.package.systemContext,
-    schemaCatalog: input.package.schemaCatalog
+    schemaCatalog: input.package.schemaCatalog,
+    intentsPath: `agent/runs/${input.package.runId}/intents.json`
   });
+  await writeJson(join2(runDir, "intents.json"), buildIntentList(input.package));
+  await writeJson(
+    join2(runDir, "crawl_logs.json"),
+    buildCrawlLogAggregate(input.package)
+  );
   await writeJson(join2(runDir, "status.json"), {
     status: "pending",
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   return { runDir };
 }
+function buildIntentList(pkg) {
+  return {
+    runId: pkg.runId,
+    workspaceId: pkg.workspaceId,
+    workspaceDomain: pkg.workspaceDomain,
+    source: "signals.intents",
+    intents: extractIntents(pkg.signals)
+  };
+}
+function buildCrawlLogAggregate(pkg) {
+  return {
+    runId: pkg.runId,
+    workspaceId: pkg.workspaceId,
+    workspaceDomain: pkg.workspaceDomain,
+    source: "signals.crawlLogs",
+    crawlLogs: extractCrawlLogs(pkg.signals)
+  };
+}
+function extractIntents(signals2) {
+  if (!signals2 || typeof signals2 !== "object") return [];
+  const intents = signals2.intents;
+  return Array.isArray(intents) ? intents : [];
+}
+function extractCrawlLogs(signals2) {
+  if (!signals2 || typeof signals2 !== "object") return null;
+  return signals2.crawlLogs ?? null;
+}
+function buildContextSignals(signals2) {
+  if (!signals2 || typeof signals2 !== "object" || Array.isArray(signals2))
+    return signals2;
+  const record = signals2;
+  const { crawlLogs: _crawlLogs, ...rest } = record;
+  const { crawlLogsSummary: _crawlLogsSummary, ...contextSignals } = rest;
+  return contextSignals;
+}
 async function writeJson(path2, value) {
   await writeFile(path2, `${JSON.stringify(value, null, 2)}
 `);
@@ -7361,22 +7406,317 @@ async function gitOutput(repoPath, args) {
   }
 }
 
+// src/geo/scaffold.ts
+import { execFile as execFile7 } from "node:child_process";
+import {
+  cp,
+  mkdir as mkdir3,
+  readdir as readdir2,
+  readFile,
+  rm,
+  stat as stat2,
+  writeFile as writeFile2
+} from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { dirname, join as join4, relative, resolve as resolve2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { promisify as promisify7 } from "node:util";
+var execFileAsync6 = promisify7(execFile7);
+var DEFAULT_SKILLPACK_RELATIVE_PATH = join4(
+  "apps",
+  "anymorph-geo-skills",
+  "plugins",
+  "anymorph-geo",
+  "skills"
+);
+var MANAGED_PATHS = [".claude/skills", ".agents/skills", "agent/contracts"];
+async function initGeoScaffold(input) {
+  return applyGeoScaffold(input, { createMemory: true });
+}
+async function syncGeoScaffold(input) {
+  return applyGeoScaffold(input, { createMemory: false });
+}
+async function doctorGeoScaffold(input) {
+  const repoPath = resolve2(input.repoPath);
+  const skillsSourceDir = await resolveSkillSourceDir(input.skillsSourceDir);
+  const manifestHash = await hashDirectory(skillsSourceDir);
+  const problems = [];
+  for (const target of [".claude/skills", ".agents/skills"]) {
+    await compareDirectories(skillsSourceDir, join4(repoPath, target), target, problems);
+  }
+  for (const path2 of [
+    "agent/BRAND.md",
+    "agent/STRATEGY.md",
+    "agent/LEARNINGS.md",
+    "agent/runs/.gitkeep",
+    "agent/archive/.gitkeep",
+    "agent/skillpack.json"
+  ]) {
+    if (!await exists(join4(repoPath, path2))) problems.push(`Missing ${path2}`);
+  }
+  const lock = await readJson(join4(repoPath, "agent", "skillpack.json"));
+  if (lock && typeof lock === "object") {
+    const actual = lock.manifestHash;
+    if (actual !== manifestHash) {
+      problems.push("agent/skillpack.json manifestHash does not match current skillpack");
+    }
+  }
+  return {
+    ok: problems.length === 0,
+    repoPath,
+    skillsSourceDir,
+    changed: [],
+    problems,
+    manifestHash
+  };
+}
+async function resolveSkillSourceDir(explicit) {
+  if (explicit) {
+    const resolved = resolve2(explicit);
+    await ensureDirectory2(resolved);
+    return resolved;
+  }
+  for (const root of searchRoots()) {
+    const candidate = join4(root, DEFAULT_SKILLPACK_RELATIVE_PATH);
+    if (await isDirectory(candidate)) return candidate;
+  }
+  throw new Error(
+    `Could not find GEO skillpack. Pass --skills-source <path> pointing to ${DEFAULT_SKILLPACK_RELATIVE_PATH}.`
+  );
+}
+async function applyGeoScaffold(input, options) {
+  const repoPath = resolve2(input.repoPath);
+  const skillsSourceDir = await resolveSkillSourceDir(input.skillsSourceDir);
+  await ensureDirectory2(repoPath);
+  const changed = [];
+  const problems = [];
+  const manifestHash = await hashDirectory(skillsSourceDir);
+  await syncManagedDirectory(skillsSourceDir, join4(repoPath, ".claude", "skills"), changed);
+  await syncManagedDirectory(skillsSourceDir, join4(repoPath, ".agents", "skills"), changed);
+  await syncContracts(repoPath, changed);
+  await ensureRunDirs(repoPath, changed);
+  if (options.createMemory) await ensureMemoryFiles(repoPath, changed);
+  await writeSkillpackLock(
+    {
+      repoPath,
+      skillsSourceDir,
+      ref: input.ref ?? "local",
+      manifestHash
+    },
+    changed
+  );
+  return {
+    ok: problems.length === 0,
+    repoPath,
+    skillsSourceDir,
+    changed,
+    problems,
+    manifestHash
+  };
+}
+async function syncManagedDirectory(sourceDir, targetDir, changed) {
+  await rm(targetDir, { recursive: true, force: true });
+  await mkdir3(dirname(targetDir), { recursive: true });
+  await cp(sourceDir, targetDir, { recursive: true });
+  changed.push(relative(process.cwd(), targetDir) || targetDir);
+}
+async function syncContracts(repoPath, changed) {
+  const contractsDir = join4(repoPath, "agent", "contracts");
+  await mkdir3(contractsDir, { recursive: true });
+  await writeIfChanged(
+    join4(contractsDir, "actions.schema.json"),
+    `${JSON.stringify(ACTIONS_SCHEMA, null, 2)}
+`,
+    changed
+  );
+  await writeIfChanged(
+    join4(contractsDir, "memory-item.schema.json"),
+    `${JSON.stringify(MEMORY_ITEM_SCHEMA, null, 2)}
+`,
+    changed
+  );
+}
+async function ensureRunDirs(repoPath, changed) {
+  for (const path2 of [join4(repoPath, "agent", "runs"), join4(repoPath, "agent", "archive")]) {
+    await mkdir3(path2, { recursive: true });
+    await writeIfMissing(join4(path2, ".gitkeep"), "", changed);
+  }
+}
+async function ensureMemoryFiles(repoPath, changed) {
+  await mkdir3(join4(repoPath, "agent"), { recursive: true });
+  await writeIfMissing(
+    join4(repoPath, "agent", "BRAND.md"),
+    "# Brand\n\nInitial local scaffold. Replace with workspace brand context before serious runs.\n",
+    changed
+  );
+  await writeIfMissing(
+    join4(repoPath, "agent", "STRATEGY.md"),
+    "# GEO Strategy\n\n## Current Priorities\n\n- Initial local scaffold.\n",
+    changed
+  );
+  await writeIfMissing(
+    join4(repoPath, "agent", "LEARNINGS.md"),
+    "# Learnings\n\n## Stable Learnings\n\n- Initial local scaffold.\n",
+    changed
+  );
+}
+async function writeSkillpackLock(input, changed) {
+  const sourceCommit = await gitOutput2(input.skillsSourceDir, ["rev-parse", "HEAD"]);
+  const lock = {
+    name: "anymorph-geo",
+    source: input.skillsSourceDir,
+    sourceRepo: "opactor-dev/anymorph-geo-skills",
+    requestedRef: input.ref,
+    resolvedCommit: sourceCommit,
+    manifestHash: input.manifestHash,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    managedPaths: MANAGED_PATHS
+  };
+  await writeIfChanged(
+    join4(input.repoPath, "agent", "skillpack.json"),
+    `${JSON.stringify(lock, null, 2)}
+`,
+    changed
+  );
+}
+async function compareDirectories(sourceDir, targetDir, displayPrefix, problems) {
+  const sourceFiles = await listFiles(sourceDir);
+  const targetFiles = await listFiles(targetDir);
+  const targetSet = new Set(targetFiles);
+  for (const file of sourceFiles) {
+    const source = await readFile(join4(sourceDir, file), "utf8");
+    const targetPath = join4(targetDir, file);
+    if (!await exists(targetPath)) {
+      problems.push(`Missing ${displayPrefix}/${file}`);
+      continue;
+    }
+    const target = await readFile(targetPath, "utf8");
+    if (source !== target) problems.push(`Drifted ${displayPrefix}/${file}`);
+    targetSet.delete(file);
+  }
+  for (const extra of targetSet) problems.push(`Extra managed file ${displayPrefix}/${extra}`);
+}
+async function hashDirectory(dir) {
+  const files = await listFiles(dir);
+  const hash = createHash("sha256");
+  for (const file of files) {
+    hash.update(file);
+    hash.update("\0");
+    hash.update(await readFile(join4(dir, file)));
+    hash.update("\0");
+  }
+  return `sha256:${hash.digest("hex")}`;
+}
+async function listFiles(dir, base = "") {
+  let entries;
+  try {
+    entries = await readdir2(join4(dir, base), { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const name = String(entry.name);
+    const path2 = base ? `${base}/${name}` : name;
+    if (entry.isDirectory()) files.push(...await listFiles(dir, path2));
+    else if (entry.isFile()) files.push(path2);
+  }
+  return files.sort();
+}
+async function writeIfMissing(path2, content, changed) {
+  if (await exists(path2)) return;
+  await mkdir3(dirname(path2), { recursive: true });
+  await writeFile2(path2, content);
+  changed.push(relative(process.cwd(), path2) || path2);
+}
+async function writeIfChanged(path2, content, changed) {
+  const current = await readFile(path2, "utf8").catch(() => null);
+  if (current === content) return;
+  await mkdir3(dirname(path2), { recursive: true });
+  await writeFile2(path2, content);
+  changed.push(relative(process.cwd(), path2) || path2);
+}
+async function readJson(path2) {
+  const raw = await readFile(path2, "utf8").catch(() => null);
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function gitOutput2(cwd, args) {
+  try {
+    const { stdout } = await execFileAsync6("git", args, { cwd });
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function searchRoots() {
+  const roots = /* @__PURE__ */ new Set();
+  let cwd = resolve2(process.cwd());
+  for (; ; ) {
+    roots.add(cwd);
+    const parent = dirname(cwd);
+    if (parent === cwd) break;
+    cwd = parent;
+  }
+  let here = dirname(fileURLToPath2(import.meta.url));
+  for (; ; ) {
+    roots.add(here);
+    const parent = dirname(here);
+    if (parent === here) break;
+    here = parent;
+  }
+  return [...roots];
+}
+async function ensureDirectory2(path2) {
+  const s = await stat2(path2);
+  if (!s.isDirectory()) throw new Error(`${path2} is not a directory`);
+}
+async function isDirectory(path2) {
+  return stat2(path2).then((s) => s.isDirectory()).catch(() => false);
+}
+async function exists(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 { access, readFile } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { access, readFile as readFile2 } from "node:fs/promises";
+import { join as join5 } from "node:path";
 async function validateGeoRunArtifacts(input) {
-  const runDir = join4(input.repoPath, "agent", "runs", input.runId);
+  const runDir = join5(input.repoPath, "agent", "runs", input.runId);
   const errors = [];
   const warnings = [];
-  const manifest = await readJson(join4(runDir, "manifest.json"), errors);
-  const actions = await readJson(join4(runDir, "actions.json"), errors);
-  const status = await readJson(join4(runDir, "status.json"), errors);
-  const skillUsage = await readJson(join4(runDir, "skill-usage.json"), errors);
-  await requireFile(join4(runDir, "rationale.md"), errors);
+  const manifest = await readJson2(join5(runDir, "manifest.json"), errors);
+  const actions = await readJson2(join5(runDir, "actions.json"), errors);
+  const status = await readJson2(join5(runDir, "status.json"), errors);
+  await requireFile(join5(runDir, "rationale.md"), errors);
   if (manifest) validateManifest(manifest, input.runId, errors);
   if (actions) validateActions(actions, input.runId, errors);
   if (status) validateStatus(status, errors);
-  if (skillUsage) validateSkillUsage(skillUsage, errors);
   return {
     ok: errors.length === 0,
     errors,
@@ -7391,9 +7731,9 @@ async function requireFile(path2, errors) {
     errors.push(`Missing ${shortPath(path2)}`);
   }
 }
-async function readJson(path2, errors) {
+async function readJson2(path2, errors) {
   try {
-    const raw = await readFile(path2, "utf8");
+    const raw = await readFile2(path2, "utf8");
     return JSON.parse(raw);
   } catch (err) {
     const message = err instanceof SyntaxError ? "Invalid JSON" : "Missing";
@@ -7436,6 +7776,7 @@ function validateActions(value, runId, errors) {
   }
   if (value.runId !== runId) errors.push(`actions.json runId must be ${runId}`);
   if (!Array.isArray(value.actions)) errors.push("actions.json actions must be an array");
+  if (Array.isArray(value.actions)) validateActionItems(value.actions, errors);
   if (!Array.isArray(value.artifactPaths)) {
     errors.push("actions.json artifactPaths must be an array");
     return;
@@ -7450,19 +7791,100 @@ function validateActions(value, runId, errors) {
     }
   }
 }
-function validateStatus(value, errors) {
-  if (!isRecord(value)) {
-    errors.push("status.json must be an object");
+function validateActionItems(actions, errors) {
+  if (actions.length > 20) errors.push("actions.json actions must contain at most 20 items");
+  actions.forEach((action, index) => validateActionItem(action, index, errors));
+}
+function validateActionItem(action, index, errors) {
+  const prefix = `actions.json actions[${index}]`;
+  if (!isRecord(action)) {
+    errors.push(`${prefix} must be an object`);
     return;
   }
-  if (value.status !== "proposed") errors.push('status.json status must be "proposed"');
+  requireString(action, "id", prefix, errors);
+  requireEnum(action, "operation", ["create", "update"], prefix, errors);
+  requireEnum(action, "surface", ["on_page", "off_page"], prefix, errors);
+  requireEnum(action, "assetType", ["brand_owned", "geo_page", "third_party"], prefix, errors);
+  validateIntentRef(action, prefix, errors);
+  validateTarget(action, prefix, errors);
+  requireString(action, "objective", prefix, errors);
+  requireString(action, "changeBrief", prefix, errors);
+  requireString(action, "reason", prefix, errors);
+  requireString(action, "expectedOutcome", prefix, errors);
+  validateEvidence(action.evidence, prefix, errors);
+  requireEnum(action, "priority", ["high", "medium", "low"], prefix, errors);
+  requireEnum(action, "confidence", ["high", "medium", "low"], prefix, errors);
+}
+function validateIntentRef(action, prefix, errors) {
+  if (action.intentId !== null && typeof action.intentId !== "string") {
+    errors.push(`${prefix}.intentId must be a string or null`);
+  }
+  if (action.intentId === null) {
+    if (!isRecord(action.proposedIntent)) {
+      errors.push(`${prefix}.proposedIntent is required when intentId is null`);
+      return;
+    }
+    requireString(action.proposedIntent, "name", `${prefix}.proposedIntent`, errors);
+    requireString(action.proposedIntent, "reason", `${prefix}.proposedIntent`, errors);
+  }
+}
+function validateTarget(action, prefix, errors) {
+  const target = action.target;
+  if (!isRecord(target)) {
+    errors.push(`${prefix}.target must be an object`);
+    return;
+  }
+  if (action.operation === "create") {
+    if (typeof target.url === "string" && target.url.length > 0) {
+      errors.push(`${prefix}.target.url must be omitted for create actions`);
+    }
+    if (typeof target.pageId === "string" && target.pageId.length > 0) {
+      errors.push(`${prefix}.target.pageId must be omitted for create actions`);
+    }
+    if (!Array.isArray(target.queryCluster) && typeof target.description !== "string") {
+      errors.push(`${prefix}.target needs queryCluster or description for create actions`);
+    }
+  }
+  if (action.operation === "update") {
+    const hasUrl = typeof target.url === "string" && target.url.length > 0;
+    const hasPageId = typeof target.pageId === "string" && target.pageId.length > 0;
+    if (!hasUrl && !hasPageId) {
+      errors.push(`${prefix}.target needs pageId or url for update actions`);
+    }
+  }
+}
+function validateEvidence(value, prefix, errors) {
+  if (!Array.isArray(value)) {
+    errors.push(`${prefix}.evidence must be an array`);
+    return;
+  }
+  value.forEach((item, index) => {
+    const evidencePrefix = `${prefix}.evidence[${index}]`;
+    if (!isRecord(item)) {
+      errors.push(`${evidencePrefix} must be an object`);
+      return;
+    }
+    requireEnum(item, "type", ["signal", "workspace", "source", "research"], evidencePrefix, errors);
+    requireString(item, "ref", evidencePrefix, errors);
+    requireString(item, "summary", evidencePrefix, errors);
+  });
+}
+function requireString(record, key, prefix, errors) {
+  if (typeof record[key] !== "string" || record[key].length === 0) {
+    errors.push(`${prefix}.${key} must be a non-empty string`);
+  }
 }
-function validateSkillUsage(value, errors) {
+function requireEnum(record, key, allowed, prefix, errors) {
+  if (typeof record[key] !== "string" || !allowed.includes(record[key])) {
+    errors.push(`${prefix}.${key} must be one of ${allowed.join(", ")}`);
+  }
+}
+function validateStatus(value, errors) {
   if (!isRecord(value)) {
-    errors.push("skill-usage.json must be an object");
+    errors.push("status.json must be an object");
     return;
   }
-  if (!Array.isArray(value.skills)) errors.push("skill-usage.json skills must be an array");
+  if (value.status !== "proposed") errors.push('status.json status must be "proposed"');
 }
 function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -7475,12 +7897,62 @@ function shortPath(path2) {
 
 // src/commands/geo.ts
 function buildGeoCommand() {
-  const geo = new Command("geo").description("Prepare and validate local GEO strategy runs");
-  geo.command("prepare <workspace>").description("Prepare a local GEO strategy run package").option("--repo <path>", "Use an explicit tenant repo path").option("--days <days>", "Signal lookback window in days", parsePositiveInt).option("--json", "Output as JSON").action(geoPrepareCommand);
+  const geo = new Command("geo").description("Manage local GEO repo setup and strategy runs");
+  geo.command("init").description("Initialize GEO scaffold and skills in a tenant repo").option("--repo <path>", "Tenant repo path", ".").option("--skills-source <path>", "Use an explicit GEO skillpack source directory").option("--ref <ref>", "Skillpack ref label to write into agent/skillpack.json", "local").option("--json", "Output as JSON").action(geoInitCommand);
+  geo.command("sync").description("Sync managed GEO scaffold files without touching memory or run artifacts").option("--repo <path>", "Tenant repo path", ".").option("--skills-source <path>", "Use an explicit GEO skillpack source directory").option("--ref <ref>", "Skillpack ref label to write into agent/skillpack.json", "local").option("--json", "Output as JSON").action(geoSyncCommand);
+  geo.command("doctor").description("Check whether a tenant repo GEO scaffold matches the installed skillpack").option("--repo <path>", "Tenant repo path", ".").option("--skills-source <path>", "Use an explicit GEO skillpack source directory").option("--json", "Output as JSON").action(geoDoctorCommand);
+  geo.command("prepare <workspace>").description("Prepare a local GEO strategy run package").option("--repo <path>", "Use an explicit tenant repo path").option("--days <days>", "Signal lookback window in days", parsePositiveInt).option("--skills-source <path>", "Use an explicit GEO skillpack source directory").option("--skip-scaffold", "Skip GEO scaffold sync before writing the run package").option("--json", "Output as JSON").action(geoPrepareCommand);
   geo.command("validate <runId>").description("Validate local GEO strategy run artifacts before pushing").option("--repo <path>", "Use an explicit tenant repo path").option("--json", "Output as JSON").action(geoValidateCommand);
+  geo.command("intents <runId>").description("Show the pre-fetched intents for a local GEO strategy run").option("--repo <path>", "Use an explicit tenant repo path").option("--json", "Output as JSON").action(geoIntentsCommand);
   geo.command("status <runId>").description("Show backend sync status for a GEO strategy run").option("--json", "Output as JSON").action(geoStatusCommand);
   return geo;
 }
+async function geoInitCommand(opts) {
+  try {
+    const result = await initGeoScaffold({
+      repoPath: opts.repo,
+      skillsSourceDir: opts.skillsSource,
+      ref: opts.ref
+    });
+    printScaffoldResult("Initialized GEO scaffold", result, opts.json);
+  } catch (err) {
+    printScaffoldError("Couldn't initialize GEO scaffold", err);
+  }
+}
+async function geoSyncCommand(opts) {
+  try {
+    const result = await syncGeoScaffold({
+      repoPath: opts.repo,
+      skillsSourceDir: opts.skillsSource,
+      ref: opts.ref
+    });
+    printScaffoldResult("Synced GEO scaffold", result, opts.json);
+  } catch (err) {
+    printScaffoldError("Couldn't sync GEO scaffold", err);
+  }
+}
+async function geoDoctorCommand(opts) {
+  try {
+    const result = await doctorGeoScaffold({
+      repoPath: opts.repo,
+      skillsSourceDir: opts.skillsSource
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      process.exit(result.ok ? 0 : 1);
+    }
+    if (result.ok) {
+      console.log(source_default.green("\n  GEO scaffold is healthy.\n"));
+      return;
+    }
+    console.error(source_default.red("\n  GEO scaffold has drift\n"));
+    for (const problem of result.problems) console.error(`  - ${problem}`);
+    console.error();
+    process.exit(1);
+  } catch (err) {
+    printScaffoldError("Couldn't check GEO scaffold", err);
+  }
+}
 async function geoPrepareCommand(workspace, opts) {
   const res = await apiRequest("POST", "/api/cli/geo-strategy/prepare", {
     workspace,
@@ -7495,6 +7967,13 @@ async function geoPrepareCommand(workspace, opts) {
   let runDir;
   try {
     repoPath = await prepareTenantRepo({ package: pkg, repo: opts.repo });
+    if (!opts.skipScaffold) {
+      await initGeoScaffold({
+        repoPath,
+        skillsSourceDir: opts.skillsSource,
+        ref: pkg.branch
+      });
+    }
     ({ runDir } = await writeGeoRunPackage({ repoPath, package: pkg }));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -7554,6 +8033,45 @@ async function geoValidateCommand(runId, opts) {
   console.error();
   process.exit(1);
 }
+async function geoIntentsCommand(runId, opts) {
+  const repoPath = opts.repo ?? await findRepoForRun(runId);
+  if (!repoPath) {
+    console.error(source_default.red(`Could not find local repo for run ${runId}. Pass --repo <path>.`));
+    process.exit(1);
+  }
+  let payload;
+  try {
+    payload = await readGeoIntentList(join6(repoPath, "agent", "runs", runId));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(source_default.red(`Couldn't read intents for run ${runId}: ${message}`));
+    process.exit(1);
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  console.log();
+  console.log(source_default.bold(`  GEO intents for ${runId}`));
+  console.log(`  ${source_default.bold("Workspace:")} ${payload.workspaceDomain ?? payload.workspaceId ?? "unknown"}`);
+  console.log(`  ${source_default.bold("Count:")}     ${payload.intents.length}`);
+  console.log();
+  for (const intent of payload.intents) {
+    const row = intent && typeof intent === "object" ? intent : {};
+    const id = stringValue(row.id ?? row.intentId ?? row.intent_id) ?? "unknown";
+    const name = stringValue(row.name ?? row.intentName ?? row.intent_name) ?? "(unnamed)";
+    const type = stringValue(row.type ?? row.intentType ?? row.intent_type);
+    const visibility = numberValue(row.currentVisibility ?? row.current_visibility);
+    const competitor = numberValue(row.competitorVisibility ?? row.competitor_visibility);
+    const details = [
+      type ? `type=${type}` : null,
+      visibility !== null ? `visibility=${formatPct(visibility)}` : null,
+      competitor !== null ? `competitor=${formatPct(competitor)}` : null
+    ].filter(Boolean).join(", ");
+    console.log(`  - ${name} ${source_default.dim(`(${id})`)}${details ? source_default.dim(` - ${details}`) : ""}`);
+  }
+  console.log();
+}
 async function geoStatusCommand(runId, opts) {
   const res = await apiRequest("GET", `/api/cli/geo-strategy/runs/${encodeURIComponent(runId)}`);
   if (!res.ok) {
@@ -7579,10 +8097,64 @@ function parsePositiveInt(value) {
   }
   return parsed;
 }
+async function readGeoIntentList(runDir) {
+  try {
+    const raw = await readFile3(join6(runDir, "intents.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && Array.isArray(parsed.intents)) {
+      return parsed;
+    }
+    throw new Error("intents.json does not contain an intents array");
+  } catch (err) {
+    const contextRaw = await readFile3(join6(runDir, "context.json"), "utf8").catch(() => null);
+    if (!contextRaw) throw err;
+    const context = JSON.parse(contextRaw);
+    return {
+      runId: context.runId,
+      workspaceId: context.workspaceId,
+      workspaceDomain: context.workspaceDomain,
+      intents: Array.isArray(context.signals?.intents) ? context.signals.intents : []
+    };
+  }
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function formatPct(value) {
+  return `${(value * 100).toFixed(1)}%`;
+}
 async function printApiFailure(res, fallback2) {
   const body = await res.json().catch(() => null);
   console.error(source_default.red(body?.message ?? body?.error ?? fallback2));
 }
+function printScaffoldResult(title, result, json) {
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(result.ok ? 0 : 1);
+  }
+  console.log();
+  console.log(source_default.green.bold(`  ${title}`));
+  console.log(`  ${source_default.bold("Repo:")}      ${result.repoPath}`);
+  console.log(`  ${source_default.bold("Skillpack:")} ${result.skillsSourceDir}`);
+  console.log(`  ${source_default.bold("Hash:")}      ${result.manifestHash}`);
+  if (result.changed.length > 0) {
+    console.log();
+    console.log(source_default.bold("  Changed:"));
+    for (const path2 of result.changed) console.log(`  - ${path2}`);
+  } else {
+    console.log();
+    console.log(source_default.dim("  No file changes."));
+  }
+  console.log();
+}
+function printScaffoldError(prefix, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(source_default.red(`${prefix}: ${message}`));
+  process.exit(1);
+}
 
 // src/index.ts
 var program2 = new Command();

package/package.json

@@ -1,11 +1,11 @@
 {
 	"name": "anymorph",
-	"version": "0.2.0",
+	"version": "0.2.1",
 	"description": "Check your brand's AI visibility across ChatGPT, Perplexity, Gemini, and more",
 	"type": "module",
 	"private": false,
 	"bin": {
-		"anymorph": "./dist/index.js"
+		"anymorph": "dist/index.js"
 	},
 	"files": [
 		"dist",