@rockysoft/opencode-hybrid-workflow 0.0.0-stage → 0.3.2-beta.1

package/core/dashboard.js

@@ -0,0 +1,72 @@
+import { captureTimeline, captureTotals, visibleCalls, countedCalls, summarize } from './dashboard-state.js';
+const $ = id => document.getElementById(id);
+const number = value => value == null ? 'Unavailable' : value.toLocaleString('en-US');
+const money = value => value == null ? 'Cost unavailable' : Math.abs(value.high-value.low)<.005 ? `$${value.low.toFixed(2)}` : `$${value.low.toFixed(2)}–$${value.high.toFixed(2)}`;
+let currentData;
+let scope;
+let resets = {};
+function resetKey(kind) { return `hybrid-activity-v1:${scope}:${kind}`; }
+function loadResets(data) {
+  const nextScope = JSON.stringify([data.project, data.task]);
+  if (scope === nextScope) return;
+  scope = nextScope; resets = {};
+  for (const kind of ['timeline','totals']) {
+    try { const value=JSON.parse(localStorage.getItem(resetKey(kind))); if(value && typeof value==='object' && typeof value.at==='string') resets[kind]=value; } catch { /* Bad or unavailable storage never blocks live data. */ }
+  }
+}
+function changeReset(kind, restore = false) {
+  if (!currentData?.task) return;
+  const value = restore ? null : kind==='timeline' ? captureTimeline(currentData.calls) : captureTotals(currentData.calls);
+  resets[kind]=value;
+  let saved=true;
+  try { if(value) localStorage.setItem(resetKey(kind),JSON.stringify(value)); else localStorage.removeItem(resetKey(kind)); } catch { saved=false; }
+  render(currentData);
+  $('notice').textContent=(restore ? `${kind==='timeline'?'Timeline':'Totals'} restored.` : kind==='timeline' ? 'Finished calls hidden. Active calls and totals are unchanged.' : 'Totals reset. Timeline is unchanged; further usage from active calls will count.') + (saved ? '' : ' Browser storage is unavailable; this change lasts only until reload.');
+}
+for (const kind of ['timeline','totals']) {
+  $(`clear-${kind}`).addEventListener('click',()=>changeReset(kind));
+  $(`restore-${kind}`).addEventListener('click',()=>changeReset(kind,true));
+}
+function el(tag, text, className) { const node = document.createElement(tag); if (text != null) node.textContent = text; if (className) node.className = className; return node; }
+function detail(title,text,key) { const d=el('details'); d.dataset.key=key; d.append(el('summary',title),el('pre',text || 'Not available')); return d; }
+function duration(call) { if (!call.startedAt) return 'Duration unavailable'; const end = call.endedAt ? Date.parse(call.endedAt) : ['running','preparing','untracked-active'].includes(call.status) ? Date.now() : NaN; if (!Number.isFinite(end)) return 'End time unavailable'; const seconds=Math.max(0,Math.floor((end-Date.parse(call.startedAt))/1000));return `${Math.floor(seconds/60)}m ${seconds%60}s`; }
+function render(data) {
+  currentData=data; loadResets(data);
+  const calls=visibleCalls(data.calls,resets.timeline);
+  const totals=summarize(countedCalls(data.calls,resets.totals),data.efforts ?? {});
+  for (const kind of ['timeline','totals']) {
+    $(`clear-${kind}`).disabled=!data.task;
+    $(`restore-${kind}`).hidden=!resets[kind];
+    $(`${kind}-since`).textContent=resets[kind] ? `${kind==='totals'?'Counting from':'Cleared'} ${new Date(resets[kind].at).toLocaleString()}` : kind==='totals'?'All recorded calls':'';
+  }
+  const open = new Set([...document.querySelectorAll('details[open][data-key]')].map(node=>node.dataset.key));
+  $('project').textContent=data.project || 'Coding workspace'; $('phase').textContent=data.phase;
+  $('phase-note').textContent=data.operationActive ? 'A bridge operation is active.' : data.lockPresent ? 'An operation lock remains, but its process is not running. Inspect before continuing.' : 'No bridge operation is active. The implementation model may be working in OpenCode.';
+  if(data.decision) $('phase-note').textContent += ` ${data.decision.reason} Blocking: ${data.decision.major.length}. Advisory: ${data.decision.advisory.length}.`;
+  if(data.pauseReason) $('phase-note').textContent += ` ${data.pauseReason}`;
+  $('totals').replaceChildren(...totals.map(total=>{const box=el('article',null,'metric');box.append(el('h2',`${total.who==='astra'?'Astra':'Opus'} · ${total.effort || 'configured'} effort`),el('div',total.total==null?'Usage unavailable':number(total.total)+' tokens','number'),el('div',money(total.cost),'cost'),el('small',`${total.measuredCalls} of ${total.calls} calls measured · ${total.pricedCalls} priced${total.measuredCalls<total.calls || total.pricedCalls<total.calls?' · partial total':''}`),el('small',total.models.join(' · ') || 'No calls counted'),el('small',`Input: ${number(total.input)}`),el('small',`Output: ${number(total.output)}`),el('small',`Cache: ${number(total.cache)}`));return box;}));
+  $('pricing-basis').textContent=(data.pricing?.basis || 'Rates unavailable.') + (data.pricing?.date ? ` Verified ${data.pricing.date}.` : '');
+  $('pricing-sources').replaceChildren(...(data.pricing?.sources ?? []).map(source=>{const link=el('a',source.name);link.href=source.url;link.target='_blank';link.rel='noopener noreferrer';return link;}));
+  $('call-count').textContent=`${calls.length} visible of ${data.calls.length} calls · ${data.rounds ?? 0} planning rounds completed`;
+  $('timeline').replaceChildren(...calls.map(call=>{
+    const card=el('article',null,`call ${call.status}`);const head=el('div',null,'call-head');
+    head.append(el('h3',`${String(call.sequence).padStart(2,'0')} · ${call.who==='astra'?'Astra':'Opus'} — ${call.label}`),el('span',call.verdict || call.status,`badge ${call.verdict || call.status}`));card.append(head);
+    card.append(el('div',`${call.resolvedModels.join(', ') || call.requestedModel+' (requested; resolved identity unavailable)'} · ${call.effort} effort · ${duration(call)} · ${call.peerReportsReceived} peer reports supplied`,'meta'),el('p',call.currentAction,'action'));
+    card.append(el('p',call.usage ? `Processed ${number(call.usage.total)} · input ${number(call.usage.input)}${call.usage.inputIncludesCache?' (includes cache reads)':''} · output ${number(call.usage.output)} · cache read ${number(call.usage.cacheRead)} · cache write ${number(call.usage.cacheWrite)}` : 'Token usage unavailable — not captured by this call, or the CLI has not reported it yet.','usage'));
+    card.append(el('p',money(call.cost),'call-cost'));
+    if(call.report)card.append(detail(`Report · ${call.verdict}`,call.report,call.id+'report'));
+    if(call.artifactHash)card.append(el('small',`Reviewed artifact: ${call.artifactHash}`));
+    if(call.findings.length)card.append(detail('Classified findings',JSON.stringify(call.findings,null,2),call.id+'findings'));
+    card.append(detail('Brief and clarifications actually supplied',`${call.brief || 'No saved brief'}\n\nClarification:\n${call.clarification || 'None forwarded'}`,call.id+'brief'));
+    if(call.toolEvents.length)card.append(detail('Observed tool activity (names only)',call.toolEvents.map(tool=>`${new Date(tool.at).toLocaleTimeString()} · ${tool.name}`).join('\n'),call.id+'tools'));
+    return card;
+  }));
+  if (!calls.length) $('timeline').append(el('p','No visible calls. New calls will appear here; cleared history can be restored.','muted'));
+  for(const node of document.querySelectorAll('details[data-key]')) node.open=open.has(node.dataset.key);
+  $('plan').querySelector('pre').textContent=data.plan || 'No agreed plan has been saved yet.';
+  $('connection').textContent='● Live · refreshes every 2 seconds';$('updated').textContent='Updated '+new Date(data.updatedAt).toLocaleTimeString();$('error').textContent='';
+}
+async function poll(){try{const response=await fetch('/api/status',{cache:'no-store'});if(!response.ok)throw Error(`Monitor returned ${response.status}`);render(await response.json());}catch(error){$('connection').textContent='Disconnected';$('error').textContent=error.message+' — last displayed data may be stale.';}finally{setTimeout(poll,2000);}}
+poll();
+
+

