@mogragsigma/dsh-dual-host-plugin 0.33.3 → 2.0.0

package/bundle/managed-execution.js

@@ -0,0 +1,207 @@
+import {ManagedTriggers} from './managed-triggers.js';
+import {CLOUD_TASK_POLICY,autonomous} from './managed-cloud-policy.js';
+import {parseEnvelope} from './task-envelope.js';
+import {developmentContract,legacyResourceBusy} from './managed-development-contract.js';
+import {repositoryResources} from './managed-development.js';
+// One cloud authority for native long-running work. Legacy local records are retained, not dispatched.
+// Existing authenticated DirectLink transports this protocol. IM is not an authority.
+import {ManagedSlots,ManagedBudget} from './managed-runtime.js';
+import {tx} from './recovery.js';
+import {isAbsolute,normalize} from 'node:path';
+const json=JSON.stringify;
+const atomic=(db,fn)=>db.isTransaction?fn():tx(db,fn);
+const fail=s=>{throw Error('TASK_EXECUTION_'+s);};
+export function executionSpec(x){
+ if(!x||Object.keys(x).some(k=>!['execution_policy','end_at','schedule','role','cwd','max_requests','active_timeout_ms','period_seconds','search','commands','development'].includes(k))||!['local','cloud'].includes(x.role)||typeof x.cwd!=='string'||!isAbsolute(x.cwd)||normalize(x.cwd)!==x.cwd||x.cwd.length>1000||x.cwd.includes('\0'))fail('SPEC_INVALID');
+ const free=autonomous(x);if(x.schedule!==undefined&&(!free||x.period_seconds!==undefined||!x.schedule||typeof x.schedule!=='object'||Array.isArray(x.schedule)))fail('SCHEDULE_INVALID');if(x.execution_policy!==undefined&&!free||free&&x.role!=='cloud')fail('CLOUD_ONLY');
+ if(free&&(x.max_requests!==undefined||x.active_timeout_ms!==undefined||x.commands!==undefined))fail('RETIRED_LIMIT');
+ if(free&&x.end_at!==undefined&&(!Number.isSafeInteger(x.end_at)||x.end_at<=0))fail('LIMIT_INVALID');
+ if(!free&&(!Number.isInteger(x.max_requests)||x.max_requests<1||x.max_requests>100000||!Number.isInteger(x.active_timeout_ms)||x.active_timeout_ms<1000||x.active_timeout_ms>86400000)||x.period_seconds!==undefined&&(!Number.isInteger(x.period_seconds)||x.period_seconds<60||x.period_seconds>366*86400))fail('LIMIT_INVALID');
+ if(x.commands!==undefined&&(!Array.isArray(x.commands)||x.role!=='local'||x.commands.length<1||x.commands.length>8||new Set(x.commands).size!==x.commands.length||x.commands.some(n=>typeof n!=='string'||!/^[a-z][a-z0-9_-]{0,39}$/.test(n))))fail('COMMAND_CONTRACT_INVALID');
+ if(x.search!==undefined){const s=x.search,p=s?.model_policy;if(!s||Object.keys(s).some(k=>!['scope','model_policy','max_requests'].includes(k))||typeof s.scope!=='string'||!s.scope.trim()||s.scope.length>1000||!p||Object.keys(p).some(k=>!['provider','model','reasoningEffort'].includes(k))||p.provider!=='deepseek-official'||typeof p.model!=='string'||!p.model.trim()||p.model.length>200||p.reasoningEffort!=='disabled'||(!free&&(!Number.isSafeInteger(s.max_requests)||s.max_requests<1||s.max_requests>x.max_requests))||free&&s.max_requests!==undefined)fail('SEARCH_CONTRACT_INVALID');}
+ return {role:x.role,cwd:x.cwd,...(free?{execution_policy:CLOUD_TASK_POLICY,...(x.end_at!==undefined?{end_at:x.end_at}:{})}:{max_requests:x.max_requests,active_timeout_ms:x.active_timeout_ms}),...(x.schedule?{schedule:x.schedule}:{}),...(x.period_seconds?{period_seconds:x.period_seconds}:{}),...(x.search?{search:x.search}:{}),...(x.commands?{commands:x.commands}:{}),...(x.development!==undefined?{development:developmentContract(x.development,x.role)}:{})};
+}
+export class ManagedExecution {
+ constructor(g){
+  this.g=g;this.db=g.store.db;this.now=g.now;this.slots=new ManagedSlots(this.db,this.now,{localEnabled:false});this.budgets=new ManagedBudget(this.db,this.now);
+  this.db.exec(`CREATE TABLE IF NOT EXISTS managed_development_evidence(task_id TEXT PRIMARY KEY,revision INTEGER NOT NULL,record TEXT NOT NULL); CREATE TABLE IF NOT EXISTS managed_executions(task_id TEXT PRIMARY KEY,approval_id TEXT NOT NULL,
+   revision INTEGER NOT NULL,role TEXT NOT NULL,spec TEXT NOT NULL,state TEXT NOT NULL,due INTEGER NOT NULL,
+   human INTEGER NOT NULL DEFAULT 0,claim TEXT,instance TEXT,started INTEGER,lease_until INTEGER,
+   session_id TEXT,report TEXT,error TEXT,parked_state TEXT,runs INTEGER NOT NULL DEFAULT 0,input_cursor INTEGER NOT NULL DEFAULT 0);
+   CREATE TABLE IF NOT EXISTS managed_execution_receipts(claim TEXT PRIMARY KEY,payload TEXT NOT NULL,result TEXT NOT NULL);
+   CREATE TABLE IF NOT EXISTS managed_unstarted_reclaims(claim TEXT PRIMARY KEY,task_id TEXT NOT NULL,instance TEXT NOT NULL,role TEXT NOT NULL);`);
+  if(!this.db.prepare('PRAGMA table_info(managed_executions)').all().some(x=>x.name==='authority'))this.db.exec('ALTER TABLE managed_executions ADD COLUMN authority TEXT');
+  if(!this.db.prepare('PRAGMA table_info(managed_executions)').all().some(x=>x.name==='occurrence_id'))this.db.exec('ALTER TABLE managed_executions ADD COLUMN occurrence_id TEXT');
+  this.schedules=new ManagedTriggers(this);
+ }
+ observed(id,baseline){try{this.g.observer?.changed(id,baseline);}catch{} /* Never block execution for observation failure. */}
+ get(id){return this.db.prepare('SELECT * FROM managed_executions WHERE task_id=?').get(id);}
+ busy(id){return !!this.db.prepare('SELECT 1 FROM managed_slots WHERE task_id=?').get(id);}
+ owns(id){return !!this.get(id);}
+ authority(r,{resuming=false}={}){
+  if(!r)fail('NOT_FOUND');if(!resuming)this.g.continuity.assertActive(r.task_id);
+  if(autonomous(JSON.parse(r.spec))){
+   if(!r.authority||this.g.catalog.head(r.task_id).spec_revision!==r.revision)fail('AUTHORITY_CHANGED');
+   const spec=JSON.parse(r.spec);if(spec.end_at&&this.now()>=spec.end_at)fail('BUSINESS_DEADLINE');
+   this.g.sourceRouting?.assertTask(r.task_id,{required:JSON.parse(r.authority).kind==='proactive-policy'});
+   return JSON.parse(r.authority);
+  }
+  const a=this.g.approvals.view(r.approval_id);
+  if(a.state!=='approved'||a.spec_revision!==r.revision||json(a.proposal.execution)!==r.spec)fail('AUTHORITY_CHANGED');
+  return a;
+ }
+ view(id){const r=this.get(id);if(!r)return null;return {task_id:id,role:r.role,state:r.state,due:r.due,report:r.report?JSON.parse(r.report):null,error:r.error,runs:r.runs,session_id:r.session_id,development:this.evidenceView(id),budget:this.budgets.view(id),filesystem:r.role==='cloud'?'host-account':'approved-local-workspace',slot_held:this.busy(id),schedules:this.schedules.list(id)};}
+ evidenceView(id){const r=this.db.prepare('SELECT * FROM managed_development_evidence WHERE task_id=?').get(id);return r?{...JSON.parse(r.record),task_revision:r.revision,historical:r.revision!==this.g.catalog.head(id).spec_revision||JSON.parse(r.record).approval_id!==this.get(id)?.approval_id,checked_now:false}:null;}
+ evidence(role,a){this.validate(role,a);const r=this.owned(role,a);if(!JSON.parse(r.spec).development||!a.evidence||a.evidence.schema!==1||Buffer.byteLength(json(a.evidence))>131072)fail('EVIDENCE_INVALID');this.db.prepare('INSERT OR REPLACE INTO managed_development_evidence VALUES (?,?,?)').run(r.task_id,r.revision,json({...a.evidence,approval_id:r.approval_id}));return {saved:true};}
+ // Direct, durable user-task authority; approval_id='' is only a schema-compatible
+ // absence marker. There is no synthetic approval or credential row.
+ start({task_id,expected_revision,spec,policy}){
+  const h=this.g.catalog.head(task_id),e=parseEnvelope(h.goal);
+  if(!autonomous(e)||!this.g.continuity?.managed(task_id))fail('NATIVE_TASK_REQUIRED');
+  if(h.spec_revision!==expected_revision)fail('REVISION_CHANGED');
+  this.g.continuity.assertActive(task_id);spec=executionSpec(spec);
+  if(!autonomous(spec)||spec.role!=='cloud')fail('CLOUD_ONLY');
+  const old=this.get(task_id);
+  const existingAuthority=old?.authority?JSON.parse(old.authority):null;
+  if(e.origin.kind==='policy'){if(!this.g.sourceRouting)fail('AUTHORITY_CHANGED');this.g.sourceRouting.assertTask(task_id,{required:true});}
+  const authority=json({kind:e.origin.kind==='policy'&&existingAuthority?.kind!=='direct-user-task'?'proactive-policy':'direct-user-task',model_policy:policy,origin:e.origin,...(existingAuthority?.adoption?{adoption:existingAuthority.adoption}:{})});
+  if(old){
+   if(!autonomous(JSON.parse(old.spec)))fail('LEGACY_CONTRACT_RETAINED');
+   if(old.revision===expected_revision&&old.spec===json(spec)&&old.authority===authority)return this.view(task_id);
+   if(old.role!==spec.role||JSON.parse(old.spec).cwd!==spec.cwd)fail('SESSION_BINDING_CHANGED');
+  }
+  this.g.assertTaskQuiescent(task_id);
+  if(this.schedules.current(task_id)&&this.schedules.pending(this.schedules.current(task_id)))fail('SCHEDULE_OCCURRENCE_UNSETTLED');
+  const plan=this.schedules.prepare(task_id,spec,old);
+  atomic(this.db,()=>{
+   this.budgets.bind(task_id,policy,{executionPolicy:CLOUD_TASK_POLICY,endAt:spec.end_at,search:spec.search},{amend:!!old});
+   if(old)this.db.prepare("UPDATE managed_executions SET revision=?,spec=?,authority=?,state='queued',due=?,error=NULL,parked_state=NULL WHERE task_id=?").run(expected_revision,json(spec),authority,this.now(),task_id);
+   else this.db.prepare("INSERT INTO managed_executions(task_id,approval_id,revision,role,spec,authority,state,due) VALUES (?,'',?,'cloud',?,?,'queued',?)").run(task_id,expected_revision,json(spec),authority,this.now());
+   this.schedules.bind(task_id,spec,plan);if(plan)this.db.prepare("UPDATE managed_executions SET state='scheduled',human=0 WHERE task_id=?").run(task_id);
+  });this.observed(task_id,old?.runs??0);return this.view(task_id);
+ }
+ enqueue({task_id,approval_id}){
+  if(!this.g.continuity?.managed(task_id))fail('NATIVE_TASK_REQUIRED');
+  const existing=this.get(task_id);if(autonomous(parseEnvelope(this.g.catalog.head(task_id).goal)))fail('DIRECT_EXECUTION_REQUIRED');
+  if(existing?.approval_id===approval_id)return this.view(task_id);
+  this.g.continuity.assertActive(task_id);this.g.assertTaskQuiescent(task_id);
+  const a=this.g.approvals.view(approval_id),e=a.proposal.execution;
+  if(a.task_id!==task_id||a.state!=='approved'||!e||a.proposal.scopes.join()!=='develop')fail('APPROVAL_REQUIRED');
+  if(existing&&(existing.role!==e.role||JSON.parse(existing.spec).cwd!==e.cwd))fail('SESSION_BINDING_CHANGED');
+  tx(this.db,()=>{
+   this.budgets.bind(task_id,a.proposal.model_policy,{maxRequests:e.max_requests,endAt:a.expires,search:e.search},{amend:!!existing});
+   if(existing)this.db.prepare("UPDATE managed_executions SET approval_id=?,revision=?,spec=?,state='queued',due=?,human=0,error=NULL,parked_state=NULL WHERE task_id=?").run(approval_id,a.spec_revision,json(e),this.now(),task_id);
+   else this.db.prepare("INSERT INTO managed_executions(task_id,approval_id,revision,role,spec,state,due) VALUES (?,?,?,?,?,'queued',?)").run(task_id,approval_id,a.spec_revision,e.role,json(e),this.now());
+  });this.observed(task_id,existing?.runs??0);return this.view(task_id);
+ }
+ // Only persisted, direct human follow-input can earn the +1. New tasks never do.
+ follow(id){
+  const r=this.get(id);if(r&&JSON.parse(r.spec).schedule&&!this.schedules.followAllowed(r))return;if(!r||!['idle','waiting','waiting_input','queued'].includes(r.state)||!r.runs||!this.g.continuity.canRun(id))return;
+  const pending=this.db.prepare("SELECT count(*) n,max(CASE WHEN json_extract(e.source,'$.kind') IS NULL THEN 1 ELSE 0 END) human FROM task_inputs i JOIN task_input_events e ON i.event_id=e.id WHERE i.task_id=? AND i.mode='follow' AND i.state='saved' AND i.seq>?").get(id,r.input_cursor);
+  if(pending.n)this.db.prepare("UPDATE managed_executions SET state='queued',human=?,due=? WHERE task_id=?").run(pending.human?1:0,this.now(),id);
+ }
+ claim(role,{instance_id,development_contract,autonomy_contract}){
+  if(role==='local')return {item:null,reason:'local-managed-execution-retired'};
+  if(typeof instance_id!=='string'||!instance_id||instance_id.length>100)fail('INSTANCE_INVALID');
+  return tx(this.db,()=>{
+   this.reconcile();
+   const ready=this.db.prepare("SELECT * FROM managed_executions WHERE role=? AND state IN ('queued','waiting') AND due<=? ORDER BY human DESC,due,task_id").all(role,this.now());
+   for(const r of ready){
+    if(autonomous(JSON.parse(r.spec))&&autonomy_contract!==1)continue;
+    if(JSON.parse(r.spec).development&&development_contract!==1)continue;
+    if(!this.schedules.canClaim(r))continue;
+    try{this.authority(r);}catch(e){this.db.prepare("UPDATE managed_executions SET error=? WHERE task_id=?").run(e.message,r.task_id);continue;}
+    // Until finer path-conflict evidence exists, one explicit working directory is
+    // a cross-host resource key. It is a scheduling key, NOT a cloud file sandbox.
+    const spec=JSON.parse(r.spec);let resources=['cwd:'+spec.cwd];
+    if(spec.development){if(role==='cloud'){try{resources.push(...repositoryResources(spec.cwd,spec.development));}catch(e){if(spec.development.branch){this.db.prepare('UPDATE managed_executions SET error=? WHERE task_id=?').run(e.message,r.task_id);continue;}}}else if(role==='local')resources.push('local-managed-development');}
+    if(legacyResourceBusy(this.db,resources))continue;
+    const slot=this.slots.reserve({task_id:r.task_id,role,resources,humanFollowup:!!r.human});
+    if(!slot.reserved)continue;
+    this.db.prepare("UPDATE managed_executions SET state='claimed',claim=?,instance=?,lease_until=?,error=NULL WHERE task_id=?").run(slot.claim,instance_id,this.now()+30000,r.task_id);
+    return {item:this.item(this.get(r.task_id))};
+   }return {item:null};
+  });
+ }
+ item(r){const a=r.authority?JSON.parse(r.authority):this.g.approvals.view(r.approval_id);return {...r,spec:JSON.parse(r.spec),policy:a.model_policy??a.proposal.model_policy,goal:this.g.catalog.head(r.task_id).goal,task_scope:r.authority?parseEnvelope(this.g.catalog.head(r.task_id).goal).entry_interpretation:a.proposal.changes,budget:this.budgets.view(r.task_id),trigger:this.schedules.context(r.occurrence_id)};}
+ owned(role,a){const r=this.get(a.task_id);if(!r||r.role!==role||r.claim!==a.claim||r.instance!==a.instance_id)fail('CLAIM_DENIED');this.slots.assert(r.task_id,r.claim);return r;}
+ validate(role,a){
+  const r=this.owned(role,a);this.authority(r);
+  if(!['claimed','running'].includes(r.state)||r.lease_until<=this.now())fail('LEASE_ENDED');
+  if(r.started&&JSON.parse(r.spec).active_timeout_ms&&this.now()>=r.started+JSON.parse(r.spec).active_timeout_ms)fail('ACTIVE_LIMIT');
+  this.db.prepare('UPDATE managed_executions SET lease_until=? WHERE task_id=?').run(this.now()+30000,r.task_id);
+  try{this.g.observer?.capture(r,a.observation);}catch{} // Observability must not interrupt valid execution.
+  return {valid:true,lease_ms:30000,control_version:this.g.continuity.state(r.task_id).version,task_id:r.task_id,input_cursor:r.input_cursor,pending_input:this.db.prepare("SELECT max(seq) seq FROM task_inputs WHERE task_id=? AND mode='follow' AND state='saved'").get(r.task_id).seq??null};
+ }
+ begin(role,a){
+  this.validate(role,a);const r=this.owned(role,a);
+  if(r.state==='running')return {item:this.item(r),already_started:true};
+  this.db.prepare("UPDATE managed_executions SET state='running',started=?,human=0,runs=runs+1 WHERE task_id=?").run(this.now(),r.task_id);
+  return {item:this.item(this.get(r.task_id)),already_started:false};
+ }
+ reserve(role,a){this.validate(role,a);const r=this.owned(role,a);if(r.state!=='running')fail('NOT_RUNNING');if(a.channel!==undefined&&a.channel!=='search')fail('BUDGET_CHANNEL_INVALID');return this.budgets.reserve(r.task_id,a.policy,a.purpose,{search:a.channel==='search'});}
+ usage(role,a){this.owned(role,a);return this.budgets.usage(a.task_id,a.request_id,a.usage);}
+ inputs(role,a){this.validate(role,a);const r=this.owned(role,a);if(r.authority&&(a.after??0)>r.input_cursor)fail('INPUT_CURSOR_GAP');const result=this.g.continuity.workerRead({task_id:r.task_id,run_id:r.claim,goal:this.g.catalog.head(r.task_id).goal},{after:a.after??0,limit:20});
+  if(result.items.length)this.db.prepare('UPDATE managed_executions SET input_cursor=max(input_cursor,?) WHERE task_id=?').run(result.items.at(-1).seq,r.task_id);
+  return result;
+ }
+ finish(role,a){
+  const payload=json(a),old=this.db.prepare('SELECT * FROM managed_execution_receipts WHERE claim=?').get(a.claim);
+  if(old){if(this.get(a.task_id)?.role!==role)fail('CLAIM_DENIED');if(old.payload!==payload)fail('RECEIPT_CONFLICT');return JSON.parse(old.result);}
+  return tx(this.db,()=>{
+   const reclaimed=this.db.prepare('SELECT * FROM managed_unstarted_reclaims WHERE claim=?').get(a.claim);
+   if(reclaimed){
+    if(reclaimed.role!==role||reclaimed.task_id!==a.task_id||reclaimed.instance!==a.instance_id)fail('CLAIM_DENIED');
+    if(a.drained!==true||a.outcome!=='interrupted')fail('REPORT_INVALID');
+    const result={recorded:true,state:'reclaimed_before_start',task_id:a.task_id};
+    this.db.prepare('INSERT INTO managed_execution_receipts VALUES (?,?,?)').run(a.claim,payload,json(result));return result;
+   }
+   const r=this.owned(role,a);if(a.drained!==true)fail('DRAIN_REQUIRED');
+   if(!(typeof a.session_id==='string'&&a.session_id.startsWith('managed-')||a.session_id===null&&['failed','interrupted'].includes(a.outcome)&&!r.session_id)||typeof a.summary!=='string'||!a.summary||a.summary.length>4000||!['ready','waiting','failed','stopped','interrupted'].includes(a.outcome))fail('REPORT_INVALID');
+   if(a.error!==undefined&&(typeof a.error!=='string'||!/^([A-Z][A-Z_]{1,100})$/.test(a.error)))fail('REPORT_INVALID');
+   if(r.session_id&&r.session_id!==a.session_id)fail('SESSION_CHANGED');
+   let valid=true;try{this.authority(r);}catch{valid=false;}
+   const spec=JSON.parse(r.spec);if(valid&&a.outcome==='ready'&&autonomous(spec))this.assertCompletion(r,a.completion);
+   if(valid&&a.outcome==='ready'&&spec.development){const evidence=this.evidenceView(r.task_id),expected={workspace:'workspace_ready',commit:'commit_verified',push:'remote_commit_verified',pr:'pr_verified'}[spec.development.delivery];if(!evidence||evidence.historical||evidence.at<r.started||evidence.delivery?.mode!==spec.development.delivery||evidence.delivery?.state!==expected||evidence.checks?.some(c=>c.state!=='passed'))fail('DEVELOPMENT_EVIDENCE_REQUIRED');}
+   const state=!valid?'fenced':a.outcome==='interrupted'?(spec.period_seconds?'waiting':'queued'):a.outcome==='failed'?'needs_review':a.outcome==='stopped'?'needs_review':a.outcome==='waiting'?'waiting_input':spec.schedule&&r.occurrence_id?'scheduled':spec.period_seconds?'waiting':'idle';
+   // A late completion is retained, never used to revive stopped/revoked work.
+   this.db.prepare('UPDATE managed_executions SET state=?,due=?,session_id=?,report=?,error=?,claim=NULL,instance=NULL,lease_until=NULL,started=NULL WHERE task_id=?').run(state,spec.period_seconds?this.now()+spec.period_seconds*1000:this.now(),a.session_id,json({outcome:a.outcome,summary:a.summary,at:this.now(),late:!valid,spec_revision:r.revision}),a.error??null,r.task_id);
+   this.slots.release(r.task_id,r.claim,{drained:true});if(valid&&a.outcome==='ready')this.schedules.complete(r);this.follow(r.task_id);
+   this.observed(r.task_id,Math.max(0,r.runs-1));
+   const result={recorded:true,state:this.get(r.task_id).state,task_id:r.task_id};this.db.prepare('INSERT INTO managed_execution_receipts VALUES (?,?,?)').run(a.claim,payload,json(result));return result;
+  });
+ }
+ // Only never-started expired claims are reclaimable. Running/unknown work keeps
+ // its slot until its owning endpoint reports actual drain, even after reboot.
+ reconcile(){this.schedules.tick();for(const r of this.db.prepare("SELECT * FROM managed_executions WHERE state='claimed' AND lease_until<=?").all(this.now()))atomic(this.db,()=>{this.db.prepare('INSERT INTO managed_unstarted_reclaims VALUES (?,?,?,?)').run(r.claim,r.task_id,r.instance,r.role);this.slots.release(r.task_id,r.claim,{drained:true});this.db.prepare("UPDATE managed_executions SET state='queued',claim=NULL,instance=NULL WHERE task_id=?").run(r.task_id);});
+  for(const r of this.db.prepare("SELECT task_id FROM managed_executions WHERE state IN ('idle','waiting','waiting_input','queued')").all())this.follow(r.task_id);
+ }
+ assertResume(id){const r=this.get(id);if(!r)return;if(r.claim||this.busy(id))fail('NOT_QUIESCENT');this.authority(r,{resuming:true});if(!r.parked_state||!['queued','waiting','waiting_input','idle','scheduled'].includes(r.parked_state))fail('RESUME_NOT_READY');}
+ control(id,action){
+  const r=this.get(id);if(!r)return;this.observed(id,r.runs);this.schedules.control(id,action);
+  if(action==='pause'){const periodic=JSON.parse(r.spec).period_seconds;const parked=['claimed','running','queued'].includes(r.state)?(periodic?'waiting':'queued'):r.state;this.db.prepare('UPDATE managed_executions SET parked_state=? WHERE task_id=?').run(parked,id);}
+  if(action==='stop')this.db.prepare("UPDATE managed_executions SET parked_state=NULL,state=CASE WHEN claim IS NULL THEN 'fenced' ELSE state END WHERE task_id=?").run(id);
+  if(action==='resume'&&r.parked_state){
+   const period=JSON.parse(r.spec).period_seconds;this.authority(r);const valid=true;
+   this.db.prepare('UPDATE managed_executions SET state=?,due=?,parked_state=NULL WHERE task_id=?').run(valid?r.parked_state:'fenced',r.parked_state==='waiting'&&period?this.now()+period*1000:this.now(),id);
+   if(valid)this.follow(id);
+  }
+ }
+ suspend(role,a){
+  const done=this.db.prepare('SELECT payload FROM managed_execution_receipts WHERE claim=?').get(a.claim);
+  if(done){const p=JSON.parse(done.payload);if(p.task_id!==a.task_id||p.instance_id!==a.instance_id||this.get(a.task_id)?.role!==role)fail('CLAIM_DENIED');return {historical_receipt:true};}
+  const r=this.owned(role,a);return atomic(this.db,()=>{
+   const state=this.g.continuity.state(r.task_id);if(state.state==='active'){this.control(r.task_id,'pause');this.db.prepare("UPDATE task_continuity SET state='paused',version=version+1,control_id=NULL,targets='[]' WHERE task_id=?").run(r.task_id);this.db.prepare("UPDATE managed_executions SET error='TASK_EXECUTION_NATIVE_ARCHIVE_STOP' WHERE task_id=?").run(r.task_id);}
+   return {paused:this.g.continuity.state(r.task_id).state==='paused',task_id:r.task_id};
+  });
+ }
+ assertCompletion(r,c){
+  const latest=this.db.prepare("SELECT max(seq) n FROM task_inputs WHERE task_id=? AND mode='follow' AND state<>'handed_back'").get(r.task_id).n??0;
+  if(!c||c.round!==r.runs||c.input_cursor!==r.input_cursor||latest>r.input_cursor||c.control_version!==this.g.continuity.state(r.task_id).version)fail('COMPLETION_STALE');
+ }
+ recover(role,a){const r=this.owned(role,a);this.authority(r);if(r.state!=='running')fail('NOT_RUNNING');this.db.prepare('UPDATE managed_executions SET lease_until=? WHERE task_id=?').run(this.now()+30000,r.task_id);return this.item(this.get(r.task_id));}
+ grantId(r){return r.authority?'task:'+r.task_id+':'+r.revision+':'+r.runs+':'+r.input_cursor:r.approval_id;}
+ async deliver(role,a){this.validate(role,a);const r=this.owned(role,a),d=JSON.parse(r.spec).development,n=d?.notification;if(!n)fail('DELIVERY_AGREEMENT_REQUIRED');if(r.authority)this.assertCompletion(r,a.completion);const artifact=this.g.artifacts.load(r.task_id,a.artifact_id);if(artifact.kind!=='native_file'||artifact.spec_revision!==r.revision||!d.artifacts.includes(artifact.path)||a.current_sha256!==artifact.sha256)fail('ARTIFACT_NOT_AUTHORIZED');return this.g.notifications.media.enqueueTask(role,{task_id:r.task_id,artifact_id:a.artifact_id,mode:'file',expected_revision:r.revision,expected_binding_revision:n.binding_revision,event_id:'managed-delivery:'+this.grantId(r)+':'+artifact.id},this.grantId(r),n.target_key);}
+ artifact(role,a){this.validate(role,a);const r=this.owned(role,a),d=JSON.parse(r.spec).development;if(!d||!d.artifacts.includes(a.path))fail('ARTIFACT_NOT_AUTHORIZED');return this.g.artifacts.nativeChunk(r,a);}
+ call(method,a,role){if(!['local','cloud'].includes(role))fail('ROLE_INVALID');const m=method.slice('execution_'.length);if(m==='enqueue')return this.enqueue(a);if(m==='status')return this.view(a.task_id);if(!['usage','recover','claim','begin','validate','reserve','inputs','finish','suspend','evidence','artifact','deliver'].includes(m))fail('METHOD_DENIED');return this[m](role,a);}
+}

