mirai-graph 1.3.0 → 2.1.0

package/packages/cli/validate-process-transition-report.js

@@ -1,105 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require("fs");
-const { spawnSync } = require("child_process");
-
-const stateMachine = "examples/process-transition-minimal/state-machine.json";
-const fixtures = [
-  "examples/process-transition-minimal/results/transition-explanation-valid.json",
-  "examples/process-transition-minimal/results/transition-explanation-invalid-ready-to-written.json"
-];
-
-function readJson(filePath) {
-  return JSON.parse(fs.readFileSync(filePath, "utf8"));
-}
-
-function runValidator(args) {
-  return spawnSync(process.execPath, ["packages/cli/validate-mirai-graph.js", ...args], {
-    encoding: "utf8"
-  });
-}
-
-function sortJson(value) {
-  if (Array.isArray(value)) {
-    return value.map(sortJson);
-  }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.keys(value).sort().map((key) => [key, sortJson(value[key])])
-    );
-  }
-  return value;
-}
-
-function stable(value) {
-  return JSON.stringify(sortJson(value));
-}
-
-const errors = [];
-
-for (const fixturePath of fixtures) {
-  const fixture = readJson(fixturePath);
-  const run = runValidator(["process-transition", stateMachine, fixture.request_ref]);
-  let output;
-  try {
-    output = JSON.parse(run.stdout);
-  } catch (error) {
-    errors.push(`${fixturePath}: validator did not emit parseable JSON`);
-    continue;
-  }
-
-  if (output.valid !== fixture.expected_valid) {
-    errors.push(`${fixturePath}: expected valid=${fixture.expected_valid}, got ${output.valid}`);
-  }
-
-  if (fixture.expected_valid && run.status !== 0) {
-    errors.push(`${fixturePath}: expected validator exit 0, got ${run.status}`);
-  }
-
-  if (!fixture.expected_valid && run.status === 0) {
-    errors.push(`${fixturePath}: expected validator to fail`);
-  }
-
-  if (!output.explanation || typeof output.explanation !== "object") {
-    errors.push(`${fixturePath}: missing explanation object`);
-    continue;
-  }
-
-  if (stable(output.explanation) !== stable(fixture.explanation)) {
-    errors.push(`${fixturePath}: explanation does not match committed fixture`);
-  }
-
-  if (fixture.expected_error && !output.errors.includes(fixture.expected_error)) {
-    errors.push(`${fixturePath}: expected error not found`);
-  }
-}
-
-const markdown = runValidator([
-  "--markdown",
-  "process-transition",
-  stateMachine,
-  "examples/process-transition-minimal/transition-request.json"
-]);
-if (markdown.status !== 0) {
-  errors.push(`markdown report failed with exit ${markdown.status}`);
-}
-for (const requiredText of [
-  "Process Transition Decision Report",
-  "Transition: `release_ready -> released`",
-  "Kaizen decision: `satisfied`",
-  "Missing Evidence"
-]) {
-  if (!markdown.stdout.includes(requiredText)) {
-    errors.push(`markdown report missing ${requiredText}`);
-  }
-}
-
-const output = {
-  mode: "process_transition_report",
-  valid: errors.length === 0,
-  checked_files: fixtures,
-  errors
-};
-
-console.log(JSON.stringify(output, null, 2));
-process.exit(output.valid ? 0 : 1);

package/packages/cli/validate-profile-results.js

@@ -1,64 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require("fs");
-
-const resultFiles = [
-  "examples/minimal-graph/results/profile-conformance-result.json",
-  "examples/ai-employee-minimal/results/profile-conformance-result.json",
-  "examples/skill-runtime-minimal/results/profile-conformance-result.json",
-  "examples/organization-governance-minimal/results/profile-conformance-result.json",
-  "benchmarks/synthetic-context-reduction-v0/results/profile-conformance-result.json",
-  "pilots/independent-implementation-001-conference-planning/results/profile-conformance-result.json",
-  "pilots/independent-implementation-002-software-specification/results/profile-conformance-result.json",
-  "pilots/independent-implementation-003-ai-employee-workflow/results/profile-conformance-result.json",
-  "pilots/independent-implementation-004-research-program/results/profile-conformance-result.json",
-  "pilots/independent-implementation-005-organization-governance/results/profile-conformance-result.json"
-];
-
-const errors = [];
-
-for (const file of resultFiles) {
-  let result;
-  try {
-    result = JSON.parse(fs.readFileSync(file, "utf8"));
-  } catch (error) {
-    errors.push(`${file}: cannot read JSON: ${error.message}`);
-    continue;
-  }
-
-  if (result.valid !== true) {
-    errors.push(`${file}: valid must be true`);
-  }
-
-  if (!Array.isArray(result.errors) || result.errors.length !== 0) {
-    errors.push(`${file}: errors must be an empty array`);
-  }
-
-  if (typeof result.profile !== "string" || result.profile.trim() === "") {
-    errors.push(`${file}: profile must be a non-empty string`);
-  }
-
-  if (
-    typeof result.command !== "string" ||
-    !result.command.includes("validate-mirai-graph.js")
-  ) {
-    errors.push(`${file}: command must reference validate-mirai-graph.js`);
-  }
-
-  if (
-    typeof result.claim_supported !== "string" ||
-    !result.claim_supported.includes("declared Mirai Graph profile shape")
-  ) {
-    errors.push(`${file}: claim_supported must stay limited to profile shape conformance`);
-  }
-}
-
-const output = {
-  mode: "profile_conformance_results",
-  valid: errors.length === 0,
-  checked_files: resultFiles,
-  errors
-};
-
-console.log(JSON.stringify(output, null, 2));
-process.exit(output.valid ? 0 : 1);

