@rockysoft/opencode-hybrid-workflow 1.0.1 → 1.1.1

package/assets/integrations/impeccable/typeset.md

@@ -0,0 +1,90 @@
+Typography carries information, hierarchy, and voice. Improve it inside the established visual world; do not replace the identity unless the user asked to.
+
+---
+
+## Visitor mode
+
+- **Persuade + Experience:** display type may carry the voice. Use decisive contrast and responsive scale when the composition benefits.
+- **Operate + Read:** stability, scanability, and measure come first. A single well-tuned family and fixed role scale are often right.
+- **Native:** follow [ios.md](ios.md) or [android.md](android.md), including platform scaling and accessibility behavior.
+
+If typography replacement would create a new identity, route through [new-work.md](new-work.md) and update DESIGN.md. Otherwise preserve confirmed families and improve their use.
+
+## Two isolated assessments
+
+When a sub-agent tool is available and permitted, run these independently; otherwise run them yourself in this order. Do not let detector findings anchor the design assessment.
+
+1. **Typographic assessment:** inspect representative pages and styles. Answer every question below with a file, selector, or computed value:
+   - **Authority and fit:** Which faces, weights, and roles are established? Do they fit the product and selected world, or are they unexamined defaults? Is every family necessary?
+   - **Hierarchy:** Can heading, body, label, metadata, and data roles be distinguished at a glance? Are adjacent sizes or weights too close to carry different jobs?
+   - **Scale and consistency:** Is there a deliberate role scale, or a collection of arbitrary values? Do repeated roles stay identical across screens and states?
+   - **Reading:** Does body copy stay within a comfortable 45–75 character measure? Are line height, paragraph rhythm, contrast, and tracking tuned to the actual face, width, language, and surface?
+   - **Stress:** What happens with long headings, localization expansion, zoom, narrow containers, missing weights, and font fallback?
+   - **Delivery:** Are only used assets loaded? Do fallback metrics, loading strategy, and variable-font settings avoid invisible text and disruptive reflow?
+2. **Mechanical scan:** run:
+
+```bash
+.opencode/skills/impeccable/scripts/impeccable detect --json --scope type [target files or dirs]
+```
+
+Also inspect dynamic or arbitrary font values the detector cannot interpret. Synthesize both assessments before editing, noting what each caught alone. A clean scan is a floor, not proof of good typography.
+
+## Set the system
+
+Before editing, state:
+
+- the roles the interface needs;
+- the intended contrast between those roles;
+- the reading measure and density;
+- which existing faces and weights are authoritative;
+- any performance, localization, or accessibility constraints.
+
+Use the fewest roles and families that make the hierarchy unmistakable. Combine size, weight, space, and tone deliberately instead of asking size alone to do all the work. Role names and tokens should describe purpose rather than values.
+
+## Apply
+
+- Keep body copy comfortably readable and zoomable. Use 1rem / 16px as the ordinary web body floor unless a dense role, platform convention, or user setting justifies otherwise.
+- Keep prose in the 45–75ch range. Tune line height inversely with measure: wider lines generally need more leading.
+- Compensate light text on dark surfaces on all three perceptual axes: slightly more line height, a touch more tracking, and one step more weight when the face needs it.
+- Tune line height to the face, width, language, and contrast, not a universal ratio.
+- Keep repeated roles consistent across screens and states.
+- Use numeric, tabular, code, and label features when their content benefits.
+- Load only used font assets and weights. Provide metric-compatible fallbacks and avoid blocking text.
+- Let marketing display type respond to available space when useful; keep dense product and reading surfaces spatially predictable.
+- Preserve browser zoom, user font settings, Dynamic Type, and platform text scaling.
+- Use paragraph spacing or first-line indentation as the primary paragraph rhythm; combining both usually double-marks the boundary.
+
+Do not make type decorative at the expense of comprehension, or introduce a second family without a clear role it alone can perform.
+
+## Line breaks
+
+After Matthew Butterick's *Practical Typography*, paraphrased; where his numbers differ from these, these stand.
+
+- Set `text-wrap: balance` on headings and short centered blocks, and `text-wrap: pretty` on body copy. Both are progressive: a browser that ignores them keeps its default wrap.
+- `pretty` pulls a word down beside a lone last word. It does not fill the last line, and a two-word tail is fine.
+- In a column too narrow for either to help, edit the copy or widen the column.
+- Break a heading by hand only between phrases, and check the break at every width the heading renders at. A hard break that lands mid-line on a phone is worse than the default wrap.
+- An uneven break can carry meaning: a headline that lands on one word for weight, a poster line, a pull quote. Make it deliberate with a hard break or a wrap set on that element, and keep it rare. The detector's `straggler` and `unbalanced-heading` findings are advisory for this reason; say which breaks are intended.
+
+## Verify
+
+- Primary, secondary, body, and metadata roles are recognizable without reading the copy.
+- Long text remains comfortable across relevant widths and languages.
+- The typography belongs to the product and its established world.
+- Loading does not create disruptive reflow or invisible text.
+- Zoom, text scaling, focus, contrast, and reduced viewport paths remain usable.
+- The final mechanical scan has no unexplained findings.
+
+Answer each item with rendered or source evidence, then rerun the scan. Do not substitute a bare “yes” for verification.
+
+When the hierarchy holds, hand off to `/impeccable polish`.
+
+## Live-mode signature params
+
+Every variant declares a coarse `scale` parameter and authors its type ramp against `var(--p-scale, 1)`.
+
+```json
+{"id":"scale","kind":"range","min":0.85,"max":1.3,"step":0.05,"default":1,"label":"Scale"}
+```
+
+Add at most one pairing or weight parameter when it represents a real system choice. Follow [live.md](live.md)'s parameter contract.