package/bundle/managed-policy.js

@@ -0,0 +1,20 @@
+// Task policy is not an OS sandbox. These guards catch explicit high-risk
+// requests; arbitrary shell programs still run with the cloud account's rights.
+import {homedir} from 'node:os';
+import {resolve,relative,isAbsolute,dirname,basename} from 'node:path';
+import {realpathSync} from 'node:fs';
+const fail=s=>{throw Error('TASK_EXECUTION_'+s);};
+export const under=(root,path)=>{const rel=relative(root,path);return rel===''||rel!=='..'&&!rel.startsWith('../')&&!isAbsolute(rel);};
+const physical=p=>{p=resolve(p);try{return realpathSync(p);}catch(e){if(e.code!=='ENOENT'&&e.code!=='ENOTDIR')throw e;const parent=dirname(p);return parent===p?p:resolve(physical(parent),basename(p));}};
+export function assertExplicitRisk(exec,cwd,{stateDir,protectedRoots=[],development,role='cloud'}={}){
+ const roots=[stateDir,process.env.DSH_HOME,resolve(homedir(),'.ssh'),resolve(homedir(),'.aws'),...protectedRoots].filter(Boolean).map(physical);
+ const arg=exec.arguments??{},path=arg.file_path??arg.path;
+ if(typeof path==='string'&&roots.some(root=>under(root,physical(resolve(cwd,path)))))fail('PROTECTED_DATA');
+ if(exec.name==='bash'){
+  const command=arg.command;if(typeof command!=='string')fail('COMMAND_INVALID');
+  if(/\b(?:sudo|su|systemctl|launchctl|shutdown|reboot|mkfs(?:\.\w+)?|fdisk|parted)\b|\brm\s+[^\n;&|]*-[\w]*[rR]|\bgit\b[^\n;&|]*\b(?:reset|clean|rebase|merge)\b|\bgit\b[^\n;&|]*(?:--force|--mirror|--delete|--amend|\s-[a-zA-Z]*f(?:\s|$))|\bgit\s+(?:branch\s+-[dD]|tag\s+-d)|\b(?:npm|pnpm|yarn)\s+publish\b|\b(?:gh|glab)\s+(?:(?:pr|mr)\s+(?:merge|close)|release\s+create)\b|\b(?:kubectl|terraform)\b[^\n;&|]*\b(?:apply|destroy|delete)\b/.test(command))fail('HIGH_RISK_REVIEW_REQUIRED');
+  const mode=role==='cloud'?development?.delivery:null;
+  if(/\bgit\b[^\n;&|]*\bcommit\b/.test(command)&&!['commit','push','pr'].includes(mode)||/\bgit\b[^\n;&|]*\bpush\b/.test(command)&&!['push','pr'].includes(mode)||/\b(?:gh|glab)\s+(?:pr|mr)\s+create\b/.test(command)&&mode!=='pr')fail('HIGH_RISK_REVIEW_REQUIRED');
+  if(roots.some(p=>command.includes(p))||/(?:~\/|\$HOME\/)(?:\.ssh|\.aws|\.dsh)(?:[\/\s]|$)/.test(command))fail('PROTECTED_DATA');
+ }
+}

