mirai-graph 1.1.1 → 1.3.0

package/packages/project-technology/index.js

@@ -14,15 +14,17 @@ const {
   validateManifest,
 } = require("../cli/graph-manifest");
 const traversal = require("./context-traversal");
+const continuity = require("./continuity");
+const artifacts = require("./artifact-release");
 
 const CONTRACT_VERSION = "1.0.0";
 const EXTENSION_KEY = "mirai.project_technology";
 const LEGACY_EXTENSION_KEY = "simai.project_technology";
 const LOCAL_DIR = path.join(".mirai-graph", "project-technology");
 const LEGACY_LOCAL_DIR = path.join(".simai", "project-technology");
-const INVENTORY_FILE = path.join(LOCAL_DIR, "inventory.json");
-const BINDING_FILE = path.join(LOCAL_DIR, "target-provider-binding.json");
-const IMPORT_DIR = path.join(LOCAL_DIR, "provider-exports");
+const INVENTORY_FILE = "inventory.json";
+const BINDING_FILE = "target-provider-binding.json";
+const IMPORT_DIR = "provider-exports";
 const EXPORT_FILE = path.join("graph", "generated", "project-technology", "target-provider-export.json");
 const TARGET_DIGEST_RE = /^sha256:[0-9a-f]{64}$/;
 const REVISION_RE = /^[0-9a-f]{40}$/;
@@ -90,6 +92,58 @@ function normalizeRepo(repo) {
   return path.resolve(repo || ".");
 }
 
+function runtimeRoot(repo, manifest = null, options = {}) {
+  return continuity.stateRoot(repo, manifest || readManifest(repo).manifest, options);
+}
+
+function legacyRuntimeState(repo) {
+  const root = path.join(repo, LOCAL_DIR);
+  return {
+    root,
+    present: fs.existsSync(root),
+    inventory: path.join(root, INVENTORY_FILE),
+    binding: path.join(root, BINDING_FILE),
+  };
+}
+
+function migrateProjectLocalRuntime(repo, manifest, root) {
+  const legacy = legacyRuntimeState(repo);
+  if (!legacy.present) return { changed: false, blockers: [], migration_ref: null };
+  const blockers = [];
+  let changed = false;
+  if (fs.existsSync(legacy.binding)) {
+    const binding = readJson(legacy.binding);
+    const identity = bindingValues(binding); blockers.push(...identity.blockers);
+    const ref = String(binding.provider_export_ref || "");
+    const exportPath = ref && !path.isAbsolute(ref) ? path.resolve(repo, ref) : null;
+    const exported = exportPath ? readExport(exportPath) : { export: {}, blockers: ["legacy_provider_export_missing"] };
+    blockers.push(...exported.blockers);
+    for (const key of Object.keys(identity.values)) if (exported.export[key] !== identity.values[key]) blockers.push(`legacy_${key}_mismatch`);
+    if (!blockers.length) {
+      const exportBytes = canonicalBytes(exported.export);
+      const exportSha = sha256(exportBytes);
+      changed = atomicWrite(path.join(root, IMPORT_DIR, `${exportSha}.json`), exportBytes) || changed;
+      changed = atomicWrite(path.join(root, BINDING_FILE), canonicalBytes({
+        schema_version: "1.0.0", ...identity.values,
+        provider_export_ref: `host-local://${IMPORT_DIR}/${exportSha}.json`,
+        provider_export_sha256: exportSha,
+      })) || changed;
+    }
+  }
+  if (blockers.length) return { changed: false, blockers: [...new Set(blockers)].sort(), migration_ref: null };
+  const receipt = {
+    schema_version: "1.0.0",
+    status: "migrated",
+    repository_id: manifest.id,
+    source: LOCAL_DIR,
+    source_preserved: true,
+    active_runtime: "host-local",
+  };
+  const receiptName = `project-local-runtime-${sha256(canonicalBytes(receipt)).slice(0, 16)}.json`;
+  changed = atomicWrite(path.join(root, "migrations", receiptName), canonicalBytes(receipt)) || changed;
+  return { changed, blockers: [], migration_ref: `host-local://migrations/${receiptName}` };
+}
+
 function readManifest(repo) {
   const manifestPath = path.join(repo, "graph.json");
   if (!fs.existsSync(manifestPath)) return { manifest: null, blockers: ["graph_manifest_missing"] };
@@ -106,6 +160,7 @@ function extensionContract() {
     enabled: true,
     context_policy: "task_scoped",
     source_boundary: "hybrid_sot",
+    continuity_policy: "task_boundary",
   };
 }
 
