project-autopilot 12.0.0 → 12.0.1

package/scripts/model-discovery.mjs

@@ -5,12 +5,44 @@ import {resolveAdapterTransport} from './adapter-transport.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
 import {fileURLToPath} from 'node:url';
+import {
+  isOpenCodeAdapter,
+  openCodeHelpArgs,
+  cachedOpenCodeGeneration,
+  rememberOpenCodeGeneration
+} from './opencode-generation.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const DOCUMENTED_MODELS_DIR = path.join(__dirname, '..', 'adapters', 'documented-models');
 const DOCUMENTED_EFFORT_DIR = path.join(__dirname, '..', 'adapters', 'documented-effort');
 
+// Short probe limit for --help/--version capability detection. Model-list
+// discovery is a different, slower call (a real `opencode models --verbose`
+// can take >10 s on a busy machine and print thousands of lines), so it gets
+// its own, more realistic limit below.
 export const DISCOVERY_TIMEOUT_MS = 10_000;
+export const MODEL_DISCOVERY_TIMEOUT_MS = 30_000;
+
+// Tests (and operators with unusually slow providers) can override the
+// model-list limit. Read at call time so tests can set it after importing
+// this module.
+export function modelDiscoveryTimeoutMs(){
+  const raw = Number(process.env.AP_MODEL_DISCOVERY_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : MODEL_DISCOVERY_TIMEOUT_MS;
+}
+
+export function modelDiscoveryTimeoutLabel(ms = modelDiscoveryTimeoutMs()){
+  const seconds = ms / 1000;
+  return `${Number.isInteger(seconds) ? seconds : seconds.toFixed(1)} s`;
+}
+
+// Backlog #5: a cold first start (opencode rebuilding its data for a new
+// project) can exceed the normal model-list budget even though the CLI is
+// working. Setup/config retry that timed-out probe ONCE with twice the
+// effective budget; the env override still scales both attempts.
+export function modelDiscoveryRetryTimeoutMs(){
+  return modelDiscoveryTimeoutMs() * 2;
+}
 
 function cleanLines(text){
   return String(text||'').split(/\r?\n/).map(s=>s.trim()).filter(Boolean);
@@ -133,14 +165,22 @@ function flagFromHelp(text, aliases){
 export async function discoverCapabilities(meta, deadline){
   if(!deadline) deadline = newDeadline();
   const help=await collectHelpText(meta, deadline);
+  const openCodeGeneration = isOpenCodeAdapter(meta)
+    ? rememberOpenCodeGeneration(meta, help)
+    : null;
+  // OpenCode 2.x has no reasoning/effort flag: the level is a model suffix.
+  // Its help names --model's value as "provider/model#variant" instead.
+  const openCodeModelSuffix = openCodeGeneration === "2";
   const modelFlag = flagFromHelp(help, ['--model','-m']);
   // Try the adapter's OWN declared effort_flag first (e.g. OpenCode's is
   // "--variant" — its reasoning/effort levels ARE its model variants, there
   // is no separate "--effort" flag), then the two generic literal names as
   // a fallback for adapters that don't declare one.
-  const effortFlag = meta.effort_mode === 'config'
-    ? flagFromHelp(help, ['--config'])
-    : flagFromHelp(help, [meta.effort_flag, '--effort', '--reasoning-effort'].filter(Boolean));
+  const effortFlag = openCodeModelSuffix
+    ? null
+    : meta.effort_mode === 'config'
+      ? flagFromHelp(help, ['--config'])
+      : flagFromHelp(help, [meta.effort_flag, '--effort', '--reasoning-effort'].filter(Boolean));
   const variantFlagRaw = flagFromHelp(help, ['--variant']);
   // If the flag just detected for "variant" is the exact same literal flag
   // already claimed by "effort" above (OpenCode's case once help text from
@@ -159,16 +199,26 @@ export async function discoverCapabilities(meta, deadline){
     const flag = String(arg).replace(/^.*?--/, "--");
     return help.includes(flag);
   });
-  return {
+  const capabilities = {
     model: !!modelFlag,
     model_flag: modelFlag,
-    effort: !!effortFlag,
+    effort: openCodeModelSuffix ? !!modelFlag : !!effortFlag,
     effort_flag: effortFlag,
-    variant: !!variantFlag,
-    variant_flag: variantFlag,
+    variant: openCodeModelSuffix ? false : !!variantFlag,
+    variant_flag: openCodeModelSuffix ? null : variantFlag,
     resume: resumeSupported,
     discovery: meta.model_discovery || 'manual'
   };
+  if (isOpenCodeAdapter(meta)) {
+    capabilities.opencode_generation = openCodeGeneration;
+    if (openCodeModelSuffix) {
+      capabilities.effort_mode = 'model_suffix';
+      capabilities.standalone = true;
+    } else {
+      capabilities.standalone = false;
+    }
+  }
+  return capabilities;
 }
 
 export async function discoverAdapter(meta){
@@ -258,20 +308,83 @@ export function parseOpenCodeVerboseOutput(text){
   return out;
 }
 
-async function discoverFromOpenCode(binary, deadline){
-  if(!deadline) deadline = newDeadline();
-  let r=await spawnWithDeadline(binary,['models','--verbose'],{encoding:'utf8',stdio:['ignore','pipe','pipe']}, deadline);
+// OpenCode 2.x's machine-readable catalog: `api GET /api/model` returns
+// {location, data:[{providerID,id,name,variants:[{id,settings}],status,enabled}]}.
+// The per-model variant ids are the reasoning/effort levels (the same
+// dimension 1.x reports through `models --verbose`). A disabled or
+// non-active entry is not selectable, mirroring the usable-only 1.x list.
+export function parseOpenCodeApiModels(text){
+  let parsed;
+  try{ parsed=JSON.parse(String(text||'').trim()); }catch{ return []; }
+  const data=Array.isArray(parsed) ? parsed : parsed?.data;
+  if(!Array.isArray(data)) return [];
+  const out=[];
+  const seen=new Set();
+  for(const model of data){
+    if(!model || typeof model!=='object') continue;
+    const provider=typeof model.providerID==='string' ? model.providerID : '';
+    const modelId=typeof model.id==='string' ? model.id : (typeof model.modelID==='string' ? model.modelID : '');
+    if(!provider || !modelId) continue;
+    if(model.enabled === false) continue;
+    if(typeof model.status === 'string' && model.status !== 'active') continue;
+    const id=`${provider}/${modelId}`;
+    if(seen.has(id)) continue;
+    seen.add(id);
+    const variants=Array.isArray(model.variants)
+      ? model.variants.map(v=>typeof v==='string' ? v : v?.id).filter(Boolean)
+      : [];
+    out.push({id,label:model.name||model.modelID||modelId,reasoning:variants,variants});
+  }
+  return out;
+}
+
+async function resolveOpenCodeGeneration(meta, deadline){
+  const cached=cachedOpenCodeGeneration(meta);
+  if(cached !== undefined) return {generation:cached, timedOut:false};
+  const r=await spawnWithDeadline(meta.binary,openCodeHelpArgs(meta),{encoding:'utf8',stdio:['ignore','pipe','pipe']}, deadline);
+  if(r.timedOut) return {generation:null, timedOut:true};
+  return {generation:rememberOpenCodeGeneration(meta, `${r.stdout||''}\n${r.stderr||''}`), timedOut:false};
+}
+
+async function discoverFromOpenCode(meta, deadline){
+  if(!deadline) deadline = newDeadline(modelDiscoveryTimeoutMs());
+  const generation=await resolveOpenCodeGeneration(meta, deadline);
+  if(generation.timedOut) return {items:[], status:'timeout'};
+  let timedOut=false;
+  if(generation.generation === '2'){
+    let r=await spawnWithDeadline(meta.binary,['api','GET','/api/model'],{encoding:'utf8',stdio:['ignore','pipe','pipe']}, deadline);
+    if(r.timedOut) timedOut=true;
+    if(r.status===0 && r.stdout){
+      const items=parseOpenCodeApiModels(r.stdout);
+      if(items.length) return {items, status:'reported'};
+    }
+    if(remaining(deadline) <= 0) return {items:[], status:timedOut ? 'timeout' : 'unsupported'};
+    // 2.x `models --verbose` no longer exists; the plain list still gives
+    // ids, so it remains the last-resort fallback (levels unavailable).
+    r=await spawnWithDeadline(meta.binary,['models'],{encoding:'utf8',stdio:['ignore','pipe','pipe']}, deadline);
+    if(r.timedOut) timedOut=true;
+    if(r.status!==0 || !r.stdout) return {items:[], status:timedOut ? 'timeout' : 'unsupported'};
+    const items=unique(cleanLines(r.stdout)
+      .filter(line=>/^[A-Za-z0-9._-]+\/[A-Za-z0-9._:@+-]+(?:\s|$)/.test(line))
+      .map(line=>line.split(/\s+/)[0]))
+      .map(id=>({id,label:id,reasoning:[],variants:discoverOpenCodeVariants(id)}));
+    return {items, status:items.length ? 'reported' : 'unsupported'};
+  }
+  let r=await spawnWithDeadline(meta.binary,['models','--verbose'],{encoding:'utf8',stdio:['ignore','pipe','pipe']}, deadline);
+  if(r.timedOut) timedOut=true;
   if(r.status===0 && r.stdout){
     const verbose=parseOpenCodeVerboseOutput(r.stdout);
-    if(verbose.length) return verbose;
+    if(verbose.length) return {items:verbose, status:'reported'};
   }
-  if(remaining(deadline) <= 0) return [];
-  r=await spawnWithDeadline(binary,['models'],{encoding:'utf8',stdio:['ignore','pipe','pipe']}, deadline);
-  if(r.status!==0 || !r.stdout) return [];
-  return unique(cleanLines(r.stdout)
+  if(remaining(deadline) <= 0) return {items:[], status:timedOut ? 'timeout' : 'unsupported'};
+  r=await spawnWithDeadline(meta.binary,['models'],{encoding:'utf8',stdio:['ignore','pipe','pipe']}, deadline);
+  if(r.timedOut) timedOut=true;
+  if(r.status!==0 || !r.stdout) return {items:[], status:timedOut ? 'timeout' : 'unsupported'};
+  const items=unique(cleanLines(r.stdout)
     .filter(line=>/^[A-Za-z0-9._-]+\/[A-Za-z0-9._:@+-]+(?:\s|$)/.test(line))
     .map(line=>line.split(/\s+/)[0]))
     .map(id=>({id,label:id,reasoning:[],variants:discoverOpenCodeVariants(id)}));
+  return {items, status:items.length ? 'reported' : 'unsupported'};
 }
 
 
@@ -280,12 +393,14 @@ export function parseAntigravityModels(text){
 }
 
 async function discoverAntigravityModels(binary, deadline){
-  if(!deadline) deadline = newDeadline();
+  if(!deadline) deadline = newDeadline(modelDiscoveryTimeoutMs());
   const transport=resolveAdapterTransport({driver:adapterDriver('antigravity'),request:{binary,args:['models']}});
-  if(!transport.available) return [];
+  if(!transport.available) return {items:[], status:'unsupported'};
   const r=await spawnWithDeadline(transport.invocation.binary,transport.invocation.args,{encoding:'utf8',stdio:['ignore','pipe','pipe']}, deadline);
-  if(r.status!==0 || !r.stdout) return [];
-  return parseAntigravityOutput(r.stdout);
+  if(r.timedOut) return {items:[], status:'timeout'};
+  if(r.status!==0 || !r.stdout) return {items:[], status:'unsupported'};
+  const items=parseAntigravityOutput(r.stdout);
+  return {items, status:items.length ? 'reported' : 'unsupported'};
 }
 
 function parseAntigravityOutput(text){
@@ -316,14 +431,20 @@ function parseAntigravityOutput(text){
 }
 
 async function discoverFromCursor(binary, deadline){
-  if(!deadline) deadline = newDeadline();
+  if(!deadline) deadline = newDeadline(modelDiscoveryTimeoutMs());
+  let timedOut=false;
   let r=await spawnWithDeadline(binary,['models'],{encoding:'utf8',stdio:['ignore','pipe','pipe']}, deadline);
-  if(r.status!==0 && remaining(deadline) > 0) r=await spawnWithDeadline(binary,['--list-models'],{encoding:'utf8',stdio:['ignore','pipe','pipe']}, deadline);
-  if(r.status!==0 || !r.stdout) return [];
-  return unique(cleanLines(r.stdout)
+  if(r.timedOut) timedOut=true;
+  if(r.status!==0 && remaining(deadline) > 0){
+    r=await spawnWithDeadline(binary,['--list-models'],{encoding:'utf8',stdio:['ignore','pipe','pipe']}, deadline);
+    if(r.timedOut) timedOut=true;
+  }
+  if(r.status!==0 || !r.stdout) return {items:[], status:timedOut ? 'timeout' : 'unsupported'};
+  const items=unique(cleanLines(r.stdout)
     .filter(line=>!/^(available|models|model|name|id|usage|help|press|cursor agent|available models|model list)\b/i.test(line))
     .map(line=>line.replace(/^[-*•]\s*/,'').split(/\s{2,}|\t/)[0].trim())
     .filter(line=>line && line.length<160));
+  return {items, status:items.length ? 'reported' : 'unsupported'};
 }
 
 function normalizeCodexModels(result){
@@ -336,7 +457,8 @@ function normalizeCodexModels(result){
   })).filter(m=>m.id);
 }
 
-function discoverFromCodexAppServer(binary){
+function discoverFromCodexAppServer(binary, deadline){
+  if(!deadline) deadline = newDeadline(modelDiscoveryTimeoutMs());
   return new Promise(resolve => {
     const child = spawnAgent(binary,['app-server','--stdio'],{encoding:'utf8',stdio:['pipe','pipe','ignore']});
     let done = false;
@@ -344,8 +466,8 @@ function discoverFromCodexAppServer(binary){
       if(done) return;
       done = true;
       killTree(child);
-      resolve([]);
-    }, 7000);
+      resolve({items:[], status:'timeout'});
+    }, remaining(deadline));
     const finish = (result) => {
       if(done) return;
       done = true;
@@ -363,15 +485,18 @@ function discoverFromCodexAppServer(binary){
         try{ const msg=JSON.parse(line); replies.push(msg); }catch{}
       }
       const modelReply=replies.find(x=>x?.id===2 && x?.result);
-      if(modelReply) finish(normalizeCodexModels(modelReply));
+      if(modelReply){
+        const items=normalizeCodexModels(modelReply);
+        finish({items, status:items.length ? 'reported' : 'unsupported'});
+      }
     });
-    child.on('error',()=>finish([]));
-    child.on('exit',()=>{ if(!replies.find(x=>x?.id===2)) finish([]); });
+    child.on('error',()=>finish({items:[], status:'error'}));
+    child.on('exit',()=>{ if(!replies.find(x=>x?.id===2)) finish({items:[], status:'unsupported'}); });
     try{
       child.stdin.write(JSON.stringify({jsonrpc:'2.0',id:1,method:'initialize',params:{clientInfo:{name:'project-autopilot',version:'10.2.0'}}})+'\n');
       child.stdin.write(JSON.stringify({jsonrpc:'2.0',method:'initialized',params:{}})+'\n');
       child.stdin.write(JSON.stringify({jsonrpc:'2.0',id:2,method:'model/list',params:{includeHidden:false}})+'\n');
-    }catch{ finish([]); }
+    }catch{ finish({items:[], status:'unsupported'}); }
   });
 }
 
@@ -380,17 +505,30 @@ function discoverFromCodexAppServer(binary){
  * Empty means no supported machine-readable discovery is available.
  * Autopilot never invents a catalog.
  * The return value is Promise<array|string> because Codex discovery is async.
+ * The array carries a non-enumerable `status` side field
+ * ("reported"|"timeout"|"unsupported"|"error") so callers can tell a slow
+ * model list from a CLI that genuinely has no machine-readable one.
  */
-export async function discoverModelCatalog(meta){
+function catalogStatus(items, status){
+  Object.defineProperty(items, 'status', {value:status, enumerable:false, configurable:true});
+  return items;
+}
+
+export async function discoverModelCatalog(meta, {timeoutMs = modelDiscoveryTimeoutMs()} = {}){
   const binary=meta.binary; const kind=meta.model_discovery;
-  const deadline = newDeadline();
+  const deadline = newDeadline(timeoutMs);
   try{
-    if(kind==='opencode_models') return await discoverFromOpenCode(binary, deadline);
-    if(kind==='cursor_models') return (await discoverFromCursor(binary, deadline)).map(id=>({id,label:id,reasoning:[],variants:[]}));
-    if(kind==='codex_app_server') return await discoverFromCodexAppServer(binary);
-    if(kind==='antigravity_models') return await discoverAntigravityModels(binary, deadline);
-  }catch{}
-  return [];
+    let result;
+    if(kind==='opencode_models') result=await discoverFromOpenCode(meta, deadline);
+    else if(kind==='cursor_models'){
+      const cursor=await discoverFromCursor(binary, deadline);
+      result={items:cursor.items.map(id=>({id,label:id,reasoning:[],variants:[]})), status:cursor.status};
+    }
+    else if(kind==='codex_app_server') result=await discoverFromCodexAppServer(binary, deadline);
+    else if(kind==='antigravity_models') result=await discoverAntigravityModels(binary, deadline);
+    else result={items:[], status:'unsupported'};
+    return catalogStatus(result.items, result.status);
+  }catch{ return catalogStatus([], 'error'); }
 }
 
 export async function discoverModels(meta){

package/scripts/opencode-generation.mjs

@@ -0,0 +1,116 @@
+// OpenCode 1.x / 2.x generation detection, cached per binary.
+//
+// 1.x (`opencode-ai`) exposes reasoning/effort through `run --variant` and
+// lists per-model levels via `models --verbose`.
+// 2.x (`@opencode/cli`) has no `run --variant`: the level is a model suffix,
+// `--model provider/model#level`, and `models --verbose` is gone (levels come
+// from `opencode api GET /api/model`). It also needs `--standalone` for an
+// OPENCODE_CONFIG_CONTENT-defined agent (e.g. autopilot_readonly) to be seen.
+//
+// The probe is a real `run --help` launch, memoized per process so a mission
+// pays for it once. Capability discovery normally fills this cache before any
+// launch, so buildInvocation/verifyAgentInvocation just read it. A failed or
+// unknown probe deliberately falls back to the 1.x path: that keeps the
+// pre-2.x behaviour byte-for-byte identical when the help text cannot be read.
+//
+// The cache key is the adapter BINARY only (resolved path, else name), never
+// the help argv: model discovery, capability discovery, the driver and the
+// invocation verifier all describe the same installed CLI, so one probe must
+// serve all of them even when a caller passes a partial adapter object
+// (`{binary}`) and another the full manifest (with `help_args`).
+import fs from "node:fs";
+import path from "node:path";
+import {spawnAgentSync, resolveAgentBinary} from "./agent-process.mjs";
+
+export const OPENCODE_HELP_ARGS = Object.freeze(["run", "--help"]);
+export const OPENCODE_GENERATION_1 = "1";
+export const OPENCODE_GENERATION_2 = "2";
+
+const generationCache = new Map();
+
+export function isOpenCodeAdapter(adapter = {}) {
+  if (!adapter || typeof adapter !== "object") return false;
+  if (adapter.driver === "opencode" || adapter.model_discovery === "opencode_models") return true;
+  // Manifest-shaped adapter without a driver/kind (tests and older callers).
+  return adapter.effort_flag === "--variant"
+    && /(^|[\\/])opencode(?:\.(?:exe|cmd|bat))?$/i.test(String(adapter.binary || ""));
+}
+
+export function openCodeHelpArgs(adapter = {}) {
+  return Array.isArray(adapter.help_args) && adapter.help_args.length
+    ? adapter.help_args.map(String)
+    : [...OPENCODE_HELP_ARGS];
+}
+
+function generationKey(adapter = {}) {
+  const binary = String(adapter?.binary || "opencode");
+  let resolved = binary;
+  try {
+    if (path.isAbsolute(binary) || /[\\/]/.test(binary)) {
+      resolved = fs.existsSync(binary) ? fs.realpathSync(binary) : path.resolve(binary);
+    } else {
+      resolved = resolveAgentBinary(binary) || binary;
+      if (resolved && fs.existsSync(resolved)) resolved = fs.realpathSync(resolved);
+    }
+  } catch { /* keep the caller-supplied name */ }
+  return resolved;
+}
+
+export function generationFromHelp(text) {
+  const value = String(text || "");
+  // 1.x help names the flag itself; 2.x help names it only inside the model
+  // value description. Check the real flag first so a 2.x help that happens
+  // to mention the word "variant" elsewhere is not misclassified.
+  if (/(?:^|\s)--variant(?:\s|=|,|$)/m.test(value)) return OPENCODE_GENERATION_1;
+  if (/--model\b[\s\S]{0,200}?#variant/.test(value) || /provider\/model#variant/.test(value)) {
+    return OPENCODE_GENERATION_2;
+  }
+  return null;
+}
+
+export function cachedOpenCodeGeneration(adapter = {}) {
+  return generationCache.get(generationKey(adapter));
+}
+
+// Populate the cache from help text already collected by capability
+// discovery, so model discovery and the invocation builder do not launch the
+// same probe again.
+export function rememberOpenCodeGeneration(adapter, helpText) {
+  const generation = generationFromHelp(helpText);
+  if (generation) generationCache.set(generationKey(adapter), generation);
+  return generation;
+}
+
+// Synchronous probe for launch-time callers (applyAgentSelections,
+// verifyAgentInvocation, the driver's buildInvocation). It is a LAST-RESORT
+// fallback: discovery normally populates the same per-binary cache first.
+// An unknown result is cached too so a broken/odd help output is not retried
+// on every role in the same process.
+export function detectOpenCodeGeneration(adapter = {}) {
+  const key = generationKey(adapter);
+  if (generationCache.has(key)) return generationCache.get(key);
+  let generation = null;
+  try {
+    const result = spawnAgentSync(adapter.binary || "opencode", openCodeHelpArgs(adapter), {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      input: "",
+      timeout: 5_000
+    });
+    generation = generationFromHelp(`${result?.stdout || ""}\n${result?.stderr || ""}`);
+  } catch { /* unknown -> 1.x path */ }
+  generationCache.set(key, generation);
+  return generation;
+}
+
+export function openCodeUsesModelSuffix(adapter = {}) {
+  return isOpenCodeAdapter(adapter) && detectOpenCodeGeneration(adapter) === OPENCODE_GENERATION_2;
+}
+
+// "provider/model#level" -> {model: "provider/model", reasoning: "level"}.
+export function splitOpenCodeModelSuffix(value) {
+  const text = String(value || "");
+  const at = text.lastIndexOf("#");
+  if (at < 0) return {model: text, reasoning: null};
+  return {model: text.slice(0, at), reasoning: text.slice(at + 1) || null};
+}

package/scripts/per-task-budget.mjs

@@ -104,7 +104,9 @@ export const PER_ROLE_CAPS_DEFAULT = {
   // Backlog #59(b): planner raised with the implementer (operator decision
   // 2026-10-10; rarely reaches the limit, and a cut re-reads uncached).
   planner: {maxTurns: 30, maxTokens: 200_000, extraSessions: 2},
-  plan_reviewer: {maxTurns: 30, maxTokens: 150_000, extraSessions: 2},
+  // Operator decision 2026-10-28: 4, because with working hand-off notes two 30-turn sessions cost less than one long session and long full reviews were stopping missions at 2.
+  // Backlog #8: 250K so a full plan re-check finishes in one session on a large plan instead of splitting at ~135K.
+  plan_reviewer: {maxTurns: 30, maxTokens: 250_000, extraSessions: 4},
   code_reviewer: {maxTurns: 22, maxTokens: 150_000, extraSessions: 2},
   // Backlog #59(b): the verifier was cut at 22 in test mission 048 trial 3
   // and re-ran in full (392K priced) — raised with the implementer.
@@ -114,11 +116,12 @@ export const PER_ROLE_CAPS_DEFAULT = {
 // Per-role wrap-up token thresholds (mission 031 Phase 1 task 1.1; mission
 // 044 Phase 1 task 1.3: per-turn values).
 // Must be strictly below the role's maxTokens so wrap-up can fire before the cap.
-// Non-planner review roles use 135K (~one turn headroom below 150K);
-// planner uses 180K (~one turn headroom below 200K).
+// planner uses 180K (~one turn headroom below 200K), plan_reviewer uses 225K
+// (~one turn headroom below its 250K cap, backlog #8); the other review roles
+// use 135K (~one turn headroom below 150K).
 export const PER_ROLE_WRAPUP_TOKENS_DEFAULT = {
   planner: 180_000,
-  plan_reviewer: 135_000,
+  plan_reviewer: 225_000,
   code_reviewer: 135_000,
   verifier: 135_000,
 };
@@ -832,10 +835,11 @@ export function clearNoProgress(state, scope) {
 //   - anything else non-empty => `tasks ${taskRef}` for multi-token refs,
 //     else `task ${taskRef}`.
 //   - missing/empty taskRef => `${Prefix} task` (framework fallback).
-// Prefix is "SpecKit" for framework "speckit" (case-insensitive), else
-// "Standalone".
+// Prefix is "SpecKit" for framework "speckit", "GSD" for "gsd"
+// (case-insensitive), else "Standalone".
 export function noProgressDisplayLabel({taskId, taskRef, framework} = {}) {
-  const prefix = String(framework ?? "").toLowerCase() === "speckit" ? "SpecKit" : "Standalone";
+  const fw = String(framework ?? "").toLowerCase();
+  const prefix = fw === "speckit" ? "SpecKit" : fw === "gsd" ? "GSD" : "Standalone";
   const id = taskId === null || taskId === undefined ? "" : String(taskId).trim();
   if (id && id.toLowerCase() !== "null" && id.toLowerCase() !== "undefined") return `task ${id}`;
   const ref = taskRef === null || taskRef === undefined ? "" : String(taskRef).trim();