package/packages/cli/validate-project-continuity.js

@@ -1,173 +0,0 @@
-#!/usr/bin/env node
-
-"use strict";
-
-const assert = require("assert");
-const fs = require("fs");
-const os = require("os");
-const path = require("path");
-const { spawnSync } = require("child_process");
-const technology = require("../project-technology");
-
-function writeJson(file, value) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
-}
-
-function git(repo, ...args) {
-  const run = spawnSync("git", args, { cwd: repo, encoding: "utf8" });
-  if (run.status !== 0) throw new Error(run.stderr || `git ${args.join(" ")} failed`);
-  return run.stdout.trim();
-}
-
-function manifest(id) {
-  return {
-    $schema: "https://mirai-graph.dev/schemas/graph-manifest.schema.json",
-    format: "mirai-graph", schema_version: "2.0.0", id, aliases: [], title: id,
-    scope: "repository", kind: "repository_graph", owner: "fixture-owner",
-    profiles: ["project_management", "implementation_control"],
-    graph: {
-      root: "graph", source_of_truth: ["graph/specs"], objects: ["graph/specs/objects.json"],
-      relations: ["graph/specs/relations.json"], schemas: [], generated: ["graph/generated"], raw_sources: ["README.md"],
-    },
-    imports: [],
-    extensions: { "mirai.project_technology": technology.extensionContract() },
-  };
-}
-
-function createRepo(root, name, withGit = true) {
-  const repo = path.join(root, name); fs.mkdirSync(repo, { recursive: true });
-  writeJson(path.join(repo, "graph.json"), manifest(name));
-  writeJson(path.join(repo, "graph/specs/objects.json"), [{
-    id: "goal.fixture.delivery", kind: "goal", title: "Deliver fixture", summary: "Complete a safe fixture task",
-    readiness: "accepted", profile: "project_management", source_refs: ["README.md"],
-  }]);
-  writeJson(path.join(repo, "graph/specs/relations.json"), []);
-  fs.writeFileSync(path.join(repo, "README.md"), "# Fixture\nPortable safe context.\n");
-  if (withGit) {
-    git(repo, "init", "-q"); git(repo, "config", "user.name", "Mirai Fixture"); git(repo, "config", "user.email", "fixture@example.invalid");
-    git(repo, "add", "."); git(repo, "commit", "-qm", "initial graph");
-  }
-  return repo;
-}
-
-function evidence(task, options = {}) {
-  return {
-    task_digest: technology.sha256(task, true),
-    outcome: options.outcome || `Verified result for ${task}`,
-    requirement_refs: options.requirement_refs || ["requirement.fixture.portability"],
-    evidence_refs: ["repo://fixture/checks/continuity"],
-    checks: [{ id: "check.fixture.continuity", verdict: "pass", evidence_ref: "repo://fixture/checks/continuity" }],
-    changed_surfaces: ["src/fixture.js"],
-    case_signature: options.case_signature || "case.fixture.portable-work",
-    method_candidate: options.method_candidate || null,
-    decisions: options.decisions || [],
-    source_revision: options.source_revision || null,
-  };
-}
-
-const checks = [];
-function check(id, condition, details = null) {
-  checks.push({ id, passed: Boolean(condition), details });
-  assert.ok(condition, `${id}: ${JSON.stringify(details)}`);
-}
-
-const root = fs.mkdtempSync(path.join(os.tmpdir(), "mirai-continuity-"));
-const stateRoot = path.join(root, "host-state");
-try {
-  const repo = createRepo(root, "git-project");
-  const before = git(repo, "status", "--porcelain=v1");
-  const taskStart = technology.execute("sync", repo, { apply: true, boundary: "task_start", stateRoot });
-  check("task_start_is_read_only", taskStart.status === "success" && taskStart.changed === false && git(repo, "status", "--porcelain=v1") === before, taskStart);
-  const preview = technology.execute("sync", repo, { apply: false, boundary: "task_complete", continuityEvidence: evidence("preview"), stateRoot });
-  check("preview_is_zero_write", preview.status === "preview" && git(repo, "status", "--porcelain=v1") === before, preview);
-  const missingReceiptVerify = technology.verify(repo, { stateRoot });
-  check("configured_continuity_without_receipt_blocks_verify", missingReceiptVerify.status === "blocked" && missingReceiptVerify.blockers.includes("continuity_missing"), missingReceiptVerify);
-
-  const first = technology.execute("sync", repo, { apply: true, boundary: "stage_complete", continuityEvidence: evidence("first", { method_candidate: "Use the verified bounded fixture path." }), stateRoot });
-  check("verified_result_is_saved", first.status === "success" && first.changed && first.continuity.saved_refs.length === 2, first);
-  check("portable_authority_is_graph_specs", fs.existsSync(path.join(repo, "graph/specs/project-continuity.json")) && first.continuity.authority === "graph/specs");
-  check("host_state_is_outside_project", !fs.existsSync(path.join(repo, ".mirai-graph/project-technology/receipts")) && fs.existsSync(stateRoot));
-  check("human_projection_is_generated", fs.readFileSync(path.join(repo, "graph/docs/project-context.md"), "utf8").includes("not a source of truth"));
-  const objectsAfterFirst = JSON.parse(fs.readFileSync(path.join(repo, "graph/specs/project-continuity.json"), "utf8")).objects;
-  check("first_method_is_proposal", objectsAfterFirst.some((item) => item.kind === "lesson" && item.readiness === "proposal"));
-  check("architecture_decision_is_not_accepted", technology.execute("sync", repo, {
-    apply: true, boundary: "task_complete", stateRoot,
-    continuityEvidence: evidence("decision", { decisions: [{ summary: "Replace the project architecture", changes_architecture: true }] }),
-  }).status === "success");
-  const decisionObjects = JSON.parse(fs.readFileSync(path.join(repo, "graph/specs/project-continuity.json"), "utf8")).objects;
-  check("architecture_change_remains_proposal", decisionObjects.some((item) => item.kind === "decision" && item.summary === "Replace the project architecture" && item.readiness === "proposal"));
-
-  const second = technology.execute("sync", repo, { apply: true, boundary: "task_complete", continuityEvidence: evidence("second", { method_candidate: "Use the verified bounded fixture path." }), stateRoot });
-  check("second_independent_case_is_saved", second.status === "success", second);
-  const objectsAfterSecond = JSON.parse(fs.readFileSync(path.join(repo, "graph/specs/project-continuity.json"), "utf8")).objects;
-  check("method_promotes_after_two_independent_cases", objectsAfterSecond.some((item) => item.kind === "lesson" && item.readiness === "accepted" && item.supporting_case_ids.length >= 2));
-
-  const beforeRepeat = fs.readFileSync(path.join(repo, "graph/specs/project-continuity.json"));
-  const repeated = technology.execute("sync", repo, { apply: true, boundary: "task_complete", continuityEvidence: evidence("second", { method_candidate: "Use the verified bounded fixture path." }), stateRoot });
-  check("repeat_is_byte_identical", repeated.status === "success" && repeated.changed === false && fs.readFileSync(path.join(repo, "graph/specs/project-continuity.json")).equals(beforeRepeat), repeated);
-  check("fresh_continuity_verifies_without_target_for_light_work", technology.verify(repo, { stateRoot }).status === "success");
-  check("fresh_receipt_allows_significant_work", technology.continuity.verify(repo, JSON.parse(fs.readFileSync(path.join(repo, "graph.json"), "utf8")), { stateRoot }).status === "success");
-
-  const staleDigest = technology.continuity.graphDigest(repo);
-  fs.appendFileSync(path.join(repo, "graph/specs/objects.json"), " ");
-  check("stale_continuity_blocks_significant_work", technology.continuity.verify(repo, JSON.parse(fs.readFileSync(path.join(repo, "graph.json"), "utf8")), { stateRoot }).blockers.includes("continuity_stale"));
-  const baseObjects = JSON.parse(fs.readFileSync(path.join(repo, "graph/specs/objects.json"), "utf8"));
-  baseObjects[0].summary = "Changed concurrently";
-  fs.writeFileSync(path.join(repo, "graph/specs/objects.json"), JSON.stringify(baseObjects, null, 2) + "\n");
-  const cas = technology.execute("sync", repo, { apply: true, boundary: "task_complete", continuityEvidence: evidence("cas"), expectedGraphDigest: staleDigest, stateRoot });
-  check("compare_and_swap_conflict_is_safe", cas.status === "blocked" && cas.blockers.includes("continuity_compare_and_swap_conflict"), cas);
-  baseObjects[0].summary = "Complete a safe fixture task";
-  fs.writeFileSync(path.join(repo, "graph/specs/objects.json"), JSON.stringify(baseObjects, null, 2) + "\n");
-
-  const secret = technology.execute("sync", repo, { apply: true, boundary: "task_complete", continuityEvidence: evidence("secret", { outcome: "token=not-a-real-secret-value-123456" }), stateRoot });
-  check("secret_is_rejected", secret.status === "blocked" && secret.blockers.includes("continuity_sensitive_or_host_data_forbidden"), secret);
-  const privatePath = technology.execute("sync", repo, { apply: true, boundary: "task_complete", continuityEvidence: { ...evidence("private"), changed_surfaces: ["source/memory/private.md"] }, stateRoot });
-  check("private_projection_is_rejected", privatePath.status === "blocked" && privatePath.blockers.includes("continuity_sensitive_or_host_data_forbidden"), privatePath);
-  const failedCheck = technology.execute("sync", repo, { apply: true, boundary: "task_complete", continuityEvidence: { ...evidence("fail"), checks: [{ id: "check.fixture", verdict: "fail", evidence_ref: "repo://fixture/fail" }] }, stateRoot });
-  check("unverified_result_is_rejected", failedCheck.status === "blocked" && failedCheck.blockers.includes("continuity_result_not_verified"), failedCheck);
-
-  git(repo, "add", "graph.json", "graph/specs", "graph/docs"); git(repo, "commit", "-qm", "portable continuity records");
-  const discovered = technology.context(repo, { phase: "discover", task: "use the verified portable work case" });
-  check("new_task_discovers_past_case", discovered.status === "success" && discovered.traversal_receipt.candidates.some((item) => item.id.startsWith("regression_case.continuity.")), discovered.blockers);
-  const beforeReadOnly = git(repo, "status", "--porcelain=v1");
-  technology.status(repo); technology.context(repo, { phase: "discover", task: "read only project context" });
-  check("read_only_operations_write_nothing", git(repo, "status", "--porcelain=v1") === beforeReadOnly);
-
-  const folder = createRepo(root, "shared-folder", false);
-  const folderFirst = technology.execute("sync", folder, { apply: true, boundary: "task_complete", continuityEvidence: evidence("folder"), stateRoot });
-  check("non_git_folder_supports_continuity", folderFirst.status === "success" && folderFirst.changed, folderFirst);
-  const folderRepeat = technology.execute("sync", folder, { apply: true, boundary: "task_complete", continuityEvidence: evidence("folder"), stateRoot });
-  check("non_git_repeat_is_idempotent", folderRepeat.status === "success" && folderRepeat.changed === false, folderRepeat);
-  const sharedLease = path.join(folder, "graph/.project-technology-continuity.lock");
-  fs.writeFileSync(sharedLease, "occupied\n");
-  const leaseConflict = technology.execute("sync", folder, { apply: true, boundary: "task_complete", continuityEvidence: evidence("parallel"), stateRoot: path.join(root, "third-installation-state") });
-  check("shared_folder_lease_blocks_parallel_writer", leaseConflict.status === "blocked" && leaseConflict.blockers.includes("continuity_lease_conflict"), leaseConflict);
-  fs.unlinkSync(sharedLease);
-  const folderDiscovery = technology.context(folder, { phase: "discover", task: "portable fixture case" });
-  check("non_git_context_is_available", folderDiscovery.status === "success", folderDiscovery.blockers);
-  check("same_content_has_stable_digest", technology.continuity.graphDigest(folder) === technology.continuity.graphDigest(folder));
-
-  const otherStateRoot = path.join(root, "other-installation-state");
-  const firstInstallContext = technology.context(repo, { phase: "discover", task: "use verified portable work" });
-  const secondInstallContext = technology.context(repo, { phase: "discover", task: "use verified portable work", stateRoot: otherStateRoot });
-  check("two_installations_get_same_context", firstInstallContext.traversal_receipt.traversal_digest === secondInstallContext.traversal_receipt.traversal_digest);
-  check("portable_specs_contain_no_host_paths", !/(?:\/Users\/|\/home\/|[A-Za-z]:\\Users\\)/.test(fs.readFileSync(path.join(repo, "graph/specs/project-continuity.json"), "utf8")));
-  check("continuity_policy_keeps_contract_version", JSON.parse(fs.readFileSync(path.join(repo, "graph.json"), "utf8")).extensions["mirai.project_technology"].contract_version === "1.0.0");
-
-  const bootstrapRepo = path.join(root, "existing-code-new-graph");
-  fs.mkdirSync(bootstrapRepo, { recursive: true });
-  fs.writeFileSync(path.join(bootstrapRepo, "README.md"), "# Existing code\n");
-  git(bootstrapRepo, "init", "-q"); git(bootstrapRepo, "config", "user.name", "Mirai Fixture"); git(bootstrapRepo, "config", "user.email", "fixture@example.invalid");
-  git(bootstrapRepo, "add", "README.md"); git(bootstrapRepo, "commit", "-qm", "existing code");
-  writeJson(path.join(bootstrapRepo, "graph.json"), manifest("bootstrap-project"));
-  writeJson(path.join(bootstrapRepo, "graph/specs/objects.json"), [{ id: "goal.bootstrap", kind: "goal", title: "Bootstrap", summary: "Use content-bound bootstrap context", readiness: "accepted", profile: "project_management" }]);
-  writeJson(path.join(bootstrapRepo, "graph/specs/relations.json"), []);
-  const bootstrapContext = technology.context(bootstrapRepo, { phase: "discover", task: "bootstrap context" });
-  check("new_git_graph_is_content_bound_before_first_commit", bootstrapContext.status === "success" && String(bootstrapContext.traversal_receipt.graph.revision).startsWith("content:"), bootstrapContext.blockers);
-
-  process.stdout.write(`${JSON.stringify({ status: "success", checks_passed: checks.length, checks_failed: 0, checks }, null, 2)}\n`);
-} catch (error) {
-  process.stdout.write(`${JSON.stringify({ status: "fail", checks_passed: checks.filter((item) => item.passed).length, checks_failed: 1, checks, error: error.message }, null, 2)}\n`);
-  process.exitCode = 1;
-}

