@givolt/i3-composer-agent 2.3.1 → 2.3.3

package/scripts/ui-prototype-execution-gates-test.js

@@ -0,0 +1,66 @@
+'use strict';
+const prototypeScripts=(()=>{const fs=require('node:fs'),path=require('node:path'),file=path.join(__dirname,'lib/installation.js');return path.join(fs.existsSync(file)?require(file).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');})();
+const test=require('node:test'),assert=require('node:assert/strict');
+const P=require(prototypeScripts+'/execution-policy.cjs');
+const E=require(prototypeScripts+'/execution-evidence.cjs');
+const G=require(prototypeScripts+'/execution-gates.cjs');
+test('native UI writes resolve relative paths from the actual tool cwd',()=>{
+ assert.equal(G.uiWrite({name:'Write',cwd:'/work',input:{file_path:'prototypes/orders/app/src/Probe.vue'}},'/work/prototypes/orders'),true);
+ assert.equal(G.uiWrite({name:'Write',cwd:'/work/prototypes/orders/app',input:{file_path:'src/Probe.vue'}},'/work/prototypes/orders'),true);
+ assert.equal(G.uiWrite({name:'Write',cwd:'/work',input:{file_path:'other/app/src/Probe.vue'}},'/work/prototypes/orders'),false);
+ assert.equal(G.uiWrite({name:'Write',input:{filePath:'/work/prototypes/orders/app/src/Probe.vue'}},'/work/prototypes/orders'),true);
+});
+function fixture() {
+ const file='/work/prototypes/orders/app/src/Orders.vue',bytes='<Table />';
+ const call=(toolCallId,name,input,result,line,skill)=>({toolCallId,name,input,result,requestLine:line,resultLine:line+1,success:true,resultDigest:E.sha(result),sessionId:'s1',contextLine:0,skill});
+ const calls=[call('front','Skill',{},'frontend instructions',3,'frontend'),call('ant','Skill',{},'antdv instructions',5,'antdv'),call('query','Bash',{command:'antdv info Table'},'Table API: rowSelection',7),call('version','Read',{file_path:'/work/app/node_modules/antdv-next/package.json'},'{"version":"1.5.3"}',9),call('write','Write',{file_path:file},'saved',11)];
+ const policy=P.create({mode:'template'}),current={digest:'candidate',inputDigest:'input',revision:'r001'};
+ const binding={schemaVersion:1,runId:'r1',sessionId:'s1',projectKey:'p1',directory:'/work/prototypes/orders',instanceId:'instance',policyDigest:policy.digest,inputDigest:'input',entryLine:1};
+ const proof={schemaVersion:1,runId:'r1',sessionId:'s1',projectKey:'p1',policyDigest:policy.digest,candidateDigest:'candidate',inputDigest:'input',revision:'r001',frontend:{toolCallId:'front',files:[{path:'app/src/Orders.vue',sha256:E.sha(bytes)}],requirementIds:['R1']},official:{skill:{toolCallId:'ant'},version:{toolCallId:'version',quote:'"version":"1.5.3"'},queries:[{component:'Table',toolCallId:'query',quote:'Table API: rowSelection'}]},templateChoice:{quote:'template mode'}};
+ return {policy,current,binding,proof,source:{calls,contextLine:0,prompts:[{line:1,text:'generate prototype in template mode',digest:'prompt'}]},scope:{requirements:[{id:'R1'}]},files:{'app/src/Orders.vue':bytes},implementation:{bindings:[{status:'implemented',components:['Table'],files:[{path:'app/src/Orders.vue'}]}]},frameworkVersion:'1.5.3'};
+}
+test('a native frontend load is required before the first actual UI write in both modes',()=>{
+ const f=fixture();assert.equal(G.evaluate(f,'implementation').status,'passed');
+ f.source.calls[0].success=false;assert.equal(G.evaluate(f,'implementation').status,'failed');
+ f.source.calls[0].success=true;f.source.calls[0].resultLine=12;assert.match(G.evaluate(f,'implementation').errors.join(),/before/);
+});
+test('IDE relative write evidence uses its bound workspace while legacy evidence keeps its contract',()=>{
+ const f=fixture();f.source.format='codebuddy-ide-index-v1';f.binding.project='/work';f.source.calls.find(c=>c.name==='Write').input.file_path='prototypes/orders/app/src/Orders.vue';
+ assert.equal(G.evaluate(f,'implementation').status,'passed');
+});
+test('current context, task and artifact identities reject replay and changed inputs',()=>{
+ for(const mutate of [f=>f.proof.runId='other',f=>f.proof.inputDigest='old',f=>f.source.contextLine=10,f=>f.source.calls[0].sessionId='s2',f=>f.binding.entryLine=20]){const f=fixture();mutate(f);assert.equal(G.evaluate(f,'implementation').status,'failed');}
+});
+test('reading a skill, adapted metadata, or incomplete review mappings cannot pass',()=>{
+ const f=fixture();f.source.calls[0].skill=null;assert.equal(G.evaluate(f,'implementation').status,'failed');
+ const g=fixture();g.proof.frontend.files=[];assert.equal(G.evaluate(g,'implementation').status,'failed');
+ const h=fixture();h.proof.frontend.requirementIds=[];assert.equal(G.evaluate(h,'implementation').status,'failed');
+});
+test('official query references must be successful, relevant, and version checked',()=>{
+ const f=fixture();assert.equal(G.evaluate(f,'design').status,'passed');
+ f.proof.official.queries[0].quote='invented';assert.equal(G.evaluate(f,'design').status,'failed');
+ const g=fixture();g.source.calls[2].input.command='antdv probe';assert.equal(G.evaluate(g,'design').status,'failed');
+ const h=fixture();h.source.calls[3].result='{"version":"1.5.2"}';assert.equal(G.evaluate(h,'design').status,'failed');
+});
+test('professional requires actual UIUX execution; explicit template choice cannot be invented',()=>{
+ const f=fixture();f.policy=P.create({mode:'professional'});f.binding.policyDigest=f.proof.policyDigest=f.policy.digest;assert.match(G.evaluate(f,'design').errors.join(),/UIUX/);
+ const g=fixture();g.proof.templateChoice.quote='use template now';assert.equal(G.evaluate(g,'design').status,'failed');
+ const h=fixture();h.proof.templateChoice.quote='template';h.source.prompts[0].text='参考 template 制作专业增强原型';assert.equal(G.evaluate(h,'design').status,'failed');
+});
+test('missing current build, fake browser IDs, and self-written passed booleans cannot finish',()=>{
+ const f=fixture();f.proof.build={toolCallId:'query'};assert.equal(G.evaluate(f,'build').status,'failed');
+ f.proof.browser={passed:true};assert.equal(G.evaluate(f,'browser').status,'failed');assert.equal(G.evaluate(f,'delivery').status,'failed');
+});
+test('the shared gate can correlate a complete synthetic chain and rejects unrelated native facts',()=>{
+ const f=fixture(),call=(toolCallId,name,input,result,line,skill)=>({toolCallId,name,input,result,requestLine:line,resultLine:line+1,success:true,resultDigest:E.sha(result),sessionId:'s1',contextLine:0,skill});
+ f.build={buildId:'b1',buildDigest:'bytes',candidateDigest:'candidate'};
+ f.source.calls.push(call('build','Bash',{command:'node /skills/native-pilot.cjs build /work/prototypes/orders'},'{"buildId":"b1","buildDigest":"bytes"}',15),call('browser','Skill',{},'browser instructions',17,'browser'),call('preview','mcp__chrome_devtools__navigate_page',{url:'http://127.0.0.1:4173/'},'opened',19),call('fact','mcp__chrome_devtools__evaluate_script',{function:'() => document.title'},'{"candidate":"candidate","saved":true}',21));
+ f.proof.build={toolCallId:'build'};f.business={previewBaseURL:'http://127.0.0.1:4173/',journeys:[{id:'save'}]};
+ const methods={dom:'evaluate_script',screenshot:'take_screenshot',console:'list_console_messages',network:'list_network_requests',accessibility:'take_snapshot',performance:'performance_stop_trace'};
+ const refs=Object.fromEntries(Object.entries(methods).map(([kind,method],i)=>{const id=kind==='dom'?'fact':kind;if(kind!=='dom')f.source.calls.push(call(id,`mcp__chrome_devtools__${method}`,{},'synthetic observation',24+i*2));return [kind,{toolCallId:id,quote:kind==='dom'?'candidate':'synthetic observation'}];}));
+ f.devtools={skill:{toolCallId:'browser'},mcp:{calls:Object.entries(methods).map(([kind,method])=>({toolCallId:refs[kind].toolCallId,tool:`mcp__chrome_devtools__${method}`}))}};
+ f.proof.browser={skill:{toolCallId:'browser'},preview:{toolCallId:'preview'},identity:{toolCallId:'fact',quote:'candidate'},observations:refs,facts:[{scenarioId:'save',checkIndex:0,toolCallId:'fact',quote:'"saved":true'}]};
+ f.assertions={schemaVersion:1,scenarios:[{scenarioId:'save',checks:[{method:'evaluate_script',pointer:'/saved',operator:'equals',expected:true}]}]};
+ assert.equal(G.evaluate(f,'delivery').status,'passed');
+ f.source.calls.find(c=>c.toolCallId==='fact').result='{"candidate":"candidate","saved":false}';f.proof.browser.facts[0].quote='"saved":false';assert.equal(G.evaluate(f,'delivery').status,'failed');
+});

package/scripts/ui-prototype-execution-policy-test.js

@@ -0,0 +1,42 @@
+'use strict';
+const prototypeScripts=(()=>{const fs=require('node:fs'),path=require('node:path'),file=path.join(__dirname,'lib/installation.js');return path.join(fs.existsSync(file)?require(file).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');})();
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const P = require(prototypeScripts+'/execution-policy.cjs');
+test('CodeBuddy policy defaults never confuse a PRD scope file with project/global installation scope',()=>{
+ const options={host:'codebuddy',scope:'/work/prototypes/.preparation/orders/scope.json'};
+ const result=P.creationOptions(options,{name:'i3-composer-agent',scope:'global',agents:['codebuddy']});
+ assert.equal(result.scope,options.scope);assert.equal(result.executionPolicy,P.ID);
+ assert.equal(P.creationOptions({host:'codex'},{name:'i3-composer-agent'}).executionPolicy,undefined);
+ assert.equal(P.creationOptions({},null).executionPolicy,undefined);
+});
+
+test('analysis and inspection never acquire implementation requirements', () => {
+  for (const operation of ['analyze', 'inspect', 'confirm-baseline']) {
+    const policy = P.create({ operation });
+    assert.deepEqual(P.requirements(policy, 'implementation-entry'), []);
+    assert.equal(policy.readOnly, true);
+  }
+});
+test('both generation modes require frontend loading before implementation', () => {
+  for (const operation of ['create', 'revise']) for (const mode of ['professional', 'template']) {
+    const policy = P.create({ operation, mode });
+    assert.ok(P.requirements(policy, 'implementation-entry').includes('frontend'));
+    assert.ok(P.requirements(policy, 'browser-entry').includes('browser'));
+    assert.equal(P.requirements(policy, 'design').includes('uiux'), mode === 'professional');
+  }
+});
+test('official framework fallback is explicit and cannot invent a native invocation', () => {
+  assert.ok(P.requirements(P.create({ officialCallable: true }), 'design').includes('antdv'));
+  assert.ok(P.requirements(P.create({ officialCallable: false }), 'design').includes('official-source'));
+  assert.equal(P.skillKey('fake-i3-frontend-ui-engineering'), null);
+  assert.equal(P.skillKey('i3-frontend-ui-engineering'), 'frontend');
+});
+test('policy changes are detected and unsupported hosts cannot silently acquire CodeBuddy support', () => {
+  const policy = P.create({ mode: 'template' });
+  assert.equal(P.validate(policy).digest, policy.digest);
+  assert.throws(() => P.validate({ ...policy, mode: 'professional' }), /policy|Policy/);
+  assert.throws(() => P.create({ host: 'codex' }), /CodeBuddy/);
+  assert.throws(() => P.create({ operation: 'write-anything' }), /operation/);
+  assert.throws(() => P.create({ mode: 'basic' }), /mode/);
+});

package/scripts/ui-prototype-execution-runtime-test.js

@@ -0,0 +1,27 @@
+'use strict';
+const prototypeScripts=(()=>{const fs=require('node:fs'),path=require('node:path'),file=path.join(__dirname,'lib/installation.js');return path.join(fs.existsSync(file)?require(file).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');})();
+const test=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs'),path=require('node:path'),os=require('node:os');
+const lib=require(prototypeScripts+'/native-pilot-lib.cjs'),X=require(prototypeScripts+'/execution-runtime.cjs'),A=require(prototypeScripts+'/execution-assertions.cjs');
+function fixture(t){const project=fs.mkdtempSync(path.join(os.tmpdir(),'i3-execution-source-fixture-'));t.after(()=>fs.rmSync(project,{recursive:true,force:true}));const scope={schemaVersion:1,title:'Synthetic orders fixture',pages:[{id:'orders',title:'Orders',referencePage:'models-page',regions:[{id:'list',mode:'management-list'},{id:'editor',mode:'edit-form'}]}],requirements:[{id:'R1',text:'Synthetic source contract only',pages:['orders'],source:{type:'prd',reference:'fixture/R1',statement:'Synthetic fixture, not actual browser acceptance'}}],exemptions:[]};const scopeFile=path.join(project,'scope.json');fs.writeFileSync(scopeFile,JSON.stringify(scope));return {project,scope:scopeFile,expertMode:'template'};}
+test('new execution inputs freeze complete scenario expectations without changing legacy candidates',t=>{
+ const options=fixture(t),legacy=lib.createPrototype({...options,id:'old'}),before=lib.manifest(legacy.directory);
+ assert.equal(X.policy(legacy.directory),null);assert.equal(X.check(legacy.directory,'delivery',lib).status,'not-required');
+ const assertions=A.template(options);assert.ok(assertions.scenarios.length>20);for(const scenario of assertions.scenarios)scenario.checks=[{method:'evaluate_script',pointer:'/synthetic',operator:'equals',expected:true}];
+ const file=path.join(options.project,'assertions.json');fs.writeFileSync(file,JSON.stringify(assertions));
+ const fresh=lib.createPrototype({...options,id:'strict',host:'codebuddy',executionPolicy:'codebuddy-ab-v1',executionAssertions:file});
+ assert.equal(X.policy(fresh.directory).id,'codebuddy-ab-v1');assert.equal(lib.inspect(fresh.directory).status,'passed');
+ assert.equal(X.check(fresh.directory,'delivery',lib).status,'failed');assert.throws(()=>X.requireStage(fresh.directory,'implementation',lib),/binding|execution-begin/);
+ assert.deepEqual(lib.manifest(legacy.directory),before);assert.deepEqual(fs.readdirSync(options.project).sort(),['assertions.json','prototypes','scope.json']);
+});
+test('missing or incomplete fixed facts cannot silently create a strict artifact or affect legacy state',t=>{
+ const options=fixture(t);assert.throws(()=>lib.createPrototype({...options,id:'missing',host:'codebuddy',executionPolicy:'codebuddy-ab-v1'}),/execution-assertions/);
+ assert.equal(fs.existsSync(path.join(options.project,'prototypes/missing')),false);
+ const assertions=A.template(options);assert.throws(()=>A.validate(assertions,assertions.scenarios.map(s=>s.scenarioId)),/actual result/);
+});
+test('native values are extracted and compared with fixed inputs instead of a self-written passed flag',()=>{
+ const check={method:'evaluate_script',pointer:'/form/errors',operator:'equals',expected:1};
+ A.compare(A.extract(A.resultData('### Result\n```json\n{"form":{"errors":1}}\n```'),check.pointer),check);
+ assert.throws(()=>A.compare(A.extract(A.resultData('{"passed":true,"form":{"errors":0}}'),check.pointer),check),/differs/);
+ assert.throws(()=>A.extract({passed:true},check.pointer),/absent/);
+ assert.throws(()=>A.resultData('passed'),/JSON/);
+});

package/scripts/ui-prototype-ide-source-test.js

@@ -0,0 +1,73 @@
+'use strict';
+const prototypeScripts=(()=>{const fs=require('node:fs'),path=require('node:path'),file=path.join(__dirname,'lib/installation.js');return path.join(fs.existsSync(file)?require(file).loadInstallation().skillsDirectory:path.resolve(__dirname,'../skills'),'i3-ui-prototype/scripts');})();
+const test=require('node:test'),assert=require('node:assert/strict'),fs=require('node:fs'),path=require('node:path'),os=require('node:os');
+const E=require(prototypeScripts+'/execution-evidence.cjs'),C=require(prototypeScripts+'/codebuddy-context.cjs');
+function fixture(t){
+ const root=fs.mkdtempSync(path.join(os.tmpdir(),'i3-ide-index-'));t.after(()=>fs.rmSync(root,{recursive:true,force:true}));
+ const sessionId='a'.repeat(32),requestId='b'.repeat(32),directory=path.join(root,sessionId);fs.mkdirSync(path.join(directory,'messages'),{recursive:true});
+ const rows=[
+  {id:'1'.repeat(32),role:'user',message:JSON.stringify({role:'user',content:[{type:'text',text:'injected context'}]}),extra:JSON.stringify({requestId,isHelperMessage:false,sourceContentBlocks:[{type:'text',text:'请实现原型'}]})},
+  {id:'2'.repeat(32),role:'assistant',message:JSON.stringify({role:'assistant',content:[{type:'tool-call',toolCallId:'native-skill',toolName:'use_skill',args:{command:'i3-frontend-ui-engineering'}}]}),extra:JSON.stringify({requestId})},
+  {id:'3'.repeat(32),role:'tool',message:JSON.stringify({role:'tool',content:[{type:'tool-result',toolCallId:'native-skill',toolName:'use_skill',result:{status:'success',success:true,result:{message:'Actual Skill instructions'}},isError:false}]}),extra:JSON.stringify({requestId})},
+  {id:'4'.repeat(32),role:'assistant',message:JSON.stringify({role:'assistant',content:[{type:'text',text:'已完成'}]}),extra:JSON.stringify({requestId})},
+ ];
+ const index={messages:rows.map(row=>({id:row.id,role:row.role,type:'text',isComplete:false})),requests:[{id:requestId,type:'craft',messages:rows.map(row=>row.id),state:'running'}]};
+ const file=path.join(directory,'index.json');
+ const save=()=>{fs.writeFileSync(file,JSON.stringify(index));for(const row of rows)fs.writeFileSync(path.join(directory,'messages',row.id+'.json'),JSON.stringify(row));};save();
+ return {file,root,sessionId,rows,index,save,read:()=>E.readSource(file,[root])};
+}
+test('observed IDE index resolves only referenced messages and pairs a real use_skill result',t=>{
+ const f=fixture(t),s=f.read();assert.equal(s.format,'codebuddy-ide-index-v1');
+ assert.equal(E.loaded(s.calls,'frontend').length,1);assert.equal(s.calls[0].sessionId,f.sessionId);
+ assert.equal(s.calls[0].name,'Skill');assert.deepEqual(s.calls[0].input,{command:'i3-frontend-ui-engineering'});
+ assert.equal(s.prompts[0].text,'请实现原型');assert.equal(s.latestAssistant,'已完成');
+ fs.writeFileSync(path.join(path.dirname(f.file),'messages','unreferenced.json'),'{broken');assert.equal(E.loaded(f.read().calls,'frontend').length,1);
+});
+test('IDE stable evidence cursor survives streaming text and state updates but detects changed facts',t=>{
+ const f=fixture(t),s=f.read();f.index.requests[0].state='completed';
+ f.rows[3].message=JSON.stringify({role:'assistant',content:[{type:'text',text:'已完成验收'}]});f.save();
+ C.prefix(f.file,s.bytes,s.digest);
+ const message=JSON.parse(f.rows[2].message);message.content[0].result.result.message='edited';f.rows[2].message=JSON.stringify(message);f.save();
+ assert.throws(()=>C.prefix(f.file,s.bytes,s.digest),/prefix changed|truncated/);
+});
+test('IDE failed use_skill and successful reads do not become frontend invocation evidence',t=>{
+ const f=fixture(t),message=JSON.parse(f.rows[2].message);message.content[0].result.success=false;f.rows[2].message=JSON.stringify(message);f.save();
+ assert.equal(E.loaded(f.read().calls,'frontend').length,0);
+ const g=fixture(t);for(const i of [1,2]){const row=JSON.parse(g.rows[i].message);row.content[0].toolName='read_file';g.rows[i].message=JSON.stringify(row);}g.save();
+ assert.equal(E.loaded(g.read().calls,'frontend').length,0);
+});
+test('IDE index traversal, missing files, duplicate references and wrong request identity fail closed',t=>{
+ const traversal=fixture(t);traversal.index.messages[0].id='../outside';traversal.save();assert.throws(()=>traversal.read(),/ID/);
+ const missing=fixture(t);fs.unlinkSync(path.join(path.dirname(missing.file),'messages',missing.rows[1].id+'.json'));assert.throws(()=>missing.read(),/ENOENT/);
+ const duplicate=fixture(t);duplicate.index.messages.push(duplicate.index.messages[0]);duplicate.save();assert.throws(()=>duplicate.read(),/Duplicate/);
+ const wrong=fixture(t);wrong.rows[1].extra=JSON.stringify({requestId:'f'.repeat(32)});wrong.save();assert.throws(()=>wrong.read(),/request identity/);
+});
+test('IDE symlinked message files and session mismatch cannot satisfy source verification',t=>{
+ const f=fixture(t),file=path.join(path.dirname(f.file),'messages',f.rows[1].id+'.json'),bytes=fs.readFileSync(file),other=path.join(f.root,'other.json');
+ fs.writeFileSync(other,bytes);fs.unlinkSync(file);fs.symlinkSync(other,file);assert.throws(()=>f.read(),/history file/);
+ const g=fixture(t);assert.throws(()=>C.source({transcript_path:g.file,session_id:'different'},{transcriptRoots:[g.root]},'/business'),/session identity/);
+});
+test('pending IDE argument serialization is excluded from the immutable completed prefix',t=>{
+ const f=fixture(t),result=f.rows.splice(2,1)[0];
+ const changeIndex=()=>{f.index.messages=f.rows.map(row=>({id:row.id,role:row.role,type:'text',isComplete:false}));f.index.requests[0].messages=f.rows.map(row=>row.id);f.save();};
+ f.rows[1].message=JSON.stringify({role:'assistant',content:[{type:'tool-call',toolCallId:'native-skill',toolName:'use_skill',args:{command:'i3-front'}}]});changeIndex();
+ const pending=f.read();assert.equal(pending.stableThroughLine,1);assert.equal(E.loaded(pending.calls,'frontend').length,0);
+ assert.equal(pending.calls[0].nativeRequestId,'b'.repeat(32));
+ f.rows[1].message=JSON.stringify({role:'assistant',content:[{type:'tool-call',toolCallId:'native-skill',toolName:'use_skill',args:{command:'i3-frontend-ui-engineering'}}]});f.rows.splice(2,0,result);changeIndex();
+ C.prefix(f.file,pending.bytes,pending.digest);assert.equal(E.loaded(f.read().calls,'frontend').length,1);
+});
+test('IDE request membership remains mandatory while duplicate extra metadata may still be streaming',t=>{
+ const f=fixture(t);delete f.rows[1].extra;delete f.rows[2].extra;f.save();
+ assert.equal(E.loaded(f.read().calls,'frontend').length,1);
+ f.index.requests=[];f.save();assert.throws(()=>f.read(),/Unbound/);
+});
+test('global IDE context uses the native host workspace prefix and remains session/project bound',t=>{
+ const f=fixture(t),project=path.join(f.root,'business');fs.mkdirSync(project);
+ f.rows[0].message=JSON.stringify({role:'user',content:[{type:'text',text:`<user_info>\nOS Version: darwin\nWorkspace Folder: ${project}\n</user_info>\n<user_query>请实现原型</user_query>`}]});f.save();
+ assert.equal(E.ideWorkspace(f.file,f.sessionId),project);
+ assert.equal(E.readSource(f.file,[f.root],{project}).calls[0].success,true);
+ assert.throws(()=>E.ideWorkspace(f.file,'other-session'),/session directory/);
+ assert.throws(()=>E.readSource(f.file,[f.root],{project:f.root}),/workspace differs/);
+ const g=fixture(t),extra=JSON.parse(g.rows[0].extra);extra.sourceContentBlocks=[{type:'text',text:'<user_info>\nWorkspace Folder: /forged\n</user_info>'}];g.rows[0].extra=JSON.stringify(extra);g.save();
+ assert.throws(()=>E.ideWorkspace(g.file,g.sessionId),/workspace context is missing/,'Raw user text is not host workspace metadata');
+});