mirai-graph 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to Mirai Graph will be documented in this file.
 
 ## [Unreleased]
 
+## [1.5.0] - 2026-09-03
+
+Compatible 1.x maintenance line, published under `legacy-1`; the npm `latest`
+channel and the separate 2.x development line are unchanged.
+
+- Project Technology can connect and refresh a bounded provider export without
+  Git using explicit authenticated-release trust supplied by the consumer.
+  Exact export bytes, graph identity, revision and forward ancestry are checked;
+  target/architecture/permission gates are unchanged. No automatic trust discovery.
+- Read-only source export verification proves the archive anchor against the
+  accepted target and Git revision before a distributor seals it in release
+  metadata. CLI trust can be supplied on stdin; no temporary trust file is needed.
+- No-Git inventory covers explicitly declared graph and raw-source paths, detects
+  stale content and blocks unsafe or missing sources before sync writes. Existing
+  Git inventories remain revision-bound; this does not invent source history.
+
 ## [1.4.0] - 2026-08-29
 
 ### Added

package/CITATION.cff

@@ -17,5 +17,5 @@ keywords:
   - complex systems
   - context engineering
   - systems engineering
-version: "1.2.0"
-date-released: "2026-08-27"
+version: "1.5.0"
+date-released: "2026-09-03"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mirai-graph",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "private": false,
   "description": "An evolutionary graph operating model for managing the growth of complex systems.",
   "license": "MIT",