package/bundle/managed-runtime.js

@@ -0,0 +1,186 @@
+// R3 primitives shared by the coordinator and managed execution endpoints.
+// No IM identity, session deletion, implicit retry or replacement-session recovery.
+import {CLOUD_TASK_POLICY} from './managed-cloud-policy.js';
+import {randomUUID} from 'node:crypto';
+import {isAbsolute,normalize} from 'node:path';
+
+const json=JSON.stringify;
+export const ARCHIVE_IDLE_MS=7*86400000;
+const fail=code=>{throw Error('TASK_RUNTIME_'+code);};
+const text=s=>typeof s==='string'&&s.length>0&&s.length<=512&&!s.includes('\0');
+const atomic=(db,fn)=>{if(db.isTransaction)return fn();db.exec('BEGIN IMMEDIATE');try{const r=fn();db.exec('COMMIT');return r;}catch(e){if(db.isTransaction)db.exec('ROLLBACK');throw e;}};
+
+// DSH rc.1 exposes Agent.model; rc.5 exposes a scoped public selection helper.
+// Keep one selection per live Agent and release its listeners with that scope.
+const legacySelections=new WeakMap();
+export async function selectManagedModel(agent,policy,load=()=>import('@deepseek-ai/dsh-agent')){
+ if(typeof agent?.model?.select==='function'){agent.model.select(policy);return;}
+ const existing=legacySelections.get(agent);if(existing){existing.current={...policy};return;}
+ const native=await load();
+ if(typeof native.installModelSelection!=='function'||native.installModelSelection.length<2||typeof agent?.ctx?.effect!=='function')throw Error('TASK_EXECUTION_MODEL_SELECTION_UNAVAILABLE');
+ const selection={current:{...policy},assembled:undefined};
+ const dispose=native.installModelSelection(agent.ctx,selection);
+ agent.ctx.effect(()=>()=>{dispose();legacySelections.delete(agent);});
+ legacySelections.set(agent,selection);
+}
+
+// Same meaning as prototype WorkerSlots: a starting or background-settling worker
+// still holds its slot. Durable ownership also prevents an offline peer's lease
+// expiry from granting an unsafe replacement. Only a verified drain releases it.
+export class ManagedSlots {
+ constructor(db,now=Date.now,{localEnabled=true}={}){
+  this.db=db;this.now=now;this.localEnabled=localEnabled;
+  db.exec(`CREATE TABLE IF NOT EXISTS managed_slots(
+   task_id TEXT PRIMARY KEY,claim TEXT UNIQUE NOT NULL,role TEXT NOT NULL,
+   resources TEXT NOT NULL,person INTEGER NOT NULL,created INTEGER NOT NULL);`);
+ }
+ list(){return this.db.prepare('SELECT * FROM managed_slots ORDER BY created,task_id').all();}
+ reserve({task_id,role,resources=[],humanFollowup=false}){
+  if(!text(task_id)||!['local','cloud'].includes(role)||typeof humanFollowup!=='boolean'||!Array.isArray(resources)||resources.length>16||resources.some(x=>!text(x))||new Set(resources).size!==resources.length)fail('SLOT_INVALID');
+  if(role==='local'&&!this.localEnabled)return {reserved:false,reason:'local_execution_retired'};
+  return atomic(this.db,()=>{
+   const rows=this.list();
+   if(rows.some(r=>r.task_id===task_id))return {reserved:false,reason:'task_running'};
+   if(rows.some(r=>JSON.parse(r.resources).some(x=>resources.includes(x))))return {reserved:false,reason:'resource_busy'};
+   // CR-02: cloud 3+1, local one independently bounded worker, not a shared pool.
+   const used=rows.filter(r=>r.role===role).length,limit=role==='local'?1:3+(humanFollowup?1:0);
+   if(used>=limit)return {reserved:false,reason:'worker_busy'};
+   const claim=randomUUID();
+   this.db.prepare('INSERT INTO managed_slots VALUES (?,?,?,?,?,?)').run(task_id,claim,role,json([...resources].sort()),Number(humanFollowup),this.now());
+   return {reserved:true,claim,task_id,extra_slot:role==='cloud'&&used>=3};
+  });
+ }
+ assert(task,claim){const r=this.db.prepare('SELECT * FROM managed_slots WHERE task_id=?').get(task);if(!r||r.claim!==claim)fail('STALE_SLOT');return r;}
+ release(task,claim,{drained}={}){this.assert(task,claim);if(drained!==true)fail('DRAIN_REQUIRED');this.db.prepare('DELETE FROM managed_slots WHERE task_id=? AND claim=?').run(task,claim);}
+ snapshot(){const rows=this.list();return {ordinary:3,human_followup_extra:1,local_limit:this.localEnabled?1:0,cloud_held:rows.filter(r=>r.role==='cloud').length,local_held:rows.filter(r=>r.role==='local').length,held:rows.length,unknown_owners_still_hold:true};}
+}
+
+// Counts actual dispatched model requests, not model turns or token billing.
+// The caller must route root, descendant, auxiliary and retry streams here BEFORE
+// dispatch. Failed/unknown calls are charged; a restart never refunds them.
+export class ManagedBudget {
+ constructor(db,now=Date.now){
+  this.db=db;this.now=now;
+  db.exec(`CREATE TABLE IF NOT EXISTS managed_budgets(task_id TEXT PRIMARY KEY,policy TEXT NOT NULL,max_requests INTEGER NOT NULL,end_at INTEGER NOT NULL);
+   CREATE TABLE IF NOT EXISTS managed_model_requests(id TEXT PRIMARY KEY,task_id TEXT NOT NULL,purpose TEXT NOT NULL,created INTEGER NOT NULL);
+   CREATE INDEX IF NOT EXISTS managed_model_requests_task ON managed_model_requests(task_id);`);
+  if(!db.prepare('PRAGMA table_info(managed_model_requests)').all().some(x=>x.name==='usage'))db.exec('ALTER TABLE managed_model_requests ADD COLUMN usage TEXT');
+  if(!db.prepare('PRAGMA table_info(managed_model_requests)').all().some(x=>x.name==='policy'))db.exec('ALTER TABLE managed_model_requests ADD COLUMN policy TEXT');
+  if(!db.prepare('PRAGMA table_info(managed_budgets)').all().some(x=>x.name==='mode'))db.exec("ALTER TABLE managed_budgets ADD COLUMN mode TEXT NOT NULL DEFAULT 'capped'");
+  if(!db.prepare('PRAGMA table_info(managed_budgets)').all().some(x=>x.name==='search'))db.exec('ALTER TABLE managed_budgets ADD COLUMN search TEXT');
+ }
+ bind(task,policy,{maxRequests,endAt,search,executionPolicy},{amend=false}={}){
+  const unlimited=executionPolicy===CLOUD_TASK_POLICY;
+  if(unlimited){maxRequests=0;endAt??=0;} // explicit no-limit discriminator, never a huge cap
+  if(!text(task)||!policy||!text(policy.provider)||!text(policy.model)||Object.keys(policy).some(k=>!['provider','model','reasoningEffort'].includes(k))||policy.reasoningEffort!==undefined&&!text(policy.reasoningEffort)||(!unlimited&&(!Number.isSafeInteger(maxRequests)||maxRequests<1||maxRequests>100000))||!Number.isSafeInteger(endAt)||endAt!==0&&endAt<=this.now()||!unlimited&&endAt===0)fail('BUDGET_INVALID');
+  const saved={provider:policy.provider,model:policy.model,...(policy.reasoningEffort!==undefined?{reasoningEffort:policy.reasoningEffort}:{})};
+  const old=this.db.prepare('SELECT * FROM managed_budgets WHERE task_id=?').get(task);
+  const auxiliary=search?json(search):null;
+  const mode=unlimited?'unlimited':'capped';
+  if(old){
+   if(!unlimited&&amend&&search&&search.max_requests<this.searchUsed(task))fail('BUDGET_BELOW_USED');
+   if(amend){if(!unlimited&&maxRequests<this.view(task).used)fail('BUDGET_BELOW_USED');this.db.prepare('UPDATE managed_budgets SET policy=?,max_requests=?,end_at=?,search=?,mode=? WHERE task_id=?').run(json(saved),maxRequests,endAt,auxiliary,mode,task);}
+   else if(old.policy!==json(saved)||old.max_requests!==maxRequests||old.end_at!==endAt||old.search!==auxiliary||old.mode!==mode)fail('BUDGET_CHANGED');
+   return this.view(task);
+  }
+  this.db.prepare('INSERT INTO managed_budgets(task_id,policy,max_requests,end_at,search,mode) VALUES (?,?,?,?,?,?)').run(task,json(saved),maxRequests,endAt,auxiliary,mode);return this.view(task);
+ }
+ view(task){const r=this.db.prepare('SELECT * FROM managed_budgets WHERE task_id=?').get(task);if(!r)fail('BUDGET_NOT_FOUND');return {...r,max_requests:r.mode==='unlimited'?null:r.max_requests,end_at:r.end_at||null,policy:JSON.parse(r.policy),search:r.search?JSON.parse(r.search):null,search_used:this.searchUsed(task),usage_status:'unknown-unless-native-reported',request_count_scope:'native llm streams and managed_search; native web_search internal requests unknown',used:this.db.prepare('SELECT count(*) n FROM managed_model_requests WHERE task_id=?').get(task).n};}
+ usage(task,id,usage){
+  if(!id||!usage||typeof usage!=='object')return {recorded:false,status:'unknown'};
+  const safe=Object.fromEntries(Object.entries(usage).filter(([k,v])=>/^(inputTokens|outputTokens|totalTokens|cachedInputTokens)$/.test(k)&&Number.isFinite(v)&&v>=0));
+  if(!Object.keys(safe).length)return {recorded:false,status:'unknown'};
+  try{const r=this.db.prepare('UPDATE managed_model_requests SET usage=? WHERE task_id=? AND id=?').run(json(safe),task,id);return {recorded:r.changes===1,status:r.changes?'reported':'unknown'};}catch{return {recorded:false,status:'unknown'};}
+ }
+ searchUsed(task){return this.db.prepare("SELECT count(*) n FROM managed_model_requests WHERE task_id=? AND purpose='managed-search'").get(task).n;}
+ reserve(task,policy,purpose,{search=false}={}){
+  if(!text(purpose))fail('REQUEST_INVALID');
+  return atomic(this.db,()=>{
+   const b=this.view(task),p=search?b.search?.model_policy:b.policy;
+   if(search&&(!p||b.mode!=='unlimited'&&b.search_used>=b.search.max_requests))fail('SEARCH_BUDGET_EXHAUSTED');
+   if(!search&&purpose==='managed-search')fail('REQUEST_INVALID');
+   if(policy?.provider!==p.provider||policy?.model!==p.model||p.reasoningEffort!==undefined&&policy.reasoningEffort!==p.reasoningEffort)fail('MODEL_CHANGED');
+   if(b.end_at&&this.now()>=b.end_at)fail('DEADLINE');if(b.mode!=='unlimited'&&b.used>=b.max_requests)fail('BUDGET_EXHAUSTED');
+   const id=randomUUID();this.db.prepare('INSERT INTO managed_model_requests(id,task_id,purpose,created,policy) VALUES (?,?,?,?,?)').run(id,task,search?'managed-search':purpose,this.now(),json(p));return {id,used:b.used+1,limit:b.max_requests};
+  });
+ }
+}
+
+// Persist exactly the target Host's resolved route. An execution-role default is
+// subordinate to an explicit task route; absent effort is not forced to `high`.
+export async function resolveManagedModel(ctx,explicit,roleDefault){
+ const input=explicit??roleDefault??{};
+ if(!ctx.llm?.resolveCallConfig)fail('MODEL_UNAVAILABLE');
+ const p=await ctx.llm.resolveCallConfig(input,AbortSignal.timeout(5000));
+ if(!text(p?.provider)||!text(p?.model)||input.provider&&p.provider!==input.provider||input.model&&p.model!==input.model||input.reasoningEffort!==undefined&&p.reasoningEffort!==input.reasoningEffort)fail('MODEL_CHANGED');
+ return {provider:p.provider,model:p.model,...(p.reasoningEffort!==undefined?{reasoningEffort:p.reasoningEffort}:{})};
+}
+
+export class ManagedSessions {
+ constructor(ctx,db,{now=Date.now,canResume=()=>false,canArchive=()=>false,hasBackground=async()=>true}={}){
+  this.ctx=ctx;this.db=db;this.now=now;this.canResume=canResume;this.canArchive=canArchive;this.hasBackground=hasBackground;this.handles=new Map();this.pending=new Set();
+  db.exec(`CREATE TABLE IF NOT EXISTS managed_sessions(task_id TEXT PRIMARY KEY,role TEXT NOT NULL,
+   session_id TEXT UNIQUE NOT NULL,workspace TEXT NOT NULL,state TEXT NOT NULL,last_used INTEGER NOT NULL,error TEXT);`);
+ }
+ get(task){return this.db.prepare('SELECT * FROM managed_sessions WHERE task_id=?').get(task);}
+ owned(id){return this.db.prepare('SELECT * FROM managed_sessions WHERE session_id=?').get(id);}
+ touch(id){if(this.owned(id))this.db.prepare('UPDATE managed_sessions SET last_used=? WHERE session_id=?').run(this.now(),id);}
+ update(task,state,error=null){this.db.prepare('UPDATE managed_sessions SET state=?,error=? WHERE task_id=?').run(state,error,task);}
+ async open({task_id,role,workspace,agentOptions,setup}){
+  if(!text(task_id)||!['local','cloud'].includes(role)||!text(workspace)||!isAbsolute(workspace)||normalize(workspace)!==workspace)fail('SESSION_INVALID');
+  if(this.pending.has(task_id)||this.handles.has(task_id))fail('SESSION_BUSY');
+  if(!await this.canResume(task_id))fail('EXECUTION_FENCED');
+  this.pending.add(task_id);let handle,changed=false;
+  try{
+   let row=this.get(task_id),fresh=!row;
+   if(row&&(row.role!==role||row.workspace!==workspace))fail('SESSION_BINDING_CHANGED');
+   if(row&&['creating','running','uncertain'].includes(row.state))fail('SESSION_RECONCILE_REQUIRED');
+   if(!this.ctx.workspaceRegistry?.unarchiveSession||!this.ctx.workspaceRegistry?.archiveSession)fail('ARCHIVE_API_UNAVAILABLE');
+   if(!row){
+    const id='managed-'+randomUUID();
+    this.db.prepare("INSERT INTO managed_sessions VALUES (?,?,?,?,'creating',?,NULL)").run(task_id,role,id,workspace,this.now());row=this.get(task_id);changed=true;
+   }
+   // Public API deliberately does not prove existence. resume() MUST load the
+   // same persisted identity successfully; never fall back to create().
+   if(!fresh){changed=true;await this.ctx.workspaceRegistry.unarchiveSession(row.session_id);}
+   if(!await this.canResume(task_id))fail('EXECUTION_FENCED');
+   const options={agentOptions,setup:async(a,agent)=>{
+    if(agent.id!==row.session_id||agent.session.header.cwd!==workspace)fail('SESSION_BINDING_CHANGED');
+    const inner=await setup?.(a,agent);
+    // The publication gate is synchronous by native contract. Do not mistake
+    // an unresolved Promise for an affirmative authority decision.
+    return {commit:()=>{if(this.canResume(task_id)!==true)fail('EXECUTION_FENCED');inner?.commit?.();}};
+   }};
+   handle=await this.ctx.agents.withoutInitiator(()=>fresh?
+    this.ctx.agents.create({...options,sessionId:row.session_id,meta:{cwd:workspace}}):
+    this.ctx.agents.resume({...options,resumeSessionId:row.session_id}));
+   if(!await this.canResume(task_id))fail('EXECUTION_FENCED');
+   this.handles.set(task_id,handle);this.update(task_id,'running');this.touch(row.session_id);return handle;
+  }catch(e){
+   if(handle)try{await handle.dispose();}catch{this.handles.set(task_id,handle);}
+   if(changed)this.update(task_id,'uncertain',String(e.code??e.message).slice(0,200));throw e;
+  }finally{this.pending.delete(task_id);}
+ }
+ async idle(task){
+  const handle=this.handles.get(task),row=this.get(task);if(!handle||!row)fail('SESSION_NOT_OWNED');
+  try{
+   if(handle.agent.status!=='idle'||await this.hasBackground(row.session_id))fail('SESSION_BUSY');
+   if(await this.ctx.sessions.flush(handle.agent.session)!==true)fail('PERSISTENCE_UNAVAILABLE');
+   await handle.dispose();this.handles.delete(task);this.update(task,'idle');this.touch(row.session_id);
+  }catch(e){this.update(task,'uncertain',String(e.code??e.message).slice(0,200));throw e;}
+ }
+ async archiveIdle(){
+  const results=[];
+  for(const row of this.db.prepare("SELECT * FROM managed_sessions WHERE state='idle' AND last_used<=?").all(this.now()-ARCHIVE_IDLE_MS)){
+   if(this.pending.has(row.task_id)||this.handles.has(row.task_id)||!await this.canArchive(row.task_id)||await this.hasBackground(row.session_id)||this.ctx.agents.get(row.session_id))continue;
+   this.pending.add(row.task_id);
+   try{
+    // No stopActivity: the native registry independently refuses active work.
+    await this.ctx.workspaceRegistry.archiveSession(row.session_id);
+    this.update(row.task_id,'archived');results.push({task_id:row.task_id,archived:true});
+   }catch(e){results.push({task_id:row.task_id,archived:false,error:String(e.code??e.message).slice(0,200)});}
+   finally{this.pending.delete(row.task_id);}
+  }
+  return results;
+ }
+}