@@ -432,19 +487,23 @@ function context(repoArg, options = {}) {
       source_refs: (nodes.get(candidate.id)?.source_refs || []).map((source) => source.ref),
     })),
     runtime_contract: { graph_first_scope: "routing/capability/policy orientation", raw_source_authoritative: true, canonical_write_allowed: false },
+    continuity: continuity.status(normalizeRepo(repoArg), readManifest(normalizeRepo(repoArg)).manifest, options),
   };
 }
 
-function targetBindingStatus(repo) {
-  const bindingPath = path.join(repo, BINDING_FILE);
+function targetBindingStatus(repo, options = {}) {
+  const manifest = readManifest(repo).manifest;
+  const root = runtimeRoot(repo, manifest, options);
+  const bindingPath = path.join(root, BINDING_FILE);
   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"] }; }
   const identity = bindingValues(binding);
   const exportRef = String(binding.provider_export_ref || "");
-  const exportPath = exportRef && !path.isAbsolute(exportRef) ? path.resolve(repo, exportRef) : null;
+  const hostPrefix = "host-local://";
+  const exportPath = exportRef.startsWith(hostPrefix) ? path.join(root, exportRef.slice(hostPrefix.length)) : null;
   const blockers = [...identity.blockers];
-  if (!exportPath || !exportPath.startsWith(`${repo}${path.sep}`)) blockers.push("provider_export_outside_repository");
+  if (!exportPath || !exportPath.startsWith(`${root}${path.sep}`)) blockers.push("provider_export_outside_host_state");
   const exported = exportPath ? readExport(exportPath) : { export: {}, blockers: ["provider_export_missing"] };
   blockers.push(...exported.blockers);
   for (const key of Object.keys(identity.values)) if (exported.export[key] !== identity.values[key]) blockers.push(`${key}_mismatch`);
@@ -466,18 +525,20 @@ function targetBindingStatus(repo) {
   };
 }
 
-function status(repoArg) {
+function status(repoArg, options = {}) {
   const repo = normalizeRepo(repoArg);
   const manifestState = readManifest(repo);
   const ext = extensionState(manifestState.manifest);
   let stored = null;
-  try { if (fs.existsSync(path.join(repo, INVENTORY_FILE))) stored = readJson(path.join(repo, INVENTORY_FILE)); } catch (_) { /* stale */ }
+  const root = runtimeRoot(repo, manifestState.manifest, 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];
+  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}`);
-  const binding = targetBindingStatus(repo);
+  const binding = targetBindingStatus(repo, options);
   if (binding.status === "blocked") blockers.push(...binding.blockers);
   return result("status", "read_only", blockers.length ? "blocked" : "success", {
     repository_id: manifestState.manifest?.id || path.basename(repo),
@@ -486,6 +547,7 @@ function status(repoArg) {
     technology_freshness: freshness,
     technology_digest: current.inventory_digest,
     target_binding: binding,
+    continuity: continuity.status(repo, manifestState.manifest, {}),
     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",
   });
@@ -502,18 +564,18 @@ function plan(repoArg) {
   const state = status(repoArg);
   return result("plan", "read_only", "success", {
     current_status: state.status,
-    planned_changes: ["validate_graph_manifest", "migrate_legacy_extension_if_present", "enable_public_contract", "build_safe_inventory", "verify_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",
   });
 }
 
-function preview(operation, repoArg) {
-  const state = status(repoArg);
+function preview(operation, repoArg, options = {}) {
+  const state = status(repoArg, options);
   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` });
 }
 