package/core/decision.mjs

@@ -0,0 +1,22 @@
+// A verdict is not a vote that can erase another reviewer's material finding.
+export const findingSchema = {
+  type: 'object', additionalProperties: false,
+  properties: {
+    id: { type: 'string' }, severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low', 'info'] },
+    category: { type: 'string', enum: ['defect', 'evidence', 'preference'] },
+    summary: { type: 'string' }, evidence: { type: 'string' }, consequence: { type: 'string' },
+    resolution: { type: 'string' },
+  }, required: ['id', 'severity', 'category', 'summary', 'evidence', 'consequence', 'resolution'],
+};
+// Keep the existing export/state key compatible; this is the blocking threshold.
+export const isMajor = finding => ['critical', 'high', 'medium'].includes(finding.severity);
+export function decide(astra, opus) {
+  const results=[astra,opus].filter(Boolean);
+  const findings = results.flatMap((result, i) => result.findings.map(f => ({ ...f, reviewer: i ? 'opus' : 'astra' })));
+  const major = findings.filter(isMajor);
+  const approved = major.length === 0 && results.some(result => result.verdict === 'pass') &&
+    results.every(result => result.verdict !== 'blocked');
+  return { approved, major, advisory: findings.filter(f => !isMajor(f)), policy: 'medium-blocking-v2',
+    reason: approved ? 'At least one approval; no configured reviewer has unresolved medium, high or critical findings.' :
+      major.length ? 'Resolve the listed medium, high or critical findings, then verify the same revised artifact.' : 'Neither reviewer approved; consolidate the bounded tradeoffs.' };
+}

package/core/design.mjs

