313 lines
20 KiB
Python
313 lines
20 KiB
Python
import json
|
|
import subprocess
|
|
from pathlib import Path
|
|
|
|
|
|
MODULE = Path(__file__).parents[1] / "frontend" / "human-gates.js"
|
|
PROGRESSIVE = Path(__file__).parents[1] / "frontend" / "progressive-human-gates.js"
|
|
INDEX = Path(__file__).parents[1] / "frontend" / "index.html"
|
|
DASHBOARD = Path(__file__).parents[1] / "frontend" / "dashboard.js"
|
|
WORKER = Path(__file__).parents[1] / "frontend" / "service-worker.js"
|
|
LIVE_SNAPSHOT = Path(__file__).parents[1] / "frontend" / "progressive-live-snapshot.js"
|
|
PROGRESSIVE_MY_WORK = Path(__file__).parents[1] / "frontend" / "progressive-my-work.js"
|
|
MY_WORK = Path(__file__).parents[1] / "frontend" / "my-work.js"
|
|
|
|
|
|
def run_node(body):
|
|
script = f"const createHumanGates=require({json.dumps(str(MODULE))});\n" + body
|
|
result = subprocess.run(["node", "-e", script], check=True, text=True, capture_output=True)
|
|
return json.loads(result.stdout)
|
|
|
|
|
|
def test_progressive_my_work_and_human_gates_share_one_cold_live_snapshot():
|
|
script = f"""
|
|
const createProgressiveLiveSnapshot=require({json.dumps(str(LIVE_SNAPSHOT))});
|
|
globalThis.buildMyWork=require({json.dumps(str(MY_WORK))});
|
|
const createProgressiveMyWork=require({json.dumps(str(PROGRESSIVE_MY_WORK))});
|
|
const createProgressiveHumanGates=require({json.dumps(str(PROGRESSIVE))});
|
|
let liveCalls=0, directMyWorkCalls=0, resolveLive;
|
|
const broker=createProgressiveLiveSnapshot({{fetchSnapshot:()=>{{
|
|
liveCalls += 1;
|
|
return new Promise(resolve=>{{resolveLive=resolve;}});
|
|
}}}});
|
|
const workDocument={{
|
|
hidden:false,
|
|
querySelector:selector=>selector==='#my-work-list'?{{innerHTML:''}}:selector==='#my-work-status'?{{textContent:''}}:null,
|
|
querySelectorAll:()=>[],
|
|
}};
|
|
const work=createProgressiveMyWork({{
|
|
document:workDocument, liveSnapshot:broker,
|
|
fetchSnapshot:async()=>{{directMyWorkCalls += 1; return {{}};}},
|
|
}});
|
|
const nodes={{
|
|
'#human-gates-count':{{}}, '#human-gates-list':{{innerHTML:'',addEventListener(){{}}}},
|
|
'#human-gates-status':{{}}, '#human-gates':{{hidden:true}},
|
|
'#human-gate-detail':{{innerHTML:'',addEventListener(){{}},querySelectorAll:()=>[]}},
|
|
'#open-human-gates':{{addEventListener(){{}}}}, '#close-human-gates':{{addEventListener(){{}}}},
|
|
}};
|
|
const gates=createProgressiveHumanGates({{
|
|
document:{{querySelector:selector=>nodes[selector]||null}},
|
|
location:{{hash:'#/my-work/human-gates'}}, history:{{replaceState(){{}}}},
|
|
storage:{{getItem:()=>null,setItem(){{}}}}, isOnline:()=>true,
|
|
liveSnapshot:broker,
|
|
fetchJson:async path=>({{pending_count:1,items:[{{id:'g1',title:'Shared identity',candidate_hash:'abc',revision:1,checks:[]}}]}}),
|
|
}});
|
|
(async()=>{{
|
|
const workStart=work.start(); const gateStart=gates.start();
|
|
await Promise.resolve(); await Promise.resolve();
|
|
const callsWhilePending=liveCalls;
|
|
resolveLive({{context:{{user:{{id:7,login:'timmy'}},issues:[],pull_requests:[]}},events:[],notifications:[]}});
|
|
await Promise.all([workStart,gateStart]);
|
|
process.stdout.write(JSON.stringify({{
|
|
callsWhilePending,liveCalls,directMyWorkCalls,
|
|
login:work.login(),gateStarted:gates.handoff().started,
|
|
}}));
|
|
}})().catch(error=>{{console.error(error);process.exit(1);}});
|
|
"""
|
|
result = subprocess.run(["node", "-e", script], capture_output=True, text=True)
|
|
|
|
assert result.returncode == 0, result.stderr
|
|
assert json.loads(result.stdout) == {
|
|
"callsWhilePending": 1,
|
|
"liveCalls": 1,
|
|
"directMyWorkCalls": 0,
|
|
"login": "timmy",
|
|
"gateStarted": True,
|
|
}
|
|
|
|
|
|
def test_queue_loads_pending_count_uses_account_cache_and_renders_inbox_zero():
|
|
output = run_node(r"""
|
|
const values=new Map(); const storage={getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)};
|
|
let response={pending_count:1,items:[{id:'g1',title:'Candidate',candidate_hash:'abc123',priority:4,state:'pending',revision:1,checks:[]}]};
|
|
const nodes={count:{textContent:''},list:{innerHTML:''},status:{textContent:''},panel:{hidden:true}};
|
|
const gates=createHumanGates({storage,getLogin:()=> 'timmy',isOnline:()=>true,nodes,location:{hash:''},fetchJson:async()=>response});
|
|
(async()=>{ await gates.load(); const first={snapshot:gates.snapshot(),count:nodes.count.textContent,html:nodes.list.innerHTML,keys:[...values.keys()]}; response={pending_count:0,items:[]}; await gates.load(); process.stdout.write(JSON.stringify({first,zero:{snapshot:gates.snapshot(),status:nodes.status.textContent,html:nodes.list.innerHTML}})); })();
|
|
""")
|
|
assert output["first"]["count"] == "1"
|
|
assert "abc123" in output["first"]["html"]
|
|
assert output["first"]["keys"] == ["stackchain.human-gates.v1:timmy"]
|
|
assert output["zero"]["snapshot"]["pending_count"] == 0
|
|
assert "Inbox zero" in output["zero"]["html"]
|
|
|
|
|
|
def test_queue_changes_publish_mobile_counts_and_authoritative_decision_completion():
|
|
output = run_node(r"""
|
|
const changes=[];
|
|
const item={id:'g1',title:'Candidate',candidate_hash:'abc123',revision:1,checks:[]};
|
|
const gates=createHumanGates({
|
|
storage:{getItem:()=>null,setItem(){}}, getLogin:()=> 'timmy', isOnline:()=>true,
|
|
nodes:{count:{},list:{},status:{},panel:{},detail:{}}, location:{hash:''},
|
|
onChange:(snapshot, state)=>changes.push({count:snapshot.pending_count,...state}),
|
|
fetchJson:async(path, options={})=>options.method==='POST' ? {receipt_id:'r1'} : {pending_count:1,items:[item]},
|
|
});
|
|
(async()=>{await gates.load();gates.reviewNext();await gates.decideAndNext('release',{checklist:{exact_hash:true,artifacts_reviewed:true,provenance_reviewed:true}});process.stdout.write(JSON.stringify(changes));})();
|
|
""")
|
|
assert output == [
|
|
{"count": 1, "available": True, "authoritative": True},
|
|
{"count": 0, "available": True, "authoritative": True, "decision": True},
|
|
]
|
|
|
|
|
|
def test_queue_load_failure_distinguishes_cached_read_only_data_from_unavailable():
|
|
output = run_node(r"""
|
|
const cached={pending_count:1,items:[{id:'g1',title:'Cached',candidate_hash:'abc'}]};
|
|
const changes=[];
|
|
const make=(value,label)=>createHumanGates({
|
|
storage:{getItem:()=>value ? JSON.stringify(value) : null,setItem(){}},
|
|
getLogin:()=> 'timmy', isOnline:()=>false, nodes:{count:{},list:{},status:{},panel:{}}, location:{hash:''},
|
|
onChange:(snapshot,state)=>changes.push({label,count:snapshot.pending_count,...state}),
|
|
fetchJson:async()=>{throw new Error('network')},
|
|
});
|
|
(async()=>{await make(cached,'cached').load();try{await make(null,'empty').load()}catch(_){}process.stdout.write(JSON.stringify(changes));})();
|
|
""")
|
|
assert output == [
|
|
{"label": "cached", "count": 1, "available": True, "authoritative": False, "cached": True},
|
|
{"label": "empty", "count": 0, "available": False, "authoritative": False},
|
|
]
|
|
|
|
|
|
def test_review_next_is_a_fixed_snapshot_and_decision_and_next_advances_without_new_arrivals():
|
|
output = run_node(r"""
|
|
const calls=[]; const nodes={count:{textContent:''},list:{innerHTML:''},status:{textContent:''},panel:{hidden:true},detail:{innerHTML:''}};
|
|
const initial={pending_count:2,items:[{id:'old',title:'Old',candidate_hash:'a1',revision:1,checks:[]},{id:'next',title:'Next',candidate_hash:'b2',revision:1,checks:[]}]};
|
|
const gates=createHumanGates({storage:{getItem:()=>null,setItem(){}},getLogin:()=> 'timmy',isOnline:()=>true,nodes,location:{hash:'#/my-work/human-gates'},fetchJson:async(path,options={})=>{calls.push({path,options}); if(options.method==='POST') return {receipt_id:'r1',state:'released'}; return initial;}});
|
|
(async()=>{await gates.load(); const reviewed=gates.reviewNext(); initial.items.unshift({id:'new',title:'New arrival',candidate_hash:'c3',revision:1,checks:[]}); const result=await gates.decideAndNext('release',{checklist:{exact_hash:true,artifacts_reviewed:true,provenance_reviewed:true}}); process.stdout.write(JSON.stringify({reviewed,result,current:gates.current(),calls,hash:gates.route()}));})();
|
|
""")
|
|
assert output["reviewed"]["id"] == "old"
|
|
assert output["result"]["receipt"]["receipt_id"] == "r1"
|
|
assert output["current"]["id"] == "next"
|
|
assert output["hash"] == "#/my-work/human-gates"
|
|
post = next(call for call in output["calls"] if call["options"].get("method") == "POST")
|
|
assert post["path"] == "api/v1/human-gates/old/decision"
|
|
assert "Idempotency-Key" in post["options"]["headers"]
|
|
|
|
|
|
def test_review_loads_exact_detail_with_links_provenance_and_history():
|
|
output = run_node(r"""
|
|
const detail={id:'g1',title:'Candidate',project:'stackchain/dashboard',candidate_hash:'abc123',revision:1,checks:[{name:'unit',state:'success',required:true}],artifacts:[{name:'manifest',url:'https://forge.example/manifest'}],links:[{label:'pull',url:'https://forge.example/pull/1'}],score:{value:98,provenance:'eval/v1'},provenance:{producer:'bot',run_id:'9'},history:[{action:'intake',at:100}]};
|
|
const nodes={count:{},list:{},status:{},panel:{},detail:{innerHTML:''}};
|
|
const gates=createHumanGates({storage:{getItem:()=>null,setItem(){}},getLogin:()=> 'timmy',isOnline:()=>true,nodes,location:{hash:''},fetchJson:async path=>path.endsWith('/g1')?detail:{pending_count:1,items:[detail]}});
|
|
(async()=>{await gates.load();gates.reviewNext();await new Promise(resolve=>setTimeout(resolve,0));process.stdout.write(JSON.stringify({html:nodes.detail.innerHTML}));})();
|
|
""")
|
|
assert "stackchain/dashboard" in output["html"]
|
|
assert "https://forge.example/pull/1" in output["html"]
|
|
assert "bot" in output["html"]
|
|
assert "intake" in output["html"]
|
|
|
|
|
|
def test_release_requires_override_for_unmet_required_checks_and_decisions_require_online_identity():
|
|
output = run_node(r"""
|
|
let online=true, login='timmy', posts=0;
|
|
const item={id:'g1',title:'Failing',candidate_hash:'a1',revision:1,checks:[{name:'browser',state:'failure',required:true}]};
|
|
const gates=createHumanGates({storage:{getItem:()=>null,setItem(){}},getLogin:()=>login,isOnline:()=>online,nodes:{count:{},list:{},status:{},panel:{},detail:{}},location:{hash:''},fetchJson:async(path,options={})=>{if(options.method==='POST'){posts++;return {receipt_id:'r1'}};return {pending_count:1,items:[item]};}});
|
|
(async()=>{await gates.load();gates.reviewNext();let override,offline,identity;try{await gates.decideAndNext('release',{checklist:{exact_hash:true,artifacts_reviewed:true,provenance_reviewed:true}})}catch(e){override=e.message} online=false;try{await gates.decideAndNext('hold',{reason:'wait',checklist:{exact_hash:true,artifacts_reviewed:true,provenance_reviewed:true}})}catch(e){offline=e.message} online=true;login='';try{await gates.decideAndNext('hold',{reason:'wait',checklist:{exact_hash:true,artifacts_reviewed:true,provenance_reviewed:true}})}catch(e){identity=e.message}process.stdout.write(JSON.stringify({override,offline,identity,posts}));})();
|
|
""")
|
|
assert "override reason" in output["override"]
|
|
assert "online" in output["offline"]
|
|
assert "identity" in output["identity"]
|
|
assert output["posts"] == 0
|
|
|
|
|
|
def test_offline_cache_is_scoped_to_immutable_account_identity():
|
|
output = run_node(r"""
|
|
const values=new Map(); const storage={getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)};
|
|
let account='1:timmy'; const nodes={count:{},list:{},status:{},panel:{}};
|
|
const gates=createHumanGates({storage,getLogin:()=> 'timmy',getAccountKey:()=>account,isOnline:()=>true,nodes,location:{hash:''},fetchJson:async()=>({pending_count:1,items:[{id:'g1',title:'Private',candidate_hash:'a1'}]})});
|
|
(async()=>{await gates.load();account='2:timmy';process.stdout.write(JSON.stringify({keys:[...values.keys()],restored:gates.restoreCached()}));})();
|
|
""")
|
|
assert output["keys"] == ["stackchain.human-gates.v1:1:timmy"]
|
|
assert output["restored"] is None
|
|
|
|
|
|
def test_account_switch_clears_in_memory_gate_data_before_failed_load():
|
|
output = run_node(r"""
|
|
const values=new Map(); const storage={getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)};
|
|
let account='1:timmy', fail=false; const nodes={count:{},list:{innerHTML:''},status:{},panel:{}};
|
|
const gates=createHumanGates({storage,getLogin:()=> 'timmy',getAccountKey:()=>account,isOnline:()=>true,nodes,location:{hash:''},fetchJson:async()=>{if(fail)throw new Error('offline');return {pending_count:1,items:[{id:'private-1',title:'Principal 1 private',candidate_hash:'secret'}]}}});
|
|
(async()=>{await gates.load();account='2:timmy';fail=true;try{await gates.load()}catch(_){}process.stdout.write(JSON.stringify({snapshot:gates.snapshot(),html:nodes.list.innerHTML}));})();
|
|
""")
|
|
assert output["snapshot"] == {"pending_count": 0, "items": []}
|
|
assert "Principal 1 private" not in output["html"]
|
|
assert "secret" not in output["html"]
|
|
|
|
|
|
def test_stale_account_load_cannot_overwrite_new_account_queue_or_cache():
|
|
output = run_node(r"""
|
|
const values=new Map(); const storage={getItem:k=>values.get(k)||null,setItem:(k,v)=>values.set(k,v)};
|
|
let account='1:timmy', resolveA, resolveB;
|
|
const responseA=new Promise(resolve=>resolveA=resolve), responseB=new Promise(resolve=>resolveB=resolve);
|
|
const gates=createHumanGates({storage,getLogin:()=> 'timmy',getAccountKey:()=>account,isOnline:()=>true,nodes:{count:{},list:{innerHTML:''},status:{},panel:{}},location:{hash:''},fetchJson:()=>account.startsWith('1:')?responseA:responseB});
|
|
(async()=>{const loadA=gates.load();account='2:timmy';const loadB=gates.load();resolveB({pending_count:1,items:[{id:'b',title:'B gate',candidate_hash:'bhash'}]});await loadB;resolveA({pending_count:1,items:[{id:'a-secret',title:'A secret',candidate_hash:'asecret'}]});await loadA;process.stdout.write(JSON.stringify({snapshot:gates.snapshot(),cached:JSON.parse(values.get('stackchain.human-gates.v1:2:timmy'))}));})();
|
|
""")
|
|
assert [item["id"] for item in output["snapshot"]["items"]] == ["b"]
|
|
assert [item["id"] for item in output["cached"]["items"]] == ["b"]
|
|
|
|
|
|
def test_decision_retry_reuses_the_same_idempotency_key():
|
|
output = run_node(r"""
|
|
let attempts=0; const keys=[];
|
|
const item={id:'g1',title:'Candidate',candidate_hash:'a1',revision:1,checks:[]};
|
|
const gates=createHumanGates({storage:{getItem:()=>null,setItem(){}},getLogin:()=> 'timmy',isOnline:()=>true,nodes:{count:{},list:{},status:{},panel:{},detail:{}},location:{hash:''},fetchJson:async(path,options={})=>{if(options.method==='POST'){keys.push(options.headers['Idempotency-Key']);attempts++;if(attempts===1)throw new Error('network');return {receipt_id:'r1'}};return {pending_count:1,items:[item]};}});
|
|
(async()=>{await gates.load();gates.reviewNext();const values={reason:'wait',checklist:{}};try{await gates.decideAndNext('hold',values)}catch(_){}await gates.decideAndNext('hold',values);process.stdout.write(JSON.stringify({keys}));})();
|
|
""")
|
|
assert len(output["keys"]) == 2
|
|
assert output["keys"][0] == output["keys"][1]
|
|
|
|
|
|
def test_concurrent_decision_taps_submit_once_and_advance_once():
|
|
output = run_node(r"""
|
|
let posts=0, releasePost; const posted=new Promise(resolve=>releasePost=resolve);
|
|
const items=[{id:'g1',title:'One',candidate_hash:'a1',revision:1,checks:[]},{id:'g2',title:'Two',candidate_hash:'b2',revision:1,checks:[]}];
|
|
const gates=createHumanGates({storage:{getItem:()=>null,setItem(){}},getLogin:()=> 'timmy',isOnline:()=>true,nodes:{count:{},list:{},status:{},panel:{},detail:{}},location:{hash:''},fetchJson:async(path,options={})=>{if(options.method==='POST'){posts++;await posted;return {receipt_id:'r1'}};return {pending_count:2,items};}});
|
|
(async()=>{await gates.load();gates.reviewNext();const values={reason:'wait',checklist:{}};const first=gates.decideAndNext('hold',values);const second=gates.decideAndNext('hold',values);releasePost();await Promise.all([first,second]);process.stdout.write(JSON.stringify({posts,current:gates.current()?.id,snapshot:gates.snapshot()}));})();
|
|
""")
|
|
assert output["posts"] == 1
|
|
assert output["current"] == "g2"
|
|
assert output["snapshot"]["pending_count"] == 1
|
|
assert [item["id"] for item in output["snapshot"]["items"]] == ["g2"]
|
|
|
|
|
|
def test_selecting_a_queue_card_opens_that_exact_gate():
|
|
output = run_node(r"""
|
|
const details={
|
|
g1:{id:'g1',title:'First',project:'p/one',candidate_hash:'a1',revision:1,checks:[]},
|
|
g2:{id:'g2',title:'Second',project:'p/two',candidate_hash:'b2',revision:1,checks:[]},
|
|
};
|
|
const nodes={count:{},list:{},status:{},panel:{},detail:{innerHTML:''}};
|
|
const gates=createHumanGates({storage:{getItem:()=>null,setItem(){}},getLogin:()=> 'timmy',isOnline:()=>true,nodes,location:{hash:''},fetchJson:async path=>path.includes('/g')?details[path.split('/').pop()]:{pending_count:2,items:Object.values(details)}});
|
|
(async()=>{await gates.load();gates.reviewNext();gates.select('g2');await new Promise(resolve=>setTimeout(resolve,0));process.stdout.write(JSON.stringify({current:gates.current().id,html:nodes.detail.innerHTML}));})();
|
|
""")
|
|
assert output["current"] == "g2"
|
|
assert "Second" in output["html"]
|
|
assert "p/two" in output["html"]
|
|
|
|
|
|
def test_human_gate_mobile_shell_and_deep_route_are_wired():
|
|
index = INDEX.read_text()
|
|
dashboard = DASHBOARD.read_text()
|
|
assert 'id="human-gates"' in index
|
|
assert 'id="human-gates-count"' in index
|
|
assert 'Review next <span id="human-gates-count"' in index
|
|
assert 'static/human-gates.js' in index
|
|
assert "#/my-work/human-gates" in dashboard
|
|
assert "createHumanGates" in dashboard
|
|
assert "planningOwnerAccountKey = confirmedOwnerLogin && saved.user?.id" in dashboard
|
|
assert 'data-mobile-queue="gate"' in index
|
|
assert 'data-mobile-queue-count="gate"' in index
|
|
assert "openHumanGates: () => openHumanGates()" in dashboard
|
|
assert "const humanGatesOnChange = (snapshot, state)=>" in dashboard
|
|
assert "queueCounts.gate = snapshot.pending_count" in dashboard
|
|
assert "preparationItems.gate = snapshot.items" in dashboard
|
|
assert "mobileStartDay.reconcile({authoritative:true, authoritativePhases:['gate']})" in dashboard
|
|
assert "counts.gate = queueCounts.gate" in dashboard
|
|
assert "gate:preparationItems.gate || []" in dashboard
|
|
assert "stackchain-dashboard-shell-v142" in WORKER.read_text()
|
|
|
|
|
|
def test_deep_link_opens_human_gates_without_waiting_for_optional_workspace():
|
|
script = f"""
|
|
const createProgressiveHumanGates=require({json.dumps(str(PROGRESSIVE))});
|
|
const listeners={{}}; const requests=[];
|
|
const nodes={{
|
|
'#human-gates-count':{{}}, '#human-gates-list':{{innerHTML:''}},
|
|
'#human-gates-status':{{}}, '#human-gates':{{hidden:true}},
|
|
'#human-gate-detail':{{innerHTML:'',querySelectorAll:()=>[]}},
|
|
'#open-human-gates':{{addEventListener:(name,fn)=>listeners.open=fn}},
|
|
'#close-human-gates':{{addEventListener:(name,fn)=>listeners.close=fn}},
|
|
}};
|
|
nodes['#human-gates-list'].addEventListener=(name,fn)=>listeners.list=fn;
|
|
nodes['#human-gate-detail'].addEventListener=(name,fn)=>listeners.detail=fn;
|
|
const document={{querySelector:selector=>nodes[selector]||null}};
|
|
const app=createProgressiveHumanGates({{
|
|
document, location:{{hash:'#/my-work/human-gates'}},
|
|
history:{{replaceState(){{}}}}, storage:{{getItem:()=>null,setItem(){{}}}},
|
|
isOnline:()=>true, getIdentity:async()=>({{login:'timmy',accountKey:'7:timmy'}}),
|
|
fetchJson:async path=>{{requests.push(path);return {{pending_count:1,items:[{{id:'g1',title:'Ship it',candidate_hash:'abc',revision:1,checks:[]}}]}};}},
|
|
}});
|
|
(async()=>{{const started=await app.start();process.stdout.write(JSON.stringify({{
|
|
started,hidden:nodes['#human-gates'].hidden,html:nodes['#human-gates-list'].innerHTML,
|
|
requests,listeners:Object.keys(listeners).sort(),handoff:app.handoff().started,
|
|
}}));}})();
|
|
"""
|
|
result = subprocess.run(["node", "-e", script], check=True, text=True, capture_output=True)
|
|
output = json.loads(result.stdout)
|
|
assert output == {
|
|
"started": True,
|
|
"hidden": False,
|
|
"html": '<button class="human-gate-card" type="button" data-human-gate-id="g1"><strong>Ship it</strong><code>abc</code><span>Priority 0</span></button>',
|
|
"requests": ["api/v1/human-gates", "api/v1/human-gates/g1"],
|
|
"listeners": ["close", "detail", "list", "open"],
|
|
"handoff": True,
|
|
}
|
|
|
|
|
|
def test_dashboard_adopts_progressive_human_gates_without_a_second_list_load():
|
|
dashboard = DASHBOARD.read_text()
|
|
index = INDEX.read_text()
|
|
assert 'static/progressive-human-gates.js' in index
|
|
assert "window.stackchainProgressiveHumanGates?.handoff?.()" in dashboard
|
|
assert "progressiveHumanGatesHandoff?.controller || createHumanGates" in dashboard
|
|
assert "if (!progressiveHumanGatesHandoff?.started) humanGates.load()" in dashboard
|
|
assert "if (window.location.hash === '#/my-work/human-gates' && !progressiveHumanGatesHandoff?.started) openHumanGates()" in dashboard
|