mirai-graph 1.5.0 → 1.6.0

package/.github/workflows/ci.yml

@@ -29,6 +29,9 @@ jobs:
       - name: Verify portable project continuity
         run: node packages/cli/validate-project-continuity.js
 
+      - name: Verify local target and provider contracts
+        run: npm run test:project-technology
+
   release-check:
     runs-on: ubuntu-latest
 

package/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to Mirai Graph will be documented in this file.
 
 ## [Unreleased]
 
+## [1.6.0] - Unpublished candidate
+
+Compatible additive release for the 1.x line; intended npm channel `legacy-1`.
+The 2.x `latest` channel is not changed. Publication and independent acceptance
+are pending; no installed consumer is automatically migrated.
+
+- A valid new Git branch without its first commit can inventory only explicitly
+  declared sources. Corrupt or unavailable Git stays blocked; no revision is
+  invented and provider export still requires a real commit. The existing
+  three-platform CI matrix now includes local-target/provider regressions.
+
+- Explicitly selected local accepted targets in ordinary folders and
+  Git repositories, using the existing execution-contract validator and graph
+  reader. Independent caller-verified approval anchors prevent self-acceptance.
+- Local selection/disconnection reuse continuity lease, CAS, backup and rollback;
+  diagnostics are read-only. Semantic acceptance and source-content freshness
+  are separate; significant work requires current verification evidence.
+- `plan` now reports the same target binding as `status`, `context` and `verify`.
+  External provider identity and ancestry checks are unchanged.
+
 ## [1.5.0] - 2026-09-03
 
 Compatible 1.x maintenance line, published under `legacy-1`; the npm `latest`

package/CITATION.cff

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

package/README.md

@@ -2,6 +2,12 @@
 
 Make your project understandable to humans and AI.
 
