mirai-graph 1.4.0 → 1.6.0

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", "--verify", "HEAD^{commit}") || null;
+  if (!revision) {
+    if (fs.existsSync(path.join(repo, ".git")) && !unbornGitBranch(repo)) 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,14 +498,28 @@ 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;
 }
 
-function context(repoArg, options = {}) {
+// A valid new repository has no HEAD commit yet. It may inventory declared
+// sources, but must never impersonate a revision-bound provider. Missing tools,
+// corrupt refs/index and detached invalid HEAD are not an unborn branch.
+function unbornGitBranch(repo) {
+  const options = { cwd: repo, encoding: "utf8", env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" } };
+  const branch = spawnSync("git", ["symbolic-ref", "--quiet", "HEAD"], options);
+  const ref = (branch.stdout || "").trim();
+  if (branch.status !== 0 || !ref.startsWith("refs/heads/")) return false;
+  const existing = spawnSync("git", ["show-ref", "--verify", "--quiet", ref], options);
+  if (existing.status !== 1 || existing.stderr) return false;
+  return spawnSync("git", ["status", "--porcelain=v1", "--untracked-files=no"], options).status === 0;
+}
+
+function contextTraversal(repoArg, options = {}) {
   if (options.phase === "expand") return traversal.expandContext(repoArg, options.traversalReceipt, options.selectedIds, options);
   if (options.phase === "compile") return traversal.compileContext(repoArg, options.traversalReceipt, options.selection, options);
   if (options.phase === "verify") return traversal.verifyContext(repoArg, options.contextPack, options.usageEvidence, options);
@@ -492,10 +542,147 @@ function context(repoArg, options = {}) {
   };
 }
 
+function context(repoArg, options = {}) {
+  const output = contextTraversal(repoArg, options);
+  const binding = targetBindingStatus(normalizeRepo(repoArg), options);
+  const blockers = [...(output.blockers || [])];
+  if (options.significantWork && binding.status !== "ready") blockers.push(...binding.blockers, "accepted_target_binding_required_for_significant_work");
+  if (options.significantWork && binding.source_kind === "local") blockers.push(...localVerificationBlockers(normalizeRepo(repoArg), options));
+  return { ...output, target_binding: binding, blockers: [...new Set(blockers)].sort(),
+    status: blockers.length ? "blocked" : output.status };
+}
+
+function localVerificationBlockers(repo, options) {
+  const current = continuity.status(repo, readManifest(repo).manifest, options);
+  if (!current.terminal_receipt) return ["local_target_verification_missing"];
+  return current.terminal_receipt.current_graph_digest === current.graph_digest ? [] : ["local_target_verification_stale"];
+}
+
+// Resolve a local target from the same canonical object reader used by context.
+// Approval origin is a caller responsibility, just like archive-provider trust.
+// Never infer that trust from the decision file or persist it as approval.
+function localTargetStatus(repo, manifest, selection, options = {}) {
+  const blockers = [];
+  const blocked = () => ({ status: "blocked", enabled: true, source_kind: "local", blockers: [...new Set(blockers)].sort(), next_action: "review the local target and verify its owner acceptance" });
+  if (!selection || selection.kind !== "local" || Object.keys(selection).some(k => !["kind", "target_id", "acceptance_ref"].includes(k)) ||
+      !REF_RE.test(selection.target_id || "") || !REF_RE.test(selection.acceptance_ref || "")) {
+    blockers.push("local_target_selection_invalid"); return blocked();
+  }
+  const graph = traversal.readGraph(repo);
+  blockers.push(...graph.blockers);
+  if (!(graph.objects instanceof Map)) { blockers.push("local_target_graph_invalid"); return blocked(); }
+  const target = graph.objects.get(selection.target_id)?.value;
+  const decision = graph.objects.get(selection.acceptance_ref)?.value;
+  const decisionRecord = graph.objects.get(selection.acceptance_ref);
+  if (decisionRecord && (!decisionRecord.relative.startsWith("graph/specs/") || !localSafeFile(repo, decisionRecord.relative))) blockers.push("local_target_acceptance_source_unsafe");
+  if (!target || !["contract", "system"].includes(target.tz_role)) { blockers.push("local_target_missing_or_invalid"); return blocked(); }
+  const normalized = normalizeExecutionContract(target.provider_execution_contract);
+  blockers.push(...normalized.blockers);
+  const contract = normalized.contract;
+  const accepted = obj => obj && ACCEPTED_LIFECYCLES.has(obj.lifecycle) &&
+    (!obj.readiness || ACCEPTED_LIFECYCLES.has(obj.readiness));
+  if (!accepted(target)) blockers.push("local_target_not_accepted");
+  const refs = new Set([selection.target_id, contract.goal_binding?.goal_id,
+    ...(contract.goal_binding?.done_when_ids || []), ...(contract.constraint_ids || []),
+    ...(contract.non_goal_ids || []), ...(contract.deferred_boundary_ids || []),
+    ...(contract.decision_refs || []), contract.architecture_contract?.contract_ref]);
+  for (const item of contract.requirement_bindings || []) {
+    refs.add(item.requirement_id);
+    for (const id of [...item.acceptance_ids, ...item.done_when_ids]) refs.add(id);
+  }
+  // The approval object cannot participate in the digest it signs.
+  refs.delete(selection.acceptance_ref); refs.delete(undefined);
+  const active = new Set(); const visited = new Set();
+  function visit(id) {
+    if (active.has(id)) { blockers.push("local_target_required_cycle"); return; }
+    if (visited.has(id)) return;
+    visited.add(id); active.add(id);
+    for (const relation of graph.relations.filter(r => r.source === id && traversal.REQUIRED_RELATIONS.has(r.type))) {
+      if (!ACCEPTED_LIFECYCLES.has(relation.lifecycle || relation.readiness)) blockers.push("local_target_relation_not_accepted");
+      if (relation.target === selection.acceptance_ref) continue;
+      refs.add(relation.target); visit(relation.target);
+    }
+    active.delete(id);
+  }
+  for (const id of [...refs]) visit(id);
+  const semanticObjects = []; const sources = [];
+  const excluded = new Set(["created_at", "updated_at", "semantic_digest", "execution_contract_digest", "content_revision", "evidence", "approval_ref"]);
+  for (const id of [...refs].sort()) {
+    const record = graph.objects.get(id);
+    if (!record) { blockers.push("local_target_required_object_missing"); continue; }
+    if (!accepted(record.value)) blockers.push("local_target_required_object_not_accepted");
+    if (!record.relative.startsWith("graph/specs/") || !localSafeFile(repo, record.relative)) { blockers.push("local_target_source_unsafe"); continue; }
+    const value = Object.fromEntries(Object.entries(record.value).filter(([key]) => !excluded.has(key)));
+    // Digests of referenced tools/evidence belong to content freshness, not meaning.
+    const sourceRefs = record.value.source_refs || [];
+    const evidenceRefs = record.value.evidence || [];
+    if (!Array.isArray(sourceRefs) || !Array.isArray(evidenceRefs) ||
+        sourceRefs.some(ref => typeof (typeof ref === "string" ? ref : ref?.ref) !== "string")) {
+      blockers.push("local_target_source_refs_invalid"); continue;
+    }
+    value.source_refs = sourceRefs.map(ref => typeof ref === "string" ? ref : ref.ref).sort();
+    semanticObjects.push(value);
+    for (const raw of [...sourceRefs, ...evidenceRefs]) {
+      const ref = typeof raw === "string" ? raw : raw?.ref;
+      if (!localSafeFile(repo, ref)) { blockers.push("local_target_source_unsafe_or_missing"); continue; }
+      const bytes = fs.readFileSync(path.join(repo, ref));
+      const actual = sha256(bytes, true);
+      if (typeof raw === "object" && (raw.sha256 || raw.digest) && (raw.sha256 || raw.digest) !== actual) blockers.push("local_target_source_digest_mismatch");
+      sources.push({ ref, sha256: actual });
+    }
+  }
+  const relations = graph.relations.filter(r => refs.has(r.source) && refs.has(r.target)).map(({ _record, ...r }) =>
+    Object.fromEntries(Object.entries(r).filter(([k]) => !excluded.has(k))));
+  relations.sort((a,b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  if (relations.some(r => r.type === "conflicts_with")) blockers.push("local_target_conflict");
+  if (contract.goal_binding?.done_when_ids.some(id => !contract.requirement_bindings.some(r => r.done_when_ids.includes(id)))) blockers.push("local_target_done_when_uncovered");
+  const semanticDigest = sha256(canonicalBytes({ graph_id: manifest.id, target_id: selection.target_id, objects: semanticObjects, relations }), true);
+  const executionDigest = sha256(canonicalBytes(contract));
+  const contentRevision = sha256(canonicalBytes([...new Map(sources.map(s => [s.ref, s])).values()].sort((a,b) => a.ref < b.ref ? -1 : a.ref > b.ref ? 1 : 0)), true);
+  if (target.semantic_digest !== semanticDigest) blockers.push("local_target_semantic_digest_mismatch");
+  if (target.content_revision !== contentRevision) blockers.push("local_target_content_stale");
+  if (!decision || decision.kind !== "decision" || decision.subtype !== "architecture_baseline_acceptance" || !accepted(decision)) blockers.push("local_target_acceptance_missing_or_invalid");
+  const architecture = contract.architecture_contract || {};
+  if (!contract.decision_refs?.includes(selection.acceptance_ref) || architecture.acceptance_ref !== selection.acceptance_ref) blockers.push("local_target_acceptance_ref_mismatch");
+  if (decision && (decision.graph_id !== manifest.id || decision.target_id !== selection.target_id ||
+      decision.owner_id !== architecture.architecture_owner_id || decision.semantic_digest !== semanticDigest ||
+      decision.execution_contract_digest !== executionDigest || !REF_RE.test(decision.approval_ref || ""))) blockers.push("local_target_acceptance_identity_mismatch");
+  const trust = options.localAcceptance;
+  if (!trust || Object.keys(trust).some(k => !["graphId", "targetId", "ownerId", "decisionSha256"].includes(k)) ||
+      trust.graphId !== manifest.id || trust.targetId !== selection.target_id || trust.ownerId !== architecture.architecture_owner_id ||
+      !decision || trust.decisionSha256 !== sha256(canonicalBytes(decision))) blockers.push("local_target_acceptance_unverified");
+  if (!contract.allowed_change_scope?.some(s => s.repository_id === manifest.id)) blockers.push("local_target_repository_scope_unapproved");
+  return { ...blocked(), status: blockers.length ? "blocked" : "ready", repository_id: manifest.id,
+    target_id: selection.target_id, acceptance_ref: selection.acceptance_ref,
+    semantic_digest: semanticDigest, content_revision: contentRevision,
+    execution_contract_digest: executionDigest, execution_contract: contract,
+    next_action: blockers.length ? "review the local target and verify its owner acceptance" : "none" };
+}
+
+function localSafeFile(repo, ref) {
+  if (typeof ref !== "string" || !ref || /[:\\\\]/.test(ref) || path.posix.isAbsolute(ref) || ref.split("/").some(p => ["..", ".", "source", "generated"].includes(p)) ||
+      SECRET_PARTS.some(p => ref.toLowerCase().includes(p))) return false;
+  let current = repo;
+  try {
+    for (const part of ref.split("/")) { current = path.join(current, part); if (fs.lstatSync(current).isSymbolicLink()) return false; }
+    return fs.statSync(current).isFile();
+  } catch (_) { return false; }
+}
+
 function targetBindingStatus(repo, options = {}) {
   const manifest = readManifest(repo).manifest;
   const root = runtimeRoot(repo, manifest, options);
   const bindingPath = path.join(root, BINDING_FILE);
+  const selection = options.targetSource || manifest?.extensions?.[EXTENSION_KEY]?.target_source;
+  if (selection) {
+    if (fs.existsSync(bindingPath)) return { status: "blocked", enabled: true, source_kind: "conflict", blockers: ["local_external_target_conflict"], next_action: "explicitly reconcile local and external targets" };
+    const local = localTargetStatus(repo, manifest, selection, options);
+    if (manifest?.extensions?.[EXTENSION_KEY]?.enabled !== true) {
+      local.status = "blocked";
+      local.blockers = [...new Set([...local.blockers, "project_technology_disabled"])].sort();
+    }
+    return local;
+  }
   if (!fs.existsSync(bindingPath)) return { status: "not_configured", enabled: false, blockers: [], next_action: "connect an exact target provider binding" };
   let binding;
   try { binding = readJson(bindingPath); } catch (_) { return { status: "blocked", enabled: true, blockers: ["target_binding_invalid"] }; }
@@ -521,6 +708,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 +723,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}`);
@@ -548,7 +736,7 @@ function status(repoArg, options = {}) {
     technology_freshness: freshness,
     technology_digest: current.inventory_digest,
     target_binding: binding,
-    continuity: continuity.status(repo, manifestState.manifest, {}),
+    continuity: continuity.status(repo, manifestState.manifest, options),
     blockers: [...new Set(blockers)].sort(),
     next_action: ext.legacy ? "run enable --apply to migrate the legacy contract" : blockers.length ? "run plan, then the required transactional operation" : "none",
   });
@@ -561,10 +749,11 @@ function explain(repoArg) {
   });
 }
 
-function plan(repoArg) {
-  const state = status(repoArg);
+function plan(repoArg, options = {}) {
+  const state = status(repoArg, options);
   return result("plan", "read_only", "success", {
     current_status: state.status,
+    target_binding: state.target_binding,
     planned_changes: ["validate_graph_manifest", "migrate_legacy_extension_if_present", "migrate_project_local_runtime_to_host_state", "enable_public_contract", "build_safe_inventory", "verify_target_binding"],
     blockers: state.blockers.filter((item) => !["project_technology_not_configured", "project_technology_migration_required", "project_technology_inventory_missing", "project_technology_inventory_stale"].includes(item)),
     next_action: "rerun the selected operation with --apply",
@@ -573,6 +762,8 @@ function plan(repoArg) {
 
 function preview(operation, repoArg, options = {}) {
   const state = status(repoArg, options);
+  if (options.targetSource) return result(operation, "preview", "preview", { apply_required: true,
+    target_binding: state.target_binding, blockers: state.target_binding.blockers, next_action: "sync --apply with expected graph digest and independently verified acceptance" });
   return result(operation, "preview", "preview", { apply_required: true, current_status: state.status, blockers: state.blockers.filter((item) => item.startsWith("graph_manifest_")), next_action: `${operation} --apply` });
 }
 
@@ -580,11 +771,13 @@ 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];
   delete extensions[LEGACY_EXTENSION_KEY];
-  extensions[EXTENSION_KEY] = extensionContract();
+  extensions[EXTENSION_KEY] = { ...extensionContract(), ...(extensions[EXTENSION_KEY]?.target_source ? { target_source: extensions[EXTENSION_KEY].target_source } : {}) };
   manifest.extensions = extensions;
   const root = runtimeRoot(repo, manifest, options);
   const runtimeMigration = migrateProjectLocalRuntime(repo, manifest, root);
@@ -615,12 +808,15 @@ function enable(repoArg, options = {}) {
 
 function sync(repoArg, options = {}) {
   const repo = normalizeRepo(repoArg);
+  if (options.targetSource) return syncLocalSelection(repo, options);
   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");
+  const binding = targetBindingStatus(repo, options);
+  if (binding.source_kind && binding.status !== "ready") blockers.push(...binding.blockers);
   if (blockers.length) return result("sync", "transactional", "fail", { blockers: [...new Set(blockers)].sort(), next_action: "enable or repair Project Technology" });
   let continuityResult = null;
   if (options.boundary) {
@@ -648,6 +844,56 @@ function sync(repoArg, options = {}) {
   });
 }
 
+function syncLocalSelection(repo, options, remove = false) {
+  const operation = remove ? "disconnect" : "sync";
+  const manifestState = readManifest(repo);
+  const manifest = manifestState.manifest;
+  const ext = extensionState(manifest);
+  const binding = targetBindingStatus(repo, options);
+  const blockers = [...manifestState.blockers, ...ext.blockers, ...(remove ? [] : binding.blockers)];
+  if (!remove && ext.contract?.enabled !== true) blockers.push("project_technology_not_enabled");
+  if (options.boundary) blockers.push("local_target_selection_requires_separate_boundary");
+  const beforeDigest = continuity.graphDigest(repo);
+  if (!options.expectedGraphDigest || beforeDigest !== options.expectedGraphDigest) blockers.push("local_target_compare_and_swap_conflict");
+  if (blockers.length) return result(operation, "transactional", "blocked", { target_binding: binding, blockers: [...new Set(blockers)].sort() });
+  const root = runtimeRoot(repo, manifest, options);
+  const lease = continuity.lock(repo, root);
+  if (!lease.acquired) return result(operation, "transactional", "blocked", { blockers: ["continuity_lease_conflict"] });
+  const file = path.join(repo, "graph.json"); const inventoryPath = path.join(root, INVENTORY_FILE);
+  const before = fs.readFileSync(file);
+  const inventoryBefore = fs.existsSync(inventoryPath) ? fs.readFileSync(inventoryPath) : null;
+  try {
+    if (continuity.graphDigest(repo) !== beforeDigest) return result(operation, "transactional", "blocked", { blockers: ["local_target_compare_and_swap_conflict"] });
+    const next = structuredClone(manifest);
+    if (remove) delete next.extensions[EXTENSION_KEY].target_source;
+    else next.extensions[EXTENSION_KEY].target_source = options.targetSource;
+    if (canonicalBytes(next) === canonicalBytes(manifest)) return result(operation, "transactional", "success", { target_binding: binding });
+    const backup = path.join(root, "rollback", beforeDigest.slice(7), "graph.json");
+    atomicWrite(backup, before);
+    atomicWrite(file, canonicalBytes(next));
+    const inv = inventory(repo);
+    if (inv.blockers?.length) throw new Error("local_target_inventory_failed");
+    atomicWrite(inventoryPath, canonicalBytes(inv));
+    // No source write besides the selector is permitted in this transaction.
+    // Ignore expected Git dirtiness from the selector itself during readback.
+    if (!fs.readFileSync(file).equals(Buffer.from(canonicalBytes(next)))) throw new Error("local_target_readback_failed");
+    const readback = targetBindingStatus(repo, remove ? { ...options, targetSource: undefined } : options);
+    if (!remove && (readback.semantic_digest !== binding.semantic_digest || readback.content_revision !== binding.content_revision ||
+        readback.blockers.some(code => code !== "graph_source_not_revision_bound"))) throw new Error("local_target_source_changed_during_selection");
+    return result(operation, "transactional", "success", { changed: true, target_binding: readback,
+      rollback_ref: `host-local://rollback/${beforeDigest.slice(7)}/graph.json`, technology_digest: inv.inventory_digest });
+  } catch (_) {
+    let restored = false;
+    try {
+      atomicWrite(file, before);
+      if (inventoryBefore) atomicWrite(inventoryPath, inventoryBefore);
+      else if (fs.existsSync(inventoryPath)) fs.unlinkSync(inventoryPath);
+      restored = fs.readFileSync(file).equals(before);
+    } catch (_) { /* recovery required remains explicit */ }
+    return result(operation, "transactional", "fail", { blockers: [restored ? "local_target_rollback_applied" : "local_target_recovery_required"] });
+  } finally { continuity.releaseLock(lease); }
+}
+
 function provide(repoArg, options = {}) {
   const repo = normalizeRepo(repoArg);
   const identity = bindingValues(options);
@@ -661,7 +907,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 +917,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 +953,21 @@ 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");
+  if (manifestState.manifest?.extensions?.[EXTENSION_KEY]?.target_source) blockers.push("local_external_target_conflict");
+  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 +982,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]);
@@ -735,6 +1016,7 @@ function connect(repoArg, options = {}) {
 
 function disconnect(repoArg, options = {}) {
   const repo = normalizeRepo(repoArg);
+  if (readManifest(repo).manifest?.extensions?.[EXTENSION_KEY]?.target_source) return syncLocalSelection(repo, options, true);
   const root = runtimeRoot(repo, readManifest(repo).manifest, options);
   const bindingPath = path.join(root, BINDING_FILE);
   if (!fs.existsSync(bindingPath)) return result("disconnect", "transactional", "success");
@@ -768,7 +1050,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);
@@ -776,6 +1091,7 @@ function verify(repoArg, options = {}) {
   const continuityResult = continuity.verify(repo, manifest, options);
   if (continuity.continuityPolicy(manifest) === "task_boundary" || options.receiptDigest || options.significantWork) blockers.push(...continuityResult.blockers);
   if (options.significantWork && state.target_binding.status !== "ready") blockers.push("accepted_target_binding_required_for_significant_work");
+  if (options.significantWork && state.target_binding.source_kind === "local") blockers.push(...localVerificationBlockers(repo, options));
   return result("verify", "read_only", blockers.length ? "blocked" : "success", {
     repository_id: state.repository_id,
     enabled: state.enabled,
@@ -835,6 +1151,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/1.6.0.md

@@ -0,0 +1,43 @@
+# Mirai Graph 1.6.0 candidate
+
+Status: local release preparation, not published or independently accepted.
+This is an additive compatible 1.x release. Intended npm channel: `legacy-1`;
+it must not move the separate 2.x `latest` channel.
+
+## Result
+
+An ordinary project folder can explicitly select its own accepted target without
+Git or a self-connected external provider. The caller authenticates the human
+approval and supplies an independent trust anchor; the graph cannot approve
+itself. Existing external provider bindings remain supported and fail closed.
+
+The same target identity is exposed in status, plan, context and verify. Selection
+and disconnect reuse the existing transaction, lease, compare-and-swap, backup
+and rollback. Semantic acceptance is distinct from source-content freshness.
+Significant work still requires current task-boundary verification evidence.
+
+A valid new Git branch can inventory declared sources before its first commit.
+Corrupt refs/indexes and unavailable Git remain blocked. No commit revision is
+invented and provider export still requires a real committed revision.
+
+## Compatibility
+
+- Manifest schema remains `2.0.0`; activation contract remains `1.0.0`.
+- No new profile, engine, approval issuer or source-of-truth store.
+- Local target selection is explicit; missing approval never falls back to ready.
+- An offline synchronization conflict requires reconciliation. A filesystem
+  lease is not a distributed lock between disconnected copies.
+- A new host may inspect the project, but cannot execute solely because a copied
+  folder declares itself accepted or contains a matching adjacent checksum.
+
+## Verification and limits
+
+The implementation commits passed the complete test suite and the existing
+Windows/macOS/Ubuntu Project Technology, context and continuity CI matrix.
+Release packaging is checked separately on the versioned artifact. These tests
+do not prove the complete installer of any downstream application, a real shared
+network filesystem or an employee's legacy installation.
+
+Independent acceptance, immutable package publication and downstream exact-lock
+installation are separate requirements. No tag, GitHub Release or npm package
+is represented as published by this candidate document.

package/releases/README.md

@@ -15,6 +15,10 @@ Release notes must separate:
 
 ## Release Notes
 
+- [v1.6.0 candidate](1.6.0.md) - local accepted targets and valid unborn Git
+  inventory; unpublished, intended for `legacy-1` only.
+- [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-extension.schema.json

@@ -10,6 +10,15 @@
     "enabled": { "type": "boolean" },
     "context_policy": { "const": "task_scoped" },
     "source_boundary": { "const": "hybrid_sot" },
-    "continuity_policy": { "enum": ["task_boundary"] }
+    "continuity_policy": { "enum": ["task_boundary"] },
+    "target_source": {
+      "type": "object", "additionalProperties": false,
+      "required": ["kind", "target_id", "acceptance_ref"],
+      "properties": {
+        "kind": { "const": "local" },
+        "target_id": { "type": "string", "minLength": 2 },
+        "acceptance_ref": { "type": "string", "minLength": 2 }
+      }
+    }
   }
 }