@@ -14,7 +14,7 @@
   },
   "scripts": {
     "pretest": "npm run test:project-technology && npm run test:context-traversal && npm run test:project-continuity && npm run test:artifact-releases && npm run test:technology-courses && npm run validate:project-technology-schemas",
-    "test:project-technology": "node packages/cli/validate-project-technology.js",
+    "test:project-technology": "node packages/cli/validate-project-technology.js && node packages/cli/validate-provider-archive.js",
     "test:context-traversal": "node packages/cli/validate-context-traversal.js",
     "test:project-continuity": "node packages/cli/validate-project-continuity.js",
     "test:artifact-releases": "node packages/cli/validate-artifact-releases.js",

package/packages/cli/project-technology.js

@@ -13,6 +13,7 @@ function usage() {
   console.error("Options: --apply --task <text> --source <file> --target-id <id>");
   console.error("         --semantic-digest <sha256:...> --provider-revision <sha>");
   console.error("         --refresh-binding --significant-work --max-objects <count>");
+  console.error("Archive connect: --provider-archive-trust <verified-release-anchor.json>");
   console.error("Continuity: sync --boundary task_start|stage_complete|task_complete [--evidence <json>] [--expected-graph-digest <sha256:...>]");
   console.error("            verify --significant-work [--receipt-digest <sha256:...>]");
   console.error("Context: --phase discover --task <text>");
@@ -46,7 +47,9 @@ function parse(argv) {
   const options = {};
   const values = new Set(["--task", "--source", "--target-id", "--semantic-digest", "--provider-revision", "--max-objects", "--phase", "--input", "--select", "--selection", "--packet", "--evidence", "--selector", "--reason", "--confidence", "--context-budget", "--boundary", "--expected-graph-digest", "--receipt-digest", "--state-root", "--matter-id", "--direction", "--artifact-root", "--release-date", "--release-id", "--parent-release", "--base-release", "--target-release", "--client-note", "--technology", "--scenario", "--audience", "--course-pack", "--projection"]);
   const flags = new Set(["--apply", "--refresh-binding", "--significant-work", "--create-export"]);
+  values.add("--provider-archive-trust");
   const names = {
+    "--provider-archive-trust": "providerArchiveTrustFile",
     "--task": "task", "--source": "source", "--target-id": "targetId",
     "--semantic-digest": "semanticDigest", "--provider-revision": "providerRevision",
     "--max-objects": "maxObjects", "--apply": "apply",
@@ -89,6 +92,11 @@ function readJsonFile(file) {
 }
 
 function hydrateContextOptions(request) {
+  if (request.options.providerArchiveTrustFile) {
+    if (request.operation !== "connect") throw new Error("archive trust is only supported by connect");
+    request.options.providerArchive = request.options.providerArchiveTrustFile === "-"
+      ? JSON.parse(fs.readFileSync(0, "utf8")) : readJsonFile(request.options.providerArchiveTrustFile);
+  }
   if (request.operation === "sync" && request.options.boundary) {
     if (request.options.boundary !== "task_start" && !request.options.evidenceFile) throw new Error(`${request.options.boundary} requires --evidence`);
     if (request.options.evidenceFile) request.options.continuityEvidence = readJsonFile(request.options.evidenceFile);

package/packages/cli/validate-provider-archive.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+"use strict";
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const vm = require("vm");
+const { createRequire } = require("module");
+const { spawnSync } = require("child_process");
+const technology = require("../project-technology");
+const fixtureFile = path.join(__dirname, "validate-project-technology.js");
+const fixtureText = fs.readFileSync(fixtureFile, "utf8");
+const sandbox = { require: createRequire(fixtureFile), module: { exports: {} } };
+vm.runInNewContext(fixtureText.slice(0, fixtureText.indexOf("const checks = [];")) +
+  "\nmodule.exports={initRepo,addTarget,git,TARGET_ID,SEMANTIC_DIGEST};", sandbox);
+const fixture = sandbox.module.exports;
+const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "mirai-archive-test-")));
+const originalPath = process.env.PATH;
+const checks = [];
+function check(id, condition, details) { checks.push({ id, passed: Boolean(condition) }); assert.ok(condition, `${id}: ${JSON.stringify(details)}`); }
+function digestTree(dir) {
+  const files = [];
+  function walk(current) {
+    if (!fs.existsSync(current)) return;
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const file = path.join(current, entry.name);
+      if (entry.isDirectory()) walk(file);
+      else files.push([path.relative(dir, file), technology.sha256(fs.readFileSync(file))]);
+    }
+  }
+  walk(dir); return technology.sha256(JSON.stringify(files.sort()));
+}
+try {
+  const sourceRoot = path.join(root, "source"); fs.mkdirSync(sourceRoot);
+  const provider = fixture.initRepo(sourceRoot, "fixture-provider");
+  const consumer = fixture.initRepo(sourceRoot, "fixture-consumer");
+  let revision = fixture.addTarget(provider);
+  const stateRoot = path.join(root, "state");
+  const base = { targetId: fixture.TARGET_ID, semanticDigest: fixture.SEMANTIC_DIGEST, stateRoot, apply: true };
+  for (const repo of [provider, consumer]) assert.equal(technology.execute("enable", repo, base).status, "success");
+  fixture.git(provider, "add", "graph.json"); fixture.git(provider, "commit", "-qm", "accepted activation");
+  revision = fixture.git(provider, "rev-parse", "HEAD");
+  const releases = [];
+  for (let n = 0; n < 2; n++) {
+    if (n) { fixture.git(provider, "commit", "--allow-empty", "-qm", "compatible revision"); revision = fixture.git(provider, "rev-parse", "HEAD"); }
+    const provided = technology.execute("provide", provider, { ...base, providerRevision: revision });
+    assert.equal(provided.status, "success");
+    const beforeSourceProof = digestTree(root);
+    const sourceProof = technology.execute("verify", provider, { source: path.join(provider, provided.export_ref) });
+    check(`source_export_proven_${n}`, sourceProof.status === "success" && sourceProof.provider_archive.providerRevision === revision, sourceProof);
+    check(`source_proof_zero_write_${n}`, digestTree(root) === beforeSourceProof);
+    check(`source_proof_not_authority_${n}`, technology.execute("verify", provider, { source: path.join(provider, provided.export_ref), significantWork: true }).status === "blocked");
+    const providerManifestPath = path.join(provider, "graph.json");
+    const providerManifestBytes = fs.readFileSync(providerManifestPath);
+    fs.appendFileSync(providerManifestPath, " ");
+    check(`uncommitted_manifest_blocks_source_proof_${n}`, technology.execute("verify", provider, { source: path.join(provider, provided.export_ref) }).blockers.includes("provider_manifest_not_revision_bound"));
+    fs.writeFileSync(providerManifestPath, providerManifestBytes);
+    const bytes = fs.readFileSync(path.join(provider, provided.export_ref));
+    const source = path.join(root, `export-${n}.json`); fs.writeFileSync(source, bytes);
+    check(`external_export_blocks_source_proof_${n}`, technology.execute("verify", provider, { source }).blockers.includes("provider_export_outside_repository"));
+    // Build anchor on the verified SOURCE side, before Git is removed.
+    const ancestors = n ? [releases[0].providerRevision] : [];
+    for (const ancestor of ancestors) fixture.git(provider, "merge-base", "--is-ancestor", ancestor, revision);
+    releases.push({ ...base, source, providerRevision: revision, providerArchive: {
+      exportSha256: technology.sha256(bytes), graphId: "fixture-provider", providerRevision: revision, ancestorRevisions: ancestors,
+    } });
+  }
+  const packedConsumer = path.join(root, "consumer");
+  fs.cpSync(consumer, packedConsumer, { recursive: true, filter: file => path.basename(file) !== ".git" });
+  const emptyPath = path.join(root, "no-tools"); fs.mkdirSync(emptyPath); process.env.PATH = emptyPath;
+  check("git_is_absent", spawnSync("git", ["--version"]).error?.code === "ENOENT");
+  const invoke = options => technology.execute("connect", packedConsumer, options);
+  const noTrust = { ...releases[0] }; delete noTrust.providerArchive;
+  check("untrusted_archive_blocked", invoke(noTrust).blockers.includes("provider_revision_order_unverifiable"));
+  const before = digestTree(root);
+  check("preview", invoke({ ...releases[0], apply: false }).status === "preview");
+  check("preview_zero_write", digestTree(root) === before);
+  const connected = invoke(releases[0]);
+  check("archive_connect", connected.status === "success", connected);
+  check("complete_contract_imported", connected.target_binding.status === "ready", connected);
+  const after = digestTree(root);
+  check("repeat_changed_false", invoke(releases[0]).changed === false);
+  check("repeat_byte_identical", digestTree(root) === after);
+  const status = technology.execute("status", packedConsumer, base);
+  check("read_only_ready", status.target_binding.status === "ready", status);
+  technology.execute("verify", packedConsumer, base);
+  check("diagnostics_zero_write", digestTree(root) === after);
+  function denied(id, options, blocker) {
+    const prior = digestTree(root); const result = invoke(options);
+    check(id, result.status === "fail" && (!blocker || result.blockers.includes(blocker)), result);
+    check(`${id}_zero_write`, prior === digestTree(root));
+  }
+  denied("null_trust", { ...releases[0], providerArchive: null }, "provider_archive_trust_invalid");
+  denied("bad_digest", { ...releases[0], providerArchive: { ...releases[0].providerArchive, exportSha256: "0".repeat(64) } }, "provider_archive_export_digest_mismatch");
+  denied("bad_graph", { ...releases[0], providerArchive: { ...releases[0].providerArchive, graphId: "other.provider" } }, "provider_archive_graph_mismatch");
+  denied("bad_revision", { ...releases[0], providerArchive: { ...releases[0].providerArchive, providerRevision: "f".repeat(40) } }, "provider_archive_revision_mismatch");
+  denied("extra_trust_fields", { ...releases[0], providerArchive: { ...releases[0].providerArchive, approved: true } }, "provider_archive_trust_invalid");
+  denied("explicit_refresh_required", releases[1], "target_provider_refresh_required");
+  denied("missing_ancestry", { ...releases[1], refreshBinding: true, providerArchive: { ...releases[1].providerArchive, ancestorRevisions: [] } }, "provider_revision_not_forward");
+  denied("target_mismatch", { ...releases[1], targetId: "other.target", refreshBinding: true }, "target_provider_target_mismatch");
+  denied("semantic_mismatch", { ...releases[1], semanticDigest: `sha256:${"3".repeat(64)}`, refreshBinding: true }, "target_provider_semantic_mismatch");
+  const refreshed = invoke({ ...releases[1], refreshBinding: true });
+  check("forward_refresh", refreshed.status === "success" && refreshed.changed, refreshed);
+  const refreshedTree = digestTree(root);
+  check("refresh_idempotent", invoke({ ...releases[1], refreshBinding: true }).changed === false);
+  check("refresh_byte_identical", digestTree(root) === refreshedTree);
+  denied("downgrade", { ...releases[0], refreshBinding: true }, "provider_revision_not_forward");
+  const original = fs.readFileSync(releases[1].source);
+  fs.appendFileSync(releases[1].source, " ");
+  denied("tampered_bytes", { ...releases[1], refreshBinding: true }, "provider_archive_export_digest_mismatch");
+  fs.writeFileSync(releases[1].source, original);
+  function alteredExport(id, alter, expected) {
+    const payload = JSON.parse(original); alter(payload);
+    fs.writeFileSync(releases[1].source, technology.canonicalBytes(payload));
+    const options = { ...releases[1], refreshBinding: true, providerArchive: { ...releases[1].providerArchive,
+      exportSha256: technology.sha256(fs.readFileSync(releases[1].source)), graphId: payload.provider_graph_id } };
+    denied(id, options, expected); fs.writeFileSync(releases[1].source, original);
+  }
+  alteredExport("provider_conflict", p => { p.provider_graph_id = "another.provider"; }, "target_provider_graph_conflict");
+  alteredExport("incomplete_contract", p => { p.requirement_bindings = []; });
+  alteredExport("contract_tamper", p => { p.goal_binding.done_when_ids = ["done.other"]; });
+  alteredExport("valid_but_different_contract", p => {
+    p.allowed_change_scope[0].file_patterns = ["packages/other/**"];
+    p.execution_contract_digest = technology.sha256(technology.canonicalBytes(technology.normalizeExecutionContract(p).contract));
+  }, "provider_execution_contract_refresh_mismatch");
+  alteredExport("reviewed_not_accepted", p => { p.architecture_contract.lifecycle = "reviewed"; });
+  alteredExport("private_extra_field", p => { p.private_source = "not allowed"; }, "provider_export_not_bounded");
+  const graphFile = path.join(packedConsumer, "graph.json"); const graphBefore = fs.readFileSync(graphFile);
+  const graph = JSON.parse(graphBefore); graph.extensions["mirai.project_technology"].enabled = false;
+  fs.writeFileSync(graphFile, JSON.stringify(graph));
+  denied("disabled", releases[1], "project_technology_not_enabled");
+  check("disabled_diagnostics_available", technology.execute("status", packedConsumer, base).operation_mode === "read_only");
+  fs.writeFileSync(graphFile, graphBefore);
+  const trustFile = path.join(root, "trust.json"); fs.writeFileSync(trustFile, JSON.stringify(releases[1].providerArchive));
+  const cli = spawnSync(process.execPath, [path.join(__dirname, "project-technology.js"), "connect", packedConsumer,
+    "--source", releases[1].source, "--target-id", base.targetId, "--semantic-digest", base.semanticDigest,
+    "--provider-revision", releases[1].providerRevision, "--state-root", stateRoot,
+    "--provider-archive-trust", trustFile, "--apply"], { encoding: "utf8" });
+  check("cli_no_git_idempotent", cli.status === 0 && JSON.parse(cli.stdout).changed === false, cli.stdout);
+  // A new identity field is optional for historical Git exports, but required
+  // for authenticated archive imports. Existing stored contracts remain valid.
+  const legacy = JSON.parse(original); delete legacy.provider_graph_id;
+  fs.writeFileSync(releases[1].source, technology.canonicalBytes(legacy));
+  check("historical_export_readable", technology.readExport(releases[1].source).blockers.length === 0);
+  denied("legacy_archive_needs_graph_identity", { ...releases[1], providerArchive: { ...releases[1].providerArchive,
+    exportSha256: technology.sha256(fs.readFileSync(releases[1].source)) } }, "provider_archive_graph_mismatch");
+  fs.writeFileSync(releases[1].source, original);
+  const folderInventory = technology.inventory(packedConsumer);
+  check("folder_inventory_nonempty", folderInventory.files.some(file => file.path === "graph.json") && folderInventory.files.some(file => file.path === "README.md"), folderInventory);
+  check("folder_inventory_sync", technology.execute("sync", packedConsumer, base).status === "success");
+  check("folder_inventory_sync_noop", technology.execute("sync", packedConsumer, base).changed === false);
+  const readme = path.join(packedConsumer, "README.md"); const readmeBefore = fs.readFileSync(readme);
+  fs.appendFileSync(readme, "\nChanged declared raw source\n");
+  const staleTree = digestTree(root);
+  check("folder_changed_source_is_stale", technology.execute("status", packedConsumer, base).blockers.includes("project_technology_inventory_stale"));
+  check("folder_stale_status_zero_write", digestTree(root) === staleTree);
+  fs.writeFileSync(readme, readmeBefore);
+  const graphForMissing = JSON.parse(fs.readFileSync(graphFile)); graphForMissing.graph.raw_sources.push("missing-required-source.md");
+  fs.writeFileSync(graphFile, JSON.stringify(graphForMissing));
+  const missingBefore = digestTree(root);
+  check("missing_declared_source_blocks_sync", technology.execute("sync", packedConsumer, base).blockers.includes("inventory_declared_source_missing"));
+  check("missing_source_sync_zero_write", digestTree(root) === missingBefore);
+  fs.writeFileSync(graphFile, graphBefore);
+  console.log(JSON.stringify({ status: "success", check_count: checks.length, checks }, null, 2));
+} finally { process.env.PATH = originalPath; fs.rmSync(root, { recursive: true, force: true }); }

package/packages/project-technology/index.js

@@ -36,7 +36,7 @@ const TARGET_EXPORT_KEYS = new Set([
   "schema_version", "target_id", "semantic_digest", "provider_revision",
   "decision_refs", "goal_binding", "requirement_bindings", "constraint_ids",
   "non_goal_ids", "deferred_boundary_ids", "allowed_change_scope",
-  "architecture_contract", "execution_contract_digest",
+  "architecture_contract", "execution_contract_digest", "provider_graph_id",
 ]);
 const SECRET_PARTS = [".env", "credential", "secret", "token", "password", "private-key", "id_rsa", ".pem", ".p12"];
 const EXCLUDED_PARTS = new Set([".git", ".mirai-graph", ".simai", "node_modules", "vendor", "dist", "build", "coverage", "generated"]);
@@ -425,6 +425,7 @@ function readExport(filePath) {
   try { payload = JSON.parse(bytes.toString("utf8").replace(/^\uFEFF/, "")); } catch (_) { return { export: {}, blockers: ["provider_export_invalid"] }; }
   if (!payload || typeof payload !== "object" || Array.isArray(payload)) return { export: {}, blockers: ["provider_export_invalid"] };
   if (Object.keys(payload).some((key) => !TARGET_EXPORT_KEYS.has(key))) blockers.push("provider_export_not_bounded");
+  if (Object.hasOwn(payload, "provider_graph_id") && (typeof payload.provider_graph_id !== "string" || !REF_RE.test(payload.provider_graph_id))) blockers.push("provider_graph_id_invalid");
   const identity = bindingValues(payload); blockers.push(...identity.blockers);
   const executionFields = [
     "decision_refs", "goal_binding", "requirement_bindings", "constraint_ids",
@@ -435,7 +436,7 @@ function readExport(filePath) {
   const digest = sha256(canonicalBytes(normalized.contract));
   if (!payload.execution_contract_digest) blockers.push("provider_execution_contract_digest_missing");
   else if (payload.execution_contract_digest !== digest) blockers.push("provider_execution_contract_digest_mismatch");
-  return { export: { schema_version: "1.0.0", ...identity.values, ...normalized.contract, execution_contract_digest: digest }, blockers: [...new Set(blockers)].sort(), raw_sha256: sha256(bytes) };
+  return { export: { schema_version: "1.0.0", ...identity.values, ...normalized.contract, execution_contract_digest: digest, ...(payload.provider_graph_id ? { provider_graph_id: payload.provider_graph_id } : {}) }, blockers: [...new Set(blockers)].sort(), raw_sha256: sha256(bytes) };
 }
 
 function trackedFiles(repo) {
@@ -453,7 +454,42 @@ function safeTrackedFile(relative) {
 
 function inventory(repo) {
   const entries = [];
-  for (const relative of trackedFiles(repo).filter(safeTrackedFile).sort()) {
+  const blockers = [];
+  let files = trackedFiles(repo);
+  const revision = git(repo, "rev-parse", "HEAD") || null;
+  if (!revision) {
+    if (fs.existsSync(path.join(repo, ".git"))) blockers.push("inventory_git_unavailable");
+    else {
+      // Ordinary folders and immutable distributions have no Git index. Use
+      // only explicitly declared graph/raw sources, never scan arbitrary data.
+      const graph = readManifest(repo).manifest?.graph || {};
+      const refs = ["graph.json", ...(graph.source_of_truth || []), ...(graph.objects || []),
+        ...(graph.relations || []), ...(graph.schemas || []), ...(graph.raw_sources || [])];
+      const found = new Set();
+      const visited = new Set();
+      function collect(relative) {
+        if (typeof relative !== "string" || !relative || path.isAbsolute(relative) || relative.includes("\\") || relative.includes(":") || relative.split("/").includes("..") || /[?*\[\]]/.test(relative)) {
+          blockers.push("inventory_declared_source_unsafe_or_unsupported"); return;
+        }
+        if (!safeTrackedFile(relative)) return;
+        if (visited.has(relative)) return;
+        visited.add(relative);
+        if (visited.size > 10000) { blockers.push("inventory_declared_source_budget_exceeded"); return; }
+        const absolute = path.join(repo, relative);
+        if (!fs.existsSync(absolute)) { blockers.push("inventory_declared_source_missing"); return; }
+        if (fs.lstatSync(absolute).isSymbolicLink() || !fs.realpathSync(absolute).startsWith(`${fs.realpathSync(repo)}${path.sep}`)) {
+          blockers.push("inventory_declared_source_unsafe_or_unsupported"); return;
+        }
+        if (fs.statSync(absolute).isDirectory()) {
+          for (const name of fs.readdirSync(absolute).sort()) collect(`${relative.replace(/\/$/, "")}/${name}`);
+        } else if (fs.statSync(absolute).isFile()) found.add(relative);
+        else blockers.push("inventory_declared_source_unsafe_or_unsupported");
+      }
+      refs.forEach(collect);
+      files = [...found];
+    }
+  }
+  for (const relative of files.filter(safeTrackedFile).sort()) {
     const absolute = path.join(repo, relative);
     if (!fs.existsSync(absolute) || fs.lstatSync(absolute).isSymbolicLink() || !fs.statSync(absolute).isFile()) continue;
     const bytes = fs.readFileSync(absolute);
@@ -462,10 +498,11 @@ function inventory(repo) {
   const payload = {
     schema_version: "1.0.0",
     repository_id: readManifest(repo).manifest?.id || path.basename(repo),
-    revision: git(repo, "rev-parse", "HEAD") || null,
+    revision,
     files: entries,
   };
   payload.inventory_digest = sha256(canonicalBytes(payload), true);
+  if (blockers.length) payload.blockers = [...new Set(blockers)].sort();
   return payload;
 }
 
@@ -521,6 +558,7 @@ function targetBindingStatus(repo, options = {}) {
     provider_export_sha256: binding.provider_export_sha256 || null,
     execution_contract: Object.fromEntries(["decision_refs", "goal_binding", "requirement_bindings", "constraint_ids", "non_goal_ids", "deferred_boundary_ids", "allowed_change_scope", "architecture_contract"].map((key) => [key, exported.export[key]])),
     execution_contract_digest: exported.export.execution_contract_digest || null,
+    provider_graph_id: exported.export.provider_graph_id || null,
     blockers: [...new Set(blockers)].sort(),
     next_action: blockers.length ? "refresh or repair the exact provider binding" : "none",
   };
@@ -535,7 +573,7 @@ function status(repoArg, options = {}) {
   try { if (fs.existsSync(path.join(root, INVENTORY_FILE))) stored = readJson(path.join(root, INVENTORY_FILE)); } catch (_) { /* stale */ }
   const current = inventory(repo);
   const freshness = stored && stored.inventory_digest === current.inventory_digest ? "current" : stored ? "stale" : "missing";
-  const blockers = [...manifestState.blockers, ...ext.blockers];
+  const blockers = [...manifestState.blockers, ...ext.blockers, ...(current.blockers || [])];
   if (!stored && legacyRuntimeState(repo).present) blockers.push("project_technology_host_state_migration_required");
   if (ext.contract && ext.contract.enabled === false) blockers.push("project_technology_disabled");
   if (freshness !== "current") blockers.push(`project_technology_inventory_${freshness}`);
@@ -580,6 +618,8 @@ function enable(repoArg, options = {}) {
   const repo = normalizeRepo(repoArg);
   const manifestState = readManifest(repo);
   if (!manifestState.manifest || manifestState.blockers.length) return result("enable", "transactional", "fail", { blockers: manifestState.blockers, next_action: "repair graph.json" });
+  const inventoryPreflight = inventory(repo);
+  if (inventoryPreflight.blockers?.length) return result("enable", "transactional", "blocked", { blockers: inventoryPreflight.blockers, next_action: "repair declared graph sources" });
   const manifest = structuredClone(manifestState.manifest);
   const extensions = { ...(manifest.extensions || {}) };
   const legacy = extensions[LEGACY_EXTENSION_KEY];
@@ -617,7 +657,7 @@ function sync(repoArg, options = {}) {
   const repo = normalizeRepo(repoArg);
   const manifestState = readManifest(repo);
   const ext = extensionState(manifestState.manifest);
-  const blockers = [...manifestState.blockers, ...ext.blockers];
+  const blockers = [...manifestState.blockers, ...ext.blockers, ...(inventory(repo).blockers || [])];
   const hostRoot = runtimeRoot(repo, manifestState.manifest, options);
   if (legacyRuntimeState(repo).present && !fs.existsSync(path.join(hostRoot, INVENTORY_FILE))) blockers.push("project_technology_host_state_migration_required");
   if (!ext.contract || ext.legacy || ext.contract.enabled !== true) blockers.push("project_technology_not_enabled");
@@ -661,7 +701,7 @@ function provide(repoArg, options = {}) {
   blockers.push(...target.blockers);
   if (blockers.length) return result("provide", "transactional", "fail", { blockers: [...new Set(blockers)].sort(), next_action: "repair the accepted target contract" });
   const executionContractDigest = sha256(canonicalBytes(target.contract));
-  const payload = { schema_version: "1.0.0", ...identity.values, ...target.contract, execution_contract_digest: executionContractDigest };
+  const payload = { schema_version: "1.0.0", ...identity.values, ...target.contract, execution_contract_digest: executionContractDigest, provider_graph_id: manifestState.manifest.id };
   const changed = atomicWrite(path.join(repo, EXPORT_FILE), canonicalBytes(payload));
   return result("provide", "transactional", "success", { changed, export_ref: EXPORT_FILE, target_binding: payload });
 }
@@ -671,6 +711,32 @@ function providerRootFor(exportPath) {
   return completed.status === 0 ? completed.stdout.trim() : null;
 }
 
+// This is explicit consumer trust, NOT an assertion read from the provider.
+// The caller must obtain it from authenticated, checksum-bound release metadata.
+// Keeping it out of the export prevents an archive from authenticating itself.
+function archiveProviderIdentity(source, exported, anchor) {
+  const fail = code => ({ blockers: [code], ancestors: [] });
+  if (!anchor || typeof anchor !== "object" || Array.isArray(anchor)) return fail("provider_archive_trust_invalid");
+  const keys = ["exportSha256", "graphId", "providerRevision", "ancestorRevisions"];
+  if (Object.keys(anchor).some(key => !keys.includes(key)) || keys.some(key => !Object.hasOwn(anchor, key))) return fail("provider_archive_trust_invalid");
+  if (!/^[0-9a-f]{64}$/.test(anchor.exportSha256 || "") ||
+      typeof anchor.graphId !== "string" || !REF_RE.test(anchor.graphId) ||
+      !REVISION_RE.test(anchor.providerRevision || "") ||
+      !Array.isArray(anchor.ancestorRevisions) || anchor.ancestorRevisions.length > 4096 ||
+      anchor.ancestorRevisions.some(rev => typeof rev !== "string" || !REVISION_RE.test(rev) || rev === anchor.providerRevision) ||
+      new Set(anchor.ancestorRevisions).size !== anchor.ancestorRevisions.length) return fail("provider_archive_trust_invalid");
+  try {
+    // Parent aliases such as macOS /var are allowed; the exact bytes are pinned.
+    if (fs.lstatSync(source).isSymbolicLink()) return fail("provider_archive_source_unsafe");
+    if (!fs.statSync(source).isFile() || fs.statSync(source).size > 1024 * 1024) return fail("provider_archive_source_unsafe");
+    const bytes = fs.readFileSync(source);
+    if (sha256(bytes) !== anchor.exportSha256 || canonicalBytes(JSON.parse(bytes)) !== canonicalBytes(exported)) return fail("provider_archive_export_digest_mismatch");
+  } catch (_) { return fail("provider_archive_source_unsafe"); }
+  if (exported.provider_graph_id !== anchor.graphId) return fail("provider_archive_graph_mismatch");
+  if (exported.provider_revision !== anchor.providerRevision) return fail("provider_archive_revision_mismatch");
+  return { blockers: [], ancestors: anchor.ancestorRevisions };
+}
+
 function connect(repoArg, options = {}) {
   const repo = normalizeRepo(repoArg);
   const source = path.resolve(String(options.source || ""));
@@ -681,14 +747,20 @@ function connect(repoArg, options = {}) {
   const blockers = [...identity.blockers, ...read.blockers, ...manifestState.blockers, ...ext.blockers];
   if (!ext.contract || ext.legacy || ext.contract.enabled !== true) blockers.push("project_technology_not_enabled");
   for (const key of Object.keys(identity.values)) if (read.export[key] !== identity.values[key]) blockers.push(`${key}_mismatch`);
-  const providerRoot = providerRootFor(source);
-  if (!providerRoot) blockers.push("provider_revision_order_unverifiable");
+  const archiveRequested = Object.hasOwn(options, "providerArchive");
+  const archive = archiveRequested ? archiveProviderIdentity(source, read.export, options.providerArchive) : null;
+  const providerRoot = archiveRequested ? null : providerRootFor(source);
+  if (archive) blockers.push(...archive.blockers);
+  else if (!providerRoot) blockers.push("provider_revision_order_unverifiable");
   else if (git(providerRoot, "rev-parse", "HEAD").toLowerCase() !== identity.values.provider_revision) blockers.push("provider_revision_does_not_match_head");
   const root = runtimeRoot(repo, manifestState.manifest, options);
   const currentPath = path.join(root, BINDING_FILE);
   let current = null;
   try { if (fs.existsSync(currentPath)) current = readJson(currentPath); } catch (_) { blockers.push("current_target_binding_invalid"); }
   if (current) {
+    const currentExport = targetBindingStatus(repo, options);
+    const existingGraphId = currentExport.provider_graph_id;
+    if (existingGraphId && existingGraphId !== read.export.provider_graph_id) blockers.push("target_provider_graph_conflict");
     if (!options.refreshBinding) {
       const same = Object.keys(identity.values).every((key) => current[key] === identity.values[key]);
       if (!same) blockers.push("target_provider_conflict", "target_provider_refresh_required");
@@ -703,7 +775,9 @@ function connect(repoArg, options = {}) {
       const currentState = targetBindingStatus(repo, options);
       if (currentState.status !== "ready") blockers.push(...currentState.blockers);
       if (currentState.execution_contract_digest !== read.export.execution_contract_digest) blockers.push("provider_execution_contract_refresh_mismatch");
-      if (!providerRoot) blockers.push("provider_revision_order_unverifiable");
+      if (archive) {
+        if (current.provider_revision !== identity.values.provider_revision && !archive.ancestors.includes(current.provider_revision)) blockers.push("provider_revision_not_forward");
+      } else if (!providerRoot) blockers.push("provider_revision_order_unverifiable");
       else {
         if (current.provider_revision !== identity.values.provider_revision) {
           const ancestry = spawnSync("git", ["-C", providerRoot, "merge-base", "--is-ancestor", current.provider_revision, identity.values.provider_revision]);
@@ -768,7 +842,40 @@ function repair(repoArg, options = {}) {
   return sync(repo, options);
 }
 
+function verifyProviderExport(repoArg, options = {}) {
+  const repo = normalizeRepo(repoArg);
+  const source = path.resolve(options.source || path.join(repo, EXPORT_FILE));
+  const exported = readExport(source);
+  const manifestState = readManifest(repo);
+  const ext = extensionState(manifestState.manifest);
+  const identity = bindingValues(exported.export);
+  const blockers = [...exported.blockers, ...manifestState.blockers, ...ext.blockers, ...identity.blockers];
+  if (options.significantWork) blockers.push("provider_export_verification_is_not_execution_authority");
+  if (!trackedFiles(repo).includes("graph.json") || spawnSync("git", ["diff", "--quiet", "HEAD", "--", "graph.json"], { cwd: repo }).status !== 0) blockers.push("provider_manifest_not_revision_bound");
+  if (!source.startsWith(`${repo}${path.sep}`)) blockers.push("provider_export_outside_repository");
+  if (ext.contract?.enabled !== true || ext.legacy) blockers.push("project_technology_not_enabled");
+  const head = git(repo, "rev-parse", "HEAD");
+  if (head !== identity.values.provider_revision) blockers.push("provider_revision_does_not_match_head");
+  if (exported.export.provider_graph_id !== manifestState.manifest?.id) blockers.push("provider_archive_graph_mismatch");
+  const target = targetContract(repo, identity.values.target_id, identity.values.semantic_digest, manifestState.manifest);
+  blockers.push(...target.blockers);
+  if (sha256(canonicalBytes(target.contract)) !== exported.export.execution_contract_digest) blockers.push("provider_execution_contract_source_mismatch");
+  // Bound supported ancestry; deeper histories need a narrower supported
+  // release window rather than unbounded metadata in every consumer.
+  const history = git(repo, "rev-list", "--max-count=4098", "HEAD").split("\n").filter(Boolean);
+  if (history[0] !== head || history.length > 4097) blockers.push("provider_archive_ancestry_unverifiable_or_too_large");
+  return result("verify", "read_only", blockers.length ? "blocked" : "success", {
+    blockers: [...new Set(blockers)].sort(),
+    provider_archive: blockers.length ? null : {
+      exportSha256: exported.raw_sha256, graphId: manifestState.manifest.id,
+      providerRevision: head, ancestorRevisions: history.slice(1),
+    },
+    next_action: blockers.length ? "repair the canonical provider export before packaging" : "seal this anchor in authenticated release metadata",
+  });
+}
+
 function verify(repoArg, options = {}) {
+  if (options.source) return verifyProviderExport(repoArg, options);
   const state = status(repoArg, options);
   const blockers = [...state.blockers];
   const repo = normalizeRepo(repoArg);
@@ -835,6 +942,7 @@ module.exports = {
   sync,
   targetBindingStatus,
   verify,
+  verifyProviderExport,
   verifyArtifactRelease: artifacts.verifyArtifactRelease,
   verifyTechnologyCourse: technologyCourse.verifyTechnologyCourse,
   verifyContext: traversal.verifyContext,

package/releases/1.5.0.md

@@ -0,0 +1,37 @@
+# Mirai Graph 1.5.0
+
+Compatible additive release for existing 1.x consumers. Published to npm under
+`legacy-1`; it does not replace the 2.x `latest` channel or migrate consumers.
+
+## Changes
+
+- Existing Project Technology connect/refresh can import a bounded provider
+  export without Git when an authenticated distributor supplies its exact
+  export digest, graph identity, revision and forward ancestry proof.
+- Read-only source verification binds that proof to the accepted target and
+  real Git revision before packaging. Caller-supplied trust is not inferred
+  from an export's own claims and never grants permission to perform work.
+- Folder inventory follows only explicitly declared graph and raw-source paths,
+  detects stale content and rejects unsafe or missing sources.
+- CLI archive trust can be passed through stdin without a temporary trust file.
+
+## Compatibility and safety
+
+Existing Git provider operations, complete target and execution contracts,
+transactional rollback and fail-closed behavior remain in force. No new profile,
+registry, daemon or schema family is introduced. The graph manifest remains
+2.0.0 and the Project Technology activation contract remains 1.0.0.
+
+Archive metadata must come from an independently authenticated release; this
+package does not establish a distributor's trust or copy private source content.
+
+## Verification
+
+`npm run release:check` runs the current suite, including 39 existing Project
+Technology checks and 71 archive/source-proof checks. The archive cases cover
+no-Git import, exact replay, forward refresh, downgrade, tamper, graph conflict,
+missing trust, source inventory and read-only behavior.
+
+Local validation uses macOS ARM64 with Node 22.23.2. Federation's native
+Windows/macOS/Linux complete installation matrix is a separate acceptance gate;
+this release does not claim that matrix or a Federation release has passed.

package/releases/README.md

@@ -15,6 +15,8 @@ Release notes must separate:
 
 ## Release Notes
 
+- [v1.5.0](1.5.0.md) - compatible 1.x authenticated archive providers and
+  declared-source inventory without Git (`legacy-1`, not npm `latest`).
 - [v1.2.0](1.2.0.md) - portable task-boundary project continuity in Project
   Technology.
 - [v1.1.0](1.1.0.md) - universal sequential context traversal and usage

package/schemas/project-technology-target-export.schema.json

@@ -15,6 +15,7 @@
     "target_id": { "type": "string", "minLength": 2 },
     "semantic_digest": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" },
     "provider_revision": { "type": "string", "pattern": "^[0-9a-f]{40}$" },
+    "provider_graph_id": { "type": "string", "minLength": 2, "maxLength": 256, "pattern": "^[A-Za-z0-9][A-Za-z0-9._:/@?=+*-]+$" },
     "decision_refs": { "$ref": "#/$defs/nonEmptyRefs" },
     "goal_binding": {
       "type": "object", "additionalProperties": false,

package/standard/project-technology.md

@@ -7,6 +7,59 @@ not a profile, a second graph or a source of domain methodology.
 
 ## One Mechanism, Different Graphs
 
+### Archived providers (unreleased compatibility extension)
+
+The normal source provider path continues to verify Git HEAD and ancestry.
+For an immutable distribution, `connect` also accepts `providerArchive` in the
+JavaScript options, or `--provider-archive-trust <file>` in the CLI (use `-`
+to read that bounded JSON from stdin without creating a temporary file):
+
+```json
+{
+  "exportSha256": "<SHA-256 of the exact bounded export bytes>",
+  "graphId": "example.provider",
+  "providerRevision": "<exact 40-character source revision>",
+  "ancestorRevisions": ["<previous supported revision, proven during release build>"]
+}
+```
+
+This is a **consumer trust input**, not provider self-authentication. The caller
+must derive it from an authenticated release lock/manifest after checking its
+integrity and issuer. Never calculate a hash from an untrusted download and
+call that authentication. Mirai does not discover, download or trust adjacent
+metadata automatically. Packaging must verify the export against the accepted
+source target and the declared source revision before publishing its digest.
+Ancestor entries must be proven by the source Git history during that build;
+they are not inferred from version numbers, dates or commit hash ordering.
+
+The existing `technology verify <repository> --source <bounded-export>` and
+`verifyProviderExport(repository, options)` provide a read-only source-side
+proof for packaging. They require a revision-bound enabled manifest, exact HEAD,
+accepted target and matching execution contract, and return the anchor with at
+most 4096 proven ancestors. A packaging caller must then authenticate the release
+metadata containing this anchor. This proof is not permission to execute a
+significant task; requesting significant work through it is blocked.
+
+Exports produced by `provide` now include `provider_graph_id`. Old Git-backed
+exports remain readable; archive import requires the graph identity. `connect`
+uses the same full accepted execution contract validation and atomic import.
+`--refresh-binding` still requires the same target and semantic/architecture
+contract; a changed revision must explicitly descend from the current binding
+in the authenticated release metadata. A wrong or incomplete anchor fails,
+even when a working Git checkout happens to be available. The caller cannot
+use archive trust to authorize work, change owners, expand scope or bypass
+acceptance. `provide` continues to require the canonical Git source; archive
+consumers import its immutable output, never regenerate acceptance from copies.
+
+Status/verify use the hash-bound local import and remain read-only. Without a
+Git repository, inventory reads only the manifest and explicitly declared graph
+and raw-source paths, with a bounded traversal. Missing, unsafe or unsupported
+declared paths block sync before writes. Symlinks and secret/excluded paths are
+not imported. Ordinary folders use content digests and a null inventory revision,
+never a fabricated Git revision. If Git metadata exists but Git is unavailable,
+inventory fails closed instead of silently treating a checkout as an archive.
+Raw-source access and release authenticity remain separate responsibilities.
+
 The root `graph.json` declares the repository scope and profiles. The same
 Project Technology operations therefore work for: