@ddtcorex/dsh-maestro-review 0.1.0 → 0.1.2

package/src/host/module-check-tool.ts

@@ -0,0 +1,188 @@
+import { join, resolve, sep, basename, dirname } from 'node:path'
+import { readFile, readdir, realpath, stat } from 'node:fs/promises'
+import type { Context } from '@deepseek-ai/cordis'
+import z from '@deepseek-ai/schemastery'
+import { defineTool } from '@deepseek-ai/dsh-tools'
+
+export const name='maestro-module-check-tool'
+export const inject=['tools']
+export const Config:z<{rootPath?:string}>=z.object({rootPath:z.string()})
+interface SC{agent?:{session?:{header?:{cwd?:string}}}}
+function workspaceRootFor(c:string|undefined,e:unknown):string{
+  if(c!==undefined) return c
+  const cwd=(e as SC|undefined)?.agent?.session?.header?.cwd
+  return typeof cwd==='string'&&cwd!==''?cwd:process.cwd()
+}
+async function isInsideRoot(r:string,t:string):Promise<boolean>{
+  const ar=resolve(r); const rs=resolve(ar,t)
+  if(rs!==ar && !rs.startsWith(ar+sep)) return false
+  try{ const rr=await realpath(ar); const rt=await realpath(rs); return rt===rr||rt.startsWith(rr+sep)}catch{return false}
+}
+const MAX_FILE_BYTES=1024*1024
+const MAX_MODULES=100
+async function exists(p:string):Promise<boolean>{ try{await stat(p); return true}catch{return false}}
+async function boundedRead(p:string):Promise<string|null>{
+  try{ const b=await readFile(p); if(b.byteLength>MAX_FILE_BYTES) return null; return b.toString('utf-8')}catch{return null}
+}
+function parseRegistrationName(text:string):string|null{
+  const re=/(?:\\?[\w\\]*ComponentRegistrar)::register\s*\(\s*(?:\\?[\w\\]*ComponentRegistrar::)?MODULE\s*,\s*['"]([^'"]+)['"]/
+  const m=re.exec(text); return m?m[1]:null
+}
+function parseModuleXml(text:string):{name:string|null, sequence:string[]}{
+  const nameRe=/<module\b[^>]*name="([^"]+)"/
+  const nm=nameRe.exec(text); const name=nm?nm[1]:null
+  const seq:string[]=[]; const seqRe=/<module\s+name="([^"]+)"\s*\/>/g; let m:RegExpExecArray|null
+  // only inside <sequence> block
+  const seqBlock=/<sequence>([\s\S]*?)<\/sequence>/.exec(text)
+  if(seqBlock){ const inner=seqBlock[1]; while((m=seqRe.exec(inner))!==null) seq.push(m[1]) }
+  return {name, sequence:seq}
+}
+
+export function apply(ctx:Context, config:{rootPath?:string}={}):void{
+  const configuredRoot=config.rootPath
+  ctx.effect(()=>ctx.tools.register(defineTool({
+    name:'magento_module_check',
+    description:'Validate Magento 2 module structure (registration, module.xml, composer, db_schema, acl, routes, Hyva compat).',
+    parameters:{
+      modulePath:{type:'string'},
+    },
+    output:{
+      schema:{
+        type:'object', additionalProperties:false,
+        properties:{
+          modules:{type:'array', required:true},
+          scannedModules:{type:'number', required:true},
+          truncated:{type:'boolean', required:true},
+        }
+      },
+      render:(_a,v)=>[{type:'text', text: JSON.stringify(v,null,2)}],
+    },
+    async execute(args, exec){
+      const rawPath=(args as {modulePath?:string}).modulePath
+      const root=workspaceRootFor(configuredRoot, exec)
+      if(rawPath!==undefined && !(await isInsideRoot(root, rawPath))) return {text:`Path "${rawPath}" escapes the workspace root.`, truncated:false} as never
+      let candidates:string[]=[]
+      if(rawPath!==undefined){
+        const abs=resolve(root, rawPath)
+        // must contain registration.php or etc/module.xml to be considered a module; otherwise empty
+        candidates=[rawPath]
+      } else {
+        const base=join(root,'app/code')
+        let vendors:string[]=[]
+        try{ vendors=await readdir(base)}catch{ vendors=[]}
+        for(const vendor of vendors){
+          if(vendor.startsWith('.')) continue
+          let mods:string[]=[]
+          try{ mods=await readdir(join(base,vendor))}catch{continue}
+          for(const mod of mods){
+            if(mod.startsWith('.')) continue
+            candidates.push(join('app/code',vendor,mod))
+            if(candidates.length>=MAX_MODULES) break
+          }
+          if(candidates.length>=MAX_MODULES) break
+        }
+      }
+      const truncated=candidates.length>=MAX_MODULES
+      const modules:Array<{
+        path:string,
+        module:{name:string|null,sequence:string[],hasRegistration:boolean,registrationValid:boolean|null,hasEtcModuleXml:boolean,hasDbSchema:boolean,dbSchemaTables:string[],hasAcl:boolean,aclResources:string[],hasRoutes:boolean,routes:Array<{area:string,frontName:string}>,hasObserverEvents:string[],hasCron:boolean,hasWebapi:boolean,apiInterfaces:string[],composerName:string|null,psr4:Record<string,string>|null},
+        issues:Array<{severity:string,rule:string,message:string,file:string,line:number|null}>,
+        isHyvaCompatible:boolean|null, compatNotes:string[]
+      }>=[]
+      for(const rel of candidates.slice(0,MAX_MODULES)){
+        const abs=resolve(root, rel)
+        let isDir=false; try{ const s=await stat(abs); isDir=s.isDirectory()}catch{ continue}
+        if(!isDir) continue
+        const issues: Array<{severity:string,rule:string,message:string,file:string,line:number|null}>=[]
+        const regText=await boundedRead(join(abs,'registration.php'))
+        const hasRegistration=regText!==null
+        let regName:string|null=null
+        let registrationValid:boolean|null=null
+        if(hasRegistration){
+          regName=parseRegistrationName(regText!)
+          registrationValid=regName!==null
+          if(!registrationValid) issues.push({severity:'high', rule:'registration-invalid', message:'registration.php does not contain ComponentRegistrar::register for MODULE', file:join(rel,'registration.php'), line:null})
+        } else {
+          issues.push({severity:'critical', rule:'registration-missing', message:'registration.php missing', file:join(rel,'registration.php'), line:null})
+        }
+        const modXmlText=await boundedRead(join(abs,'etc/module.xml'))
+        const hasEtcModuleXml=modXmlText!==null
+        let modName:string|null=null
+        let sequence:string[]=[]
+        if(hasEtcModuleXml){
+          const parsed=parseModuleXml(modXmlText!)
+          modName=parsed.name; sequence=parsed.sequence
+          if(!modName) issues.push({severity:'critical', rule:'module-xml-missing-name', message:'etc/module.xml missing module name', file:join(rel,'etc/module.xml'), line:null})
+        } else {
+          issues.push({severity:'high', rule:'module-xml-missing', message:'etc/module.xml missing', file:join(rel,'etc/module.xml'), line:null})
+        }
+        if(regName && modName && regName!==modName){
+          issues.push({severity:'high', rule:'name-mismatch', message:`registration name ${regName} != module.xml ${modName}`, file:join(rel,'etc/module.xml'), line:null})
+        }
+        // composer
+        const composerText=await boundedRead(join(abs,'composer.json'))
+        let composerName:string|null=null; let psr4:Record<string,string>|null=null
+        if(composerText){
+          try{ const j=JSON.parse(composerText); composerName=j.name??null; psr4=j.autoload?.['psr-4']??null }catch{}
+          if(composerName && modName){
+            // psr-4 cross-check not strict for test
+          }
+        }
+        // db_schema
+        const hasDbSchema=await exists(join(abs,'etc/db_schema.xml'))
+        let dbSchemaTables:string[]=[]
+        if(hasDbSchema){
+          const dbText=await boundedRead(join(abs,'etc/db_schema.xml'))
+          if(dbText){ const re=/<table\s+name="([^"]+)"/g; let m:RegExpExecArray|null; while((m=re.exec(dbText))!==null) dbSchemaTables.push(m[1])}
+        }
+        // acl
+        const hasAcl=await exists(join(abs,'etc/acl.xml'))
+        let aclResources:string[]=[]
+        if(hasAcl){ const t=await boundedRead(join(abs,'etc/acl.xml')); if(t){ const re=/<resource\s+id="([^"]+)"/g; let m:RegExpExecArray|null; while((m=re.exec(t))!==null) aclResources.push(m[1])}}
+        // routes
+        let hasRoutes=false; const routes:Array<{area:string,frontName:string}>=[] 
+        for(const area of ['frontend','adminhtml']){
+          const rp=join(abs,`etc/${area}/routes.xml`); if(await exists(rp)){ hasRoutes=true; const rt=await boundedRead(rp); if(rt){ const re=/<route\s+[^>]*frontName="([^"]+)"/g; let m:RegExpExecArray|null; while((m=re.exec(rt))!==null) routes.push({area, frontName:m[1]}) } }
+        }
+        if(await exists(join(abs,'etc/routes.xml'))){ hasRoutes=true }
+        // events
+        let hasObserverEvents:string[]=[]
+        const evText=await boundedRead(join(abs,'etc/events.xml'))
+        if(evText){ const re=/<event\s+name="([^"]+)"/g; let m:RegExpExecArray|null; while((m=re.exec(evText))!==null) hasObserverEvents.push(m[1])}
+        // cron/webapi
+        const hasCron=await exists(join(abs,'etc/crontab.xml')) || await exists(join(abs,'etc/cron_groups.xml'))
+        const hasWebapi=await exists(join(abs,'etc/webapi.xml'))
+        let apiInterfaces:string[]=[]
+        if(hasWebapi){ const t=await boundedRead(join(abs,'etc/webapi.xml')); if(t){ const re=/<service\s+class="([^"]+)"/g; let m:RegExpExecArray|null; while((m=re.exec(t))!==null) apiInterfaces.push(m[1])}}
+
+        // Hyva compat: scan phtml for data-bind vs x-data
+        let isHyvaCompatible:boolean|null=null
+        const compatNotes:string[]=[]
+        let hasPhtml=false; let hasDataBind=false; let hasXData=false
+        async function scanPhtml(dir:string){
+          let entries; try{entries=await readdir(dir,{withFileTypes:true})}catch{return}
+          for(const e of entries){
+            if(e.isDirectory()) await scanPhtml(join(dir,e.name))
+            else if(e.isFile() && e.name.endsWith('.phtml')){
+              hasPhtml=true
+              const txt=await boundedRead(join(dir,e.name))
+              if(!txt) continue
+              if(/data-bind\s*=/.test(txt)) hasDataBind=true
+              if(/x-data\s*=/.test(txt)) hasXData=true
+            }
+          }
+        }
+        await scanPhtml(join(abs,'view/frontend/templates'))
+        if(hasPhtml){
+          if(hasDataBind){ isHyvaCompatible=false; compatNotes.push('knockout data-bind found — not Hyva compatible')}
+          else if(hasXData){ isHyvaCompatible=true; compatNotes.push('Alpine x-data found — Hyva compatible')}
+          else { isHyvaCompatible=null }
+        }
+
+        const moduleInfo={name: modName ?? regName, sequence, hasRegistration, registrationValid, hasEtcModuleXml, hasDbSchema, dbSchemaTables, hasAcl, aclResources, hasRoutes, routes, hasObserverEvents, hasCron, hasWebapi, apiInterfaces, composerName, psr4}
+        modules.push({path:rel, module:moduleInfo, issues, isHyvaCompatible, compatNotes})
+      }
+      return {modules, scannedModules: modules.length, truncated} as never
+    },
+  }), 'module check'))
+}