-function enable(repoArg) {
+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" });
@@ -523,7 +585,13 @@ function enable(repoArg) {
   delete extensions[LEGACY_EXTENSION_KEY];
   extensions[EXTENSION_KEY] = extensionContract();
   manifest.extensions = extensions;
-  const migrationRoot = path.join(repo, LOCAL_DIR, "migrations", sha256(canonicalBytes({ legacy: legacy || null, head: git(repo, "rev-parse", "HEAD") })).slice(0, 16));
+  const root = runtimeRoot(repo, manifest, options);
+  const runtimeMigration = migrateProjectLocalRuntime(repo, manifest, root);
+  if (runtimeMigration.blockers.length) return result("enable", "transactional", "fail", {
+    blockers: runtimeMigration.blockers,
+    next_action: "repair the project-local runtime before host-state migration",
+  });
+  const migrationRoot = path.join(root, "migrations", sha256(canonicalBytes({ legacy: legacy || null, head: git(repo, "rev-parse", "HEAD") })).slice(0, 16));
   fs.mkdirSync(migrationRoot, { recursive: true });
   atomicWrite(path.join(migrationRoot, "graph.json.before"), fs.readFileSync(path.join(repo, "graph.json")));
   if (legacy) atomicWrite(path.join(migrationRoot, "legacy-extension.json"), canonicalBytes(legacy));
@@ -531,25 +599,52 @@ function enable(repoArg) {
   if (fs.existsSync(legacyLocal)) atomicWrite(path.join(migrationRoot, "legacy-local-state.json"), canonicalBytes({ status: "preserved_for_rollback", path: LEGACY_LOCAL_DIR }));
   const manifestChanged = atomicWrite(path.join(repo, "graph.json"), canonicalBytes(manifest));
   const inv = inventory(repo);
-  const inventoryChanged = atomicWrite(path.join(repo, INVENTORY_FILE), canonicalBytes(inv));
+  const inventoryChanged = atomicWrite(path.join(root, INVENTORY_FILE), canonicalBytes(inv));
   const verified = readManifest(repo);
   if (verified.blockers.length || extensionState(verified.manifest).blockers.length) {
     fs.copyFileSync(path.join(migrationRoot, "graph.json.before"), path.join(repo, "graph.json"));
     return result("enable", "transactional", "fail", { blockers: ["project_technology_enable_rolled_back", ...verified.blockers], next_action: "inspect the rollback receipt" });
   }
-  return result("enable", "transactional", "success", { changed: manifestChanged || inventoryChanged, migration_ref: path.relative(repo, migrationRoot).split(path.sep).join("/"), technology_digest: inv.inventory_digest });
+  return result("enable", "transactional", "success", {
+    changed: manifestChanged || inventoryChanged || runtimeMigration.changed,
+    migration_ref: runtimeMigration.migration_ref || `host-local://migrations/${path.basename(migrationRoot)}`,
+    technology_digest: inv.inventory_digest,
+  });
 }
 
-function sync(repoArg) {
+function sync(repoArg, options = {}) {
   const repo = normalizeRepo(repoArg);
   const manifestState = readManifest(repo);
   const ext = extensionState(manifestState.manifest);
   const blockers = [...manifestState.blockers, ...ext.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");
   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) {
+    continuityResult = continuity.sync(repo, manifestState.manifest, options.boundary, options.continuityEvidence, options);
+    if (continuityResult.status !== "success") return result("sync", "transactional", continuityResult.status, {
+      blockers: continuityResult.blockers,
+      continuity: continuityResult.continuity || null,
+      next_action: "repair the continuity evidence or reconcile the graph state",
+    });
+    if (options.boundary === "task_start") return result("sync", "read_only", "success", {
+      changed: false,
+      technology_digest: inventory(repo).inventory_digest,
+      target_binding: targetBindingStatus(repo, options),
+      continuity: continuityResult.continuity,
+    });
+  }
   const inv = inventory(repo);
-  const changed = atomicWrite(path.join(repo, INVENTORY_FILE), canonicalBytes(inv));
-  return result("sync", "transactional", "success", { changed, technology_digest: inv.inventory_digest, target_binding: targetBindingStatus(repo) });
+  const currentManifest = readManifest(repo).manifest;
+  const changed = atomicWrite(path.join(runtimeRoot(repo, currentManifest || manifestState.manifest, options), INVENTORY_FILE), canonicalBytes(inv));
+  return result("sync", "transactional", "success", {
+    changed: changed || Boolean(continuityResult?.changed),
+    technology_digest: inv.inventory_digest,
+    target_binding: targetBindingStatus(repo, options),
+    continuity: continuityResult?.continuity || continuity.status(repo, currentManifest, options),
+  });
 }
 
 function provide(repoArg, options = {}) {
@@ -588,7 +683,8 @@ function connect(repoArg, options = {}) {
   const providerRoot = providerRootFor(source);
   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 currentPath = path.join(repo, BINDING_FILE);
+  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) {
@@ -596,14 +692,14 @@ function connect(repoArg, options = {}) {
       const same = Object.keys(identity.values).every((key) => current[key] === identity.values[key]);
       if (!same) blockers.push("target_provider_conflict", "target_provider_refresh_required");
       else {
-        const currentState = targetBindingStatus(repo);
+        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("target_provider_conflict", "provider_execution_contract_mismatch");
       }
     } else {
       if (current.target_id !== identity.values.target_id) blockers.push("target_provider_target_mismatch");
       if (current.semantic_digest !== identity.values.semantic_digest) blockers.push("target_provider_semantic_mismatch");
-      const currentState = targetBindingStatus(repo);
+      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");
@@ -618,8 +714,8 @@ function connect(repoArg, options = {}) {
   if (blockers.length) return result("connect", "transactional", "fail", { blockers: [...new Set(blockers)].sort(), next_action: "repair the provider export or request an explicit accepted target change" });
   const exportBytes = canonicalBytes(read.export);
   const exportSha = sha256(exportBytes);
-  const imported = path.join(repo, IMPORT_DIR, `${exportSha}.json`);
-  const binding = { schema_version: "1.0.0", ...identity.values, provider_export_ref: path.relative(repo, imported).split(path.sep).join("/"), provider_export_sha256: exportSha };
+  const imported = path.join(root, IMPORT_DIR, `${exportSha}.json`);
+  const binding = { schema_version: "1.0.0", ...identity.values, provider_export_ref: `host-local://${IMPORT_DIR}/${exportSha}.json`, provider_export_sha256: exportSha };
   const transaction = fs.mkdtempSync(path.join(os.tmpdir(), "mirai-project-technology-"));
   const bindingBefore = fs.existsSync(currentPath) ? fs.readFileSync(currentPath) : null;
   const importBefore = fs.existsSync(imported) ? fs.readFileSync(imported) : null;
@@ -627,7 +723,7 @@ function connect(repoArg, options = {}) {
     const exportChanged = atomicWrite(imported, exportBytes);
     const bindingChanged = atomicWrite(currentPath, canonicalBytes(binding));
     fs.rmSync(transaction, { recursive: true, force: true });
-    return result("connect", "transactional", "success", { changed: exportChanged || bindingChanged, refresh_binding: Boolean(options.refreshBinding), target_binding: targetBindingStatus(repo) });
+    return result("connect", "transactional", "success", { changed: exportChanged || bindingChanged, refresh_binding: Boolean(options.refreshBinding), target_binding: targetBindingStatus(repo, options) });
   } catch (_) {
     if (bindingBefore) atomicWrite(currentPath, bindingBefore); else if (fs.existsSync(currentPath)) fs.unlinkSync(currentPath);
     if (importBefore) atomicWrite(imported, importBefore); else if (fs.existsSync(imported)) fs.unlinkSync(imported);
@@ -636,14 +732,15 @@ function connect(repoArg, options = {}) {
   }
 }
 
-function disconnect(repoArg) {
+function disconnect(repoArg, options = {}) {
   const repo = normalizeRepo(repoArg);
-  const bindingPath = path.join(repo, BINDING_FILE);
+  const root = runtimeRoot(repo, readManifest(repo).manifest, options);
+  const bindingPath = path.join(root, BINDING_FILE);
   if (!fs.existsSync(bindingPath)) return result("disconnect", "transactional", "success");
-  const backup = path.join(repo, LOCAL_DIR, "rollback", `binding-${sha256(fs.readFileSync(bindingPath)).slice(0, 16)}.json`);
+  const backup = path.join(root, "rollback", `binding-${sha256(fs.readFileSync(bindingPath)).slice(0, 16)}.json`);
   atomicWrite(backup, fs.readFileSync(bindingPath));
   fs.unlinkSync(bindingPath);
-  return result("disconnect", "transactional", "success", { changed: true, rollback_ref: path.relative(repo, backup).split(path.sep).join("/") });
+  return result("disconnect", "transactional", "success", { changed: true, rollback_ref: `host-local://rollback/${path.basename(backup)}` });
 }
 
 function disable(repoArg) {
@@ -658,19 +755,25 @@ function disable(repoArg) {
   return result("disable", "transactional", "success", { changed });
 }
 
-function repair(repoArg) {
+function repair(repoArg, options = {}) {
   const repo = normalizeRepo(repoArg);
   const manifestState = readManifest(repo);
   if (!manifestState.manifest || manifestState.blockers.length) return result("repair", "transactional", "fail", { blockers: manifestState.blockers, next_action: "repair graph.json before Project Technology" });
   const ext = extensionState(manifestState.manifest);
-  if (!ext.contract || ext.legacy) return enable(repo);
-  if (ext.blockers.length) return enable(repo);
-  return sync(repo);
+  if (!ext.contract || ext.legacy) return enable(repo, options);
+  if (ext.blockers.length) return enable(repo, options);
+  const root = runtimeRoot(repo, manifestState.manifest, options);
+  if (legacyRuntimeState(repo).present && !fs.existsSync(path.join(root, INVENTORY_FILE))) return enable(repo, options);
+  return sync(repo, options);
 }
 
 function verify(repoArg, options = {}) {
-  const state = status(repoArg);
+  const state = status(repoArg, options);
   const blockers = [...state.blockers];
+  const repo = normalizeRepo(repoArg);
+  const manifest = readManifest(repo).manifest;
+  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");
   return result("verify", "read_only", blockers.length ? "blocked" : "success", {
     repository_id: state.repository_id,
@@ -679,17 +782,19 @@ function verify(repoArg, options = {}) {
     technology_freshness: state.technology_freshness,
     technology_digest: state.technology_digest,
     target_binding: state.target_binding,
+    continuity: continuityResult.continuity,
     blockers: [...new Set(blockers)].sort(),
     next_action: blockers.length ? "repair the listed Project Technology blockers" : "none",
   });
 }
 
 function execute(operation, repoArg, options = {}) {
+  if (operation === "artifact") return artifacts.executeArtifact(repoArg, options);
   const readOnly = { explain, status, plan, verify, context };
   if (readOnly[operation]) return readOnly[operation](repoArg, options);
   const transactional = { enable, sync, connect, disconnect, provide, disable, repair };
   if (!transactional[operation]) return result(operation, "read_only", "fail", { blockers: ["unsupported_project_technology_operation"] });
-  if (!options.apply) return preview(operation, repoArg);
+  if (!options.apply) return preview(operation, repoArg, options);
   return transactional[operation](repoArg, options);
 }
 
@@ -699,9 +804,11 @@ module.exports = {
   LOCAL_DIR,
   bindingValues,
   canonicalBytes,
+  compareArtifactReleases: artifacts.compareArtifactReleases,
   connect,
   compileContext: traversal.compileContext,
   context,
+  createArtifactRelease: artifacts.createArtifactRelease,
   discoverContext: traversal.discoverContext,
   disable,
   disconnect,
@@ -711,7 +818,9 @@ module.exports = {
   explain,
   extensionContract,
   inventory,
+  inspectArtifactBundle: artifacts.inspectArtifactBundle,
   normalizeExecutionContract,
+  continuity,
   plan,
   provide,
   readExport,
@@ -721,5 +830,6 @@ module.exports = {
   sync,
   targetBindingStatus,
   verify,
+  verifyArtifactRelease: artifacts.verifyArtifactRelease,
   verifyContext: traversal.verifyContext,
 };

package/profiles/implementation-control/profile.json

@@ -47,7 +47,9 @@
     "review",
     "release_gate",
     "kaizen_item",
-    "evidence"
+    "evidence",
+    "regression_case",
+    "lesson"
   ],
   "allowed_relation_types": [
     "derives_projection",

package/profiles/project-management/profile.json

@@ -12,7 +12,14 @@
     "milestone",
     "stakeholder",
     "evidence",
-    "governance_gate"
+    "governance_gate",
+    "project_dna",
+    "stage",
+    "batch",
+    "requirement",
+    "method",
+    "lesson",
+    "regression_case"
   ],
   "allowed_relation_types": [
     "depends_on",

package/releases/1.2.0.md

@@ -0,0 +1,19 @@
+# Mirai Graph 1.2.0
+
+Mirai Graph 1.2.0 adds portable project continuity to the existing Project
+Technology mechanism.
+
+Verified outcomes, requirements, evidence and reusable cases can now be stored
+in `graph/specs` and discovered automatically by a later task. The mechanism
+does not store chat transcripts and does not introduce a second memory database.
+
+Mutable receipts and rollback data remain on the current host. Git repositories
+and ordinary shared folders use the same canonical graph contract; shared-folder
+writes additionally use a lease and compare-and-swap digest.
+
+Goals, architectural decisions and owner or source-of-truth changes remain
+proposals until explicitly accepted. A generated context document remains a
+readable projection rather than a source of truth or write authorization.
+
+`graph.json` remains schema `2.0.0` and
+`mirai.project_technology.contract_version` remains `1.0.0`.

package/releases/1.3.0.md

@@ -0,0 +1,16 @@
+# Mirai Graph 1.3.0
+
+Mirai Graph 1.3.0 adds generic immutable releases for file bundles to the
+existing Project Technology engine.
+
+Projects can inspect a bundle, preview or create a release, compare two
+releases and verify stored files against their manifest. The graph stores only
+safe lineage, state, references and checksums; protected artifact content
+remains outside graph data.
+
+The release supports direct files, directories, ZIP, TAR and TAR.GZ, with
+fail-closed archive checks, transactional activation, rollback, concurrency
+protection and idempotent repeats.
+
+The public `graph.json` schema remains `2.0.0`. The Project Technology
+activation contract remains `1.0.0`.

package/releases/README.md

@@ -15,9 +15,12 @@ Release notes must separate:
 
 ## Release Notes
 
+- [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
   verification in Project Technology.
 - [v1.0.0](1.0.0.md) - stable Project Technology, CLI and public contract.
+- [v1.3.0](1.3.0.md) - immutable artifact releases in Project Technology.
 - [v1.0.0-rc.6](1.0.0-rc.6.md) - anti-drift / quality-control release
   consolidation across Semantic Intent, Dynamic Episode, Goal Vector and
   Technology Quality Feedback.

package/schemas/project-technology-extension.schema.json

@@ -9,6 +9,7 @@
     "contract_version": { "const": "1.0.0" },
     "enabled": { "type": "boolean" },
     "context_policy": { "const": "task_scoped" },
-    "source_boundary": { "const": "hybrid_sot" }
+    "source_boundary": { "const": "hybrid_sot" },
+    "continuity_policy": { "enum": ["task_boundary"] }
   }
 }

package/standard/context-pack-generation.md

@@ -1,6 +1,6 @@
 # Mirai Graph Context-Pack Generation
 
-Status: 1.1 stable standard section
+Status: 1.2 stable standard section
 
 ## Purpose
 
@@ -56,7 +56,7 @@ task -> select relevant objects -> select relevant relations
      -> generate context pack -> review/use for task
 ```
 
-Project Technology 1.1 implements this as a deterministic four-phase protocol:
+Project Technology implements this as a deterministic four-phase protocol:
 
 ```text
 discover -> expand -> compile -> verify
@@ -168,6 +168,12 @@ Generated context packs may be reviewed and then used as evidence or source
 material for graph updates. They do not automatically mutate canonical graph
 state.
 
+With `continuity_policy: task_boundary`, accepted continuity objects in
+`graph/specs` participate in the same traversal as every other graph object.
+Relevant previous cases can therefore be found without reading chat history or
+requiring a user to say "continue". Host-local receipts never enter a context
+pack and never become portable authority.
+
 ## Anti-Patterns
 
 - Treating a generated context pack as the graph.

package/standard/object-model.md

@@ -112,11 +112,17 @@ Initial core kinds:
 - `resource`, `source`;
 - `check`, `gate`, `constraint`;
 - `access_requirement`.
+- `project_dna`, `stage`, `batch`;
+- `method`, `lesson`, `regression_case`.
 
 The additional domain-neutral kinds support Project Technology traversal. A
 consumer may display them using its own vocabulary without changing their
 canonical meaning.
 
+Portable continuity uses these existing domain-neutral kinds. A verified task
+result is evidence plus a regression case; an inferred reusable method remains
+a lesson proposal until its promotion rule is satisfied.
+
 ## Object Boundary Rules
 
 An object should be created when the item needs at least one of:

package/standard/project-technology.md

@@ -1,6 +1,6 @@
 # Project Technology
 
-Status: 1.1 stable standard; activation contract remains 1.0.0
+Status: 1.3 stable standard; activation contract remains 1.0.0
 
 Project Technology is the shared executable mechanism of Mirai Graph. It is
 not a profile, a second graph or a source of domain methodology.
@@ -19,6 +19,71 @@ Each graph keeps its own objects and relations. Project Technology only
 standardizes safe inventory, task context, accepted-target binding, freshness
 and verification.
 
+## Immutable Artifact Releases
+
+Project Technology can preserve versioned file bundles without turning their
+contents into graph data:
+
+```text
+inspect -> release preview -> transactional release -> compare -> verify
+```
+
+The generic CLI is:
+
+```bash
+mirai-graph technology artifact inspect . --input incoming.zip
+mirai-graph technology artifact release . --input incoming.zip --matter-id agreement-main --direction inbound
+mirai-graph technology artifact release . --input incoming.zip --matter-id agreement-main --direction inbound --apply
+mirai-graph technology artifact compare . --matter-id agreement-main --base-release 20260828-01 --target-release 20260828-02
+mirai-graph technology artifact verify . --matter-id agreement-main --release-id 20260828-02
+```
+
+The programmatic API exposes `inspectArtifactBundle`,
+`createArtifactRelease`, `compareArtifactReleases` and
+`verifyArtifactRelease`.
+
+Each immutable release keeps the original input, a normalized package, a
+hash-bound manifest and a technical comparison. The portable registry at
+`graph/specs/artifact-releases.json` stores only opaque matter/release ids,
+relative or provider refs, lineage, state and digests. Raw files, document
+contents, party names and private discussion remain in the protected artifact
+store.
+
+Direct files, directories, ZIP, TAR and TAR.GZ are supported. Unsafe paths,
+links, encrypted archives, executable or macro-enabled files, nested archives,
+normalized path collisions and configured archive limits fail closed. RAR and
+7z need an explicitly supplied safe provider.
+
+Creation uses a lease, compare-and-swap registry digest, temporary assembly,
+atomic activation and readback. Repeating the same release returns
+`changed=false`. Domain consumers own the meaning of release states; Mirai
+Graph owns only generic identity, lineage, integrity and technical comparison.
+
+## Portable Project Continuity
+
+Project Technology preserves verified project experience at task boundaries:
+
+```text
+task context -> verified outcome -> semantic candidate -> graph/specs
+             -> next task context -> usage verification
+```
+
+`graph/specs` is the portable authority. Chat history and local workflow files
+are not required by another person or installation. Mutable receipts and
+rollback data are stored outside the project in a host-local directory keyed by
+`graph.id`.
+
+The existing `sync` operation accepts `task_start`, `stage_complete` and
+`task_complete`. Task start is read-only. A completed stage or task requires a
+verified, requirement-bound input and records accepted evidence plus one
+reusable regression case. New goals, architectural decisions and ownership
+changes remain proposals.
+
+Two independent verified cases with the same signature may promote a method
+lesson when they do not change architecture. Repeated input is byte-identical
+and returns `changed=false`. Shared folders without Git additionally use a
+lease, compare-and-swap graph digest, backup, atomic write and readback.
+
 ## Sequential Context Traversal
 
 Project Technology exposes one model-independent navigation protocol:
@@ -59,13 +124,15 @@ The only manifest extension key is `mirai.project_technology`:
   "contract_version": "1.0.0",
   "enabled": true,
   "context_policy": "task_scoped",
-  "source_boundary": "hybrid_sot"
+  "source_boundary": "hybrid_sot",
+  "continuity_policy": "task_boundary"
 }
 ```
 
 Canonical graph objects remain in `graph/specs`. Exact external revisions
-remain in `graph.lock.json`. Mutable local state is ignored under
-`.mirai-graph/project-technology/`.
+remain in `graph.lock.json`. Mutable continuity state is host-local and keyed
+by graph identity; project-local runtime directories are not continuity
+authority.
 
 The only generated provider artifact is:
 
@@ -106,6 +173,14 @@ source still answers "how should the domain work be done?".
   diagnostic `verify` calls.
 - Context traversal is read-only in every phase and never grants write
   authority.
+- Chat text, secrets, private source, user paths and unverified assumptions are
+  rejected from portable continuity.
+- Significant work with an enabled continuity policy fails closed when its
+  terminal receipt is missing or stale.
+- Artifact inspection, comparison and verification are read-only. Release
+  creation is preview-only without `--apply`.
+- An artifact manifest or generated export never proves legal, business or
+  domain acceptance.
 - A context pack is not ready while a required branch, source, access boundary
   or validator is missing, stale, blocked, deprecated, conflicting or
   digest-mismatched.