package/bundle/managed-search.js

@@ -0,0 +1,57 @@
+import {validateAutonomousSearch} from './search-contract.js';
+// Reuse the existing public DeepSeek search adapter; no second search provider.
+import {createHash} from 'node:crypto';
+import {isDeepStrictEqual} from 'node:util';
+import {createTaskSearchReader} from './source-search.js';
+import {sourceUrl} from './source-web.js';
+const fail=s=>{throw Error('TASK_SEARCH_'+s);};
+export function validateManagedSearch(c){if(c!==undefined&&(!c||typeof c!=='object'||Array.isArray(c)||Object.keys(c).some(k=>!['credentialRef','model_policy'].includes(k))||typeof c.credentialRef!=='string'||!/^[_a-zA-Z][_a-zA-Z0-9]*$/.test(c.credentialRef)))fail('CONFIG_INVALID');if(c?.model_policy)validateAutonomousSearch({scope:'configured',model_policy:c.model_policy});}
+export class ManagedSearch {
+ constructor(endpoint,config,createReader=createTaskSearchReader){
+  validateManagedSearch(config);this.ep=endpoint;this.db=endpoint.db;this.pending=new Map();
+  this.db.exec('CREATE TABLE IF NOT EXISTS managed_search_operations(id TEXT PRIMARY KEY,task_id TEXT NOT NULL,fingerprint TEXT NOT NULL,state TEXT NOT NULL,result TEXT,error TEXT);');
+  this.ready=config?createReader(endpoint.ctx,config).then(r=>{this.reader=r;}).catch(()=>{}):Promise.resolve();
+ }
+ async run(b,agent,a,callId,signal){
+  if(!a||Object.keys(a).join()!=='query'||typeof a.query!=='string'||!a.query.trim()||a.query.length>300||/[\x00-\x1f]/.test(a.query)||typeof callId!=='string'||!callId||callId.length>256)fail('ARGUMENT_INVALID');
+  const policy=b.item.spec.search;if(!policy)fail('NOT_AUTHORIZED');
+  await this.ready;if(!this.reader)fail('UNAVAILABLE');
+  await this.ep.validate(b);
+  const id=JSON.stringify([b.item.claim,agent.id,callId]),fp=createHash('sha256').update(JSON.stringify([b.item.task_id,policy,a.query])).digest('hex');
+  const old=this.db.prepare('SELECT * FROM managed_search_operations WHERE id=?').get(id);
+  if(old){if(old.fingerprint!==fp)fail('EVENT_CONFLICT');if(old.state==='completed')return JSON.parse(old.result);if(this.pending.has(id))return this.pending.get(id);fail(old.error??'DISPATCH_UNCERTAIN');}
+  if(this.db.prepare("SELECT 1 FROM managed_search_operations WHERE task_id=? AND state IN ('pending','uncertain')").get(b.item.task_id))fail('DISPATCH_UNCERTAIN');
+  this.db.prepare("INSERT INTO managed_search_operations VALUES (?,?,?,'pending',NULL,NULL)").run(id,b.item.task_id,fp);
+  const work=this.dispatch(b,a,policy,id,signal).finally(()=>this.pending.delete(id));this.pending.set(id,work);return work;
+ }
+ async dispatch(b,a,policy,id,signal){
+  const deadline=AbortSignal.any([b.controller.signal,signal,AbortSignal.timeout(45000)].filter(Boolean));let reserved=false,recorded=false,returned=false;
+  try{
+   deadline.throwIfAborted();await this.ep.validate(b);
+   // Reserve before credential resolution/HTTP. A lost reserve acknowledgement is
+   // uncertain, never refunded/retried; native provider's sync callback cannot await A2A.
+   reserved=true;await this.ep.call('reserve',{task_id:b.item.task_id,claim:b.item.claim,instance_id:b.item.instance,channel:'search',policy:policy.model_policy,purpose:'managed-search'});
+   const expected={endpoint:'https://api.deepseek.com/anthropic/v1/messages',apiVersion:'2023-06-01',body:{model:policy.model_policy.model,max_tokens:2048,messages:[{role:'user',content:[{type:'text',text:'Perform a web search for the query: '+a.query}]}],tools:[{type:'web_search_20250305',name:'web_search',max_uses:1}],thinking:{type:'disabled'}}};
+   const result=await this.reader.search(a.query,policy.model_policy,deadline,request=>{
+    deadline.throwIfAborted();if(this.ep.closed||performance.now()>=b.validUntil)fail('CANCELLED');
+    if(recorded||!isDeepStrictEqual(request,expected))fail('REQUEST_CHANGED');recorded=true;
+   });returned=true;deadline.throwIfAborted();await this.ep.validate(b);
+   if(!recorded)fail('DISPATCH_UNVERIFIED');
+   if(!result||!Array.isArray(result.sources)||result.sources.length>100||typeof result.truncated!=='boolean')fail('RESULT_INVALID');
+   const sources=[],seen=new Set();let rejected=0;
+   for(const item of result.sources){let url;try{url=sourceUrl(item?.url).href;}catch{rejected++;continue;}
+    if(seen.has(url))continue;seen.add(url);
+    for(const [k,max] of [['title',500],['snippet',8000],['publishedAt',128]])if(item[k]!==undefined&&(typeof item[k]!=='string'||item[k].length>max||item[k].includes('\0')))fail('RESULT_INVALID');
+    if(sources.length<5)sources.push({url,...Object.fromEntries(['title','snippet','publishedAt'].filter(k=>item[k]!==undefined).map(k=>[k,item[k]]))});
+   }
+   const output={query:a.query,scope:policy.scope,model_policy:policy.model_policy,sources,truncated:result.truncated||seen.size>5,rejected_urls:rejected,page_content_read:false,verification:"search-snippets-only; read source body with native web_fetch before confirming claims; errors or truncated/missing body remain unverified",untrusted_external_content:true};
+   this.db.prepare("UPDATE managed_search_operations SET state='completed',result=? WHERE id=?").run(JSON.stringify(output),id);return output;
+  }catch(e){
+   const code=/^(TASK_SEARCH|TASK_RUNTIME|TASK_EXECUTION)_[A-Z_]+$/.test(e?.message)?e.message:'TASK_SEARCH_UNAVAILABLE';
+   // Reserve refusal is definitive. Network/ACK uncertainty is not a retry license.
+   const refused=/^TASK_RUNTIME_(?:SEARCH_BUDGET_EXHAUSTED|BUDGET_EXHAUSTED|MODEL_CHANGED|DEADLINE)$/.test(code);
+   const uncertain=reserved&&!returned&&!refused;
+   this.db.prepare('UPDATE managed_search_operations SET state=?,error=? WHERE id=?').run(uncertain?'uncertain':'failed',uncertain?'DISPATCH_UNCERTAIN':code.replace(/^TASK_SEARCH_/,''),id);throw Error(uncertain?'TASK_SEARCH_DISPATCH_UNCERTAIN':code);
+  }
+ }
+}