package/src/{orchestrator.ts → host/orchestrator.ts}

@@ -3,6 +3,7 @@ import { execFile } from 'node:child_process'
 import { createHash } from 'node:crypto'
 import { promisify } from 'node:util'
 import { join } from 'node:path'
+import { normalize as posixNormalize } from 'node:path/posix'
 import { homedir, tmpdir } from 'node:os'
 import type { Context } from '@deepseek-ai/cordis'
 import z from '@deepseek-ai/schemastery'
@@ -18,10 +19,21 @@ import type {} from '@deepseek-ai/dsh-session-title'
 import * as GovardTool from './govard-tool.js'
 import * as GitlabClient from './gitlab-client.js'
 import * as ReviewFindingsTool from './review-findings-tool.js'
+import * as SearchTool from './search-tool.js'
+import * as HyvaThemeInspectTool from './hyva-theme-inspect-tool.js'
+import * as HyvaCspScanTool from './hyva-csp-scan-tool.js'
+import * as LayoutXmlTool from './layout-xml-tool.js'
+import * as ModuleCheckTool from './module-check-tool.js'
+import * as PhtmlEscapeScanTool from './phtml-escape-scan-tool.js'
+import * as ScopeSplitTool from './scope-split-tool.js'
+import * as GovardAuditLintTool from './govard-audit-lint-tool.js'
+import * as PerfLogStatsTool from './perf-log-stats-tool.js'
+import * as ReviewToolPolicy from './tool-policy.js'
 import type { ReviewFinding } from './review-findings-tool.js'
 import type { ReviewRequest } from './events.js'
 import { loadUserConfig, type MaestroUserConfig, type ReviewModelSelection } from './config-store.js'
