mirai-graph 1.1.1 → 1.2.0

package/.github/workflows/ci.yml

@@ -26,6 +26,9 @@ jobs:
       - name: Verify deterministic context traversal
         run: node packages/cli/validate-context-traversal.js
 
+      - name: Verify portable project continuity
+        run: node packages/cli/validate-project-continuity.js
+
   release-check:
     runs-on: ubuntu-latest
 

package/CHANGELOG.md

@@ -4,6 +4,34 @@ All notable changes to Mirai Graph will be documented in this file.
 
 ## [Unreleased]
 
+## [1.2.0] - 2026-08-27
+
+### Added
+
+- Portable project continuity in the existing Project Technology `sync`,
+  `context` and `verify` operations.
+- Task-boundary evidence compaction into accepted facts, evidence, reusable
+  regression cases and bounded proposals in `graph/specs`.
+- Host-local receipts keyed by graph identity, with lease, compare-and-swap,
+  backup, atomic write, readback and rollback support for shared non-Git folders.
+- Automatic discovery of relevant previous cases through the existing context
+  traversal protocol.
+
+### Safety Boundary
+
+- Chat transcripts, secrets, private source, user paths and unverified claims
+  are not portable project memory.
+- New goals, architecture changes and ownership changes remain proposals.
+- Generated human context is a projection only and never authorizes writes.
+- The public `graph.json` schema and Project Technology activation contract
+  remain `2.0.0` and `1.0.0` respectively.
+
+### Verification
+
+- New fixtures cover Git and non-Git projects, two-installation portability,
+  idempotence, stale receipts, concurrent-write protection, secret rejection,
+  proposal boundaries and two-case method promotion.
+
 ## [1.1.1] - 2026-08-26
 
 ### Fixed

package/CITATION.cff

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

package/README.md

@@ -10,7 +10,7 @@ Use it when a software project has useful knowledge spread across README files,
 docs, issues, chats, code comments and AI prompts, and you need a small
 machine-readable map that developers and AI assistants can validate and reuse.
 
-Status: stable public `1.1.0` release.
+Status: stable public `1.2.0` release.
 
 ## What Problem Does It Solve?
 
@@ -42,7 +42,7 @@ Start with a normal repository and use Mirai Graph to:
 
 ## Current Installation Status
 
