mova-claude-import 0.1.1

package/src/run_import.ts

@@ -0,0 +1,526 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import type { ImportOptions, ImportResult } from "./index.js";
+import { redactText, redactJson, RedactionHit } from "./redaction.js";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import { getAnthropicProfileV0Files } from "./anthropic_profile_v0.js";
+import { lintV0, type LintReportV0 } from "./lint_v0.js";
+import { stableStringify } from "./stable_json.js";
+import { createExportZipV0 } from "./export_zip_v0.js";
+import { buildMovaOverlayV0, buildMovaControlEntryV0, MOVA_CONTROL_ENTRY_MARKER } from "./mova_overlay_v0.js";
+import { scanInputPolicyV0 } from "./input_policy_v0.js";
+import { EvidenceWriter } from "@leryk1981/mova-core-engine";
+import { MOVA_SPEC_BINDINGS_V0 } from "./mova_spec_bindings_v0.js";
+import { writeCleanClaudeProfileScaffoldV0 } from "./claude_profile_scaffold_v0.js";
+
+type Found = {
+  claudeMdPath?: string;
+  mcpJsonPath?: string;
+  skillFiles: string[];
+  skipped: Array<{ path: string; reason: string }>;
+};
+
+async function exists(p: string): Promise<boolean> {
+  try {
+    await fs.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function sha256File(p: string): Promise<string> {
+  const buf = await fs.readFile(p);
+  return crypto.createHash("sha256").update(buf).digest("hex");
+}
+
+async function readToolVersion(): Promise<string> {
+  try {
+    const pkgPath = fileURLToPath(new URL("../package.json", import.meta.url));
+    const raw = await fs.readFile(pkgPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.version === "string" ? parsed.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+function isLocalExcluded(rel: string, includeLocal: boolean): boolean {
+  if (includeLocal) return false;
+  const base = path.basename(rel);
+  if (base === "CLAUDE.local.md") return true;
+  if (base.includes(".local.")) return true;
+  return false;
+}
+
+async function scanProject(opts: ImportOptions): Promise<Found> {
+  const projectDir = path.resolve(opts.projectDir);
+  const skipped: Found["skipped"] = [];
+  const found: Found = { skillFiles: [], skipped };
+
+  const claudeMd = path.join(projectDir, "CLAUDE.md");
+  if (await exists(claudeMd)) found.claudeMdPath = claudeMd;
+
+  const mcpJson = path.join(projectDir, ".mcp.json");
+  if (await exists(mcpJson)) found.mcpJsonPath = mcpJson;
+
+  const skillsRoot = path.join(projectDir, ".claude", "skills");
+  if (await exists(skillsRoot)) {
+    const stack = [skillsRoot];
+    while (stack.length) {
+      const dir = stack.pop()!;
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const e of entries) {
+        const abs = path.join(dir, e.name);
+        const rel = path.relative(projectDir, abs).replace(/\\/g, "/");
+        if (isLocalExcluded(rel, opts.includeLocal)) {
+          skipped.push({ path: rel, reason: "excluded_by_default_local" });
+          continue;
+        }
+        if (e.isDirectory()) stack.push(abs);
+        else if (e.isFile() && e.name.toLowerCase().endsWith(".md"))
+          found.skillFiles.push(abs);
+      }
+    }
+  }
+
+  // placeholder for user settings exclusion
+  if (!opts.includeUserSettings) {
+    skipped.push({ path: "~/.claude/*", reason: "excluded_by_default_user_settings" });
+  }
+
+  found.skillFiles.sort((a, b) => a.localeCompare(b));
+  return found;
+}
+
+function computeRunId(hashes: string[]): string {
+  const h = crypto.createHash("sha256");
+  for (const x of hashes.sort()) h.update(x);
+  return h.digest("hex").slice(0, 16);
+}
+
+function normalizeSkillDir(rel: string): string {
+  const base = rel.replace(/\\/g, "/").replace(/\.md$/i, "");
+  const withoutRoot = base.replace(/^\.claude\/skills\//, "");
+  return withoutRoot.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+
+async function writeJsonFile(absPath: string, obj: any) {
+  await fs.mkdir(path.dirname(absPath), { recursive: true });
+  await fs.writeFile(absPath, stableStringify(obj) + "\n", "utf8");
+}
+
+async function writeTextFile(absPath: string, content: string) {
+  await fs.mkdir(path.dirname(absPath), { recursive: true });
+  await fs.writeFile(absPath, content, "utf8");
+}
+
+/** Load a JSON file and redact it */
+async function loadAndRedactJson(p: string) {
+  const raw = await fs.readFile(p, "utf8");
+  const parsed = JSON.parse(raw);
+  const { redacted, hits } = redactJson(parsed);
+  return { raw, parsed, redacted, hits };
+}
+
+async function ensureClaudeControlEntry(claudePath: string, block: string, marker: string) {
+  const content = await fs.readFile(claudePath, "utf8");
+  if (content.includes(marker)) return;
+  await fs.writeFile(claudePath, `${block}\n${content}`, "utf8");
+}
+
+function orderedObject(obj: any) {
+  return JSON.parse(stableStringify(obj));
+}
+
+async function writeEvidenceArtifact(writer: EvidenceWriter, baseDir: string, rel: string, obj: any) {
+  const target = await writer.writeArtifact(baseDir, rel, orderedObject(obj));
+  await fs.writeFile(target, stableStringify(obj) + "\n", "utf8");
+}
+
+async function loadMovaSpecSchema(fileName: string) {
+  const require = createRequire(import.meta.url);
+  const pkgPath = require.resolve("@leryk1981/mova-spec/package.json");
+  const schemaPath = path.join(path.dirname(pkgPath), "schemas", fileName);
+  const raw = await fs.readFile(schemaPath, "utf8");
+  return JSON.parse(raw);
+}
+
+async function loadMovaSpecSchemaById(schemaId: string) {
+  const fileName = schemaId.split("/").pop();
+  if (!fileName) throw new Error(`Invalid schema id: ${schemaId}`);
+  return loadMovaSpecSchema(fileName);
+}
+
+export async function runImport(opts: ImportOptions): Promise<ImportResult> {
+  const projectDir = path.resolve(opts.projectDir);
+  const outRoot = path.resolve(opts.outDir);
+  const inputPolicy = await scanInputPolicyV0(projectDir, {
+    strict: opts.strict,
+    include_local: opts.includeLocal,
+  });
+  const found = await scanProject(opts);
+
+  const inputs: Array<{ rel: string; sha256: string }> = [];
+  const redactionHits: RedactionHit[] = [];
+
+  /** Process a text file – redact and record */
+  async function processTextFile(rel: string, absPath: string) {
+    const raw = await fs.readFile(absPath, "utf8");
+    const { redacted, hits } = redactText(raw);
+    inputs.push({ rel, sha256: await sha256File(absPath) });
+    redactionHits.push(...hits);
+    return redacted;
+  }
+
+  // CLAUDE.md
+  let claudeMdRedacted = "";
+  if (found.claudeMdPath) {
+    claudeMdRedacted = await processTextFile("CLAUDE.md", found.claudeMdPath);
+  }
+
+  // .mcp.json
+  let mcpJsonRedacted = "";
+  let mcpJsonParsed: any | undefined;
+  if (found.mcpJsonPath) {
+    const { parsed, redacted, hits } = await loadAndRedactJson(found.mcpJsonPath);
+    mcpJsonParsed = parsed;
+    mcpJsonRedacted = stableStringify(redacted);
+    redactionHits.push(...hits);
+    inputs.push({
+      rel: ".mcp.json",
+      sha256: await sha256File(found.mcpJsonPath),
+    });
+  }
+
+  // skill files
+  const skillRedactedMap: Record<string, string> = {};
+  for (const f of found.skillFiles) {
+    const rel = path.relative(projectDir, f).replace(/\\/g, "/");
+    const redacted = await processTextFile(rel, f);
+    skillRedactedMap[rel] = redacted;
+  }
+
+  const runId = computeRunId(inputs.map((x) => `${x.rel}:${x.sha256}`));
+
+  const movaBase = path.join(outRoot, "mova", "claude_import", "v0");
+  const evidenceWriter = new EvidenceWriter();
+  const overlayParams = {
+    contractsDir: "mova/claude_import/v0/contracts/",
+    artifactsDir: "mova/claude_import/v0/",
+    instructionProfileFile: "instruction_profile_v0.json",
+    skillsCatalogFile: "skills_catalog_v0.json",
+    mcpServersFile: "mcp_servers_v0.json",
+    lintReportFile: "lint_report_v0.json",
+    qualityReportFile: "quality_report_v0.json",
+    exportManifestFile: "export_manifest_v0.json",
+  };
+  const normalizedSkills = Object.entries(skillRedactedMap).map(([rel, body]) => ({
+    rel,
+    body,
+    normDir: normalizeSkillDir(rel),
+    title: path.basename(rel, ".md"),
+  }));
+
+  if (!opts.dryRun) {
+    const toolVersion = await readToolVersion();
+    const versionInfo = {
+      tool_name: "mova-claude-import",
+      tool_version: toolVersion,
+      profile_version: "anthropic_profile_v0",
+      overlay_version: "mova_control_overlay_v0",
+      input_policy_version: "input_policy_v0",
+      lint_version: "lint_v0",
+      quality_version: "quality_v0",
+      export_zip_version: "export_zip_v0",
+    };
+    await writeEvidenceArtifact(evidenceWriter, movaBase, "VERSION.json", versionInfo);
+    await writeEvidenceArtifact(evidenceWriter, movaBase, "input_policy_report_v0.json", inputPolicy);
+  }
+
+  if (opts.strict && !inputPolicy.ok) {
+    const deniedRunId = computeRunId(
+      inputPolicy.denied.map((d) => `${d.path}:${d.kind}:${d.reason}`).sort()
+    );
+    if (!opts.dryRun) {
+      const manifest = {
+        tool: "mova-claude-import",
+        version: "v0",
+        run_id: deniedRunId,
+        project_dir: projectDir,
+        emit_profile: opts.emitProfile,
+        inputs: [],
+        imported: {
+          claude_md: false,
+          mcp_json: false,
+          skills_count: 0,
+        },
+        skipped: found.skipped,
+        input_policy_ok: false,
+      };
+      const episode = {
+        episode_id: deniedRunId,
+        recorded_at: "1970-01-01T00:00:00.000Z",
+        episode_type: "claude_import_run_v0",
+        run_id: deniedRunId,
+        ok: false,
+        result_core: {
+          imported: manifest.imported,
+          inputs_count: 0,
+          validation: null,
+        },
+        failure: {
+          reason: "input_policy_denied",
+          denied_count: inputPolicy.denied.length,
+        },
+      };
+      await writeEvidenceArtifact(evidenceWriter, movaBase, "import_manifest.json", manifest);
+      await writeEvidenceArtifact(evidenceWriter, movaBase, "episode_import_run.json", episode);
+    }
+    return {
+      ok: false,
+      exit_code: 2,
+      run_id: deniedRunId,
+      out_dir: outRoot,
+      imported: { claude_md: false, mcp_json: false, skills_count: 0 },
+      skipped: found.skipped,
+      lint_summary: "lint_v0: skipped",
+    };
+  }
+
+  let movaSpecSchemas: { instruction_profile: any; mcp_servers: any; core: any };
+  try {
+    movaSpecSchemas = {
+      instruction_profile: await loadMovaSpecSchemaById(MOVA_SPEC_BINDINGS_V0.instruction_profile_id),
+      mcp_servers: await loadMovaSpecSchemaById(MOVA_SPEC_BINDINGS_V0.mcp_servers_id),
+      core: await loadMovaSpecSchemaById(MOVA_SPEC_BINDINGS_V0.core_schema_id),
+    };
+  } catch (err: any) {
+    if (!opts.dryRun) {
+      const manifest = {
+        tool: "mova-claude-import",
+        version: "v0",
+        run_id: runId,
+        project_dir: projectDir,
+        emit_profile: opts.emitProfile,
+        inputs: [],
+        imported: {
+          claude_md: false,
+          mcp_json: false,
+          skills_count: 0,
+        },
+        skipped: found.skipped,
+        input_policy_ok: inputPolicy.ok,
+        failure: {
+          reason: "mova_spec_schema_missing",
+        },
+      };
+      const episode = {
+        episode_id: runId,
+        recorded_at: "1970-01-01T00:00:00.000Z",
+        episode_type: "claude_import_run_v0",
+        run_id: runId,
+        ok: false,
+        result_core: {
+          imported: manifest.imported,
+          inputs_count: 0,
+          validation: null,
+        },
+        failure: {
+          reason: "mova_spec_schema_missing",
+          detail: String(err?.message ?? err),
+        },
+      };
+      await writeEvidenceArtifact(evidenceWriter, movaBase, "import_manifest.json", manifest);
+      await writeEvidenceArtifact(evidenceWriter, movaBase, "episode_import_run.json", episode);
+    }
+    return {
+      ok: false,
+      exit_code: 2,
+      run_id: runId,
+      out_dir: outRoot,
+      imported: { claude_md: false, mcp_json: false, skills_count: 0 },
+      skipped: found.skipped,
+      lint_summary: "lint_v0: skipped",
+    };
+  }
+
+  if (!opts.dryRun && opts.emitProfile) {
+    await writeCleanClaudeProfileScaffoldV0(outRoot);
+    if (opts.emitOverlay) {
+      const controlEntry = buildMovaControlEntryV0(overlayParams);
+      const claudePath = path.join(outRoot, "CLAUDE.md");
+      if (await exists(claudePath)) {
+        await ensureClaudeControlEntry(claudePath, controlEntry, MOVA_CONTROL_ENTRY_MARKER);
+      }
+      const overlayFiles = buildMovaOverlayV0(overlayParams);
+      for (const [rel, content] of Object.entries(overlayFiles)) {
+        await writeTextFile(path.join(outRoot, rel), content);
+      }
+    }
+    const profileFiles = getAnthropicProfileV0Files();
+    for (const [rel, content] of Object.entries(profileFiles)) {
+      if (rel === "CLAUDE.md" || rel === ".claude/settings.json") continue;
+      await writeTextFile(path.join(outRoot, rel), content);
+    }
+    if (mcpJsonParsed) {
+      await writeJsonFile(path.join(outRoot, ".mcp.json"), mcpJsonParsed);
+    }
+    for (const skill of normalizedSkills) {
+      const outRel = path.join(".claude", "skills", skill.normDir, "SKILL.md");
+      await writeTextFile(path.join(outRoot, outRel), skill.body);
+    }
+  }
+
+  // Build contracts
+  const instructionProfile = {
+    profile_version: "v0",
+    claude_md: claudeMdRedacted,
+    anchors: {
+      mova_entry: "MOVA.md",
+      normalized_project: ".",
+    },
+  };
+
+  const skillsCatalog = {
+    profile_version: "v0",
+    skills: normalizedSkills.map((skill) => ({
+      skill_id: skill.normDir,
+      rel_dir: `.claude/skills/${skill.normDir}`,
+      title: skill.title,
+      skill_md: skill.body,
+    })),
+  };
+
+  const mcpServers = {
+    profile_version: "v0",
+    servers: Array.isArray(mcpJsonParsed?.servers) ? mcpJsonParsed?.servers : [],
+  };
+
+  if (!opts.dryRun) {
+    await writeJsonFile(path.join(movaBase, "contracts", "instruction_profile_v0.json"), instructionProfile);
+    await writeJsonFile(path.join(movaBase, "contracts", "skills_catalog_v0.json"), skillsCatalog);
+    await writeJsonFile(path.join(movaBase, "contracts", "mcp_servers_v0.json"), mcpServers);
+  }
+
+  // Validation with Ajv
+  const ajv = new (Ajv as any)({ allErrors: true, strict: true, validateSchema: false });
+  (addFormats as any)(ajv);
+  const coreSchemaId = movaSpecSchemas.core?.$id ?? "https://mova.dev/schemas/ds.mova_schema_core_v1.schema.json";
+  ajv.addSchema(movaSpecSchemas.core, coreSchemaId);
+  const schemaPath = (name: string) => fileURLToPath(new URL(`../schemas/${name}`, import.meta.url));
+  const schemas = {
+    instruction_profile: JSON.parse(
+      await fs.readFile(schemaPath("ds.claude_import.instruction_profile_v0.schema.json"), "utf8")
+    ),
+    skills_catalog: JSON.parse(
+      await fs.readFile(schemaPath("ds.claude_import.skills_catalog_v0.schema.json"), "utf8")
+    ),
+    mcp_servers: JSON.parse(
+      await fs.readFile(schemaPath("ds.claude_import.mcp_servers_v0.schema.json"), "utf8")
+    ),
+  };
+  const validateInstruction = ajv.compile(schemas.instruction_profile);
+  const validateSkills = ajv.compile(schemas.skills_catalog);
+  const validateMcp = ajv.compile(schemas.mcp_servers);
+  const validateSpecInstruction = ajv.compile(movaSpecSchemas.instruction_profile);
+  const validateSpecMcp = ajv.compile(movaSpecSchemas.mcp_servers);
+
+  const validationReport = {
+    instruction_profile: validateInstruction(instructionProfile),
+    skills_catalog: validateSkills(skillsCatalog),
+    mcp_servers: validateMcp(mcpServers),
+    mova_spec: {
+      instruction_profile: validateSpecInstruction(instructionProfile),
+      mcp_servers: validateSpecMcp(mcpServers),
+      errors: {
+        instruction_profile: validateSpecInstruction.errors,
+        mcp_servers: validateSpecMcp.errors,
+      },
+    },
+    errors: {
+      instruction_profile: validateInstruction.errors,
+      skills_catalog: validateSkills.errors,
+      mcp_servers: validateMcp.errors,
+    },
+  };
+
+  const manifest = {
+    tool: "mova-claude-import",
+    version: "v0",
+    run_id: runId,
+    project_dir: projectDir,
+    emit_profile: opts.emitProfile,
+    inputs: inputs.sort((a, b) => a.rel.localeCompare(b.rel)),
+    imported: {
+      claude_md: Boolean(found.claudeMdPath),
+      mcp_json: Boolean(found.mcpJsonPath),
+      skills_count: normalizedSkills.length,
+    },
+    skipped: found.skipped,
+    input_policy_ok: inputPolicy.ok,
+  };
+  const redactionReport = {
+    hits: redactionHits,
+    note: "Only presence/len recorded, values omitted.",
+  };
+
+  const episode = {
+    episode_id: runId,
+    recorded_at: "1970-01-01T00:00:00.000Z",
+    episode_type: "claude_import_run_v0",
+    run_id: runId,
+    ok: true,
+    result_core: {
+      imported: manifest.imported,
+      inputs_count: manifest.inputs.length,
+      validation: validationReport,
+    },
+  };
+
+  if (!opts.dryRun) {
+    await writeEvidenceArtifact(evidenceWriter, movaBase, "import_manifest.json", manifest);
+    await writeEvidenceArtifact(evidenceWriter, movaBase, "redaction_report.json", redactionReport);
+    await writeEvidenceArtifact(evidenceWriter, movaBase, "episode_import_run.json", episode);
+  }
+
+  let lintReport: LintReportV0 = {
+    profile_version: "v0" as const,
+    ok: true,
+    issues: [],
+    summary: "lint_v0: ok",
+  };
+  if (!opts.dryRun) {
+    lintReport = await lintV0({
+      outRoot,
+      emitProfile: opts.emitProfile,
+      mcpExpected: Boolean(found.mcpJsonPath),
+    });
+    await writeEvidenceArtifact(evidenceWriter, movaBase, "lint_report_v0.json", lintReport);
+  }
+
+  if (!opts.dryRun && opts.emitZip) {
+    const exportZip = await createExportZipV0(outRoot, opts.zipName);
+    const exportManifest = {
+      profile_version: "v0",
+      zip_rel_path: exportZip.zipRelPath,
+      zip_sha256: exportZip.zipSha256,
+      files_count: exportZip.files.length,
+      files: exportZip.files,
+    };
+    await writeEvidenceArtifact(evidenceWriter, movaBase, "export_manifest_v0.json", exportManifest);
+  }
+
+  return {
+    ok: true,
+    run_id: runId,
+    out_dir: outRoot,
+    imported: manifest.imported,
+    skipped: found.skipped,
+    lint_summary: lintReport.summary,
+  };
+}

package/src/stable_json.ts

@@ -0,0 +1,15 @@
+function sortValue(value: any): any {
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (value && typeof value === "object") {
+    const out: Record<string, any> = {};
+    for (const key of Object.keys(value).sort()) {
+      out[key] = sortValue(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+
+export function stableStringify(value: any): string {
+  return JSON.stringify(sortValue(value), null, 2);
+}

package/test/control_apply_apply.test.js

@@ -0,0 +1,40 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileP = promisify(execFile);
+
+test("control apply writes marker and report", async () => {
+  const tmp = path.join(process.cwd(), ".tmp_test_control_apply");
+  const proj = path.join(tmp, "proj");
+  const out = path.join(tmp, "out");
+  const profile = path.join(process.cwd(), "fixtures", "pos", "control_profile_filled", "claude_control_profile_v0.json");
+  await fs.rm(tmp, { recursive: true, force: true });
+  await fs.mkdir(proj, { recursive: true });
+  await fs.writeFile(path.join(proj, "CLAUDE.md"), "Hello\n", "utf8");
+  await fs.writeFile(path.join(proj, ".mcp.json"), "{\"servers\":[]}", "utf8");
+
+  await execFileP("node", [
+    "dist/cli.js",
+    "control",
+    "apply",
+    "--project",
+    proj,
+    "--profile",
+    profile,
+    "--mode",
+    "apply",
+    "--out",
+    out,
+  ]);
+
+  const claude = await fs.readFile(path.join(proj, "CLAUDE.md"), "utf8");
+  assert.ok(claude.includes("MOVA_CONTROL_ENTRY_V0"));
+
+  const runsDir = path.join(out, "mova", "claude_control", "v0", "runs");
+  const entries = await fs.readdir(runsDir);
+  assert.ok(entries.length > 0);
+});

package/test/control_check_preview.test.js

@@ -0,0 +1,38 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileP = promisify(execFile);
+
+async function readFile(p) {
+  return fs.readFile(p, "utf8");
+}
+
+test("control check does not modify project files", async () => {
+  const tmp = path.join(process.cwd(), ".tmp_test_control_check");
+  const proj = path.join(tmp, "proj");
+  const out = path.join(tmp, "out");
+  const profile = path.join(process.cwd(), "fixtures", "pos", "control_profile_filled", "claude_control_profile_v0.json");
+  await fs.rm(tmp, { recursive: true, force: true });
+  await fs.mkdir(proj, { recursive: true });
+  await fs.writeFile(path.join(proj, "CLAUDE.md"), "Hello\n", "utf8");
+  await fs.writeFile(path.join(proj, ".mcp.json"), "{\"servers\":[]}", "utf8");
+
+  const claudeBefore = await readFile(path.join(proj, "CLAUDE.md"));
+  const mcpBefore = await readFile(path.join(proj, ".mcp.json"));
+
+  await execFileP("node", ["dist/cli.js", "control", "check", "--project", proj, "--profile", profile, "--out", out]);
+
+  const claudeAfter = await readFile(path.join(proj, "CLAUDE.md"));
+  const mcpAfter = await readFile(path.join(proj, ".mcp.json"));
+
+  assert.equal(claudeBefore, claudeAfter);
+  assert.equal(mcpBefore, mcpAfter);
+
+  const runsDir = path.join(out, "mova", "claude_control", "v0", "runs");
+  const entries = await fs.readdir(runsDir);
+  assert.ok(entries.length > 0);
+});

package/test/control_prefill.test.js

@@ -0,0 +1,30 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileP = promisify(execFile);
+
+async function readFile(p) {
+  return fs.readFile(p, "utf8");
+}
+
+test("control prefill is deterministic", async () => {
+  const tmp = path.join(process.cwd(), ".tmp_test_control_prefill");
+  const proj = path.join(process.cwd(), "fixtures", "pos", "control_basic_project");
+  const out1 = path.join(tmp, "out1");
+  const out2 = path.join(tmp, "out2");
+  await fs.rm(tmp, { recursive: true, force: true });
+  await fs.mkdir(out1, { recursive: true });
+  await fs.mkdir(out2, { recursive: true });
+
+  await execFileP("node", ["dist/cli.js", "control", "prefill", "--project", proj, "--out", out1]);
+  await execFileP("node", ["dist/cli.js", "control", "prefill", "--project", proj, "--out", out2]);
+
+  const profile1 = await readFile(path.join(out1, "claude_control_profile_v0.json"));
+  const profile2 = await readFile(path.join(out2, "claude_control_profile_v0.json"));
+
+  assert.equal(profile1, profile2);
+});

package/test/demo_v0_smoke.test.js

@@ -0,0 +1,37 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileP = promisify(execFile);
+
+async function exists(p) {
+  try {
+    await fs.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+test("demo v0 produces report and referenced files", async () => {
+  const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+  await execFileP(npmCmd, ["run", "demo"], { cwd: process.cwd(), shell: true });
+
+  const demoRoot = path.join(process.cwd(), "artifacts", "demo_v0");
+  const dirs = await fs.readdir(demoRoot);
+  assert.ok(dirs.length > 0);
+  dirs.sort();
+  const reportPath = path.join(demoRoot, dirs[dirs.length - 1], "demo_report_v0.json");
+  assert.ok(await exists(reportPath));
+
+  const report = JSON.parse(await fs.readFile(reportPath, "utf8"));
+  assert.ok(await exists(report.output_path));
+  assert.ok(await exists(report.refs.manifest));
+  assert.ok(await exists(report.refs.export_manifest));
+  assert.ok(await exists(report.refs.control_runs_dir));
+  assert.ok(await exists(report.refs.control_check_summary));
+  assert.ok(await exists(report.refs.control_apply_report));
+});