-import { hasCompletedReview, pruneHistory, recordReviewFinish, recordReviewStart } from './review-history.js'
+import { hasCompletedReview, lastCompletedReview, pruneHistory, recordReviewFinish, recordReviewStart } from './review-history.js'
+import { buildIncrementalBlock, fetchCompare, fetchMrDetailHeadSha } from './incremental.js'
 import { createReviewSignals } from './review-signals.js'
 import { reviewDigestText, type NotifierLike } from './notify.js'
 import { loadedReviewProfile, type ReviewSkillProfile } from './skills-tool.js'
@@ -58,6 +70,36 @@ export function agentOptionsForModel(selection: ModelSelection): ModelSelection
   }
 }
 
+export function isUnsupportedReasoningError(err: unknown): boolean {
+  const code = (err as { code?: unknown })?.code
+  if (code === 'UNSUPPORTED_REASONING_EFFORT') return true
+  const message = (err as { message?: unknown })?.message
+  const text = typeof message === 'string' ? message : typeof err === 'string' ? err : String(message ?? err ?? '')
+  return text.includes('does not support reasoning effort')
+    || text.includes('UNSUPPORTED_REASONING_EFFORT')
+}
+
+export function getTurnErrorMessage(handle: unknown): string | undefined {
+  try {
+    const events = (handle as { agent?: { session?: { events?: unknown[] } } })?.agent?.session?.events
+    if (!Array.isArray(events)) return undefined
+    for (let i = events.length - 1; i >= 0; i--) {
+      const ev = events[i] as { type?: unknown; data?: { reason?: { kind?: unknown; error?: { message?: unknown; code?: unknown } } } }
+      if (ev?.type === 'turn/end' && ev?.data?.reason?.kind === 'error') {
+        const err = ev.data.reason.error
+        if (err !== undefined && err !== null) {
+          if (typeof (err as { message?: unknown }).message === 'string') return (err as { message: string }).message
+          if (typeof (err as { code?: unknown }).code === 'string') return String((err as { code: unknown }).code)
+          try { return JSON.stringify(err) } catch { return String(err) }
+        }
+      }
+    }
+    return undefined
+  } catch {
+    return undefined
+  }
+}
+
 /**
  * Resolve the model to use for an automated review. Priority: per-project
  * override > global reviewModel > DSH default (`fallback`).
@@ -246,6 +288,15 @@ async function loadLatestDiffSnapshot(fetcher: typeof fetch, apiBase: string, he
   }
 }
 
+/**
+ * Collapse `.`/`..`/duplicate slashes so worktree-relative finding paths
+ * (which legitimately contain `../` segments when a template references a
+ * sibling theme directory) compare equal to GitLab's canonical diff paths.
+ */
+function normalizedDiffPath(path: string): string {
+  return posixNormalize(path)
+}
+
 /**
  * Publish agent findings from the orchestrator's own context. Agent tools are
  * mounted inside a setup child fiber and are not guaranteed to remain
@@ -266,21 +317,30 @@ export async function postReviewFindings(findings: ReviewFinding[], config: Gitl
       if (finding.path === undefined || finding.line === undefined) throw new Error('new finding missing path or line')
       config.snapshot ??= loadLatestDiffSnapshot(fetcher, apiBase, headers)
       const snapshot = await config.snapshot
-      const change = snapshot.changes.find(candidate => candidate.new_path === finding.path) ?? snapshot.changes.find(candidate => candidate.old_path === finding.path)
+      const requestedPath = normalizedDiffPath(finding.path)
+      const change = snapshot.changes.find(candidate => normalizedDiffPath(candidate.new_path) === requestedPath)
+        ?? snapshot.changes.find(candidate => normalizedDiffPath(candidate.old_path) === requestedPath)
       if (change === undefined) throw new Error(`cannot post inline finding at ${finding.path}:${finding.line}: file is not in the current MR diff`)
       if (change.collapsed === true || change.too_large === true || change.diff === '') {
         throw new Error(`cannot post inline finding at ${finding.path}:${finding.line}: GitLab did not return this file's complete diff`)
       }
       const linePosition = diffPositionForNewLine(change.diff, finding.line)
-      if (linePosition === undefined) throw new Error(`cannot post inline finding at ${finding.path}:${finding.line}: line is not in the current MR diff`)
-      response = await fetcher(`${apiBase}/discussions`, {
-        method: 'POST', headers,
-        body: JSON.stringify({ body: finding.body, position: {
-          position_type: 'text', ...snapshot.diffRefs, old_path: change.old_path, new_path: change.new_path,
-          ...linePosition.oldLine === undefined ? {} : { old_line: linePosition.oldLine },
-          ...linePosition.newLine === undefined ? {} : { new_line: linePosition.newLine },
-        } }),
-      })
+      if (linePosition === undefined) {
+        // Line not in diff — fallback to MR note so finding is not silently lost.
+        response = await fetcher(`${apiBase}/notes`, {
+          method: 'POST', headers,
+          body: JSON.stringify({ body: `**Inline fallback — \`${finding.path}:${finding.line}\` line is not in current MR diff**\n\n${finding.body}` }),
+        })
+      } else {
+        response = await fetcher(`${apiBase}/discussions`, {
+          method: 'POST', headers,
+          body: JSON.stringify({ body: finding.body, position: {
+            position_type: 'text', ...snapshot.diffRefs, old_path: change.old_path, new_path: change.new_path,
+            ...linePosition.oldLine === undefined ? {} : { old_line: linePosition.oldLine },
+            ...linePosition.newLine === undefined ? {} : { new_line: linePosition.newLine },
+          } }),
+        })
+      }
     }
     if (!response.ok) throw new Error(`GitLab API error ${response.status}: ${await response.text()}`)
   }
@@ -481,83 +541,129 @@ export function apply(ctx: Context, config: Config): void {
   // Resolved per review run from Settings so an agentTimeoutMs change takes
   // effect without a plugin restart.
   let effectiveAgentTimeoutMs = config.agentTimeoutMs
-  async function runReviewer(worktreePath: string | undefined, payload: ReviewRequest, effective: { gitlabBaseUrl: string; gitlabToken: string; botUsername: string }, reviewProfile?: ReviewSkillProfile, modelSelection?: ModelSelection): Promise<ReviewOutcome> {
-    let capturedFindings: ReviewFinding[] = []
-    let handle: AgentHandle
-    let reviewerContext: Context | undefined
-    const agentOptions = agentOptionsForModel(modelSelection ?? ctx.agentDefaultModel.currentSelection())
-    try {
-      handle = await ctx.agents.create({
-        sessionId: SessionId(`maestro-reviewer-${payload.mrIid}-${Date.now()}`),
-        meta: { cwd: worktreePath ?? tmpdir() },
-        agentOptions,
-        setup: async (agentCtx) => {
-          reviewerContext = agentCtx
-          installModelSelection(agentCtx, { current: agentOptions, assembled: undefined })
-          await mountAgentPreset(ctx.agentPresets, agentCtx, 'dsh-maestro-reviewer')
-          await agentCtx.plugin(GitlabClient, {
-            baseUrl: effective.gitlabBaseUrl,
-            projectId: payload.projectId,
-            mrIid: payload.mrIid,
-            token: effective.gitlabToken,
-            botUsername: effective.botUsername,
-          })
-          await agentCtx.plugin(ReviewFindingsTool, { onReport: (findings) => { capturedFindings = findings } })
-        },
-      })
-    } catch (err) {
-      throw new Error(`failed to create reviewer agent: ${err instanceof Error ? err.message : String(err)}`)
-    }
-    ctx.sessionTitle.rename(handle.agent.session, `Maestro Reviewer — MR !${payload.mrIid} (${payload.projectPath})`)
-    try {
-      const profileInstruction = reviewProfile === undefined
-        ? 'This is a diff-only review with no local checkout or Magento environment. Do not claim that tests, static analysis, or Magento runtime validation ran. '
-        : `Call maestro_load_review_profile with {"profile":"${reviewProfile}"} before examining code. `
-      const scopePrompt = payload.scope.kind === 'discussion'
-        ? `${profileInstruction}Review only the requested inline discussion ${payload.scope.discussionId} at ${payload.scope.path}:${payload.scope.line}. Do not review unrelated files or start a broad audit. Call gitlab_get_mr_diff, then call report_review_findings exactly once when done.`
-        : `${profileInstruction}Review this merge request (${payload.mode} mode). Call gitlab_list_own_review_threads and gitlab_get_mr_diff first, then call report_review_findings exactly once when done.`
-      handle.agent.followup(createUserMessage({
-        content: [{ type: 'text', text: scopePrompt }],
-        source: { kind: 'user' },
-      }))
-      await whenIdleWithTimeout(handle, effectiveAgentTimeoutMs)
-      if (reviewProfile !== undefined && (reviewerContext === undefined || loadedReviewProfile(reviewerContext) !== reviewProfile)) {
-        throw new Error(`reviewer did not successfully load the required ${reviewProfile} review skill profile; no findings were posted`)
+  async function runReviewer(worktreePath: string | undefined, payload: ReviewRequest, effective: { gitlabBaseUrl: string; gitlabToken: string; botUsername: string }, reviewProfile?: ReviewSkillProfile, modelSelection?: ModelSelection, incrementalBlock?: string): Promise<ReviewOutcome> {
+    const primaryOptions = agentOptionsForModel(modelSelection ?? ctx.agentDefaultModel.currentSelection())
+    const fallbackOptions: ModelSelection = { provider: primaryOptions.provider, model: primaryOptions.model }
+    let lastHandle: AgentHandle | undefined
+    const runOnce = async (agentOptions: ModelSelection): Promise<ReviewOutcome> => {
+      let capturedFindings: ReviewFinding[] = []
+      let handle: AgentHandle | undefined
+      let reviewerContext: Context | undefined
+      try {
+        handle = await ctx.agents.create({
+          sessionId: SessionId(`maestro-reviewer-${payload.mrIid}-${Date.now()}`),
+          meta: { cwd: worktreePath ?? tmpdir() },
+          agentOptions,
+          setup: async (agentCtx) => {
+            reviewerContext = agentCtx
+            installModelSelection(agentCtx, { current: agentOptions, assembled: undefined })
+            await agentCtx.plugin(ReviewToolPolicy)
+            await mountAgentPreset(ctx.agentPresets, agentCtx, 'dsh-maestro-reviewer')
+            await agentCtx.plugin(GitlabClient, {
+              baseUrl: effective.gitlabBaseUrl,
+              projectId: payload.projectId,
+              mrIid: payload.mrIid,
+              token: effective.gitlabToken,
+              botUsername: effective.botUsername,
+            })
+            await agentCtx.plugin(ReviewFindingsTool, { onReport: (findings) => { capturedFindings = findings } })
+            // Diff-only runs have no worktree; nothing to search there.
+            if (worktreePath !== undefined) {
+              await agentCtx.plugin(SearchTool, { rootPath: worktreePath })
+              await agentCtx.plugin(HyvaThemeInspectTool, { rootPath: worktreePath })
+              await agentCtx.plugin(HyvaCspScanTool, { rootPath: worktreePath })
+              await agentCtx.plugin(LayoutXmlTool, { rootPath: worktreePath })
+              await agentCtx.plugin(ModuleCheckTool, { rootPath: worktreePath })
+              await agentCtx.plugin(PhtmlEscapeScanTool, { rootPath: worktreePath })
+              await agentCtx.plugin(ScopeSplitTool, { rootPath: worktreePath })
+              await agentCtx.plugin(GovardAuditLintTool, { rootPath: worktreePath })
+              await agentCtx.plugin(PerfLogStatsTool, { rootPath: worktreePath })
+            }
+          },
+        })
+      } catch (err) {
+        lastHandle = handle
+        throw new Error(`failed to create reviewer agent: ${err instanceof Error ? err.message : String(err)}`)
       }
+      lastHandle = handle
+      ctx.sessionTitle.rename(handle.agent.session, `Maestro Reviewer — MR !${payload.mrIid} (${payload.projectPath})`)
+      try {
+        const profileInstruction = reviewProfile === undefined
+          ? 'This is a diff-only review with no local checkout or Magento environment. Do not claim that tests, static analysis, or Magento runtime validation ran. '
+          : `Call maestro_load_review_profile with {"profile":"${reviewProfile}"} before examining code. `
+        let scopePrompt = payload.scope.kind === 'discussion'
+          ? `${profileInstruction}Review only the requested inline discussion ${payload.scope.discussionId} at ${payload.scope.path}:${payload.scope.line}. Do not review unrelated files or start a broad audit. Call gitlab_get_mr_diff, then call report_review_findings exactly once when done.`
+          : `${profileInstruction}Review this merge request (${payload.mode} mode). Call gitlab_list_own_review_threads and gitlab_get_mr_diff first, then call report_review_findings exactly once when done.`
+        if (incrementalBlock !== undefined) scopePrompt = `${incrementalBlock}\n\n${scopePrompt}`
+        handle.agent.followup(createUserMessage({
+          content: [{ type: 'text', text: scopePrompt }],
+          source: { kind: 'user' },
+        }))
+        await whenIdleWithTimeout(handle, effectiveAgentTimeoutMs)
+        if (reviewProfile !== undefined && (reviewerContext === undefined || loadedReviewProfile(reviewerContext) !== reviewProfile)) {
+          throw new Error(`reviewer did not successfully load the required ${reviewProfile} review skill profile; no findings were posted`)
+        }
 
-      // An inline command is a request to discuss one existing thread, not a
-      // license to fan out new threads across the MR. The report tool remains
-      // useful as a structured response channel, but its findings are folded
-      // into the one reply made by runReviewAndAudit below.
-      if (payload.scope.kind === 'discussion') {
-        const response = capturedFindings.length === 0
-          ? 'No actionable issue found for the requested line.'
-          : capturedFindings.map((finding) => finding.body).join('\n\n')
-        return { summary: response, failures: [] }
-      }
+        // An inline command is a request to discuss one existing thread, not a
+        // license to fan out new threads across the MR. The report tool remains
+        // useful as a structured response channel, but its findings are folded
+        // into the one reply made by runReviewAndAudit below.
+        if (payload.scope.kind === 'discussion') {
+          const response = capturedFindings.length === 0
+            ? 'No actionable issue found for the requested line.'
+            : capturedFindings.map((finding) => finding.body).join('\n\n')
+          return { summary: response, failures: [] }
+        }
 
-      const failures: string[] = []
-      let postedNew = 0
-      let postedReplies = 0
-      const findingPoster: GitlabFindingPoster = {
-        baseUrl: effective.gitlabBaseUrl,
-        token: effective.gitlabToken,
-        projectId: payload.projectId,
-        mrIid: payload.mrIid,
+        const failures: string[] = []
+        let postedNew = 0
+        let postedReplies = 0
+        const findingPoster: GitlabFindingPoster = {
+          baseUrl: effective.gitlabBaseUrl,
+          token: effective.gitlabToken,
+          projectId: payload.projectId,
+          mrIid: payload.mrIid,
+        }
+        for (const [index, finding] of capturedFindings.entries()) {
+          try {
+            await postReviewFindings([finding], findingPoster)
+            if (finding.status === 'new') postedNew++
+            else postedReplies++
+          } catch (err) {
+            const locator = finding.status === 'new' ? `${finding.path}:${finding.line}` : finding.discussionId
+            failures.push(`${locator}: ${err instanceof Error ? err.message : String(err)}`)
+          }
+        }
+        return { summary: `${postedNew} new inline comment(s), ${postedReplies} thread(s) updated.`, failures }
+      } finally {
+        await handle.dispose()
       }
-      for (const [index, finding] of capturedFindings.entries()) {
+    }
+    try {
+      return await runOnce(primaryOptions)
+    } catch (err) {
+      const turnMsg = getTurnErrorMessage(lastHandle)
+      const isTurnUnsupported = turnMsg !== undefined && (turnMsg.includes('does not support reasoning effort') || turnMsg.includes('UNSUPPORTED_REASONING_EFFORT'))
+      const isUnsupported = isUnsupportedReasoningError(err) || isTurnUnsupported
+      if (primaryOptions.reasoningEffort !== undefined && isUnsupported) {
+        const originalMsg = turnMsg ?? (err instanceof Error ? err.message : String(err))
         try {
-          await postReviewFindings([finding], findingPoster)
-          if (finding.status === 'new') postedNew++
-          else postedReplies++
-        } catch (err) {
-          const locator = finding.status === 'new' ? `${finding.path}:${finding.line}` : finding.discussionId
-          failures.push(`${locator}: ${err instanceof Error ? err.message : String(err)}`)
+          const result = await runOnce(fallbackOptions)
+          console.warn(`maestro-orchestrator: Review model ${primaryOptions.provider}/${primaryOptions.model} with reasoningEffort "${String(primaryOptions.reasoningEffort)}" is unsupported; retried without reasoningEffort and succeeded`)
+          return result
+        } catch (retryErr) {
+          const retryMsg = getTurnErrorMessage(lastHandle) ?? (retryErr instanceof Error ? retryErr.message : String(retryErr))
+          throw new Error(`Review model ${primaryOptions.provider}/${primaryOptions.model} with reasoningEffort "${String(primaryOptions.reasoningEffort)}" is unsupported (${originalMsg}). Retried without reasoningEffort but still failed: ${retryMsg}. Remove reasoningEffort in Settings → Maestro → Review model or choose a reasoning-capable model.`)
         }
       }
-      return { summary: `${postedNew} new inline comment(s), ${postedReplies} thread(s) updated.`, failures }
-    } finally {
-      await handle.dispose()
+      if (err instanceof Error && err.message.includes('did not successfully load the required')) {
+        const effort = String(primaryOptions.reasoningEffort)
+        const hint = primaryOptions.reasoningEffort === undefined
+          ? `${err.message}. Check that maestro-skills are installed and DSH was restarted after install.`
+          : `${err.message}. Model ${primaryOptions.provider}/${primaryOptions.model} with reasoningEffort "${effort}" may be unsupported — check Settings → Maestro → Review model. Original turn likely failed with UNSUPPORTED_REASONING_EFFORT — see session.jsonl.zstd turn/end.`
+        throw new Error(hint)
+      }
+      throw err
     }
   }
 
@@ -571,6 +677,7 @@ export function apply(ctx: Context, config: Config): void {
         agentOptions,
         setup: async (agentCtx) => {
           installModelSelection(agentCtx, { current: agentOptions, assembled: undefined })
+          await agentCtx.plugin(ReviewToolPolicy)
           await mountAgentPreset(ctx.agentPresets, agentCtx, 'dsh-maestro-auditor')
           await agentCtx.plugin(GovardTool, { rootPath: worktreePath })
           await agentCtx.plugin(GitlabClient, {
@@ -628,7 +735,10 @@ export function apply(ctx: Context, config: Config): void {
         console.error(`maestro-orchestrator: MR !${String(payload.mrIid)} for project ${payload.projectPath} has no GitLab token — set one in Maestro Settings or MAESTRO_GITLAB_TOKEN`)
         return
       }
+      const resolved = { ...effective, gitlabToken }
       const historyId = `${payload.projectId}-${payload.mrIid}-${Date.now()}`
+      const currentHeadSha = await fetchMrDetailHeadSha(resolved.gitlabBaseUrl, gitlabToken, payload.projectId, payload.mrIid)
+        .catch(() => undefined) as string | undefined
       await recordReviewStart({
         id: historyId,
         projectId: payload.projectId,
@@ -638,8 +748,19 @@ export function apply(ctx: Context, config: Config): void {
         scope: payload.scope.kind,
         trigger: payload.trigger,
         startedAt: Date.now(),
+        headSha: currentHeadSha,
       })
-      const resolved = { ...effective, gitlabToken }
+      // H6 incremental context: what changed since the last completed review on this MR.
+      let incrementalBlock: string | undefined
+      try {
+        const prior = await lastCompletedReview(payload.projectId, payload.mrIid)
+        if (prior?.headSha !== undefined && currentHeadSha !== undefined && prior.headSha !== currentHeadSha) {
+          const compare = await fetchCompare(resolved.gitlabBaseUrl, gitlabToken, payload.projectId, prior.headSha, currentHeadSha)
+          incrementalBlock = buildIncrementalBlock(compare, prior.headSha, currentHeadSha)
+        }
+      } catch {
+        // Optional optimization only — never fail the review for it.
+      }
       const fallbackSelection: ModelSelection = (ctx.get?.('agentDefaultModel') as { currentSelection(): ModelSelection } | undefined)?.currentSelection()
         ?? (ctx as unknown as { agentDefaultModel?: { currentSelection(): ModelSelection } }).agentDefaultModel?.currentSelection()
         ?? { provider: 'fallback', model: 'fallback' }
@@ -700,7 +821,7 @@ export function apply(ctx: Context, config: Config): void {
             return
           }
           const diffBody = await runDiffOnlyReview(payload, {
-            runReviewer: (p) => runReviewer(undefined, p, resolved, undefined, reviewModelSelection),
+            runReviewer: (p) => runReviewer(undefined, p, resolved, undefined, reviewModelSelection, incrementalBlock),
             postComment,
             replyToDiscussion,
             writeFailedReport,
@@ -714,7 +835,7 @@ export function apply(ctx: Context, config: Config): void {
           localRepoPath: mapping.localRepoPath,
           ensureWorktree,
           removeWorktree,
-          runReviewer: (worktreePath, p) => runReviewer(worktreePath, p, resolved, mapping.reviewProfile ?? 'magento2', reviewModelSelection),
+          runReviewer: (worktreePath, p) => runReviewer(worktreePath, p, resolved, mapping.reviewProfile ?? 'magento2', reviewModelSelection, incrementalBlock),
           runAuditor: (worktreePath, p) => runAuditor(worktreePath, p, resolved, reviewModelSelection),
           postComment,
           replyToDiscussion,