-The repository is ready as the stable `mirai-graph@1.1.0` package. To verify a
+The repository provides the stable `mirai-graph@1.2.0` package. To verify a
 repository checkout directly, use:
 
 ```bash
@@ -96,7 +96,8 @@ Enable it in the existing root manifest:
       "contract_version": "1.0.0",
       "enabled": true,
       "context_policy": "task_scoped",
-      "source_boundary": "hybrid_sot"
+      "source_boundary": "hybrid_sot",
+      "continuity_policy": "task_boundary"
     }
   }
 }
@@ -130,6 +131,17 @@ The programmatic API exposes the same operations as `discoverContext`,
 `expandContext`, `compileContext` and `verifyContext`. Mirai Graph does not call
 or depend on a particular AI model.
 
+Verified project experience can be saved without storing a chat transcript:
+
+```bash
+mirai-graph technology sync . --boundary task_complete --evidence continuity-evidence.json
+mirai-graph technology sync . --boundary task_complete --evidence continuity-evidence.json --apply
+```
+
+Accepted facts and reusable cases live in `graph/specs`; mutable receipts and
+rollback data stay host-local. The same contract works in Git repositories and
+ordinary shared folders.
+
 Changing operations return a preview unless `--apply` is explicit. See
 [Project Technology](standard/project-technology.md) for provider/consumer
 binding, local state and safety boundaries.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mirai-graph",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "private": false,
   "description": "An evolutionary graph operating model for managing the growth of complex systems.",
   "license": "MIT",
@@ -13,9 +13,10 @@
     "./project-technology": "./packages/project-technology/index.js"
   },
   "scripts": {
-    "pretest": "npm run test:project-technology && npm run test:context-traversal && npm run validate:project-technology-schemas",
+    "pretest": "npm run test:project-technology && npm run test:context-traversal && npm run test:project-continuity && npm run validate:project-technology-schemas",
     "test:project-technology": "node packages/cli/validate-project-technology.js",
     "test:context-traversal": "node packages/cli/validate-context-traversal.js",
+    "test:project-continuity": "node packages/cli/validate-project-continuity.js",
     "validate:project-technology-schemas": "node -e \"const fs=require('fs'); for (const file of ['project-technology-extension.schema.json','project-technology-target-export.schema.json','context-traversal-receipt.schema.json','context-pack.schema.json']) JSON.parse(fs.readFileSync('schemas/'+file))\"",
     "validate:graph-manifest": "node packages/cli/validate-graph-manifest-migration.js",
     "validate:minimal": "node packages/cli/validate-mirai-graph.js examples/minimal-graph",

package/packages/cli/graph-manifest.js

@@ -130,7 +130,8 @@ function validateManifest(manifest, repo = null) {
       };
       for (const field of Object.keys(expected)) if (technology[field] !== expected[field]) errors.push(`extensions.mirai.project_technology.${field} is invalid`);
       if (typeof technology.enabled !== "boolean") errors.push("extensions.mirai.project_technology.enabled is invalid");
-      for (const field of Object.keys(technology)) if (!(field in expected) && field !== "enabled") errors.push(`extensions.mirai.project_technology has unknown field ${field}`);
+      if (technology.continuity_policy !== undefined && technology.continuity_policy !== "task_boundary") errors.push("extensions.mirai.project_technology.continuity_policy is invalid");
+      for (const field of Object.keys(technology)) if (!(field in expected) && !["enabled", "continuity_policy"].includes(field)) errors.push(`extensions.mirai.project_technology has unknown field ${field}`);
     }
   }
   if (manifest.graph !== null) {

package/packages/cli/project-technology.js

@@ -13,6 +13,8 @@ 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("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>");
   console.error("         --phase expand --input <receipt.json> --select <id> [--select <id>]");
   console.error("         --phase compile --input <receipt.json> --selection <selection.json>");
@@ -25,7 +27,7 @@ function parse(argv) {
   let repository = ".";
   if (argv[0] && !argv[0].startsWith("--")) repository = argv.shift();
   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"]);
+  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"]);
   const flags = new Set(["--apply", "--refresh-binding", "--significant-work"]);
   const names = {
     "--task": "task", "--source": "source", "--target-id": "targetId",
@@ -36,6 +38,8 @@ function parse(argv) {
     "--selection": "selectionFile", "--packet": "packetFile", "--evidence": "evidenceFile",
     "--selector": "selector", "--reason": "reason", "--confidence": "confidence",
     "--context-budget": "contextBudget",
+    "--boundary": "boundary", "--expected-graph-digest": "expectedGraphDigest",
+    "--receipt-digest": "receiptDigest", "--state-root": "stateRoot",
   };
   while (argv.length) {
     const token = argv.shift();
@@ -57,6 +61,11 @@ function readJsonFile(file) {
 }
 
 function hydrateContextOptions(request) {
+  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);
+    return;
+  }
   if (request.operation !== "context" || !request.options.phase) return;
   const phase = request.options.phase;
   if (!new Set(["discover", "expand", "compile", "verify"]).has(phase)) throw new Error(`unsupported context phase ${phase}`);

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

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

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

@@ -72,6 +72,18 @@ function executionContract() {
   };
 }
 
+function continuityEvidence(repositoryId) {
+  return {
+    task_digest: technology.sha256(`task:${repositoryId}`, true),
+    outcome: `Exact target binding verified for ${repositoryId}`,
+    requirement_refs: ["requirement.fixture.runtime"],
+    evidence_refs: ["repo://fixture/evidence/project-technology"],
+    checks: [{ id: "check.fixture.binding", verdict: "pass", evidence_ref: "repo://fixture/evidence/project-technology" }],
+    changed_surfaces: ["graph/specs/project-continuity.json"],
+    case_signature: "case.fixture.target-binding",
+  };
+}
+
 function initRepo(root, name, scope = "repository", profiles) {
   const repo = path.join(root, name); fs.mkdirSync(repo, { recursive: true });
   git(repo, "init", "-q"); git(repo, "config", "user.name", "Mirai Fixture");
@@ -104,6 +116,7 @@ function check(id, condition, details = null) {
 }
 
 const root = fs.mkdtempSync(path.join(os.tmpdir(), "mirai-project-technology-test-"));
+process.env.MIRAI_GRAPH_STATE_ROOT = path.join(root, "host-state");
 try {
   const provider = initRepo(root, "fixture-provider", "repository");
   const consumer = initRepo(root, "fixture-consumer", "repository");
@@ -112,6 +125,11 @@ try {
   const federation = initRepo(root, "fixture-federation", "federation", ["project_management", "implementation_control"]);
   const providerRevision = addTarget(provider);
 
+  const legacyRuntimeRepo = initRepo(root, "legacy-runtime-repository");
+  writeJson(path.join(legacyRuntimeRepo, ".mirai-graph/project-technology/inventory.json"), { schema_version: "1.0.0", repository_id: "legacy-runtime-repository", inventory_digest: `sha256:${"0".repeat(64)}`, files: [] });
+  const legacyRuntimeEnabled = technology.execute("enable", legacyRuntimeRepo, { apply: true });
+  check("project_local_runtime_moves_to_host_state", legacyRuntimeEnabled.status === "success" && legacyRuntimeEnabled.migration_ref.startsWith("host-local://") && fs.existsSync(path.join(legacyRuntimeRepo, ".mirai-graph/project-technology/inventory.json")), legacyRuntimeEnabled);
+
   const before = fs.readFileSync(path.join(consumer, "graph.json"));
   const preview = technology.execute("enable", consumer, { apply: false });
   check("preview_is_zero_write", preview.status === "preview" && fs.readFileSync(path.join(consumer, "graph.json")).equals(before));
@@ -147,12 +165,18 @@ try {
     apply: true, source: exportPath, targetId: TARGET_ID,
     semanticDigest: SEMANTIC_DIGEST, providerRevision,
   });
-  check("consumer_binding_ready", connected.status === "success" && technology.verify(consumer, { significantWork: true }).status === "success", connected.blockers);
+  const consumerContinuity = technology.execute("sync", consumer, {
+    apply: true, boundary: "task_complete", continuityEvidence: continuityEvidence("fixture-consumer"),
+  });
+  check("consumer_binding_ready", connected.status === "success" && consumerContinuity.status === "success" && technology.verify(consumer, { significantWork: true }).status === "success", { connect: connected.blockers, continuity: consumerContinuity.blockers });
   const connectedTwo = technology.execute("connect", consumerTwo, {
     apply: true, source: exportPath, targetId: TARGET_ID,
     semanticDigest: SEMANTIC_DIGEST, providerRevision,
   });
-  check("second_consumer_binding_ready", connectedTwo.status === "success" && technology.verify(consumerTwo, { significantWork: true }).status === "success", connectedTwo.blockers);
+  const consumerTwoContinuity = technology.execute("sync", consumerTwo, {
+    apply: true, boundary: "task_complete", continuityEvidence: continuityEvidence("fixture-consumer-two"),
+  });
+  check("second_consumer_binding_ready", connectedTwo.status === "success" && consumerTwoContinuity.status === "success" && technology.verify(consumerTwo, { significantWork: true }).status === "success", { connect: connectedTwo.blockers, continuity: consumerTwoContinuity.blockers });
   const repeated = technology.execute("connect", consumer, {
     apply: true, source: exportPath, targetId: TARGET_ID,
     semanticDigest: SEMANTIC_DIGEST, providerRevision,

package/packages/project-technology/context-traversal.js

@@ -63,18 +63,27 @@ function trackedState(repo) {
   const trackedRun = spawnSync("git", ["ls-files", "-z"], { cwd: repo, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
   const dirtyRun = spawnSync("git", ["diff", "--name-only", "-z", "HEAD", "--"], { cwd: repo, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
   return {
+    hasGit: Boolean(git(repo, "rev-parse", "--is-inside-work-tree")),
     tracked: new Set(trackedRun.status === 0 ? trackedRun.stdout.split("\0").filter(Boolean) : []),
     dirty: new Set(dirtyRun.status === 0 ? dirtyRun.stdout.split("\0").filter(Boolean) : []),
   };
 }
 
 function graphBlob(graph, relative) {
+  if (!graph.hasGit) {
+    const absolute = path.join(graph.repo, relative);
+    return fs.existsSync(absolute) && !fs.lstatSync(absolute).isSymbolicLink() && fs.statSync(absolute).isFile() ? fs.readFileSync(absolute) : null;
+  }
   if (!graph.tracked?.has(relative) || graph.dirty?.has(relative)) return null;
   if (!graph.blobCache.has(relative)) graph.blobCache.set(relative, gitBlob(graph.repo, relative));
   return graph.blobCache.get(relative);
 }
 
 function revisionBound(repo, relative) {
+  if (!git(repo, "rev-parse", "--is-inside-work-tree")) {
+    const absolute = path.join(repo, relative);
+    return fs.existsSync(absolute) && !fs.lstatSync(absolute).isSymbolicLink() && fs.statSync(absolute).isFile();
+  }
   if (!gitBlob(repo, relative)) return false;
   return spawnSync("git", ["diff", "--quiet", "HEAD", "--", relative], { cwd: repo }).status === 0;
 }
@@ -197,19 +206,25 @@ function readGraph(repoArg) {
     if (!objects.has(relation.source) || !objects.has(relation.target)) { output.blockers.push("relation_endpoint_missing"); continue; }
     relations.push({ ...relation, _record: record });
   }
-  const revision = git(repo, "rev-parse", "HEAD") || null;
   const state = trackedState(repo);
-  for (const relative of unique([
+  const graphSources = unique([
     "graph.json",
     ...[...objects.values()].map((record) => record.relative),
     ...relations.map((relation) => relation._record.relative),
-  ])) if (!state.tracked.has(relative) || state.dirty.has(relative)) output.blockers.push("graph_source_not_revision_bound");
-  const graphPayload = {
+  ]);
+  const newContentBoundGraph = state.hasGit
+    && graphSources.length > 0
+    && graphSources.every((relative) => !state.tracked.has(relative))
+    && graphSources.every((relative) => !state.dirty.has(relative));
+  for (const relative of graphSources) if (state.hasGit && !newContentBoundGraph && (!state.tracked.has(relative) || state.dirty.has(relative))) output.blockers.push("graph_source_not_revision_bound");
+  const gitRevision = !newContentBoundGraph ? git(repo, "rev-parse", "HEAD") || null : null;
+  const graphPayloadBase = {
     manifest: { id: manifest.id, scope: manifest.scope, profiles: manifest.profiles, graph: manifest.graph },
     objects: [...objects.values()].map((record) => record.value).sort((a, b) => a.id.localeCompare(b.id)),
     relations: relations.map(({ _record, ...relation }) => relation).sort((a, b) => a.id.localeCompare(b.id)),
-    revision,
   };
+  const revision = gitRevision || `content:${digest(graphPayloadBase).slice(7)}`;
+  const graphPayload = { ...graphPayloadBase, revision };
   return {
     repo,
     manifest,
@@ -219,6 +234,7 @@ function readGraph(repoArg) {
     relations,
     tracked: state.tracked,
     dirty: state.dirty,
+    hasGit: state.hasGit,
     blobCache: new Map(),
     blockers: unique(output.blockers),
   };
@@ -638,7 +654,7 @@ function verifyContext(repository, contextPack, usageEvidence, options = {}) {
     const absolute = path.join(graph.repo, source.ref);
     if (!fs.existsSync(absolute) || fs.lstatSync(absolute).isSymbolicLink() || !fs.statSync(absolute).isFile()) blockers.push("context_pack_source_unavailable");
     else {
-      const blob = gitBlob(graph.repo, source.ref);
+      const blob = graphBlob(graph, source.ref);
       if (!blob || !revisionBound(graph.repo, source.ref) || digest(blob) !== source.sha256 || source.revision !== graph.revision) blockers.push("context_pack_source_revision_or_digest_mismatch");
     }
   }