package/packages/cli/validate-project-technology.js

@@ -1,296 +0,0 @@
-#!/usr/bin/env node
-
-"use strict";
-
-const assert = require("assert");
-const fs = require("fs");
-const os = require("os");
-const path = require("path");
-const { spawnSync } = require("child_process");
-const technology = require("../project-technology");
-
-const TARGET_ID = "fixture.target.accepted_v1";
-const SEMANTIC_DIGEST = `sha256:${"2".repeat(64)}`;
-
-function git(repo, ...args) {
-  const result = spawnSync("git", args, { cwd: repo, encoding: "utf8" });
-  if (result.status !== 0) throw new Error(result.stderr || `git ${args.join(" ")} failed`);
-  return result.stdout.trim();
-}
-
-function writeJson(file, value) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
-}
-
-function manifest(id, scope = "repository", profiles = ["project_management", "implementation_control"]) {
-  return {
-    $schema: "https://mirai-graph.dev/schemas/graph-manifest.schema.json",
-    format: "mirai-graph", schema_version: "2.0.0", id, aliases: [],
-    title: id, scope, kind: `${scope}_graph`, owner: "fixture-owner", profiles,
-    graph: {
-      root: "graph", source_of_truth: ["graph/specs"], objects: ["graph/specs/index.json"],
-      relations: ["graph/specs/relations.json"], schemas: [],
-      generated: ["graph/generated"], raw_sources: ["README.md"],
-    },
-    imports: [],
-  };
-}
-
-function executionContract() {
-  return {
-    decision_refs: ["decision.fixture.accepted"],
-    goal_binding: { goal_id: "goal.fixture.delivery", done_when_ids: ["done_when.fixture.ready"] },
-    requirement_bindings: [{
-      requirement_id: "requirement.fixture.runtime",
-      acceptance_ids: ["acceptance.fixture.runtime"],
-      done_when_ids: ["done_when.fixture.ready"],
-    }],
-    constraint_ids: ["constraint.fixture.single_owner"],
-    non_goal_ids: ["non_goal.fixture.parallel_runtime"],
-    deferred_boundary_ids: ["deferred.fixture.publication"],
-    allowed_change_scope: [{
-      repository_id: "fixture-consumer", owner_id: "runtime", package_id: "fixture/runtime",
-      file_patterns: ["packages/runtime/**"], actions: ["modify", "test"],
-    }, {
-      repository_id: "fixture-consumer-two", owner_id: "runtime", package_id: "fixture/runtime",
-      file_patterns: ["packages/runtime/**"], actions: ["modify", "test"],
-    }],
-    architecture_contract: {
-      contract_ref: "contract.fixture.architecture",
-      acceptance_ref: "decision.fixture.accepted", architecture_owner_id: "human.fixture.owner", lifecycle: "accepted",
-      owner_ids: ["runtime"], component_ids: ["component.fixture.runtime"],
-      package_ids: ["fixture/runtime"], capability_ids: ["capability.fixture.runtime"],
-      ownership_boundaries: [{
-        subject_ref: "capability.fixture.runtime", data_owner: "runtime", access_owner: "runtime",
-        lifecycle_owner: "runtime", interface_owner: "runtime", runtime_owner: "runtime",
-      }],
-      required_relations: ["component.fixture.runtime->capability.fixture.runtime"],
-      allowed_relations: [], forbidden_relations: ["capability.fixture.runtime->capability.fixture.legacy"],
-      required_dependencies: [], forbidden_dependencies: ["fixture/runtime->fixture/legacy"],
-    },
-  };
-}
-
-function continuityEvidence(repositoryId) {
-  return {
-    task_digest: technology.sha256(`task:${repositoryId}`, true),
-    outcome: `Exact target binding verified for ${repositoryId}`,
-    requirement_refs: ["requirement.fixture.runtime"],
-    evidence_refs: ["repo://fixture/evidence/project-technology"],
-    checks: [{ id: "check.fixture.binding", verdict: "pass", evidence_ref: "repo://fixture/evidence/project-technology" }],
-    changed_surfaces: ["graph/specs/project-continuity.json"],
-    case_signature: "case.fixture.target-binding",
-  };
-}
-
-function initRepo(root, name, scope = "repository", profiles) {
-  const repo = path.join(root, name); fs.mkdirSync(repo, { recursive: true });
-  git(repo, "init", "-q"); git(repo, "config", "user.name", "Mirai Fixture");
-  git(repo, "config", "user.email", "fixture@example.invalid");
-  writeJson(path.join(repo, "graph.json"), manifest(name, scope, profiles));
-  writeJson(path.join(repo, "graph/specs/index.json"), { object_files: [] });
-  writeJson(path.join(repo, "graph/specs/relations.json"), []);
-  fs.writeFileSync(path.join(repo, "README.md"), `# ${name}\n`);
-  git(repo, "add", "."); git(repo, "commit", "-qm", "fixture manifest");
-  return repo;
-}
-
-function addTarget(repo, contract = executionContract(), lifecycle = "accepted") {
-  const relative = `graph/specs/objects/${TARGET_ID}.json`;
-  writeJson(path.join(repo, relative), {
-    id: TARGET_ID, kind: "knowledge", subtype: "target_outcome", tz_role: "system",
-    title: "Accepted fixture target", lifecycle, semantic_digest: SEMANTIC_DIGEST,
-    source_refs: ["repo://fixture-provider/graph/specs?rev=fixture"],
-    provider_execution_contract: contract,
-  });
-  writeJson(path.join(repo, "graph/specs/index.json"), { object_files: [`objects/${TARGET_ID}.json`] });
-  git(repo, "add", "graph/specs"); git(repo, "commit", "-qm", "accepted target");
-  return git(repo, "rev-parse", "HEAD");
-}
-
-const checks = [];
-function check(id, condition, details = null) {
-  checks.push({ id, passed: Boolean(condition), details });
-  assert.ok(condition, `${id}: ${JSON.stringify(details)}`);
-}
-
-const root = fs.mkdtempSync(path.join(os.tmpdir(), "mirai-project-technology-test-"));
-process.env.MIRAI_GRAPH_STATE_ROOT = path.join(root, "host-state");
-try {
-  const provider = initRepo(root, "fixture-provider", "repository");
-  const consumer = initRepo(root, "fixture-consumer", "repository");
-  const consumerTwo = initRepo(root, "fixture-consumer-two", "repository");
-  const skill = initRepo(root, "fixture-skill", "skill", ["skill_runtime"]);
-  const federation = initRepo(root, "fixture-federation", "federation", ["project_management", "implementation_control"]);
-  const providerRevision = addTarget(provider);
-
-  const legacyRuntimeRepo = initRepo(root, "legacy-runtime-repository");
-  writeJson(path.join(legacyRuntimeRepo, ".mirai-graph/project-technology/inventory.json"), { schema_version: "1.0.0", repository_id: "legacy-runtime-repository", inventory_digest: `sha256:${"0".repeat(64)}`, files: [] });
-  const legacyRuntimeEnabled = technology.execute("enable", legacyRuntimeRepo, { apply: true });
-  check("project_local_runtime_moves_to_host_state", legacyRuntimeEnabled.status === "success" && legacyRuntimeEnabled.migration_ref.startsWith("host-local://") && fs.existsSync(path.join(legacyRuntimeRepo, ".mirai-graph/project-technology/inventory.json")), legacyRuntimeEnabled);
-
-  const before = fs.readFileSync(path.join(consumer, "graph.json"));
-  const preview = technology.execute("enable", consumer, { apply: false });
-  check("preview_is_zero_write", preview.status === "preview" && fs.readFileSync(path.join(consumer, "graph.json")).equals(before));
-  check("read_only_diagnostics_available", technology.status(consumer).operation_mode === "read_only");
-
-  for (const repo of [provider, consumer, consumerTwo, skill, federation]) {
-    const enabled = technology.execute("enable", repo, { apply: true });
-    check(`enable_${path.basename(repo)}`, enabled.status === "success", enabled.blockers);
-    check(`sync_idempotent_${path.basename(repo)}`, technology.execute("sync", repo, { apply: true }).changed === false);
-  }
-  check("skill_runtime_uses_same_engine", technology.context(skill, { task: "skill runtime policy" }).operation_id === "mirai.project_technology.context");
-  check("federation_scope_uses_same_engine", technology.status(federation).repository_id === "fixture-federation");
-
-  const provided = technology.execute("provide", provider, {
-    apply: true, targetId: TARGET_ID, semanticDigest: SEMANTIC_DIGEST, providerRevision,
-  });
-  check("bounded_provider_export", provided.status === "success", provided.blockers);
-  const exportPath = path.join(provider, provided.export_ref);
-  const exportText = fs.readFileSync(exportPath, "utf8");
-  check("export_has_no_private_source", !exportText.includes("source/private") && !exportText.includes("README content"));
-
-  const unboundProvider = initRepo(root, "unbound-provider");
-  const unboundRevision = addTarget(unboundProvider);
-  technology.execute("enable", unboundProvider, { apply: true });
-  const unboundTarget = path.join(unboundProvider, `graph/specs/objects/${TARGET_ID}.json`);
-  fs.appendFileSync(unboundTarget, " ");
-  const unboundResult = technology.execute("provide", unboundProvider, {
-    apply: true, targetId: TARGET_ID, semanticDigest: SEMANTIC_DIGEST, providerRevision: unboundRevision,
-  });
-  check("uncommitted_target_cannot_be_exported", unboundResult.status === "fail" && unboundResult.blockers.includes("provider_target_object_not_revision_bound"), unboundResult.blockers);
-
-  const connected = technology.execute("connect", consumer, {
-    apply: true, source: exportPath, targetId: TARGET_ID,
-    semanticDigest: SEMANTIC_DIGEST, providerRevision,
-  });
-  const consumerContinuity = technology.execute("sync", consumer, {
-    apply: true, boundary: "task_complete", continuityEvidence: continuityEvidence("fixture-consumer"),
-  });
-  check("consumer_binding_ready", connected.status === "success" && consumerContinuity.status === "success" && technology.verify(consumer, { significantWork: true }).status === "success", { connect: connected.blockers, continuity: consumerContinuity.blockers });
-  const connectedTwo = technology.execute("connect", consumerTwo, {
-    apply: true, source: exportPath, targetId: TARGET_ID,
-    semanticDigest: SEMANTIC_DIGEST, providerRevision,
-  });
-  const consumerTwoContinuity = technology.execute("sync", consumerTwo, {
-    apply: true, boundary: "task_complete", continuityEvidence: continuityEvidence("fixture-consumer-two"),
-  });
-  check("second_consumer_binding_ready", connectedTwo.status === "success" && consumerTwoContinuity.status === "success" && technology.verify(consumerTwo, { significantWork: true }).status === "success", { connect: connectedTwo.blockers, continuity: consumerTwoContinuity.blockers });
-  const repeated = technology.execute("connect", consumer, {
-    apply: true, source: exportPath, targetId: TARGET_ID,
-    semanticDigest: SEMANTIC_DIGEST, providerRevision,
-  });
-  check("repeated_connect_byte_identical", repeated.status === "success" && repeated.changed === false, repeated.blockers);
-
-  fs.appendFileSync(path.join(provider, "README.md"), "forward revision\n");
-  git(provider, "add", "README.md"); git(provider, "commit", "-qm", "forward provider revision");
-  const nextRevision = git(provider, "rev-parse", "HEAD");
-  const nextProvided = technology.execute("provide", provider, {
-    apply: true, targetId: TARGET_ID, semanticDigest: SEMANTIC_DIGEST, providerRevision: nextRevision,
-  });
-  const refresh = technology.execute("connect", consumer, {
-    apply: true, refreshBinding: true, source: path.join(provider, nextProvided.export_ref),
-    targetId: TARGET_ID, semanticDigest: SEMANTIC_DIGEST, providerRevision: nextRevision,
-  });
-  check("forward_refresh_preserves_contract", refresh.status === "success" && refresh.changed, refresh.blockers);
-  const refreshAgain = technology.execute("connect", consumer, {
-    apply: true, refreshBinding: true, source: path.join(provider, nextProvided.export_ref),
-    targetId: TARGET_ID, semanticDigest: SEMANTIC_DIGEST, providerRevision: nextRevision,
-  });
-  check("refresh_is_idempotent", refreshAgain.status === "success" && refreshAgain.changed === false, refreshAgain.blockers);
-
-  const conflictingProvider = path.join(root, "conflicting-provider");
-  git(root, "clone", "-q", provider, conflictingProvider);
-  const conflictingPayload = JSON.parse(fs.readFileSync(path.join(provider, nextProvided.export_ref), "utf8"));
-  conflictingPayload.non_goal_ids = ["non_goal.fixture.other_runtime"];
-  const normalizedConflict = technology.normalizeExecutionContract(conflictingPayload).contract;
-  conflictingPayload.execution_contract_digest = technology.sha256(technology.canonicalBytes(normalizedConflict));
-  const conflictingExport = path.join(conflictingProvider, "graph/generated/project-technology/conflicting-target-export.json");
-  writeJson(conflictingExport, conflictingPayload);
-  const providerConflict = technology.execute("connect", consumer, {
-    apply: true, source: conflictingExport, targetId: TARGET_ID,
-    semanticDigest: SEMANTIC_DIGEST, providerRevision: nextRevision,
-  });
-  check("two_provider_conflict_fails_closed", providerConflict.status === "fail" && providerConflict.blockers.includes("target_provider_conflict"), providerConflict.blockers);
-
-  const downgrade = technology.execute("connect", consumer, {
-    apply: true, refreshBinding: true, source: exportPath,
-    targetId: TARGET_ID, semanticDigest: SEMANTIC_DIGEST, providerRevision,
-  });
-  check("provider_downgrade_fails_closed", downgrade.status === "fail" && downgrade.blockers.includes("provider_revision_not_forward"), downgrade.blockers);
-
-  fs.appendFileSync(path.join(provider, "README.md"), "provider moved without export\n");
-  git(provider, "add", "README.md"); git(provider, "commit", "-qm", "provider moved past export");
-  const staleProvider = technology.execute("connect", consumer, {
-    apply: true, refreshBinding: true, source: path.join(provider, nextProvided.export_ref),
-    targetId: TARGET_ID, semanticDigest: SEMANTIC_DIGEST, providerRevision: nextRevision,
-  });
-  check("stale_provider_export_fails_closed", staleProvider.status === "fail" && staleProvider.blockers.includes("provider_revision_does_not_match_head"), staleProvider.blockers);
-
-  const wrongTarget = technology.execute("connect", initRepo(root, "wrong-target"), {
-    apply: true, source: exportPath, targetId: "fixture.target.other",
-    semanticDigest: SEMANTIC_DIGEST, providerRevision,
-  });
-  check("target_mismatch_fails_closed", wrongTarget.status === "fail" && wrongTarget.blockers.includes("target_id_mismatch"), wrongTarget.blockers);
-  const wrongDigest = technology.execute("connect", initRepo(root, "wrong-digest"), {
-    apply: true, source: exportPath, targetId: TARGET_ID,
-    semanticDigest: `sha256:${"3".repeat(64)}`, providerRevision,
-  });
-  check("digest_mismatch_fails_closed", wrongDigest.status === "fail" && wrongDigest.blockers.includes("semantic_digest_mismatch"), wrongDigest.blockers);
-
-  const tampered = path.join(root, "tampered.json");
-  const tamperedPayload = JSON.parse(exportText); tamperedPayload.non_goal_ids = ["non_goal.fixture.tampered"];
-  writeJson(tampered, tamperedPayload);
-  check("tampered_contract_fails_closed", technology.readExport(tampered).blockers.includes("provider_execution_contract_digest_mismatch"));
-
-  const incomplete = executionContract(); incomplete.requirement_bindings = [];
-  check("incomplete_contract_fails_closed", technology.normalizeExecutionContract(incomplete).blockers.includes("provider_contract_requirement_bindings_empty"));
-  const cycle = executionContract(); cycle.architecture_contract.required_dependencies = ["aa->bb", "bb->aa"];
-  check("dependency_cycle_fails_closed", technology.normalizeExecutionContract(cycle).blockers.includes("provider_architecture_dependency_cycle"));
-  check("blocked_significant_work_keeps_status", technology.verify(skill, { significantWork: true }).status === "blocked" && technology.status(skill).operation_mode === "read_only");
-
-  const disabled = technology.execute("disable", skill, { apply: true });
-  check("disabled_state_fails_closed", disabled.status === "success" && technology.verify(skill, { significantWork: true }).status === "blocked");
-
-  const largeProvider = initRepo(root, "large-provider");
-  addTarget(largeProvider);
-  const emptyBlob = spawnSync("git", ["hash-object", "-w", "--stdin"], {
-    cwd: largeProvider, input: "", encoding: "utf8",
-  }).stdout.trim();
-  const padding = "x".repeat(190);
-  const indexInfo = Array.from({ length: 5200 }, (_, index) =>
-    `100644 ${emptyBlob}\tarchive/${String(index).padStart(5, "0")}-${padding}.txt\n`
-  ).join("");
-  const indexed = spawnSync("git", ["update-index", "--index-info"], {
-    cwd: largeProvider, input: indexInfo, encoding: "utf8", maxBuffer: 64 * 1024 * 1024,
-  });
-  check("large_repository_fixture_created", indexed.status === 0, indexed.stderr);
-  git(largeProvider, "commit", "-qm", "large tracked index");
-  const largeRevision = git(largeProvider, "rev-parse", "HEAD");
-  check("large_repository_enable", technology.execute("enable", largeProvider, { apply: true }).status === "success");
-  const largeProvided = technology.execute("provide", largeProvider, {
-    apply: true, targetId: TARGET_ID, semanticDigest: SEMANTIC_DIGEST, providerRevision: largeRevision,
-  });
-  check("large_repository_target_is_not_lost_to_process_buffer", largeProvided.status === "success", largeProvided.blockers);
-
-  const cli = spawnSync(process.execPath, [path.join(__dirname, "mirai-graph.js"), "technology", "explain", federation], { encoding: "utf8" });
-  const cliResult = JSON.parse(cli.stdout);
-  check("unified_cli_contract", cli.status === 0 && cliResult.operation_id === "mirai.project_technology.explain" && cliResult.operation_mode === "read_only");
-
-  const cliFromCwd = spawnSync(process.execPath, [path.join(__dirname, "mirai-graph.js"), "technology", "status"], {
-    cwd: federation, encoding: "utf8",
-  });
-  const cliFromCwdResult = JSON.parse(cliFromCwd.stdout);
-  check("unified_cli_defaults_to_caller_cwd", cliFromCwd.status === 0 && cliFromCwdResult.repository_id === "fixture-federation", cliFromCwdResult);
-
-  const cliDot = spawnSync(process.execPath, [path.join(__dirname, "mirai-graph.js"), "technology", "status", "."], {
-    cwd: federation, encoding: "utf8",
-  });
-  const cliDotResult = JSON.parse(cliDot.stdout);
-  check("unified_cli_resolves_relative_repo_from_caller_cwd", cliDot.status === 0 && cliDotResult.repository_id === "fixture-federation", cliDotResult);
-
-  process.stdout.write(`${JSON.stringify({ status: "success", checks_passed: checks.length, checks_failed: 0, checks }, null, 2)}\n`);
-} finally {
-  fs.rmSync(root, { recursive: true, force: true });
-}