@@ -0,0 +1,139 @@
+import {lead,feedback} from '../lib/reviewers.mjs';
+import { mkdirSync, readFileSync, writeFileSync, readdirSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { hash, snapshot } from './snapshot.mjs';
+import { decide } from './decision.mjs';
+import { runProcess } from './workers.mjs';
+import { captureImages } from './images.mjs';
+
+export const DESIGN_POLICY = `UI/UX ownership: the implementation model must not invent visual direction or interaction design. Claude/Opus authors new design decisions and Astra reviews them. This applies to new projects, substantial features without a design, and later redesign/improve-UI requests. Small/medium additions can reuse an established design system and supplied Figma/Claude/local designs can be implemented faithfully, with concrete reference evidence. Escalate material gaps instead of filling them with your own design. Before edits call hybrid_checkpoint design when design is pending; do not bypass through subagents. Read the returned approved design document and give it to frontend-engineer. Existing/supplied exceptions require designMode and designEvidence at begin. Architecture planning does not authorize new visual decisions.`;
+
+export function designIntent(text = '') {
+  // This is an admission safety net, not a substitute for the semantic routing rule.
+  const value = text.toLowerCase().replace(/\b(?:do not|don't|without|no)\s+(?:re-?design|redesign|redisign)\b/g, 'preserve');
+  const supplied = /\b(figma|supplied design|provided design|claude design|design file|reference design)\b/.test(value) && /\b(implement|match|follow|reproduce|replicate)\b/.test(value);
+  if (/\b(choose|invent|decide|pick|propose)\b.{0,60}\b(design|layout|palette|typography|interaction|font|visual direction)\b/.test(value)) return 'new';
+  if (/\b(re-?design|redisign|restyle|rebrand)\b/.test(value) ||
+      /\b(improve|better|polish|modernize|refresh)\b.{0,55}\b(ui|ux|design|interface|look|visuals?)\b/.test(value) ||
+      /\b(ui|ux|design|interface)\b.{0,40}\b(better|professional|polish|improve)\b/.test(value) ||
+      /\b(make|give)\b.{0,50}\b(look|feel)\b.{0,30}\b(professional|modern|premium|better)\b/.test(value)) return 'new';
+  if (supplied && !/\b(invent|choose|new design decisions)\b/.test(value)) return 'supplied';
+  if (/\b(follow|match|reuse|using)\b.{0,45}\b(existing|current|established)\b.{0,30}\b(pattern|design system|component)\b/.test(value)) return 'existing';
+  if (/\b(add|create|build|design)\b.{0,65}\b(new)\b.{0,30}\b(flow|interface|interaction|page|screen|form)\b/.test(value)) return 'new';
+  if (/\b(create|build|new|design)\b.{0,65}\b(website|landing page|portfolio|dashboard|design system)\b/.test(value)) return 'new';
+  return 'none';
+}
+
+export function recordDesignRequest(controller, text, messageID) {
+  if (designIntent(text) !== 'new') return;
+  if (typeof messageID !== 'string' || !messageID) throw new Error('Cannot track design request without a message identity.');
+  const directory = path.join(controller.folder, 'design-requests'); mkdirSync(directory, {recursive:true});
+  const file = path.join(directory, hash(String(messageID)) + '.json');
+  try { writeFileSync(file, JSON.stringify({ text, at: new Date().toISOString() }), {flag:'wx'}); }
+  catch (error) { if (error.code !== 'EEXIST') throw error; }
+}
+export function requests(controller) {
+  const directory = path.join(controller.folder, 'design-requests');
+  if (!existsSync(directory)) return [];
+  return readdirSync(directory).filter(n=>/^[a-f0-9]{64}\.json$/.test(n)).sort().map(name=>{
+    const value = JSON.parse(readFileSync(path.join(directory,name),'utf8'));
+    return {id:name, ...value};
+  }).sort((a,b)=>a.at.localeCompare(b.at)||a.id.localeCompare(b.id));
+}
+export function pendingRequests(controller, state) {
+  const acknowledged = new Set(state?.designAcknowledged ?? []);
+  return requests(controller).filter(r=>!acknowledged.has(r.id));
+}
+export function designPending(controller, state) {
+  return pendingRequests(controller,state).length > 0 || (state?.designMode === 'new' && !state.designApproval);
+}
+export function assertDesign(controller, state) {
+  if (designPending(controller,state)) throw new Error('UI/UX design pending: call hybrid_checkpoint design. Claude designs; Astra reviews before implementation.');
+  if (state.designApproval && (!state.designPath || hash(readFileSync(state.designPath,'utf8')) !== state.designApproval.hash)) throw new Error('Approved design changed or is missing. Revalidate design before implementation.');
+}
+export function beginDesign(controller, input, previous) {
+  if (!input.designMode) throw new Error('Every task needs explicit designMode none/existing/supplied/new. Use none for backend-only or exact mechanical changes, existing for faithful pattern reuse, supplied for provided design, new for design decisions.');
+  const detected = designIntent(input.brief);
+  const mode = detected === 'new' || input.designMode === 'new' ? 'new' : detected !== 'none' ? detected : input.designMode;
+  if (!['none','existing','supplied','new'].includes(mode)) throw new Error('designMode must be none/existing/supplied/new.');
+  if (['existing','supplied'].includes(mode) && (typeof input.designEvidence !== 'string' || input.designEvidence.trim().length < 20)) throw new Error('Existing/supplied design requires concrete reference paths/URLs and the patterns to follow in designEvidence.');
+  if (input.designEvidence !== undefined && (typeof input.designEvidence !== 'string')) throw new Error('Design evidence must be text.');
+  return {designMode:mode, designEvidence:input.designEvidence ?? '', designAcknowledged:previous?.designAcknowledged ?? []};
+}
+
+async function skillEvidence(controller, brief, compact) {
+  const settings = controller.config.design;
+  if (!settings?.skillsDirectory || !settings.pythonExecutable) throw new Error('Design skill configuration missing; implementation remains blocked.');
+  const skills = {};
+  for (const name of ['frontend-design','ui-ux-pro-max','web-design-guidelines']) {
+    skills[name] = readFileSync(path.join(settings.skillsDirectory,name,'SKILL.md'),'utf8');
+  }
+  const script = path.join(settings.skillsDirectory,'ui-ux-pro-max','scripts','search.py');
+  // Fixed local, read-only search command; no shell, model-selected executable, or persistence flags.
+  const args = ['-B',script,...(compact ? ['--domain','ux'] : ['--design-system']),'--',brief.slice(0,350)];
+  const search = await runProcess(settings.pythonExecutable,args,controller.folder,'',30000);
+  return {skills, search, searchMode:compact?'ux':'design-system', guidance:'Use these skill instructions and actual local search results. Opus chooses the design, not the search catalog or implementation model. Fetch current web-design-guidelines using WebFetch. Do not claim to have run a native skill tool in this isolated reviewer environment.'};
+}
+
+export async function design(state, input, signal) {
+  if (!['implement','fix','review','design'].includes(state.phase)) throw new Error('Complete architecture planning first; design can then run before implementation.');
+  if (state.mode === 'feature') this.assertPlan(state);
+  if (typeof input.checks !== 'undefined' && (typeof input.checks !== 'string')) throw new Error('Design evidence must be concise text.');
+  if (!designPending(this,state) && !input.checks?.trim() && !input.images?.length && state.designApproval) return this.status();
+  const pending = pendingRequests(this,state);
+  const brief = pending.length ? pending.map(r=>r.text).join('\n\n') : state.brief;
+  const evidence = {brief, userDirections:pending, plan:state.plan, referenceEvidence:state.designEvidence ?? '', supplied:input.checks ?? ''};
+  const tree = snapshot(this.directory);
+  const images=captureImages(this.directory,input.images,tree.fingerprint);
+  evidence.visualEvidence=images.map(i=>i.manifest);
+  const evidenceHash = hash(JSON.stringify([evidence,tree.fingerprint]));
+  if (state.designPause?.evidenceHash === evidenceHash) throw new Error('Design requires new evidence or a clarified requirement: '+state.designPause.reason);
+  this.checkpoint(state,'design');
+  state.designResumePhase ??= ['fix','review'].includes(state.phase) ? 'fix' : 'implement';
+  if(state.mode==='cosmetic') state.mode='small';
+  state.phase='design'; this.save(state);
+  const skills = await (this.designEvidence ?? skillEvidence)(this,brief,state.mode === 'small');
+  if (state.designEvidenceHash !== evidenceHash) { state.designNeedsRevision=true; state.designEvidenceHash=evidenceHash; delete state.designPause; }
+  while (true) {
+    if(signal?.aborted) throw new Error('Design cancelled; approval remains closed.');
+    if (!state.designCandidate || state.designNeedsRevision) {
+      const authored = await this.ask(state,lead(this.config),'design-author',{
+        ...evidence, skills, previousDesign:state.designCandidate?.text ?? null, findings:state.designFeedback ?? [],
+        instruction: 'YOU own UI/UX design. Return a complete implementable design document (a concise direction for a small task). Decide audience, information hierarchy, user flows, layout, tokens/palette, typography roles, components, responsive rules, interaction/loading/empty/error states, accessibility and motion. Preserve supplied constraints. Use the design skills and research results; explain rationale. Give implementation instructions and risk-based acceptance criteria for changed component families and representative states. Do not prescribe all states at all widths by default. Name the risk each required check covers. Identify unresolved essential reference gaps; never delegate design choices to the implementation model. Do not implement code. For this author stage verdict/pass is only your assessment; independent validation follows.'
+      },signal,images,tree);
+      if (authored.verdict === 'blocked') {
+        state.designFeedback=[{who:lead(this.config),...authored}];
+        state.designPause={evidenceHash,reason:'Claude needs the evidence listed in its design report.'};this.save(state);return this.status();
+      }
+      const nextHash=hash(authored.report);
+      if (state.designCandidate?.hash===nextHash && state.designLastEvidence===evidenceHash) {
+        state.designPause={evidenceHash,reason:'Claude returned the same rejected design without new evidence.'}; this.save(state); return this.status();
+      }
+      state.designCandidate={text:authored.report,hash:nextHash}; state.designAuthorFindings=authored.findings; state.designNeedsRevision=false; this.save(state);
+    }
+    const candidate=state.designCandidate;
+    const version=hash(candidate.hash+evidenceHash);
+    if ((state.designRejected ?? []).includes(version)) {
+      state.designPause={evidenceHash,reason:'The same rejected design/evidence returned; resolve the concrete disagreement.'}; this.save(state);return this.status();
+    }
+    const file=path.join(this.folder,state.id,`design-${candidate.hash}.md`);
+    mkdirSync(path.dirname(file),{recursive:true});
+    if(existsSync(file) && hash(readFileSync(file,'utf8'))!==candidate.hash) throw new Error('Design artifact changed.');
+    writeFileSync(file,candidate.text);
+    const packet={...evidence,skills,candidate:candidate.text,artifactHash:candidate.hash,authorFindings:state.designAuthorFindings ?? [],priorFindings:state.designFeedback ?? [],
+      instruction:'Review this exact Claude-authored design. Astra challenges usability, accessibility, consistency, completeness and requirements; Claude retains aesthetic ownership. No substitute design based solely on taste. Validate medium/high/critical findings against evidence. Minor preferences are low/info. No implementation yet.'};
+    const [astra,opus]=await this.pair(state,'design-validate',packet,signal,images,tree);
+    if(snapshot(this.directory).fingerprint!==tree.fingerprint || hash(readFileSync(file,'utf8'))!==candidate.hash) throw new Error('Source or design changed during review; approval remains closed.');
+    state.designDecision=decide(astra,opus);state.designFeedback=feedback(astra,opus);state.designLastEvidence=evidenceHash;
+    if(state.designDecision.approved) {
+      state.designMode='new';state.designPath=file;state.designApproval={hash:candidate.hash,evidenceHash,at:new Date().toISOString()};
+      state.designAcknowledged=[...new Set([...(state.designAcknowledged??[]),...pending.map(r=>r.id)])];
+      state.phase=state.designResumePhase ?? 'implement';delete state.designResumePhase;state.checkpoint=null;delete state.designPause;this.save(state);return this.status();
+    }
+    state.designRejected=[...(state.designRejected??[]),version];state.designNeedsRevision=true;
+    if(astra.verdict==='blocked'||opus?.verdict==='blocked') {
+      state.designPause={evidenceHash,reason:'Gather the reviewers’ missing evidence and call design with updated checks.'};this.save(state);return this.status();
+    }
+    this.save(state);
+  }
+}

package/core/evidence.mjs

@@ -0,0 +1,82 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { hash } from './snapshot.mjs';
+
+// Size chooses transport, never whether a review is allowed. All content stays
+// in the captured workspace; no model-generated summary replaces evidence.
+export function prepareEvidence(folder, packet, tree, inlineChars = 400000) {
+  let textID = 0;
+  const readableText = (text, name) => {
+    const target = path.join(folder, name);
+    mkdirSync(path.dirname(target), { recursive: true }); writeFileSync(target, text);
+    const ref = { path: name, chars: text.length, sha256: hash(text) };
+    if (text.split('\n').some(line => line.length > 1000)) {
+      // Read tools may truncate a single long line. These JSONL records each
+      // contain <=200 UTF-16 code units; concatenate text values in order for
+      // the exact original. The raw original is always retained too.
+      const chunks = [];
+      for (let start = 0; start < text.length; start += 200)
+        chunks.push(JSON.stringify({ offset: start, text: text.slice(start, start + 200) }));
+      writeFileSync(target + '.chunks.jsonl', chunks.join('\n') + '\n');
+      ref.readableChunks = name + '.chunks.jsonl';
+    }
+    return ref;
+  };
+  const externalize = value => {
+    if (typeof value === 'string' && (value.length > 1000 || value.includes('\n')))
+      return { $evidenceText: readableText(value, `evidence/text/${textID++}.txt`) };
+    if (Array.isArray(value)) return value.map(externalize);
+    if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value).map(([k,v]) => [k,externalize(v)]));
+    return value;
+  };
+  const save = (name, value) => {
+    const text = JSON.stringify(value, null, 2);
+    const target = path.join(folder, name);
+    mkdirSync(path.dirname(target), { recursive: true });
+    writeFileSync(target, text);
+    return { path: name, chars: text.length, sha256: hash(text) };
+  };
+  save('packet.json', packet);
+  const source = Object.fromEntries(Object.entries(tree.files)
+    .filter(([, file]) => file.text !== null && !file.generated).map(([name, file]) => [name, file.text]));
+  const inventory = [];
+  for (const [name, file] of Object.entries(tree.files)) {
+    if (file.text === null) {
+      inventory.push({file:name,kind:file.kind??'opaque',bytes:file.bytes??null,sha256:file.hash,path:null,
+        evidence:'Contents withheld: binary, link or sensitive file. Metadata is not proof of correctness. Request appropriate safe checks or PNG evidence; never request credentials.'});continue;
+    }
+    const target = path.join(folder, 'source', name);
+    mkdirSync(path.dirname(target), { recursive: true }); writeFileSync(target, file.text);
+    const accessible = file.text.split('\n').some(line => line.length > 1000)
+      ? readableText(file.text, `evidence/source-text/${inventory.length}.txt`) : null;
+    inventory.push({ file: name, path: `source/${name}`, chars: file.text.length, sha256: hash(file.text), generated: !!file.generated,
+      ...(accessible ? { readableChunks: accessible.readableChunks } : {}) });
+  }
+  const generatedInventory = inventory.filter(f => f.generated).map(f => ({ ...f,
+    evidence: packet.changes?.changed.some(item => item.file === f.file)
+      ? 'Exact changed spans in packet.changes; full file in source/.'
+      : 'Body not inlined; unchanged or planning-only. Full file in source/.' }));
+  const inline = JSON.stringify({ packet, source, generatedInventory, opaqueInventory:inventory.filter(f=>f.path===null) });
+  if (inline.length <= inlineChars) return { mode: 'inline', text: inline };
+
+  const sections = [];
+  for (const [key, value] of Object.entries(packet)) {
+    if (value === undefined) continue;
+    // Numeric filenames keep untrusted field names out of filesystem paths.
+    if (key === 'changes') {
+      const changes = value.changed.map((change, i) => {
+        const { before, after, ...metadata } = change;
+        return { file: change.file, ...save(`evidence/changes/${i}.json`, { ...externalize(metadata),
+          before: { $evidenceText: readableText(before, `evidence/changes/${i}.before.txt`) },
+          after: { $evidenceText: readableText(after, `evidence/changes/${i}.after.txt`) } }) };
+      });
+      sections.push({ field: key, ...save('evidence/changes/index.json', { lines: value.lines, changes }) });
+    } else sections.push({ field: key, ...save(`evidence/sections/${sections.length}.json`, externalize(value)) });
+  }
+  const index = { transport: 'file-backed', artifactHash: packet.artifactHash ?? null,
+    sourceFingerprint: tree.fingerprint, packet: 'packet.json', sections,
+    source: save('evidence/source-index.json', inventory) };
+  save('evidence/index.json', index);
+  return { mode: 'file-backed', text: JSON.stringify({ transport: 'file-backed',
+    index: 'evidence/index.json', artifactHash: index.artifactHash, sourceFingerprint: tree.fingerprint }) };
+}

package/core/frontend-policy.mjs

@@ -0,0 +1,34 @@
+// Shared by the native OpenCode roles and the isolated premium CLI prompts.
+// These are semantic engineering criteria, not another quota or workflow gate.
+export const FRONTEND_COMMON = `Frontend engineering standard:
+Apply to affected frontend work, using the actual framework, installed versions and repository conventions. Follow the user's requirements. Choose established patterns for the problem and verify relevant current official docs; do not treat "best practices" as a fixed stack, dependency list or folder template. Visual design approval does not approve code architecture.
+Separate independently changing responsibilities: rendering/composition, interaction state/transitions, domain calculations/validation, persistence/transport and navigation/lifecycle. Keep trivial local state with its UI. Extract substantial responsibilities behind narrow typed contracts; do not create layers without a concrete benefit. File length alone is never a defect or a quota. Moving a large component wholesale into one giant hook, or splitting JSX while leaving coupled state/ref/effect orchestration untouched, is not separation of concerns.
+Give each datum and state transition one owner. Derive values rather than mirror them across state, refs and effects. Use the framework's native form/data primitives where adequate; use a reducer or explicit state model when related transitions genuinely require it, without mandating a state-machine library. Refs can hold imperative handles or justified latest-value access but must not become a parallel hidden state store. Keep pure rules independently testable. Effects synchronize external systems with cleanup; do not build chains of effects for derived state or event-driven business logic.
+Keep substantial storage/recovery and request-result handling behind focused interfaces. A coordinating hook may connect those pieces but must not also become the domain engine, storage adapter and rendering implementation. Components communicate through explicit props/events or an appropriate shared owner; do not reach into unrelated components through DOM IDs to change their state.
+For asynchronous UI, define response ownership across resubmission, record changes, unmount, custom links and browser Back/Forward. Verify the framework's real navigation lifecycle. A stale result must not resurrect discarded input, update a different record or redirect after departure. Cleanup/cancellation must not falsely imply a server mutation was rolled back. Share safe validation/limits across client and server; preserve server authority and keep server-only code out of client imports.
+Use checks proportional to behavior: pure transition/rule tests and targeted integration/browser checks for the actual lifecycle, failure and concurrency risks. Passing lint/types/build or many tests does not establish responsibility boundaries. Review the current affected feature and its dependencies cumulatively at meaningful milestones so incremental fixes do not hide structural drift. Do not impose a new checkpoint on cosmetic changes or rewrite unrelated legacy code.`;
+
+export const FRONTEND_PLAN = `Frontend planning responsibilities:
+For a substantive interactive feature, include a compact responsibility map in the existing plan: module/component or existing owner -> responsibility -> state it owns -> inputs/events/results -> dependencies. Specify server/client boundaries and shared contracts. Identify the owner of save/retry, recovery and navigation effects when applicable, with key transitions/invariants and focused acceptance scenarios. Name intended extraction boundaries before implementation; "build the editor component" alone is not sufficient for a complex workflow. Reuse established boundaries for small/medium extensions; a simple component needs only a brief rationale, not an extra document or architecture ceremony. Unbuilt UI screenshots and later visual-design documents are not prerequisites for architecture approval. Return decisions and ownership to the builder; do not implement.`;
+
+export const FRONTEND_BUILD = `Frontend implementation responsibilities:
+These duties apply to Build and implementation specialists. Read-only architects and reviewers must not implement; they assess the corresponding contracts and evidence.
+Before substantive edits, read the approved architecture/design or existing conventions and identify the responsibilities this change affects. Implement those boundaries as the feature grows, rather than deferring separation until the app is finished. Maintain narrow typed interfaces and a single state owner; preserve behavior and other contributors' work. If the approved plan concentrates incompatible responsibilities, request a focused plan amendment instead of blindly reproducing it. The builder may make ordinary code-organization choices within the plan, but new UI/UX decisions still belong to Claude with Astra review. On handoff, report actual module responsibilities, important state/lifecycle ownership, checks performed and justified exceptions. Do not claim structural quality merely because files got shorter.`;
+
+export const FRONTEND_REVIEW = `Frontend review responsibilities:
+For frontend planning, verify the responsibility/state ownership map and contracts are concrete enough to implement. For code review, inspect the actual affected feature, not only the latest tiny patch; trace one important user action through UI state, effects, transport/recovery and navigation, as applicable. Briefly report the responsibilities and source paths inspected, lifecycle checks/evidence and any justified exceptions. Findings need exact code/plan evidence, a concrete consequence and a focused remedy.
+Treat materially entangled responsibilities, duplicated authoritative rules or uncontrolled state/effect coordination as maintainability/correctness findings even when tests pass, when evidence shows a realistic regression risk or forces unrelated behavior changes together. Use medium for material maintainability defects; high/critical require corresponding impact. Do not classify such evidence as cosmetic merely because the current happy path works. Conversely, file length, number of hooks, naming taste, preferred folder layouts or optional abstractions alone do not justify medium findings. Accept cohesive simple components. Report using the configured verdict schema; these criteria do not add workflow gates or numeric work quotas.`;
+
+export const ROLE_FRONTEND_RULES = {
+  'frontend-engineer': `${FRONTEND_COMMON}\n\n${FRONTEND_BUILD}`,
+  'fullstack-architect': `${FRONTEND_PLAN}\n\nUse the frontend engineering standard: separate substantial rendering, state transitions, pure rules, persistence and lifecycle responsibilities; avoid giant-component or giant-hook plans and duplicated state. Select proportionate patterns, not mandatory layers. Include stale-response and browser-history cases where async editing is part of scope.`,
+  'code-reviewer': `${FRONTEND_COMMON}\n\n${FRONTEND_REVIEW}`,
+  'test-engineer': `Frontend behavior verification: test the specified state/lifecycle contracts, not private hook wiring or file counts. Use pure tests for nontrivial rules/transitions and integration/browser tests for crossings between UI, requests, recovery and navigation. Where applicable test resubmission, record change, unmount, browser Back/Forward and custom links while a response is delayed; verify stale responses do not restore discarded data or redirect the departed user. Shared validation boundaries need relevant boundary cases. Distinguish cancellation of client effects from cancellation of a server commit. Run only checks justified by this feature; trivial visual tweaks need no new test suite. Report untested boundaries honestly and return structural concerns to the parent.`,
+  'security-auditor': `Frontend security boundaries: check client/server import boundaries, safe shared validation contracts, server-side authorization, and identity ownership across async responses, record/account changes and local recovery. Verify stale state cannot cross users/records, expose sensitive data or weaken server checks. Code organization matters when it creates a concrete security/data-isolation consequence; report that evidence and impact, not a cosmetic file-size finding. Remain read-only and within the actual stack/scope.`,
+  'backend-engineer': `Frontend integration contracts: own authoritative server validation, authorization and domain rules. Expose narrow typed request/result contracts and safe shared constraints that frontend code can consume without importing server-only dependencies. Preserve raw form input separately from validated domain data when needed. Document committed success, validation errors, conflict/retry and uncertain transport outcomes so the frontend does not reimplement business policy or falsely treat client cancellation as server rollback. Implement only the assigned server scope using the actual project stack.`,
+};
+
+export const GLOBAL_FRONTEND_ROUTING = `## Frontend responsibility ownership
+
+Apply the role-specific frontend engineering instructions before and during substantive frontend work. Build/Plan must hand off concrete module/state ownership and acceptance scenarios, not merely a screen name. The architect defines boundaries; frontend-engineer implements them; code-reviewer examines cumulative feature structure and actual lifecycle behavior; test-engineer verifies relevant boundary cases. Small cohesive components remain simple. No line-count limits, mandatory libraries or extra review rounds. Material coupling is an engineering finding when supported by evidence, even if lint and tests pass. The isolated premium bridge receives the same criteria explicitly; native agent files alone do not configure its reviewers.
+`;

package/core/images.mjs

@@ -0,0 +1,35 @@
+import { readFileSync, lstatSync, realpathSync, mkdirSync, writeFileSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+import { hash } from './snapshot.mjs';
+
+const within = (root, file) => { const r=path.relative(root,file); return r && !r.startsWith('..'+path.sep) && r!=='..' && !path.isAbsolute(r); };
+export function captureImages(directory, images = [], artifactHash) {
+  if (!Array.isArray(images)) throw new Error('Supply an array of explicit PNG screenshots.');
+  const roots = [path.resolve(directory), path.join(tmpdir(),'opencode')].map(logical=>({logical,real:existsSync(logical)?realpathSync(logical):null}));
+  return images.map((item,i) => {
+    if (!item || typeof item.path !== 'string' || typeof item.caption !== 'string' || !item.caption.trim() || item.artifactHash !== artifactHash)
+      throw new Error('Each screenshot needs path, caption and artifactHash matching status.currentArtifactHash. Capture screenshots of that code version.');
+    const absolute = path.resolve(directory,item.path);
+    if (!roots.some(root => within(root.logical,absolute)||(root.real&&within(root.real,absolute)))) throw new Error('Screenshots must be inside this project or the dedicated temp/opencode directory.');
+    const info=lstatSync(absolute), resolved=realpathSync(absolute);
+    if (!info.isFile() || info.isSymbolicLink() || !roots.some(root => root.real&&within(root.real,resolved))) throw new Error('Screenshot links/outside paths are not allowed.');
+    if (path.extname(resolved).toLowerCase()!=='.png') throw new Error('Use PNG screenshots; all supplied images are retained.');
+    const data=readFileSync(resolved);
+    if (data.length<33 || data.subarray(0,8).toString('hex')!=='89504e470d0a1a0a' || data.toString('ascii',12,16)!=='IHDR') throw new Error('Invalid PNG screenshot.');
+    const width=data.readUInt32BE(16),height=data.readUInt32BE(20);
+    if (!width || !height) throw new Error('Invalid PNG dimensions.');
+    return { data, manifest: { path:`images/${i}.png`, caption:item.caption, sha256:hash(data), width,height,artifactHash,
+      provenance:'Captured bytes; code-version association and caption supplied by implementer, not independently verified.' } };
+  });
+}
+export function saveImages(folder, captured) {
+  if (captured.length) {
+    mkdirSync(path.join(folder,'images'),{recursive:true});
+    writeFileSync(path.join(folder,'images','manifest.json'),JSON.stringify(captured.map(i=>i.manifest),null,2));
+  }
+  return captured.map(({data,manifest}) => {
+    if(hash(data)!==manifest.sha256) throw new Error('Captured image changed before delivery.');
+    const target=path.join(folder,manifest.path);mkdirSync(path.dirname(target),{recursive:true});writeFileSync(target,data);return target;
+  });
+}

package/core/monitor-data.mjs

@@ -0,0 +1,58 @@
+import { readFileSync, readdirSync, statSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { stageLabel } from './telemetry.mjs';
+import { priceCall, pricingInfo, reportedUsage } from './pricing.mjs';
+import { summarize } from './dashboard-state.js';
+
+function json(file) {
+  try { return JSON.parse(readFileSync(file, 'utf8')); } catch { return null; }
+}
+function alive(pid) { if (!Number.isInteger(pid) || pid < 1) return false; try { process.kill(pid, 0); return true; } catch { return false; } }
+function inside(root, target) {
+  try { const relative = path.relative(realpathSync(root), realpathSync(target)); return relative !== '..' && !relative.startsWith('..' + path.sep) && !path.isAbsolute(relative); } catch { return false; }
+}
+export function readDashboard(projectFolder, config) {
+  const state = json(path.join(projectFolder, 'state.json'));
+  if (!state) return { phase: 'not-started', calls: [], totals: [], updatedAt: new Date().toISOString() };
+  if (!/^[a-f0-9-]{36}$/i.test(state.id)) throw new Error('Invalid task ID');
+  const taskFolder = path.join(projectFolder, state.id);
+  const lock = json(path.join(projectFolder, 'operation.lock'));
+  const operationActive = !!lock && alive(lock.pid);
+  let names = [];
+  try { if (inside(projectFolder, taskFolder)) names = readdirSync(taskFolder).filter(name => /^\d+-(astra|opus)-[a-z0-9-]+$/.test(name)).sort((a,b) => parseInt(a) - parseInt(b)); } catch {}
+  const calls = names.map((name, index) => {
+    const folder = path.join(taskFolder, name);
+    if (!inside(projectFolder, folder)) return null;
+    const [, sequence, who, stage] = /^(\d+)-(astra|opus)-(.+)$/.exec(name);
+    const get = name => inside(projectFolder, path.join(folder, name)) ? json(path.join(folder, name)) : null;
+    const report = get('report.json'), packet = get('packet.json'), activity = get('activity.json');
+    const legacyActive = !report && index === names.length - 1 && operationActive;
+    const configured = config[who === 'astra' ? 'codex' : 'claude']??{};
+    let status = report ? 'completed' : legacyActive ? 'untracked-active' : 'unknown';
+    if (activity) {
+      status = activity.status;
+      if (['preparing','running'].includes(status) && (!alive(activity.parentPid) || Date.now() - Date.parse(activity.updatedAt) > 30000)) status = 'stale';
+    }
+    let startedAt = activity?.startedAt;
+    if (!startedAt) { try { startedAt = statSync(path.join(folder, 'packet.json')).mtime.toISOString(); } catch {} }
+    return { id: name, sequence: Number(sequence), who, stage, label: stageLabel(stage), status,
+      requestedModel: activity?.requestedModel ?? configured.model, resolvedModels: activity?.resolvedModels ?? [], effort: activity?.effort ?? configured.effort,
+      modelEvidence: activity ? 'CLI telemetry (resolved identity when reported)' : 'Configured model; historical CLI identity unavailable',
+      startedAt, endedAt: activity?.endedAt ?? null, currentAction: activity?.currentAction ?? (legacyActive ? 'Bridge operation active; detailed telemetry unavailable' : report ? 'Saved report available' : 'No completion evidence'),
+      apiCost:activity?.apiCost,usage: activity?.usage ?? null, usageByModel: activity?.usageByModel ?? {}, toolEvents: activity?.toolEvents ?? [],
+      verdict: report?.verdict ?? activity?.verdict ?? null, report: typeof report?.report === 'string' ? report.report : null,
+      findings: Array.isArray(report?.findings) ? report.findings : [],
+      brief: packet?.brief ?? null, clarification: packet?.clarification?.text ?? null,
+      artifactHash: packet?.artifactHash ?? null,
+      peerReportsReceived: (packet?.previous?.length ?? 0) + (packet?.astra ? 1 : 0) +
+        (packet?.priorFindings?.length ?? 0) + (packet?.proposals ? Object.keys(packet.proposals).length : 0),
+    };
+  }).filter(Boolean);
+  for (const call of calls) { call.usage = reportedUsage(call); call.cost = priceCall(call); }
+  const efforts = { astra: config.codex?.effort, opus: config.claude?.effort };
+  const totals = summarize(calls, efforts);
+  return { project: state.baseline?.root, task: state.id, phase: state.phase, brief: state.brief, rounds: state.rounds,
+    operationActive, lockPresent: !!lock, calls, totals, efforts, pricing: pricingInfo, decision: state.decision ?? null,
+    pauseReason: state.pauseReason ?? null, checkpoint: state.checkpoint ?? null, updatedAt: new Date().toISOString(),
+    plan: typeof state.plan === 'string' ? state.plan : '', clarification: state.planningClarification?.text ?? null };
+}

package/core/monitor.mjs

@@ -0,0 +1,24 @@
+import http from 'node:http';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { readDashboard } from './monitor-data.mjs';
+const here = path.dirname(fileURLToPath(import.meta.url));
+export function createMonitor(projectFolder, config) {
+  return http.createServer((req, res) => {
+    const origin = `http://127.0.0.1:${res.socket.localPort}`;
+    const expectedHost = `127.0.0.1:${res.socket.localPort}`;
+    res.setHeader('Cache-Control','no-store'); res.setHeader('X-Content-Type-Options','nosniff');
+    res.setHeader('Content-Security-Policy', "default-src 'self'; script-src 'self'; style-src 'self'; connect-src 'self'; object-src 'none'; base-uri 'none'; frame-ancestors 'none'");
+    if (req.headers.host !== expectedHost || (req.headers.origin && req.headers.origin !== origin) || req.headers['sec-fetch-site'] === 'cross-site') { res.writeHead(403); res.end('Local origin required'); return; }
+    if (req.method !== 'GET') { res.writeHead(405); res.end(); return; }
+    const route = req.url?.split('?')[0];
+    try {
+      if (route === '/api/status') { res.setHeader('Content-Type','application/json'); res.end(JSON.stringify(readDashboard(projectFolder, config))); return; }
+      if (route === '/health') { res.setHeader('Content-Type','application/json'); res.end(JSON.stringify({ service: 'hybrid-activity-monitor', projectFolder, pid: process.pid })); return; }
+      const assets = { '/': ['dashboard.html','text/html'], '/app.js':['dashboard.js','text/javascript'], '/dashboard-state.js':['dashboard-state.js','text/javascript'], '/style.css':['dashboard.css','text/css'] };
+      if (!assets[route]) { res.writeHead(404); res.end(); return; }
+      const [file,type] = assets[route]; res.setHeader('Content-Type', type + '; charset=utf-8'); res.end(readFileSync(path.join(here,file)));
+    } catch { res.writeHead(503); res.end('Report data temporarily unavailable; retry shortly.'); }
+  });
+}

package/core/operation-lock.mjs

@@ -0,0 +1,82 @@
+import {createServer} from 'node:net';
+import {existsSync,readFileSync,writeFileSync,renameSync,unlinkSync,readdirSync} from 'node:fs';
+import path from 'node:path';
+import {hash} from './snapshot.mjs';
+import {sameProcess,ownIdentity} from './process-identity.mjs';
+import {acquirePosixMutex} from './posix-lock.mjs';
+
+const pending=new Set();
+const busy=()=>new Error('Another checkpoint operation is active. Wait for it to finish; history is preserved.');
+const orphanFile=file=>file+'.unreaped.json';
+function orphanAlive(file) {
+  if(!existsSync(orphanFile(file)))return false;
+  const value=JSON.parse(readFileSync(orphanFile(file),'utf8'));return (value.records ?? [value]).some(r=>r.nativeSessionID||r.descendantsUnconfirmed===true||sameProcess(r.pid,r.identity));
+}
+export function retainUnreaped(file,error){
+  const target=orphanFile(file), previous=existsSync(target)?JSON.parse(readFileSync(target,'utf8')):null;
+  const records=previous?(previous.records??[previous]):[];
+  const record={nativeSessionID:error.nativeSessionID,pid:error.unreapedPid,identity:error.workerIdentity,descendantsUnconfirmed:!!error.descendantsUnconfirmed,at:new Date().toISOString()};
+  if(!records.some(r=>r.nativeSessionID===record.nativeSessionID&&r.pid===record.pid&&r.identity===record.identity&&r.descendantsUnconfirmed===record.descendantsUnconfirmed))records.push(record);
+  writeFileSync(target,JSON.stringify({records}));
+}
+export const operationBusy=file=>pending.has(file)||existsSync(file)||orphanAlive(file);
+export function alive(pid) {
+  if(!Number.isInteger(pid)||pid<1) return true; // Unknown owner must not be mistaken for a dead one.
+  try{process.kill(pid,0);return true;}catch(error){return error.code!=='ESRCH';}
+}
+function activeChildren(folder,owner) {
+  // Only manifests created by the bridge; never inspect arbitrary source paths.
+  for(const task of readdirSync(folder,{withFileTypes:true})) {
+    if(!task.isDirectory()||!/^[a-f0-9-]{36}$/i.test(task.name))continue;
+    for(const call of readdirSync(path.join(folder,task.name),{withFileTypes:true})) {
+      if(!call.isDirectory()||!/^\d+-(astra|opus)-/.test(call.name))continue;
+      const file=path.join(folder,task.name,call.name,'activity.json');if(!existsSync(file))continue;
+      const value=JSON.parse(readFileSync(file,'utf8'));
+      // Terminal workers have exited; old PID numbers are not live process identities.
+      if(value.parentPid!==owner.pid || Date.parse(value.startedAt)<Date.parse(owner.started) || (value.endedAt&&!value.workerExitUnconfirmed))continue;
+      if(value.descendantsUnconfirmed||(value.workerPid&&sameProcess(value.workerPid,value.workerIdentity)))return true;
+    }
+  }
+  return false;
+}
+async function listen(server,address) {
+  await new Promise((resolve,reject)=>{server.once('error',reject);server.listen(address,()=>{server.removeListener('error',reject);resolve();});});
+}
+export async function acquireOperation(file,resolveNative,{platform=process.platform}={}) {
+  if(pending.has(file))throw busy();pending.add(file);
+  let releaseMutex,owned=false;
+  try {
+    if(!['win32','linux'].includes(platform))releaseMutex=await acquirePosixMutex(file);
+    else {
+      const suffix=hash(path.resolve(file)).slice(0,30);
+      const address=platform==='win32'?`\\\\.\\pipe\\opencode-hybrid-${suffix}`:`\0opencode-hybrid-${suffix}`;
+      const server=createServer(socket=>socket.destroy());
+      try{await listen(server,address);}catch{throw busy();}
+      releaseMutex=()=>new Promise(resolve=>server.close(resolve));
+    }
+    if(resolveNative)await resolveNative(file);
+    if(orphanAlive(file))throw new Error('Previous worker termination is unconfirmed. A known live worker must exit; unknown descendant processes require process-tree diagnosis before recovery. No approval was recorded.');
+    if(existsSync(orphanFile(file)))renameSync(orphanFile(file),orphanFile(file)+'.resolved-'+Date.now());
+    if(existsSync(file)) {
+      const owner=JSON.parse(readFileSync(file,'utf8'));
+      if(sameProcess(owner.pid,owner.identity)||activeChildren(path.dirname(file),owner))throw busy();
+      renameSync(file,`${file}.interrupted-${Date.now()}`);
+    }
+    writeFileSync(file,JSON.stringify({pid:process.pid,identity:ownIdentity(),started:new Date().toISOString()}),{flag:'wx'});owned=true;
+    return async()=>{try{if(owned)unlinkSync(file);}finally{try{await releaseMutex();}finally{pending.delete(file);}}};
+  } catch(error) {
+    try{if(releaseMutex)await releaseMutex();}finally{pending.delete(file);}throw error;
+  }
+}
+
+export async function resolveNativeGuards(file,inspect) {
+  const target=orphanFile(file);if(!existsSync(target))return;
+  const value=JSON.parse(readFileSync(target,'utf8')),records=value.records??[value],remaining=[];
+  for(const record of records){
+    let done=false;
+    if(record.nativeSessionID)try{const session=await inspect(record.nativeSessionID);done=!!session.time?.idle&&['succeeded','failed','interrupted'].includes(session.outcome);}catch{}
+    if(!done)remaining.push(record);
+    else if(record.pid||record.descendantsUnconfirmed)remaining.push({...record,nativeSessionID:undefined});
+  }
+  if(JSON.stringify(remaining)!==JSON.stringify(records)){const temporary=target+'.tmp';writeFileSync(temporary,JSON.stringify({records:remaining}));renameSync(temporary,target);}
+}