package/bundle/managed-tools.js

@@ -0,0 +1,17 @@
+import {managedScheduleSchema} from './managed-triggers.js';
+import {nativeModelChoice} from './native-model-choice.js';
+import {developmentSchema} from './managed-development-contract.js';
+import {currentHumanRequest} from './task-envelope.js';
+import {hash} from './store.js';
+export function registerManagedTools(g,register){
+ const str={type:'string'},policy={type:'object',properties:{provider:str,model:str,reasoningEffort:str},required:['provider','model'],additionalProperties:false};
+ const properties={schedule:managedScheduleSchema,task_id:str,expected_revision:{type:'integer',minimum:1},role:{type:'string',enum:['cloud']},cwd:str,development:{anyOf:[developmentSchema,{type:"null"}],description:"Required output agreement for ALL file tasks (reports, JSONL, data and code): use workspace delivery with real checks and relative artifact paths. Explicit null only for genuinely no-file tasks; omission is rejected."},scope:{type:'string',maxLength:3000},model_query:{type:'string',description:'User-written model name only; omit for saved task choice or cloud default.'},provider_hint:str,search:{type:'object',properties:{scope:{type:'string',maxLength:1000}},required:['scope'],additionalProperties:false},period_seconds:{type:'integer',minimum:60,maximum:31622400},end_at:{type:'integer',minimum:1}};
+ const start=async(a,e)=>{
+  const model_policy=await nativeModelChoice(g,a,e);
+  if(!Object.hasOwn(a,'development')||a.development===undefined)throw Error('TASK_OUTPUT_CONTRACT_REQUIRED: file tasks need development.artifacts/checks; use explicit null only when no file deliverable exists');
+  const {development,...rest}=a;
+  return g.call('execution_start',{...rest,...(development===null?{}:{development}),model_policy,role:'cloud',event_id:'native-execution:'+hash(g.c.role+':'+e.agent.id+':'+currentHumanRequest(e.agent).message_id+':'+e.callId)});
+ };
+ register('task_execute','Start/queue the saved explicit user task on CLOUD. No approval ID, IM permission, model request cap, fixed activity timeout or permission TTL. Omit model_query for the configured CLOUD default or saved explicit task choice; never invent a model name or resolve the entry model. Only quote a model name actually specified by the user. Search scope enables the already configured auxiliary route, without per-task model consent or a request sublimit. cwd is a working start, not a file sandbox. Native tools follow cloud account capabilities and user goal/restrictions. Optional end_at is ONLY an explicit business deadline, never an invented default. development is REQUIRED for every task: ALL file deliverables (including reports, research and JSONL) must list artifacts plus actual checks, workspace needs no Git; explicit null only for no-file tasks. Missing output agreement is an error, not a successfully queued file task; no per-artifact registration needed. Use schedule for explicit once/interval/weekly/dependency/named-signal plans; do not invent a deadline or business round count. schedule cannot combine with period_seconds. Followup does not fire a named signal. Periodic tasks reuse session, skip missed rounds, never silently switch model. Pause/stop via task_lifecycle. Historical capped/local contracts are not migrated or restarted.',properties,['task_id','expected_revision','cwd','development'],start);
+ register('task_execution_prepare','Compatibility name for task_execute on NEW cloud-autonomous tasks: this now queues execution immediately, not an approval proposal. Prefer task_execute. Existing historical approval records remain read-only and are never upgraded implicitly.',properties,['task_id','expected_revision','cwd','development'],start);
+}