+Local-target 1.6.0 candidate (not released): ordinary folders can select an accepted
+target without Git or a self-connected provider. The calling application must
+authenticate the owner's approval; adjacent checksums never grant authority.
+See [Project Technology](standard/project-technology.md#local-accepted-targets-candidate-extension)
+for the trust boundary, preview, verification and transactional selection.
+
 Mirai Graph turns scattered project knowledge into a structured graph of
 features, requirements, dependencies, risks, decisions, evidence and process
 gates.
@@ -10,7 +16,8 @@ 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.3.0` release.
+Status: compatible 1.x line; `1.6.0` is an unpublished candidate based on `1.5.0`.
+The separate 2.x line is not included or migrated here.
 
 ## What Problem Does It Solve?
 
@@ -42,20 +49,18 @@ Start with a normal repository and use Mirai Graph to:
 
 ## Current Installation Status
 
-The repository provides the stable `mirai-graph@1.3.0` package. To verify a
-repository checkout directly, use:
+The compatible published baseline is `mirai-graph@1.5.0` on `legacy-1`.
+Do not use an unversioned npm install to select this generation: `latest` is
+independent. To verify this candidate, use its exact reviewed checkout:
 
 ```bash
-git clone https://github.com/zabarov/mirai-graph.git
-cd mirai-graph
-npm install
 npm run release:check
 ```
 
-External projects use:
+External 1.x projects can explicitly pin the published baseline:
 
 ```bash
-npm install -D mirai-graph
+npm install --save-dev --save-exact mirai-graph@1.5.0
 ```
 
 ## Connect A Project In 10 Minutes

package/package.json

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

package/packages/cli/graph-manifest.js

@@ -131,7 +131,14 @@ 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");
       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 (technology.target_source !== undefined) {
+        const selected = technology.target_source;
+        if (!selected || typeof selected !== "object" || Array.isArray(selected) || selected.kind !== "local" ||
+            !/^[A-Za-z0-9][A-Za-z0-9._:-]{1,255}$/.test(selected.target_id || "") ||
+            !/^[A-Za-z0-9][A-Za-z0-9._:-]{1,255}$/.test(selected.acceptance_ref || "") ||
+            Object.keys(selected).some(key => !["kind", "target_id", "acceptance_ref"].includes(key))) errors.push("extensions.mirai.project_technology.target_source is invalid");
+      }
+      for (const field of Object.keys(technology)) if (!(field in expected) && !["enabled", "continuity_policy", "target_source"].includes(field)) errors.push(`extensions.mirai.project_technology has unknown field ${field}`);
     }
   }
   if (manifest.graph !== null) {

package/packages/cli/project-technology.js

@@ -14,6 +14,7 @@ function usage() {
   console.error("         --semantic-digest <sha256:...> --provider-revision <sha>");
   console.error("         --refresh-binding --significant-work --max-objects <count>");
   console.error("Archive connect: --provider-archive-trust <verified-release-anchor.json>");
+  console.error("Local target: sync --target-source <selector.json> --local-acceptance-trust <verified-owner-anchor.json> --expected-graph-digest <sha256:...> [--apply]");
   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>");
@@ -48,7 +49,11 @@ function parse(argv) {
   const values = new Set(["--task", "--source", "--target-id", "--semantic-digest", "--provider-revision", "--max-objects", "--phase", "--input", "--select", "--selection", "--packet", "--evidence", "--selector", "--reason", "--confidence", "--context-budget", "--boundary", "--expected-graph-digest", "--receipt-digest", "--state-root", "--matter-id", "--direction", "--artifact-root", "--release-date", "--release-id", "--parent-release", "--base-release", "--target-release", "--client-note", "--technology", "--scenario", "--audience", "--course-pack", "--projection"]);
   const flags = new Set(["--apply", "--refresh-binding", "--significant-work", "--create-export"]);
   values.add("--provider-archive-trust");
+  values.add("--local-acceptance-trust");
+  values.add("--target-source");
   const names = {
+    "--local-acceptance-trust": "localAcceptanceTrustFile",
+    "--target-source": "targetSourceFile",
     "--provider-archive-trust": "providerArchiveTrustFile",
     "--task": "task", "--source": "source", "--target-id": "targetId",
     "--semantic-digest": "semanticDigest", "--provider-revision": "providerRevision",
@@ -92,6 +97,12 @@ function readJsonFile(file) {
 }
 
 function hydrateContextOptions(request) {
+  if (request.options.localAcceptanceTrustFile === "-" && request.options.providerArchiveTrustFile === "-") throw new Error("only one trust input may consume stdin");
+  if (request.options.localAcceptanceTrustFile) {
+    request.options.localAcceptance = request.options.localAcceptanceTrustFile === "-"
+      ? JSON.parse(fs.readFileSync(0, "utf8")) : readJsonFile(request.options.localAcceptanceTrustFile);
+  }
+  if (request.options.targetSourceFile) request.options.targetSource = readJsonFile(request.options.targetSourceFile);
   if (request.options.providerArchiveTrustFile) {
     if (request.operation !== "connect") throw new Error("archive trust is only supported by connect");
     request.options.providerArchive = request.options.providerArchiveTrustFile === "-"

package/packages/cli/validate-local-target.js

@@ -0,0 +1,149 @@
+#!/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 t = require("../project-technology");
+const root = fs.mkdtempSync(path.join(os.tmpdir(), "mirai-local-target-"));
+const repo = path.join(root, "ordinary folder");
+const stateRoot = path.join(root, "host-a");
+const selection = {kind:"local", target_id:"target.example.delivery", acceptance_ref:"decision.example.accepted"};
+const write = (ref,value) => {const file=path.join(repo,ref);fs.mkdirSync(path.dirname(file),{recursive:true});fs.writeFileSync(file,t.canonicalBytes(value));};
+const read = ref => JSON.parse(fs.readFileSync(path.join(repo,ref)));
+const objRef = id => `graph/specs/objects/${id}.json`;
+const object = id => ({id,kind:"constraint",title:id,summary:"Bounded example",profile:"implementation_control",lifecycle:"accepted",readiness:"accepted",evidence:[]});
+const snapshot = dir => {const out={}; function walk(at){for(const name of fs.readdirSync(at).sort()){const f=path.join(at,name);if(fs.statSync(f).isDirectory())walk(f);else out[path.relative(dir,f)]=t.sha256(fs.readFileSync(f));}} walk(dir);return out;};
+const checks=[];
+function check(id,fn){fn();checks.push({id,passed:true});}
+let trust;
+const options = () => ({stateRoot,localAcceptance:trust});
+const binding = () => t.status(repo,options()).target_binding;
+function mutate(ref,change,test){const before=fs.readFileSync(path.join(repo,ref)); const v=read(ref);change(v);write(ref,v);try{test();}finally{fs.writeFileSync(path.join(repo,ref),before);}}
+try {
+  write("graph.json",{$schema:"https://mirai-graph.dev/schemas/graph-manifest.schema.json",format:"mirai-graph",schema_version:"2.0.0",id:"project.example",aliases:[],title:"Ordinary folder",scope:"repository",kind:"project_graph",owner:"owner.example",profiles:["project_management","implementation_control"],imports:[],graph:{root:"graph",source_of_truth:["graph/specs"],objects:["graph/specs/index.json"],relations:["graph/specs/relations.json"],schemas:[],generated:["graph/generated"],raw_sources:["data"]},extensions:{"mirai.project_technology":{contract_version:"1.0.0",enabled:true,context_policy:"task_scoped",source_boundary:"hybrid_sot"}}});
+  const contract={decision_refs:[selection.acceptance_ref],goal_binding:{goal_id:"goal.example",done_when_ids:["done.example"]},requirement_bindings:[{requirement_id:"requirement.example",acceptance_ids:["acceptance.example"],done_when_ids:["done.example"]}],constraint_ids:["constraint.example"],non_goal_ids:["non_goal.example"],deferred_boundary_ids:["deferred.example"],allowed_change_scope:[{repository_id:"project.example",owner_id:"owner.example",package_id:"package.example",file_patterns:["data/tools/**"],actions:["modify","test"]}],architecture_contract:{contract_ref:"contract.example",acceptance_ref:selection.acceptance_ref,architecture_owner_id:"human.example",lifecycle:"accepted",owner_ids:["owner.example"],component_ids:["component.example"],package_ids:["package.example"],capability_ids:["capability.example"],ownership_boundaries:[{subject_ref:"component.example",data_owner:"owner.example",access_owner:"owner.example",lifecycle_owner:"owner.example",interface_owner:"owner.example",runtime_owner:"owner.example"}],required_relations:[],allowed_relations:[],forbidden_relations:[],required_dependencies:[],forbidden_dependencies:[]}};
+  const ids=[selection.target_id,selection.acceptance_ref,"goal.example","done.example","requirement.example","acceptance.example","constraint.example","non_goal.example","deferred.example","contract.example"];
+  for(const id of ids)write(objRef(id),object(id));
+  write("graph/specs/index.json",{object_files:ids.map(id=>`objects/${id}.json`)});
+  write("graph/specs/relations.json",[]);
+  fs.mkdirSync(path.join(repo,"data/tools"),{recursive:true});fs.writeFileSync(path.join(repo,"data/tools/method.txt"),"A bounded public method.\n");
+  const target={...object(selection.target_id),kind:"contract",tz_role:"contract",provider_execution_contract:contract,source_refs:["data/tools/method.txt"]};
+  write(objRef(selection.target_id),target);
+  const candidate=t.plan(repo,{stateRoot,targetSource:selection}).target_binding;
+  assert(candidate.semantic_digest);
+  target.semantic_digest=candidate.semantic_digest;target.content_revision=candidate.content_revision;write(objRef(selection.target_id),target);
+  const decision={...object(selection.acceptance_ref),kind:"decision",subtype:"architecture_baseline_acceptance",graph_id:"project.example",target_id:selection.target_id,owner_id:"human.example",semantic_digest:candidate.semantic_digest,execution_contract_digest:candidate.execution_contract_digest,approval_ref:"approval.example.owner"};
+  write(objRef(selection.acceptance_ref),decision);
+  // Synthetic authority fixture: independent trusted input is held outside
+  // the project and frozen before tamper tests. Production must verify issuer.
+  trust={graphId:"project.example",targetId:selection.target_id,ownerId:"human.example",decisionSha256:t.sha256(t.canonicalBytes(decision))};
+  check("selection_preview_zero_write",()=>{const before=snapshot(root);const r=t.execute("sync",repo,{...options(),targetSource:selection});assert.equal(r.status,"preview");assert.equal(r.target_binding.status,"ready");assert.deepEqual(snapshot(root),before);});
+  check("selection_requires_cas",()=>assert(t.execute("sync",repo,{...options(),apply:true,targetSource:selection}).blockers.includes("local_target_compare_and_swap_conflict")));
+  check("ordinary_folder_selects_without_git",()=>{const r=t.execute("sync",repo,{...options(),apply:true,targetSource:selection,expectedGraphDigest:t.continuity.graphDigest(repo)});assert.equal(r.status,"success",JSON.stringify(r));assert.equal(r.changed,true);assert(!fs.existsSync(path.join(repo,".git")));});
+  check("ready_exact_local_identity",()=>{assert.equal(binding().status,"ready",JSON.stringify(binding()));assert.equal(binding().source_kind,"local");assert.equal(binding().provider_revision,undefined);});
+  check("status_plan_context_verify_agree_and_read_only",()=>{const before=snapshot(root);for(const op of ["status","plan","context","verify"]){const r=t.execute(op,repo,{...options(),significantWork:true,task:"Bounded example"});assert.equal(r.target_binding.status,"ready",JSON.stringify(r));}assert.deepEqual(snapshot(root),before);});
+  check("asserted_accepted_is_not_trust",()=>assert(t.status(repo,{stateRoot}).target_binding.blockers.includes("local_target_acceptance_unverified")));
+  check("two_hosts_same_target_identity",()=>assert.deepEqual(t.status(repo,{...options(),stateRoot:path.join(root,"host-b")}).target_binding,binding()));
+  check("repeat_selection_byte_identical",()=>{const before=snapshot(root);const r=t.execute("sync",repo,{...options(),apply:true,targetSource:selection,expectedGraphDigest:t.continuity.graphDigest(repo)});assert.equal(r.changed,false);assert.deepEqual(snapshot(root),before);});
+  for(const lifecycle of ["draft","reviewed","stale","deprecated","blocked"]){check(`reject_${lifecycle}`,()=>mutate(objRef(selection.target_id),v=>v.lifecycle=lifecycle,()=>assert.equal(binding().status,"blocked")));}
+  check("unapproved_semantic_change",()=>mutate(objRef("requirement.example"),v=>v.summary="Different meaning",()=>assert(binding().blockers.includes("local_target_semantic_digest_mismatch"))));
+  check("rehashed_decision_is_not_trusted",()=>mutate(objRef(selection.acceptance_ref),v=>v.approval_ref="approval.other",()=>assert(binding().blockers.includes("local_target_acceptance_unverified"))));
+  check("foreign_owner",()=>mutate(objRef(selection.acceptance_ref),v=>v.owner_id="human.other",()=>assert(binding().blockers.includes("local_target_acceptance_identity_mismatch"))));
+  for(const key of ["requirement_bindings","allowed_change_scope","non_goal_ids","constraint_ids","deferred_boundary_ids"]){check(`empty_${key}`,()=>mutate(objRef(selection.target_id),v=>v.provider_execution_contract[key]=[],()=>assert.equal(binding().status,"blocked")));}
+  check("scope_owner_unapproved",()=>mutate(objRef(selection.target_id),v=>v.provider_execution_contract.allowed_change_scope[0].owner_id="owner.other",()=>assert(binding().blockers.includes("provider_contract_scope_owner_unapproved"))));
+  check("duplicate_target",()=>mutate("graph/specs/index.json",v=>{write("graph/specs/duplicate.json",target);v.object_files.push("duplicate.json");},()=>assert(binding().blockers.includes("duplicate_object_id"))));
+  fs.unlinkSync(path.join(repo,"graph/specs/duplicate.json"));
+  check("required_cycle",()=>mutate("graph/specs/relations.json",v=>v.push({id:"relation.cycle",type:"requires",source:selection.target_id,target:selection.target_id,lifecycle:"accepted"}),()=>assert(binding().blockers.includes("local_target_required_cycle"))));
+  check("private_path_rejected",()=>mutate(objRef(selection.target_id),v=>v.source_refs=["source/private/method.txt"],()=>assert(binding().blockers.includes("local_target_source_unsafe_or_missing"))));
+  check("parent_traversal_rejected",()=>mutate(objRef(selection.target_id),v=>v.source_refs=["../outside.txt"],()=>assert(binding().blockers.includes("local_target_source_unsafe_or_missing"))));
+  check("malformed_source_refs_fail_closed",()=>mutate(objRef(selection.target_id),v=>v.source_refs={ref:"data/tools/method.txt"},()=>assert(binding().blockers.includes("local_target_source_refs_invalid"))));
+  check("tool_drift_not_semantic_acceptance",()=>{const file=path.join(repo,"data/tools/method.txt");const before=fs.readFileSync(file);fs.writeFileSync(file,"Changed tool\n");try{const b=binding();assert(b.blockers.includes("local_target_content_stale"));assert(!b.blockers.includes("local_target_semantic_digest_mismatch"));}finally{fs.writeFileSync(file,before);}});
+  check("external_binding_never_falls_back",()=>{const file=path.join(t.continuity.stateRoot(repo,read("graph.json"),options()),"target-provider-binding.json");fs.writeFileSync(file,"{}");try{assert(binding().blockers.includes("local_external_target_conflict"));}finally{fs.unlinkSync(file);}});
+  check("disabled_blocks_significant_verify",()=>mutate("graph.json",v=>v.extensions["mirai.project_technology"].enabled=false,()=>assert(t.verify(repo,{...options(),significantWork:true}).blockers.includes("project_technology_disabled"))));
+  check("shared_lease_conflict_preserves_bytes",()=>{const file=path.join(repo,"graph/.project-technology-continuity.lock");fs.writeFileSync(file,"occupied");const before=snapshot(root);try{assert(t.execute("sync",repo,{...options(),apply:true,targetSource:selection,expectedGraphDigest:t.continuity.graphDigest(repo)}).blockers.includes("continuity_lease_conflict"));assert.deepEqual(snapshot(root),before);}finally{fs.unlinkSync(file);}});
+  check("offline_stale_cas_blocks",()=>assert(t.execute("sync",repo,{...options(),apply:true,targetSource:selection,expectedGraphDigest:"sha256:"+"0".repeat(64)}).blockers.includes("local_target_compare_and_swap_conflict")));
+  check("selection_failure_rolls_back_project",()=>{
+    const manifest=read("graph.json");const unselected=structuredClone(manifest);delete unselected.extensions["mirai.project_technology"].target_source;write("graph.json",unselected);
+    const before=snapshot(repo);const rename=fs.renameSync;let injected=false;
+    fs.renameSync=(from,to)=>{const result=rename(from,to);if(!injected&&String(to)===path.join(repo,"graph.json")){injected=true;throw new Error("fixture failure after manifest rename");}return result;};
+    try{const r=t.execute("sync",repo,{...options(),apply:true,targetSource:selection,expectedGraphDigest:t.continuity.graphDigest(repo)});assert(r.blockers.includes("local_target_rollback_applied"),JSON.stringify(r));assert.deepEqual(snapshot(repo),before);}finally{fs.renameSync=rename;write("graph.json",manifest);}
+  });
+  check("cli_local_trust_and_plan",()=>{
+    const file=path.join(root,"owner-trust.json");fs.writeFileSync(file,JSON.stringify(trust));
+    const r=spawnSync(process.execPath,[path.join(__dirname,"project-technology.js"),"plan",repo,"--local-acceptance-trust",file,"--state-root",stateRoot],{encoding:"utf8"});
+    assert.equal(r.status,0,r.stderr);assert.equal(JSON.parse(r.stdout).target_binding.status,"ready");
+  });
+  check("missing_verification_blocks_execution_not_diagnostics",()=>{
+    assert(t.verify(repo,{...options(),significantWork:true}).blockers.includes("local_target_verification_missing"));
+    assert(t.context(repo,{...options(),significantWork:true,task:"Bounded example"}).blockers.includes("local_target_verification_missing"));
+    assert.equal(t.plan(repo,options()).target_binding.status,"ready");
+  });
+  const evidence={task_digest:t.sha256("verified local fixture",true),outcome:"Verified bounded local method",requirement_refs:["requirement.example"],evidence_refs:["data/tools/method.txt"],checks:[{id:"check.example",verdict:"pass",evidence_ref:"data/tools/method.txt"}],changed_surfaces:["data/tools/method.txt"]};
+  check("verified_boundary_unlocks_significant_verify",()=>{
+    const r=t.execute("sync",repo,{...options(),apply:true,boundary:"stage_complete",continuityEvidence:evidence,expectedGraphDigest:t.continuity.graphDigest(repo)});
+    assert.equal(r.status,"success",JSON.stringify(r));
+    const v=t.verify(repo,{...options(),significantWork:true});assert.equal(v.status,"success",JSON.stringify(v));
+  });
+  check("repointing_content_pin_does_not_refresh_verification",()=>{
+    const file=path.join(repo,"data/tools/method.txt");const before=fs.readFileSync(file);fs.writeFileSync(file,"A newly checked method needs fresh evidence.\n");
+    try{mutate(objRef(selection.target_id),v=>v.content_revision=binding().content_revision,()=>{
+      assert.equal(binding().status,"ready");
+      assert(t.verify(repo,{...options(),significantWork:true}).blockers.includes("local_target_verification_stale"));
+    });}finally{fs.writeFileSync(file,before);}
+  });
+  check("two_hosts_same_context_discovery_digest",()=>{
+    const a=t.context(repo,{...options(),task:"Bounded example"});const b=t.context(repo,{...options(),stateRoot:path.join(root,"host-b"),task:"Bounded example"});
+    assert.deepEqual(a.traversal_receipt,b.traversal_receipt);
+    assert(t.verify(repo,{...options(),stateRoot:path.join(root,"host-b"),significantWork:true}).blockers.includes("local_target_verification_missing"));
+  });
+  // Optional synthetic fixture for consumer integration tests; never real data.
+  if(process.env.MIRAI_LOCAL_TARGET_FIXTURE_EXPORT){
+    const output=path.resolve(process.env.MIRAI_LOCAL_TARGET_FIXTURE_EXPORT);
+    fs.mkdirSync(output,{recursive:true});
+    for(const name of ["project","state","owner-trust.json"])assert(!fs.existsSync(path.join(output,name)),"fixture destination must be empty");
+    fs.cpSync(repo,path.join(output,"project"),{recursive:true});fs.cpSync(stateRoot,path.join(output,"state"),{recursive:true});
+    fs.writeFileSync(path.join(output,"owner-trust.json"),t.canonicalBytes(trust));
+  }
+  check("local_disconnect_transaction_and_repeat",()=>{
+    const r=t.execute("disconnect",repo,{...options(),apply:true,expectedGraphDigest:t.continuity.graphDigest(repo)});
+    assert.equal(r.status,"success",JSON.stringify(r));assert.equal(r.changed,true);assert.equal(binding().status,"not_configured");assert(r.rollback_ref);
+    const before=snapshot(root);assert.equal(t.execute("disconnect",repo,{...options(),apply:true}).changed,false);assert.deepEqual(snapshot(root),before);
+    assert.equal(t.execute("sync",repo,{...options(),apply:true,targetSource:selection,expectedGraphDigest:t.continuity.graphDigest(repo)}).status,"success");
+  });
+  const unborn=path.join(root,"new Git project");fs.cpSync(repo,unborn,{recursive:true});
+  assert.equal(spawnSync("git",["init","-q",unborn]).status,0);
+  check("unborn_inventory_declared_sources_and_zero_write",()=>{
+    const before=snapshot(unborn);const inv=t.inventory(unborn);
+    assert.deepEqual(inv.blockers||[],[]);assert.equal(inv.revision,null);
+    assert(inv.files.some(f=>f.path==="data/tools/method.txt"));assert.deepEqual(snapshot(unborn),before);
+  });
+  check("unborn_sync_and_repeat",()=>{
+    assert.equal(t.execute("sync",unborn,{...options(),apply:true}).status,"success");
+    const before=snapshot(unborn);assert.equal(t.execute("sync",unborn,{...options(),apply:true}).changed,false);assert.deepEqual(snapshot(unborn),before);
+  });
+  const headFile=path.join(unborn,".git/HEAD");const headBytes=fs.readFileSync(headFile);
+  check("invalid_detached_head_not_unborn",()=>{
+    fs.writeFileSync(headFile,"f".repeat(40)+"\n");
+    try{assert(t.inventory(unborn).blockers.includes("inventory_git_unavailable"));}finally{fs.writeFileSync(headFile,headBytes);}
+  });
+  check("corrupt_symbolic_branch_not_unborn",()=>{
+    const ref=headBytes.toString().trim().replace(/^ref: /,"");const file=path.join(unborn,".git",ref);fs.mkdirSync(path.dirname(file),{recursive:true});fs.writeFileSync(file,"not-a-commit\n");
+    try{assert(t.inventory(unborn).blockers.includes("inventory_git_unavailable"));}finally{fs.unlinkSync(file);}
+  });
+  check("corrupt_index_not_unborn",()=>{
+    const file=path.join(unborn,".git/index");fs.writeFileSync(file,"broken index");
+    try{assert(t.inventory(unborn).blockers.includes("inventory_git_unavailable"));}finally{fs.unlinkSync(file);}
+  });
+  check("unavailable_git_not_unborn",()=>{
+    const prior=process.env.PATH;process.env.PATH=path.join(root,"no-tools");
+    try{assert(t.inventory(unborn).blockers.includes("inventory_git_unavailable"));}finally{process.env.PATH=prior;}
+  });
+  check("unborn_provider_does_not_invent_revision",()=>{
+    const r=t.execute("provide",unborn,{...options(),apply:true,targetId:selection.target_id,semanticDigest:target.semantic_digest,providerRevision:"a".repeat(40)});
+    assert.notEqual(r.status,"success");
+  });
+  check("git_equivalent_identity",()=>{const before=binding();for(const args of [["init","-q"],["config","user.name","Fixture"],["config","user.email","fixture@example.invalid"],["add","."],["commit","-qm","accepted fixture"]])assert.equal(spawnSync("git",args,{cwd:repo}).status,0);assert.deepEqual(binding(),before);});
+  console.log(JSON.stringify({status:"success",checks_passed:checks.length,checks},null,2));
+} finally {fs.rmSync(root,{recursive:true,force:true});}

package/packages/project-technology/continuity.js

@@ -406,6 +406,8 @@ module.exports = {
   digest,
   graphDigest,
   latestReceipt,
+  lock,
+  releaseLock,
   normalizeEvidence,
   stateRoot,
   status,

package/packages/project-technology/index.js

@@ -456,9 +456,9 @@ function inventory(repo) {
   const entries = [];
   const blockers = [];
   let files = trackedFiles(repo);
-  const revision = git(repo, "rev-parse", "HEAD") || null;
+  const revision = git(repo, "rev-parse", "--verify", "HEAD^{commit}") || null;
   if (!revision) {
-    if (fs.existsSync(path.join(repo, ".git"))) blockers.push("inventory_git_unavailable");
+    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.
@@ -506,7 +506,20 @@ function inventory(repo) {
   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);
@@ -529,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"] }; }
@@ -586,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",
   });
@@ -599,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",
@@ -611,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` });
 }
 