package/core/controller.mjs

@@ -40,7 +40,7 @@ For UI implementation reviews compare the supplied approved Claude design or est
 For planning report a concrete plan: requirements, responsibility boundaries, contracts, alternatives/tradeoffs, security, data handling, investigation points, specialist-owned slices, acceptance checks and relevant design skills.
 For author/proposal/synthesis stages, pass means your proposed document is ready for independent validation, not implementation approval. Do not use revise merely because you rewrote a plan: revise requires a concrete open finding and blocked requires a material open finding.
 Architecture planning precedes design for new applications and substantive behavior/architecture changes; existing-app visual redesigns use mode=ui and go directly to design. Claude/Opus owns new UI/UX design, using the supplied design skills and research; Astra reviews the exact design. Never assign new design decisions to the implementation model or its frontend agent. Existing/supplied design patterns may be implemented faithfully without a new design phase. Architecture approval alone is not visual-design approval. Do not block architecture planning because later design artifacts do not exist yet. The reviewer CLI receives captured skill evidence rather than OpenCode's native skill catalog.
-New websites/redesigns must use frontend-design and ui-ux-pro-max before implementation, and web-design-guidelines for review. Use pnpm where appropriate; honor installed versions and project rules.
+New websites/redesigns must use the supplied design guidance before implementation. When the packet selects Impeccable, its bundled references replace frontend-design/ui-ux-pro-max research for this checkpoint; follow its integration policy, not upstream executable workflow or delegation commands. Otherwise use frontend-design and ui-ux-pro-max before implementation, and web-design-guidelines for review. Use pnpm where appropriate; honor installed versions and project rules.
 You may read files under source/ and the packet. Never search the web with private source or internal URLs. No commands that change anything. Keep reports concise and proportional to risk. Missing evidence must be explicit.
 ${WORKFLOW_POLICY}`;
 

package/core/design.mjs

@@ -6,10 +6,12 @@ import { runProcess } from './workers.mjs';
 import { captureImages } from './images.mjs';
 import {findingChecklist,findingDecision} from './findings.mjs';
 import {browserEvidence} from '../lib/browser-evidence/receipt.mjs';
+import {impeccableIntent,impeccableEvidence} from '../lib/impeccable.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 = '') {
+  if(impeccableIntent(text))return 'new';
   // 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);
@@ -85,6 +87,8 @@ export async function design(state, input, signal) {
   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 integration=impeccableEvidence(this.config,brief,tree);
+  if(integration)evidence.impeccable={name:integration.name,mode:integration.mode,provenance:integration.provenance,digest:integration.digest};
   const captured=browserEvidence(this,state,tree.fingerprint);
   const images=[...captureImages(this.directory,input.images,tree.fingerprint),...captured.images].map((image,index)=>({...image,manifest:{...image.manifest,path:`images/${index}.png`}}));
   evidence.browserEvidence=captured.summary;
@@ -95,7 +99,7 @@ export async function design(state, input, signal) {
   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');
+  const skills = integration ? {impeccable:integration,guidance:integration.policy} : 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.');

package/core/plugin.mjs

@@ -8,6 +8,8 @@ import { Controller } from './controller.mjs';
 import { readDashboard } from './monitor-data.mjs';
 import { DESIGN_POLICY, recordDesignRequest } from './design.mjs';
 import { researchTool } from './research-tools.mjs';
+import {registerImpeccableCommand,IMPECCABLE_POLICY} from '../lib/impeccable.mjs';
+import {registerContinuation,CONTINUATION_POLICY} from '../lib/continuation.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 // V2's Plugin.define is an identity function. This plain plugin needs no installed dependencies.
@@ -20,6 +22,7 @@ export function createPlugin(config, storage = config.runtimeDirectory ?? path.j
     const compatible = config.compatibleOpenCode ?? [config.targetOpenCode];
     if (!compatible.includes(ctx.app.version)) throw new Error(`Hybrid plugin compatibility check required: running OpenCode ${ctx.app.version}; verified versions: ${compatible.join(', ')}. Run the isolated compatibility probe before adding this version. Existing task history is preserved.`);
     const controllers = new Map();
+    await registerImpeccableCommand(ctx);
     const forSession = async sessionID => {
       const result = await ctx.session.get({ sessionID });
       const session = result.data ?? result;
@@ -28,6 +31,7 @@ export function createPlugin(config, storage = config.runtimeDirectory ?? path.j
       if (!controllers.has(directory)) controllers.set(directory, new Controller(directory, config.storageFor?.(directory) ?? storage, config));
       return controllers.get(directory);
     };
+    await registerContinuation(ctx,forSession);
     await ctx.session.hook('prompt', async event => {
       if(await isReviewerSession(ctx,event.sessionID))return;
       const response = await ctx.session.get({sessionID:event.sessionID});
@@ -40,6 +44,8 @@ export function createPlugin(config, storage = config.runtimeDirectory ?? path.j
       if(await isReviewerSession(ctx,event.sessionID))return;
       event.system.push({type:'text',text:roleText(DESIGN_POLICY)});
       event.system.push({type:'text',text:roleText(WORKFLOW_POLICY)});
+      event.system.push({type:'text',text:IMPECCABLE_POLICY});
+      event.system.push({type:'text',text:CONTINUATION_POLICY});
       event.system.push({type:'text',text:`${FRONTEND_COMMON}\n${FRONTEND_BUILD}`});
       event.system.push({type:'text',text:'Hybrid recovery: completed negative/blocked code reviews allow corrections and evidence collection in fix; continue automatically and re-review, never claim acceptance. action=fix recovers a legacy completed review. New evidence in checks/images resumes paused plan/design; action=replan with concrete changed requirements opens architecture revision while preserving findings and history. action=inspect checks installed tools and CLI logins without model calls and is available during planning. Never edit bridge state or reset history. Playwright research outputs use plain filenames in .playwright-mcp/hybrid-evidence; this generated evidence is excluded from source snapshots. Navigation/resizing and screenshot capture are available while planning/designing. Supply actual PNGs to plan/design/review as images [{path,caption,artifactHash}], using status.currentArtifactHash for the code/reference being inspected. Recapture after code changes and include interaction evidence in checks. Both reviewers receive pixels; never substitute hashes or ask the user to attest images merely because they live outside Git.'});
     });

package/docs/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Release notes
 
+## 1.1.1
+
+- Recover reasoning-only silent stops in participating Hybrid sessions on OpenCode 2.2.5+. The same agent continues within the current execution, preserving user instructions and checkpoint approvals.
+- Require clear plan-review, completion and blocker handoffs in agent guidance. Visible answers and user interruptions are left alone.
+- Show a session-specific sidebar warning if recovery stops silently again without new evidence or checkpoint progress. This warning does not call a model or change approvals.
+
+## 1.1.0
+
+- Add optional Impeccable design guidance in Hybrid settings and `/hybrid-impeccable redesign` or `polish`. The configured design lead authors the direction, reviewers validate it, and the implementation model follows the approved document.
+- Bundle selected, version-pinned Impeccable references with their license. No separate engine, hooks or runtime downloads are required.
+- Recover interrupted native-provider reports as complete responses instead of accepting a continuation fragment. Incomplete recovery still blocks approval.
+- Accept an exact single JSON code-block wrapper from native reviewers while retaining strict response validation.
+
 ## 1.0.1
 
 - Refresh usage sidebar settings immediately after saving Hybrid setup, including reviewer models, effort, reviewer count and telemetry location. No restart is needed for these sidebar changes.

package/docs/impeccable.md

@@ -0,0 +1,22 @@
+# Impeccable design guidance
+
+In **/hybrid → Design guidance**, select **Impeccable**. Your selected design lead and reviewers stay in charge. Nothing else needs installing.
+
+![Select design guidance inside OpenCode](images/22-design-guidance.png)
+
+For a single task, use:
+
+```text
+/hybrid-impeccable redesign the portfolio
+/hybrid-impeccable polish the checkout
+```
+
+Or ask normally: “Use Impeccable to redesign this page.” Say “without Impeccable” to override the global setting for a request.
+
+The lead receives selected Impeccable references and existing project design documents, authors concrete implementation instructions, and submits them to the configured reviewers. Your implementation model follows the approved document. Polish preserves the current identity; redesign can replace it. The existing rule still applies: all configured reports, at least one pass, and no unresolved medium/high/critical findings.
+
+This integrates **Impeccable 4.8.0 design guidance**, not its separate executable engine. It does not install or run upstream hooks, detectors, live mode, concept boards, image generation or audit commands. Those tools' results are never implied by using the guidance. `/hybrid-impeccable` is separate from an independently installed `/impeccable` command; use the Hybrid command for this workflow.
+
+The setting affects future design checkpoints without invalidating existing approvals or changing reviewers on active tasks. The command is available on hosts with OpenCode's command transform API; normal chat routing remains available on other supported OpenCode 2 hosts.
+
+Bundled references carry their original license and exact source commit in `assets/integrations/impeccable/`. No third-party scripts or runtime downloads are required. Relevant project documents come from the same sanitized snapshot as the source evidence.

package/lib/config.mjs

@@ -34,6 +34,7 @@ export function readSettings(options={},env=process.env) {
   const config={...defaults,...supplied,reviewers:Object.fromEntries(['astra','opus'].map(who=>[who,supplied.reviewers?.[who]===null?null:supplied.reviewers?.[who]?.adapter&&supplied.reviewers[who].adapter!==defaults.reviewers[who].adapter?supplied.reviewers[who]:{...defaults.reviewers[who],...supplied.reviewers?.[who]}])),
     design:{...defaults.design,...supplied.design},verification:{...defaults.verification,...supplied.verification}};
   if(options.enabled===false)config.enabled=false;
+  if(config.design.impeccable!==undefined&&typeof config.design.impeccable!=='boolean')throw Error('design.impeccable must be true or false.');
   validateBrowser(config.reviewBrowser);
   for(const who of ['astra','opus']) {
     if(supplied.reviewers?.[who]===null)config.reviewers[who]=null;

package/lib/continuation-notice.mjs

@@ -0,0 +1,5 @@
+import {createHash} from 'node:crypto';
+export const continuationFile=sessionID=>`continuation-${createHash('sha256').update(JSON.stringify(sessionID)).digest('hex')}.json`;
+export function continuationNotice(notice,session) {
+  return notice?.busy===session?.time?.busy ? notice?.text??'' : '';
+}

package/lib/continuation.mjs

@@ -0,0 +1,85 @@
+import {createHash} from 'node:crypto';
+import {isReviewerSession} from './opencode-reviewer.mjs';
+import {writeJSONAtomic,runtimePath} from '../core/state-store.mjs';
+import {operationBusy} from '../core/operation-lock.mjs';
+import {continuationFile} from './continuation-notice.mjs';
+
+const SOURCE='hybrid-silent-stop';
+const unwrap=value=>value.data??value;
+const digest=value=>createHash('sha256').update(JSON.stringify(value)).digest('hex');
+const textOf=message=>(message?.content??[]).filter(p=>p.type==='text').map(p=>p.text??'').join('').trim();
+const meaningful=part=>part.type==='tool' && part.state?.status==='completed' &&
+  !['hybrid_activity','todowrite','todoread'].includes(part.name) &&
+  !(part.name==='hybrid_checkpoint' && ['status','inspect'].includes(part.state.input?.action));
+
+export const CONTINUATION_POLICY=`Finish the turn visibly. Reasoning and tool output are not a handoff to the user. While authorized work remains, continue gathering evidence, resolving findings and calling the next checkpoint; do not merely promise the next tool call and stop. When the user asked to review the plan before coding, finish planning and present the plan with its actual approval status and an explicit request for their review; do not start implementation. Respect all user pauses, cancellations, scope and approval requirements. If truly blocked by missing user input, authentication or unavailable external evidence, explain what is unfinished, the exact blocker and the specific next action. A model stop or successful turn is not task completion; claim completion only when the milestone and checkpoint are complete.`;
+
+// No provider call or semantic guess about consent: visible final answers are
+// left alone. This guard repairs the observed reasoning-only terminal response.
+// Receipts live in the host transcript, not the approval/state files.
+export function silentStopDecision(messages,state,sessionID,background=[]) {
+  if(!state || background.some(work=>work.sessionID===sessionID))return null;
+  const userIndex=messages.findLastIndex(m=>m.type==='user');
+  if(userIndex<0)return null;
+  const turn=messages.slice(userIndex+1),last=turn.findLast(m=>m.type==='assistant');
+  if(!last || last.error || last.finish!=='stop' || textOf(last))return null;
+  if(turn.some(m=>m.type==='assistant' && (m.error || ['error','length','content-filter'].includes(m.finish))))return null;
+  // Only sessions actually participating in the workflow, never an unrelated
+  // chat in the same directory or a model-generated reviewer session.
+  if(!messages.some(m=>m.type==='assistant' && (m.content??[]).some(p=>
+    p.name==='hybrid_checkpoint' && p.state?.status==='completed' &&
+    ['begin','plan','replan','design','review','verify','browser','fix','finish'].includes(p.state.input?.action))))return null;
+  const progress=[...new Set(turn.flatMap(m=>m.type==='assistant'?(m.content??[]):[])
+    .filter(meaningful).map(p=>digest([p.name,p.state.input,p.state.content])))].sort();
+  const key=digest([state.id,state.phase,state.candidate?.hash,state.approval?.artifactHash,
+    state.designApproval?.artifactHash,state.checkpoint,progress]);
+  const receipts=turn.filter(m=>m.type==='synthetic' && m.metadata?.source===SOURCE && m.metadata?.taskID===state.id);
+  if(receipts.some(m=>m.metadata?.key===key))return {
+    notice:`The agent stopped without a user-facing handoff after recovery. Checkpoint: ${state.phase}. Send a message to resume. Existing approvals are unchanged.`,
+  };
+  return {
+    resume:false,metadata:{source:SOURCE,taskID:state.id,key},
+    description:'Hybrid Workflow: recovering a silent stop; the agent has not handed the task back to you.',
+    text:`Hybrid Workflow detected a terminal response with no user-facing answer. Checkpoint phase: ${state.phase}. ${CONTINUATION_POLICY} Continue the next authorized step now, or provide the clear final handoff if waiting for the user. This recovery is not user consent, a new task, or permission to bypass a checkpoint. Do not repeat an unchanged failing call.`,
+  };
+}
+
+export async function registerContinuation(ctx,forSession) {
+  // experimental.idle was verified against the 2.2.5 API/host. Older hosts keep
+  // the instructions but cannot safely emulate this using after-idle timers.
+  const [major,minor,patch]=String(ctx.app?.version??'').split('.').map(Number);
+  if(major!==2 || minor<2 || (minor===2 && patch<5) || typeof ctx.session.synthetic!=='function')return;
+  const pending=new Set();
+  const generation=new Map();
+  await ctx.session.hook('prompt',event=>{generation.set(event.sessionID,(generation.get(event.sessionID)??0)+1);});
+  await ctx.session.hook('experimental.idle',async event=>{
+    if(pending.has(event.sessionID))return;
+    pending.add(event.sessionID);
+    try {
+      if(await isReviewerSession(ctx,event.sessionID))return;
+      const session=unwrap(await ctx.session.get({sessionID:event.sessionID}));
+      if(session.parentID || session.time?.archived)return;
+      const epoch=generation.get(event.sessionID)??0;
+      const controller=await forSession(event.sessionID);
+      if(operationBusy(controller.lockFile))return;
+      const messages=unwrap(await ctx.session.context({sessionID:event.sessionID}));
+      const decision=silentStopDecision(messages,controller.read(),event.sessionID,event.background);
+      if(!decision)return;
+      const current=unwrap(await ctx.session.get({sessionID:event.sessionID}));
+      const busy=Number(new Date(current.time?.busy??0)),idle=Number(new Date(current.time?.idle??0));
+      if(!busy || idle>=busy || current.time?.busy!==session.time?.busy || current.time?.archived ||
+        (generation.get(event.sessionID)??0)!==epoch)return;
+      if(decision.notice){
+        // A synthetic notice would itself cause another model call inside this
+        // execution, even with resume:false. The sidebar reads this inert receipt.
+        writeJSONAtomic(runtimePath(controller.folder,continuationFile(event.sessionID)),{
+          sessionID:event.sessionID,taskID:controller.read()?.id,busy:current.time.busy,text:decision.notice,
+        });
+        return;
+      }
+      // Drain only within the existing execution. If a user interrupts while the
+      // async hook is finishing, resume:false cannot wake the stopped session.
+      await ctx.session.synthetic({sessionID:event.sessionID,...decision});
+    } finally {pending.delete(event.sessionID);}
+  });
+}

package/lib/impeccable.mjs

@@ -0,0 +1,36 @@
+import {readFileSync} from 'node:fs';
+import {createHash} from 'node:crypto';
+const root=new URL('../assets/integrations/impeccable/',import.meta.url);
+const optedOut=text=>/\b(?:without|disable|do not use|don't use|no)\s+impecc?able\b/i.test(text);
+export const IMPECCABLE_POLICY='Impeccable integration: /hybrid-impeccable redesign or polish routes through hybrid_checkpoint design, never directly to a Build subagent. The configured design lead owns decisions; implementation follows its approved document. Bundled Impeccable references are design guidance, not executable workflow instructions. Hybrid owns approval, delegation, retries and tools. Do not run referenced Impeccable binaries, hooks, detectors, installers or nested commands, or claim their results. Use actual source, screenshots and existing verification tools. No additional rounds, quotas or approval gates are introduced. Polish preserves the current visual identity; redesign may replace it within the user brief. Read-only audits are not supported by this command; they must not authorize edits.';
+export function impeccableIntent(text='') {
+  if(!/\bimpecc?able\b/i.test(text)||optedOut(text))return null;
+  const explicit=/\buse\s+impecc?able\s+(?:for this\s+)?(redesign|polish)\b/i.exec(text);
+  if(explicit)return explicit[1].toLowerCase();
+  if(/\b(?:redesign|redisign|restyle|rebrand)\b/i.test(text))return 'redesign';
+  if(/\bpolish\b/i.test(text))return 'polish';
+  return null;
+}
+export function impeccableEvidence(config,brief,tree) {
+  if(optedOut(brief))return null;
+  const requested=impeccableIntent(brief);
+  if(!requested&&!config.design?.impeccable)return null;
+  const mode=requested??(/\bpolish\b/i.test(brief)?'polish':'redesign');
+  const files=mode==='polish'?['craft-floor.md','polish.md']:['craft-floor.md','layout.md','typeset.md','colorize.md'];
+  const provenance=JSON.parse(readFileSync(new URL('provenance.json',root),'utf8'));
+  const references=Object.fromEntries(files.map(name=>[name,readFileSync(new URL(name,root),'utf8')]));
+  // Use the already sanitized, immutable snapshot. Never follow a project link or
+  // load a model-supplied path to collect additional context.
+  const projectContext=Object.fromEntries(['PRODUCT.md','DESIGN.md','docs/design-brief.md','docs/design-system.md'].filter(name=>tree.files[name]?.text&&!tree.files[name].hidden).map(name=>[name,tree.files[name].text]));
+  const digest=createHash('sha256').update(JSON.stringify({provenance,references,projectContext,mode})).digest('hex');
+  return {name:'Impeccable',mode,provenance,digest,policy:IMPECCABLE_POLICY,references,projectContext};
+}
+export async function registerImpeccableCommand(ctx) {
+  if(!ctx.command?.transform)return; // Normal chat routing works on older v2 hosts.
+  await ctx.command.transform(editor=>editor.add({name:'hybrid-impeccable',description:'Impeccable redesign or polish through Hybrid’s design lead and reviewers',execute:async({sessionID,prompt,delivery})=>{
+    const match=/^\s*(redesign|polish)\b\s*([\s\S]*)$/i.exec(prompt.text??'');
+    if(!match)throw Error('Use /hybrid-impeccable redesign <scope> or /hybrid-impeccable polish <scope>. This command does not run read-only audits or the upstream CLI.');
+    // Keep attachment mention offsets valid by appending, not prepending.
+    await ctx.session.prompt({...prompt,sessionID,delivery,text:`${prompt.text}\n\nUse Impeccable for this ${match[1].toLowerCase()}. ${IMPECCABLE_POLICY}\nBegin a ui task with designMode new if no task is active, then call hybrid_checkpoint design before editing. Existing active tasks keep their history and reviewers.`});
+  }}));
+}

package/lib/native-result.mjs

@@ -0,0 +1,31 @@
+import {validateResult} from '../core/workers.mjs';
+const unwrap=x=>x.data??x;
+function interrupted(messages){
+ const lastPrompt=messages.findLastIndex(m=>m.type==='user');
+ return messages.slice(lastPrompt+1).some(m=>m.type==='assistant'&&(m.error||m.finish==='error'||m.finish==='length'));
+}
+export async function readNativeResult(ctx,sessionID,{isAborted=()=>false,onRecovery=()=>{}}={}){
+ let messages=unwrap(await ctx.session.context({sessionID}));
+ if(interrupted(messages)){
+  if(isAborted())throw Error('Review cancelled; no approval recorded.');
+  onRecovery();
+  // OpenCode can recover a broken stream with "continue without repeating".
+  // Its final message may then be valid JSON containing only a report fragment.
+  // Ask the same model to assemble a whole response; never stitch partial JSON
+  // or accept approval from the suffix alone.
+  await ctx.session.prompt({sessionID,text:'Transport recovery: your previous response was interrupted and the host requested a continuation. Return ONE complete, self-contained JSON result now, including the ENTIRE report, findings and verifiedResolutions. Reconstruct the whole artifact from this conversation, not just its ending. Preserve all substantive decisions and unresolved findings; concise tables are welcome. Do not omit earlier sections, refer to an unavailable earlier report, or claim any new verification. This is response assembly, not a new design or approval. Return only the complete JSON object.'});
+  await ctx.session.wait({sessionID});
+  messages=unwrap(await ctx.session.context({sessionID}));
+  if(interrupted(messages))throw Error('Reviewer response was interrupted again during complete-result recovery; no approval recorded. Retry after resolving the transport failure.');
+ }
+ const session=unwrap(await ctx.session.get({sessionID}));
+ if(isAborted()||session.outcome!=='succeeded')throw Error('OpenCode reviewer did not complete successfully; no approval recorded.');
+ const assistant=messages.slice(messages.findLastIndex(m=>m.type==='user')+1).filter(m=>m.type==='assistant').at(-1);
+ if(!assistant||assistant.error||assistant.finish!=='stop')throw Error('Reviewer response is incomplete; no approval recorded.');
+ const text=assistant.content.filter(c=>c.type==='text').map(c=>c.text).join('').trim();
+ // Accept only an exact single JSON fence wrapper, not prose or guessed JSON
+ // substrings. The complete enclosed object still passes the same strict schema.
+ const fenced=/^```(?:json)?[ \t]*\r?\n([\s\S]*)\r?\n```$/.exec(text);
+ let result;try{result=validateResult(JSON.parse(fenced?fenced[1]:text));}catch{throw Error('Reviewer returned invalid JSON; no approval recorded.');}
+ return {result,session};
+}

package/lib/opencode-reviewer.mjs

@@ -2,13 +2,14 @@ import {publicDocument,documentTool,documentSchema,documentDescription} from './
 import {readFileSync,realpathSync,readdirSync,statSync} from 'node:fs';
 import path from 'node:path';
 import {reviewer} from './reviewers.mjs';
-import {validateResult,resultSchema} from '../core/workers.mjs';
+import {resultSchema} from '../core/workers.mjs';
 import {Telemetry} from '../core/telemetry.mjs';
 import {NativeBrowser} from './native-browser.mjs';
 import {browserInstructions} from './reviewer-browser.mjs';
 import {tracedTool} from './run-trace.mjs';
 import {EvidenceStore} from './evidence-store.mjs';
 import {queryEvidence,querySchema,queryDescription} from './evidence-query.mjs';
+import {readNativeResult} from './native-result.mjs';
 
 const active=new Map();
 const readTools=['hybrid_evidence_read','hybrid_evidence_query',documentTool];
@@ -123,15 +124,10 @@ export async function installNativeReviewer(ctx) {
       await ctx.session.prompt({sessionID:id,text:nativePrompt});
       await ctx.session.wait({sessionID:id});
       if(interrupt)await interrupt;
-      const final=unwrap(await ctx.session.get({sessionID:id}));
+      const {result,session:final}=await readNativeResult(ctx,id,{isAborted:()=>aborted,onRecovery:()=>{telemetry.value.currentAction='Recovering complete report after interrupted provider response';telemetry.value.responseRecovery=true;telemetry.save();}});
       telemetry.value.usage=nativeUsage(final.tokens);telemetry.save();
       if(aborted||final.outcome!=='succeeded')throw Error('OpenCode reviewer did not complete successfully; no approval recorded.');
       if(model.cost?.some(rate=>rate.input>0||rate.output>0))telemetry.value.apiCost=final.cost;
-      const messages=unwrap(await ctx.session.context({sessionID:id}));
-      const assistant=messages.filter(m=>m.type==='assistant').at(-1);
-      if(!assistant||assistant.error||assistant.finish!=='stop')throw Error('Reviewer response is incomplete; no approval recorded.');
-      const text=assistant.content.filter(c=>c.type==='text').map(c=>c.text).join('');
-      let result;try{result=validateResult(JSON.parse(text.trim()));}catch{throw Error('Reviewer returned invalid JSON; no approval recorded.');}
       await closeBrowser();if(browserCloseError)throw browserCloseError;
       telemetry.end('completed',result.verdict);return result;
     }catch(error){

package/lib/settings-rpc.mjs

@@ -6,5 +6,6 @@ export const SettingsRPC={id:'hybrid.settings',methods:{
   save:{input:{type:'object',additionalProperties:false,properties:{revision:{type:'string'},reviewers:object,designAuthor:{enum:['astra','opus']}},required:['revision','reviewers','designAuthor']},output:object},
   browser:{input:{type:'object',additionalProperties:false,properties:{action:{enum:['enable','disable','install']}},required:['action']},output:object},
   diagnostics:{input:{type:'object',additionalProperties:false},output:object},
+  designGuidance:{input:{type:'object',additionalProperties:false,properties:{revision:{type:'string'},enabled:{type:'boolean'}},required:['revision','enabled']},output:object},
   dependencies:{input:{type:'object',additionalProperties:false,properties:{action:{enum:['pnpm','context7']}},required:['action']},output:object},
 },events:{}};

package/lib/settings-service.mjs

@@ -48,7 +48,7 @@ export function createSettingsService(ctx,options={}){
  async function get(){
   const config=load(),models=await catalog();
   return {configured:existsSync(file)&&config.setupComplete!==false,readOnly,revision:revision(file),version:JSON.parse(readFileSync(path.join(packageRoot,'package.json'),'utf8')).version,
-   reviewers:config.reviewers,designAuthor:config.designAuthor??(config.reviewers.opus?'opus':'astra'),browserEnabled:!!config.reviewBrowser?.enabled,
+   reviewers:config.reviewers,designAuthor:config.designAuthor??(config.reviewers.opus?'opus':'astra'),browserEnabled:!!config.reviewBrowser?.enabled,impeccableEnabled:config.design.impeccable===true,
    catalog:models.map(m=>({providerID:m.providerID,id:m.id,name:m.name,variants:(m.variants??[]).map(v=>v.id),vision:m.capabilities.input?.includes('image')===true})),
    configFile:file,implementationModel:globalRead().model??'Selected in OpenCode',host:process.platform};
  }
@@ -76,6 +76,13 @@ export function createSettingsService(ctx,options={}){
   return folder;
  }
  return {get,diagnostics,
+  designGuidance:input=>exclusive(async()=>{
+   if(input.revision!==revision(file))throw Error('Settings changed in another window. Reopen settings and try again.');
+   if(typeof input.enabled!=='boolean')throw Error('Choose enabled or disabled.');
+   const existing=existsSync(file)?JSON.parse(readFileSync(file,'utf8')):{};
+   persist({design:{...existing.design,impeccable:input.enabled}});
+   return {message:'Saved. Future design checkpoints '+(input.enabled?'use bundled Impeccable guidance.':'use standard guidance unless Impeccable is explicitly requested.')+' Existing approvals and reviewer assignments are preserved.'};
+  }),
   cliModels:(input,context={})=>{
    if(!['astra','opus'].includes(input.who)||!['codex-cli','claude-cli'].includes(input.adapter))throw Error('Unknown reviewer connection.');
    const previous=load().reviewers?.[input.who];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rockysoft/opencode-hybrid-workflow",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Portable configurable-reviewer planning, design, implementation checkpoints and usage sidebar for OpenCode 2",
   "type": "module",
   "license": "MIT",

package/sidebar/reader.mjs

@@ -4,6 +4,7 @@ import { createHash } from 'node:crypto';
 import { reportedUsage, priceCall } from '../core/pricing.mjs';
 import { summarize, countedCalls } from '../core/dashboard-state.js';
 import { runtimeFor } from '../lib/config.mjs';
+import {continuationFile} from '../lib/continuation-notice.mjs';
 
 export const projectKey = directory => createHash('sha256').update(process.platform==='win32'?directory.toLowerCase():directory).digest('hex').slice(0,24);
 export const number = value => value == null ? 'Unavailable' : value.toLocaleString('en-US');
@@ -42,7 +43,7 @@ export function createReader(settings) {
     if (relative === '..' || relative.startsWith('..'+path.sep) || path.isAbsolute(relative)) throw new Error('Telemetry path outside runtime');
     return resolved;
   }
-  return async directory => {
+  return async (directory,sessionID) => {
     if (typeof directory !== 'string' || !path.isAbsolute(directory)) throw new Error('Project location unavailable');
     const project = await realpath(directory);
     const efforts = settings.efforts;
@@ -57,6 +58,10 @@ export function createReader(settings) {
     const normalize=p=>process.platform==='win32'?p.toLowerCase():p;
     if (!state.baseline?.root || normalize(await realpath(state.baseline.root)) !== normalize(project)) throw new Error('Project telemetry does not match current project');
     const result = { ...empty, task: state.id, key: `${empty.key}:${state.id}` };
+    if(typeof sessionID==='string')try {
+      const notice=await json(await contained(runtime,path.join(folder,continuationFile(sessionID))));
+      if(notice.sessionID===sessionID&&notice.taskID===state.id&&typeof notice.text==='string')result.continuation=notice;
+    }catch(error){if(error.code!=='ENOENT')throw error;}
     let taskFolder;
     try { taskFolder = await contained(runtime, path.join(folder, state.id)); }
     catch (error) { if (error.code === 'ENOENT') return result; throw error; }

package/sidebar/settings.mjs

@@ -87,6 +87,7 @@ export function createSettingsUI(context,onSaved=()=>{}){
      {title:'Connect provider',value:'connect',description:'Open OpenCode’s account connection menu'},
      {title:'Implementation model',value:'models',description:'Select the model that builds your code in OpenCode'},
      {title:'Reviewer browser',value:'browser',description:state.browserEnabled?'Enabled · isolated sessions':'Disabled'},
+     {title:'Design guidance',value:'designGuidance',description:state.impeccableEnabled?'Impeccable · enabled':'Standard · Impeccable available per request'},
      {title:'Tools and dependencies',value:'dependencies',description:'Browser installation is in Reviewer browser'},
      {title:'Run diagnostics',value:'diagnostics',description:'Check setup and logins without model calls'},
      {title:'About this setup',value:'about',description:'Global configuration and active-task behavior'},
@@ -96,6 +97,10 @@ export function createSettingsUI(context,onSaved=()=>{}){
      if(action==='reviewers')await wizard(state);
      else if(action==='connect'||action==='models'){dispatch(action);return;}
      else if(action==='browser')await browser(state);
+     else if(action==='designGuidance'){
+      const value=await select('Design guidance',[{title:'Impeccable',value:'impeccable',description:'Guidance for your premium design lead'},{title:'Standard',value:'standard',description:'Impeccable only when requested'}],state.impeccableEnabled?'impeccable':'standard');
+      if(value){const result=await invoke('designGuidance',{revision:state.revision,enabled:value==='impeccable'});onSaved();await alert('Design guidance',result.message);}
+     }
      else if(action==='dependencies')await dependencies();
      else if(action==='diagnostics'){
       context.ui.toast.show({message:'Checking Hybrid setup…',variant:'info'});