@@ -624,7 +777,7 @@ function enable(repoArg, options = {}) {
   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);
@@ -655,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, ...(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) {
@@ -688,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);
@@ -748,6 +954,7 @@ function connect(repoArg, options = {}) {
   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 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);
@@ -809,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");
@@ -883,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,

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,8 @@ 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

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 }
+      }
+    }
   }
 }

package/standard/project-technology.md

@@ -1,5 +1,74 @@
 # Project Technology
 
+## Local accepted targets (candidate extension)
+
+Local targets use the same execution-contract normalizer as external providers.
+They do not need Git or a self-connected provider. The optional manifest
+`extensions.mirai.project_technology.target_source` contains exactly
+`{kind:"local", target_id, acceptance_ref}`. It selects existing `graph/specs`
+objects and never approves them. No new profile or manifest version is required.
+
+The selected target has the existing `provider_execution_contract` shape. Every
+required object, goal/Done When, requirement/acceptance, constraint, non-goal,
+deferred boundary and architecture reference must resolve to accepted canonical
+specs. Required relations close transitively; cycles and conflicts block work.
+The acceptance is a `decision` object with subtype
+`architecture_baseline_acceptance`, accepted lifecycle/readiness, `graph_id`,
+`target_id`, `owner_id`, `semantic_digest`, `execution_contract_digest` and a
+bounded `approval_ref`. It must match the declared architecture owner.
+
+The caller supplies `localAcceptance` / `--local-acceptance-trust <file>` (or `-`
+for stdin): `{graphId,targetId,ownerId,decisionSha256}`. This is **trusted caller
+input** obtained from the existing human-approval authority channel. The engine
+checks consistency, not the human's identity. Calculating the hash from an
+untrusted folder is not authentication. The anchor is never obtained from graph
+contents or auto-created/persisted by sync. A new host without authenticated
+approval gets `local_target_acceptance_unverified`; read-only diagnosis remains
+available. A host-local cache is not portable acceptance authority.
+
+`plan` returns the same `target_binding` as `status`; it exposes calculated
+digests for review even when acceptance is blocked. The local `semantic_digest`
+hashes canonical JSON of graph ID, target ID, selected objects and relations.
+Object keys are sorted; objects and relations are sorted by ID. Timestamps,
+evidence, approval refs and computed digest fields are excluded. The acceptance
+object is excluded to avoid self-reference. Source refs retain their paths, not
+content hashes. Normalized meaning, required closure and scope stay bound.
+`execution_contract_digest` hashes the shared normalized contract. Source/evidence
+bytes are separately hashed into `content_revision`; the target pins that value.
+Tool drift blocks freshness without re-accepting architecture. JSON formatting
+does not change semantics; changed source bytes (including line endings) change
+content identity intentionally. Paths, clocks and Git HEAD are not local IDs.
+`provider_revision` remains exclusive to external Git/archive bindings.
+
+Selection is `sync --target-source <selector.json> --local-acceptance-trust <anchor.json>
+--expected-graph-digest <digest> --apply`; omit `--apply` for zero-write preview.
+Use `continuity.graphDigest(repo)` for the CAS value. Selection uses the existing
+continuity lease, backup, atomic rename and readback. Repetition is byte-identical.
+Select before a separate task-boundary sync; these are not a combined transaction.
+Significant `context` and `verify` additionally require a current receipt from the
+existing continuity mechanism, even when the optional policy was omitted.
+Updating a content pin is not a verification receipt. Record actual checks through
+`sync --boundary stage_complete --evidence <checks.json> --apply` after validating
+the sources. A second host must verify those sources and record its own fresh
+receipt; it does not have to re-approve unchanged architecture.
+`disconnect --expected-graph-digest <digest> --apply` removes only the local
+selector through the same lease/CAS/backup transaction. It does not remove the
+target or its Decision. Without `--apply` it remains a preview.
+Git hygiene remains strict: a changed tracked manifest must be committed through
+the caller's authorized Git workflow before execution becomes ready.
+Before the first Git commit, a structurally valid unborn branch may inventory
+declared graph/raw sources using the same content-bound path as an ordinary
+folder. Missing Git, corrupt refs/index and invalid detached HEAD stay blocked.
+This never supplies `provider_revision` or permits a Git provider export.
+
+Local and external bindings conflict rather than override each other. Missing
+external providers never cause fallback to local data. Local raw sources must be
+safe relative files, not `source/`, generated outputs, symlinks or external URLs;
+external technologies continue to use verified providers. Raw file contents are
+not included in the target packet. Existing folder safety and action authorization
+still apply: ready is not permission to write. Shared-server leases do not lock
+offline sync replicas; divergent expected state requires reconciliation.
+
 Status: 1.4 stable standard; activation contract remains 1.0.0
 
 Project Technology is the shared executable mechanism of Mirai Graph. It is