jules-orchestrator-kit 0.32.1 → 0.32.3

package/.agent/rules/jules-protocol.md

@@ -31,3 +31,6 @@ To maximize the ratio of mergeable PRs vs. failed or hallucinated sessions:
 10. **Stop-on-Uncertainty Rule:** If the task cannot be completed safely within scope, the agent must stop without opening a PR rather than guessing.
 11. **Pre-Dispatch Grounding Mandate:** Verify all file paths, script names, and exported symbols against the live repository tree before writing them into a prompt.
 12. **Programmatic CI Scope Guarding:** Enforce prompt constraints at the CI level using an unbypassable `Agent Scope Guard` workflow that evaluates diffs against a protected paths manifest (`.agent/protected-paths.json`).
+13. **Google Labs Exploration Budget Protocol:** Execute tasks across 3 discrete phases: (1) Discovery & Symbol Tracing (silent inspection, write NO code), (2) Oracle & Test Formulation, and (3) Surgical Implementation & Verification.
+14. **Critic Agent Steering (Adversarial Pre-Review):** Jules' internal Critic Agent must evaluate proposed patches for edge-case regressions, $O(n^2)$ bottlenecks, unhandled parameters, and layout shifts (CLS) prior to PR submission.
+15. **Web Excellence & Frontend Guardrails:** Enforce quantitative Core Web Vitals (LCP < 1.2s, CLS < 0.05), WCAG 2.2 AA/AAA semantic accessibility, Schema.org JSON-LD compliance, and Playwright multi-viewport responsive testing.

package/JULES_RULES_TEMPLATE.md

@@ -57,16 +57,21 @@ Jules automatically infers test and build verification commands via `scripts/com
 - **Rebase Before PR**: Fetch latest `main`, rebase onto `origin/main`, re-execute verification suite. If the resulting diff is empty, close/abort PR without pushing.
 - **Minimal Interference**: Preserve existing function signatures, comments, and style conventions.
 - **No Token Bloat**: Exclude lockfiles, minified bundles, and binary assets from diff representations.
+- **Google Labs Exploration Budget Protocol**: Execute complex multi-step tasks across 3 discrete phases: (1) Discovery & Symbol Tracing (silent inspection, write NO code), (2) Oracle & Test Formulation, and (3) Surgical Implementation & Verification.
+- **Critic Agent Steering (Adversarial Pre-Review)**: Jules' internal Critic Agent evaluates proposed patches for edge-case regressions, $O(n^2)$ bottlenecks, unhandled parameters, and layout shifts (CLS) prior to final PR submission.
 
 ---
 
 ## 5. Security Fencing & Specialized Domain Guardrails
 
 - **Untrusted Prompt Fencing**: All dynamic user prompts and issue texts are encapsulated in `<UNTRUSTED_TASK_CONTEXT>` tags with a `# SECURITY DIRECTIVE — UNTRUSTED CONTENT FENCE` header, instructing Jules to treat enclosed text as non-executable data.
-- **Specialized Domain Personas**:
+- **Specialized Domain Personas & Task Envelopes**:
   - **Sentinel (Security)**: Enforces input sanitization, token redaction, and RBAC guardrails.
-  - **Bolt (Performance)**: Optimizes execution speed, memory usage, and prevents token bloat.
-  - **Janitor (Clean Code)**: Eliminates dead code, fixes linting warnings, and maintains strict minimal diffs.
+  - **Bolt (Performance / `web-cwv`)**: Optimizes Core Web Vitals (LCP, CLS, INP), bundle size, and prevents token bloat.
+  - **A11y Guard (`web-wcag`)**: Eliminates accessibility violations, modal focus traps, and contrast defects.
+  - **Scribe (`web-seo`)**: Injects valid Schema.org JSON-LD, OpenGraph/Twitter cards, and canonical links.
+  - **Spectator (`web-playwright`)**: E2E visual regression and multi-viewport responsive testing.
+  - **Janitor (Clean Code / `web-flaky-heal`)**: Eliminates flaky test oscillations, dead code, and linting warnings.
   - **Alchemist (Database)**: Inspects schema constraints before running or generating database migrations.
 
 ---

package/README.md

@@ -369,8 +369,9 @@ Native stdio server exposing task dispatch, gate verification, and risk auditing
 | Command | Usage | Description | Exit Codes |
 | :--- | :--- | :--- | :--- |
 | `init` | `agentctl init [--interactive] [--tier pro]` | Interactive onboarding wizard & stack oracle inspector generating `.agent/config.yml`. | `0` (Created) |
-| `task create` | `agentctl task create [--title <t>] [--prompt <p>]` | Interactively authors & scopes falsifiable task envelopes with secret scrubbing & preflight gate checks. | `0` (Queued), `1` (Unfalsifiable / Secret leak) |
-| `task optimize` | `agentctl task optimize "<prompt>" [--fix] [--json]` | Linter & optimizer scoring prompt falsifiability (0–100), fixing typos, and checking scope violations. | `0` (Scored/Fixed) |
+| `task create` | `agentctl task create [--title <t>] [--prompt <p>] [--template <id>]` | Interactively authors & scopes falsifiable task envelopes with secret scrubbing & preflight gate checks. | `0` (Queued), `1` (Unfalsifiable / Secret leak) |
+| `task template` | `agentctl task template [<id>] [--list] [--json]` | Lists and synthesizes specialized web task envelopes (`web-cwv`, `web-wcag`, `web-seo`, `web-playwright`, `web-flaky-heal`). | `0` (Synthesized/Listed) |
+| `task optimize` | `agentctl task optimize "<prompt>" [--fix] [--web] [--json]` | Linter & optimizer injecting Google Labs 3-phase exploration budgets, critic steering, and web oracles. | `0` (Scored/Fixed) |
 | `test-gen` | `agentctl test-gen --title <t> --spec <s> [--run]` | Scaffolds falsifiable unit tests, verifies **RED** failure state, and locks test in `scope.deny`. | `0` (Scaffolded/Red) |
 | `rollback` | `agentctl rollback [sessionId \| --latest]` | Restores exact commit, uncommitted files, and cleans orphan task worktrees from pre-flight checkpoints. | `0` (Restored), `1` (Error) |
 | `resume` | `agentctl resume <sessionId> --response "<reply>"` | Streams engineer response back into active Google Jules warm session context window. | `0` (Resumed), `1` (Error) |
@@ -387,7 +388,7 @@ Native stdio server exposing task dispatch, gate verification, and risk auditing
 | `clean` | `agentctl clean` | Prunes stale git worktrees, lockfiles, and temporary ledgers. | `0` (Clean) |
 | `mcp` | `agentctl mcp` | Starts stdio Model Context Protocol (MCP) server for tool integration. | `0` / Stdio stream |
 | `mcp init` | `agentctl mcp init [--target cursor\|vscode\|claude\|all]` | 1-click scaffolding for Cursor (`.cursor/mcp.json`), VS Code tasks (`tasks.json`), and Claude Desktop. | `0` (Scaffolded) |
-| `version` | `agentctl version` | Outputs orchestrator kit semantic version (`v0.31.0`). | `0` |
+| `version` | `agentctl version` | Outputs orchestrator kit semantic version (`v0.32.3`). | `0` |
 
 <br/>
 

package/bin/agentctl.mjs

@@ -14,7 +14,7 @@ const command = args[0];
 
 function printHelp() {
   console.log(`
-🚀 agentctl v0.32.1 — Universal Agent Orchestrator & Safety Gatekeeper
+🚀 agentctl v0.32.3 — Universal Agent Orchestrator & Safety Gatekeeper
 
 Usage: agentctl <command> [options]
 
@@ -31,8 +31,9 @@ Commands:
   review-repair         Parse PR review comments and synthesize OODA repair tasks
   dashboard             Start local HTTP telemetry and audit dashboard
   init                  Scaffold .agent/ config and run onboarding wizard
-  task create           Interactively author and scope a Jules task envelope
-  task optimize         Linter & optimizer for Jules task prompts (--fix, --json)
+  task create           Interactively author and scope a Jules task envelope (--template <name>)
+  task optimize         Linter & optimizer for Jules task prompts (--fix, --json, --web)
+  task template         List and generate web development task templates (--list, --json)
   test-gen              Scaffold & run automated TDD Red-to-Green test cycle (--run)
   mcp init              Scaffold IDE integration config (cursor | vscode | claude | all)
   rollback              Restore git state & working tree to atomic pre-flight checkpoint
@@ -62,7 +63,7 @@ async function main() {
   }
 
   if (command === "version" || command === "--version" || command === "-v") {
-    console.log("agentctl v0.32.0");
+    console.log("agentctl v0.32.3");
     process.exit(0);
   }
 
@@ -371,6 +372,7 @@ async function main() {
           options: {
             title: { type: "string", short: "t" },
             prompt: { type: "string", short: "p" },
+            template: { type: "string" },
             "verify-cmd": { type: "string", short: "v" },
             "auto-pr": { type: "boolean" },
             "require-plan-approval": { type: "boolean" },
@@ -384,6 +386,7 @@ async function main() {
         const res = await runTaskCreateWizard(root, {
           title: values.title,
           prompt: values.prompt,
+          template: values.template,
           verifyCmd: values["verify-cmd"],
           autoPr: values["auto-pr"],
           requirePlanApproval: values["require-plan-approval"],
@@ -399,6 +402,51 @@ async function main() {
           console.log(`   Auto-PR  : ${res.plan.flags.autoPr}`);
         }
         process.exit(0);
+      } else if (subCommand === "template") {
+        const { values, positionals } = parseArgs({
+          args: args.slice(2),
+          options: {
+            list: { type: "boolean", short: "l" },
+            json: { type: "boolean", short: "j" },
+            "verify-cmd": { type: "string", short: "v" },
+          },
+          allowPositionals: true,
+        });
+
+        const { listWebTemplates, getWebTemplate, synthesizeWebEnvelope } = await import("../src/web-templates.mjs");
+        const templateName = positionals[0];
+
+        if (values.list || !templateName) {
+          const templates = listWebTemplates();
+          if (values.json) {
+            console.log(JSON.stringify({ ok: true, templates }, null, 2));
+          } else {
+            console.log(`\n🌐 Available Web Development Task Templates`);
+            console.log(`--------------------------------------------------`);
+            templates.forEach((t) => {
+              console.log(`  • ${t.id.padEnd(16)} [${t.category}]`);
+              console.log(`    ${t.description}`);
+              console.log(`    Default Oracle: ${t.defaultVerifyCmd}\n`);
+            });
+            console.log(`Usage: agentctl task template <id> [--json]`);
+            console.log(`--------------------------------------------------\n`);
+          }
+          process.exit(0);
+        }
+
+        const tpl = getWebTemplate(templateName);
+        if (!tpl) {
+          console.error(`Error: Unknown template '${templateName}'. Run 'agentctl task template --list' to see options.`);
+          process.exit(1);
+        }
+
+        const envelope = synthesizeWebEnvelope(templateName, {}, { verifyCmd: values["verify-cmd"] });
+        if (values.json) {
+          console.log(JSON.stringify({ ok: true, ...envelope }, null, 2));
+        } else {
+          console.log(envelope.fullEnvelope);
+        }
+        process.exit(0);
       } else if (subCommand === "optimize") {
         const { values, positionals } = parseArgs({
           args: args.slice(2),
@@ -406,6 +454,7 @@ async function main() {
             fix: { type: "boolean", short: "f" },
             file: { type: "string" },
             dir: { type: "string", short: "d" },
+            web: { type: "boolean", short: "w" },
             json: { type: "boolean", short: "j" },
             "verify-cmd": { type: "string", short: "v" },
           },
@@ -426,7 +475,7 @@ async function main() {
         }
 
         if (values.fix) {
-          const opt = optimizeTaskPrompt(promptText, { rootDir: targetDir, verifyCmd: values["verify-cmd"] });
+          const opt = optimizeTaskPrompt(promptText, { rootDir: targetDir, verifyCmd: values["verify-cmd"], web: values.web });
           if (values.json) {
             console.log(JSON.stringify(opt, null, 2));
           } else {
@@ -446,6 +495,9 @@ async function main() {
           if (analysis.oracle.command) {
             console.log(`  Oracle Command   : "${analysis.oracle.command}" (${analysis.oracle.autoDetected ? "Auto-detected" : "User-supplied"})`);
           }
+          if (analysis.webIntent && analysis.webIntent.isWeb) {
+            console.log(`  Web Intent       : 🌐 YES [${analysis.webIntent.categories.join(", ")}]`);
+          }
           if (analysis.issues.length > 0) {
             console.log(`\n  Issues Identified (${analysis.issues.length}):`);
             analysis.issues.forEach((i) => console.log(`   - [${i.type}] ${i.message} (-${i.penalty} pts)`));
@@ -458,7 +510,7 @@ async function main() {
         }
         process.exit(analysis.isFalsifiable ? 0 : 1);
       } else {
-        console.error(`Unknown task subcommand '${subCommand}'. Supported: agentctl task create, agentctl task optimize`);
+        console.error(`Unknown task subcommand '${subCommand}'. Supported: agentctl task create, agentctl task optimize, agentctl task template`);
         process.exit(1);
       }
       break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jules-orchestrator-kit",
-  "version": "0.32.1",
+  "version": "0.32.3",
   "description": "Orchestration kit for running Google Jules autonomous agents.",
   "repository": {
     "type": "git",

package/scripts/jules-merge-swarm.mjs

@@ -10,7 +10,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
 import { classifyRiskTier, RISK_TIERS } from "../src/risk.mjs";
-import { changedFiles } from "../src/git.mjs";
+import { changedFiles, git, resolveBase } from "../src/git.mjs";
+import { normalizePath } from "../src/config.mjs";
 
 export const EXIT = Object.freeze({
   SUCCESS: 0,
@@ -170,16 +171,21 @@ export function checkSafetyGate(branchName = "", projectRoot = process.cwd()) {
     } catch (_) {}
   }
 
-  // Check R3 risk tier if files modified
-  try {
-    const files = changedFiles(projectRoot, process.env.BASE_BRANCH || "main");
-    if (files.length > 0) {
-      const tier = classifyRiskTier(files);
-      if (tier.tier === RISK_TIERS.R3) {
-        return { safe: false, reason: `R3 Restricted Path violation: ${tier.reason}` };
+  // Check R3 risk tier if files modified on target branch
+  if (branchName) {
+    try {
+      const baseBranch = process.env.BASE_BRANCH || "main";
+      const resolvedBase = resolveBase(projectRoot, baseBranch);
+      const raw = git(["-c", "core.quotePath=false", "diff", "-z", "--name-only", `${resolvedBase}...${branchName}`], { cwd: projectRoot, raw: true, ignoreError: true }) || "";
+      const files = raw.split("\0").map(normalizePath).filter(Boolean);
+      if (files.length > 0) {
+        const tier = classifyRiskTier(files);
+        if (tier.tier === RISK_TIERS.R3) {
+          return { safe: false, reason: `R3 Restricted Path violation: ${tier.reason}` };
+        }
       }
-    }
-  } catch (_) {}
+    } catch (_) {}
+  }
 
   return { safe: true };
 }

package/src/git.mjs

@@ -149,7 +149,7 @@ export function ensureBaseFetched(root = process.cwd(), baseRef = "main") {
         stdio: ["ignore", "ignore", "ignore"],
       });
       return true;
-    } catch (__) {
+    } catch (_) {
       return false;
     }
   }

package/src/mcp.mjs

@@ -157,10 +157,27 @@ export const MCP_TOOLS = [
         prompt: { type: "string", description: "Raw task prompt instructions to analyze or optimize" },
         fix: { type: "boolean", description: "If true, synthesizes and returns an optimized task envelope" },
         verifyCmd: { type: "string", description: "Optional explicit verification command" },
+        web: { type: "boolean", description: "Enable web domain specific optimizations" },
+        explorationBudget: { type: "boolean", description: "Include 3-phase Google Labs discovery protocol" },
+        criticGuidance: { type: "boolean", description: "Include internal critic agent review guidelines" },
       },
       required: ["prompt"],
     },
   },
+  {
+    name: "get_web_task_template",
+    description: "Retrieve or synthesize a web development task envelope (web-cwv, web-wcag, web-seo, web-playwright, web-flaky-heal) with exploration budget and critic steering.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        template: { type: "string", description: "Template ID (web-cwv, web-wcag, web-seo, web-playwright, web-flaky-heal). Omit to list all available templates." },
+        params: { type: "object", description: "Optional template parameters (targetPage, standard, schemaType, viewports, etc.)" },
+        verifyCmd: { type: "string", description: "Optional override for verification test command" },
+        explorationBudget: { type: "boolean", description: "Enable 3-phase Google Labs discovery budget (default true)" },
+        criticGuidance: { type: "boolean", description: "Enable internal critic agent focus guidelines (default true)" },
+      },
+    },
+  },
 ];
 
 export async function handleMcpRequest(request, opts = {}) {
@@ -314,7 +331,13 @@ export async function handleMcpRequest(request, opts = {}) {
         }
         const { scorePromptFalsifiability, optimizeTaskPrompt } = await import("./task-optimizer.mjs");
         const res = args.fix
-          ? optimizeTaskPrompt(args.prompt, { rootDir: root, verifyCmd: args.verifyCmd })
+          ? optimizeTaskPrompt(args.prompt, {
+              rootDir: root,
+              verifyCmd: args.verifyCmd,
+              web: args.web,
+              explorationBudget: args.explorationBudget,
+              criticGuidance: args.criticGuidance,
+            })
           : scorePromptFalsifiability(args.prompt, { rootDir: root, verifyCmd: args.verifyCmd });
         return {
           jsonrpc: "2.0",
@@ -325,6 +348,40 @@ export async function handleMcpRequest(request, opts = {}) {
         };
       }
 
+      if (toolName === "get_web_task_template") {
+        const { listWebTemplates, getWebTemplate, synthesizeWebEnvelope } = await import("./web-templates.mjs");
+        if (!args || !args.template) {
+          const templates = listWebTemplates();
+          return {
+            jsonrpc: "2.0",
+            id,
+            result: {
+              content: [{ type: "text", text: JSON.stringify({ ok: true, templates }, null, 2) }],
+            },
+          };
+        }
+        const tpl = getWebTemplate(args.template);
+        if (!tpl) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32602, message: `Unknown web template '${args.template}'` },
+          };
+        }
+        const envelope = synthesizeWebEnvelope(args.template, args.params || {}, {
+          verifyCmd: args.verifyCmd,
+          explorationBudget: args.explorationBudget,
+          criticGuidance: args.criticGuidance,
+        });
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify({ ok: true, ...envelope }, null, 2) }],
+          },
+        };
+      }
+
       return {
         jsonrpc: "2.0",
         id,

package/src/task-optimizer.mjs

@@ -73,6 +73,50 @@ export function extractPathTokens(promptText) {
   return tokens;
 }
 
+/**
+ * Detects whether a prompt text pertains to web development domains (CWV, WCAG, SEO, E2E).
+ * @param {string} promptText
+ * @returns {{ isWeb: boolean, categories: string[], suggestedOracles: string[] }}
+ */
+export function detectWebIntent(promptText) {
+  if (!promptText || typeof promptText !== "string") {
+    return { isWeb: false, categories: [], suggestedOracles: [] };
+  }
+
+  const text = promptText.toLowerCase();
+  const categories = [];
+  const suggestedOracles = [];
+
+  const isPerformance = /\b(?:lighthouse|core web vitals|cwv|lcp|cls|inp|fcp|bundle size|lazy load|lazy-load|preload|render-blocking)\b/i.test(text);
+  const isA11y = /\b(?:wcag|a11y|accessibility|aria|screen reader|contrast ratio|focus trap|keyboard navigation)\b/i.test(text);
+  const isSeo = /\b(?:seo|json-ld|schema\.org|structured data|opengraph|sitemap|canonical|meta tag)\b/i.test(text);
+  const isE2e = /\b(?:playwright|e2e|visual regression|snapshot|viewport|responsive|tailwind|css|astro|next\.js|nuxt|svelte|react|vue)\b/i.test(text);
+
+  if (isPerformance) {
+    categories.push("Performance (CWV)");
+    suggestedOracles.push("npm run build && npx lhci autorun");
+  }
+  if (isA11y) {
+    categories.push("Accessibility (WCAG)");
+    suggestedOracles.push("npx axe-cli http://localhost:3000 || npm test");
+  }
+  if (isSeo) {
+    categories.push("SEO & Structured Data");
+    suggestedOracles.push("npm run build && node scripts/validate-seo.mjs");
+  }
+  if (isE2e) {
+    categories.push("Frontend & E2E");
+    suggestedOracles.push("npx playwright test");
+  }
+
+  const isWeb = categories.length > 0;
+  return {
+    isWeb,
+    categories,
+    suggestedOracles
+  };
+}
+
 const VAGUE_BUZZWORDS = [
   { term: "clean up", penalty: 15, msg: "Vague goal: 'clean up' lacks explicit acceptance criteria." },
   { term: "make faster", penalty: 15, msg: "Vague goal: 'make faster' lacks quantitative benchmark criteria." },
@@ -106,7 +150,8 @@ export function scorePromptFalsifiability(promptText, options = {}) {
       issues: [{ type: "EMPTY_PROMPT", message: "Task prompt is empty.", penalty: 100 }],
       suggestions: ["Provide a clear description of the code change requested."],
       paths: { found: [], missingCount: 0, scopeDeniedCount: 0 },
-      oracle: { command: null, autoDetected: false, isTrivial: false }
+      oracle: { command: null, autoDetected: false, isTrivial: false },
+      webIntent: { isWeb: false, categories: [], suggestedOracles: [] }
     };
   }
 
@@ -128,13 +173,13 @@ export function scorePromptFalsifiability(promptText, options = {}) {
   // 2. Concrete Evidence Indicators (Bonus/Protection)
   const hasErrorTrace = /(?:error|exception|fail|failed|stack|traceback|line\s+\d+|exit\s+code)/i.test(rawPrompt);
   const hasSymbolRef = /(?:`[^`]+`|\b[a-zA-Z0-9_]+\.[a-zA-Z0-9_]+\b|\b[a-zA-Z0-9_]+\(\))/i.test(rawPrompt);
-  const hasExplicitCheck = /(?:verify|assert|should|must|returns?|expect)/i.test(rawPrompt);
+  const hasExplicitCheck = /(?:verify|assert|should|must|returns?|expect|< \d+|>= \d+)/i.test(rawPrompt);
 
   if (hasErrorTrace || hasSymbolRef || hasExplicitCheck) {
     score = Math.min(100, score + 10);
   } else {
     score -= 10;
-    issues.push({ type: "NO_CONCRETE_CRITERIA", message: "Lacks explicit symbol references, test names, or error tracebacks.", penalty: 10 });
+    issues.push({ type: "NO_CONCRETE_CRITERIA", message: "Lacks explicit symbol references, test names, or quantitative acceptance criteria.", penalty: 10 });
     suggestions.push("Specify exact function names, file paths, or expected test assertions.");
   }
 
@@ -192,7 +237,13 @@ export function scorePromptFalsifiability(promptText, options = {}) {
     });
   }
 
-  // 4. Stack Oracle Detection
+  // 4. Web Domain Intent Detection
+  const webIntent = detectWebIntent(rawPrompt);
+  if (webIntent.isWeb && webIntent.categories.length > 0) {
+    suggestions.push(`Web domain detected (${webIntent.categories.join(", ")}). Consider incorporating exploration budget and critic agent checks.`);
+  }
+
+  // 5. Stack Oracle Detection
   let verifyCmd = options.verifyCmd || null;
   let autoDetected = false;
   let isTrivial = false;
@@ -243,12 +294,17 @@ export function scorePromptFalsifiability(promptText, options = {}) {
       command: verifyCmd,
       autoDetected,
       isTrivial
-    }
+    },
+    webIntent
   };
 }
 
 /**
  * Transforms raw prompt into an optimized, structured task envelope.
+ * Supports Google Labs Exploration Budget Protocol & Critic Agent Guidance.
+ * @param {string} promptText
+ * @param {object} [options={}]
+ * @returns {{ optimizedPrompt: string, analysis: object }}
  */
 export function optimizeTaskPrompt(promptText, options = {}) {
   const analysis = scorePromptFalsifiability(promptText, options);
@@ -271,10 +327,31 @@ export function optimizeTaskPrompt(promptText, options = {}) {
     }
   }
 
+  const isWeb = Boolean(options.web || (analysis.webIntent && analysis.webIntent.isWeb));
+  const includeExplorationBudget = options.explorationBudget !== false;
+  const includeCriticGuidance = options.criticGuidance !== false;
+  const verifyCmd = analysis.oracle.command || options.verifyCmd || "npm test";
+
   // Construct structured Markdown envelope
   const lines = [];
   lines.push(`# TASK: ${promptBody.split("\n")[0]}`);
   lines.push("");
+
+  if (includeExplorationBudget) {
+    lines.push("## Google Labs Exploration Budget Protocol (3-Phase Discovery)");
+    lines.push("To maximize diagnostic accuracy (Hit@5 57%), execute this task in 3 distinct phases:");
+    lines.push("1. **PHASE 1: DISCOVERY & SYMBOL TRACING (Stay Silent, Write NO Code)**");
+    lines.push("   - Read target source files, definitions, and dependent call sites.");
+    lines.push("   - Formulate diagnostic hypothesis and verify exact symbol signatures before making edits.");
+    lines.push("2. **PHASE 2: ORACLE FORMULATION**");
+    lines.push(`   - Execute baseline verification: \`${verifyCmd}\`.`);
+    lines.push("   - Identify specific test assertions, benchmarks, or status codes to satisfy.");
+    lines.push("3. **PHASE 3: SURGICAL IMPLEMENTATION & VERIFICATION**");
+    lines.push("   - Apply minimal, zero-bloat code modifications.");
+    lines.push(`   - Execute \`${verifyCmd}\` and verify 100% clean exit code 0.`);
+    lines.push("");
+  }
+
   lines.push("## Objective & Acceptance Criteria");
   lines.push(`- **Goal**: ${promptBody}`);
   if (analysis.oracle.command) {
@@ -292,10 +369,22 @@ export function optimizeTaskPrompt(promptText, options = {}) {
     lines.push("");
   }
 
+  if (includeCriticGuidance) {
+    lines.push("## Internal Critic Agent Focus (Adversarial Pre-Review)");
+    lines.push("Before submitting pull request, ensure the patch satisfies:");
+    lines.push("- [ ] Correctness: Functions handle all edge-case arguments and invalid input types.");
+    lines.push("- [ ] Complexity: No accidental O(n²) bottlenecks or memory leak allocations.");
+    if (isWeb) {
+      lines.push("- [ ] Web Integrity: Zero layout shifts (CLS), broken images, or missing accessible ARIA attributes.");
+    }
+    lines.push("- [ ] Security: No unescaped user inputs, leaked tokens, or unauthorized network calls.");
+    lines.push("");
+  }
+
   lines.push("## Standard Guardrails");
   lines.push("- Do NOT modify package.json, lockfiles, or .github/ infrastructure files.");
   lines.push("- Diff Payload Governor: Keep total diff payload under 75 KB (\`git diff | wc -c\`).");
-  lines.push("- Verify before finishing: Execute full verification command and confirm zero errors.");
+  lines.push(`- Verify before finishing: Execute \`${verifyCmd}\` and confirm zero errors.`);
 
   const optimizedPrompt = lines.join("\n");
 

package/src/web-templates.mjs

@@ -0,0 +1,300 @@
+/**
+ * Zero-dependency Web Development Task Templates & Envelopes for Google Jules.
+ * Implements Google Labs Exploration Budgets and Critic Agent steering.
+ */
+
+export const WEB_TEMPLATES = {
+  "web-cwv": {
+    id: "web-cwv",
+    name: "Core Web Vitals & Lighthouse Budget Guard",
+    description: "Audit and optimize frontend performance against hard Core Web Vitals and Lighthouse metrics.",
+    defaultVerifyCmd: "npm run build && npx lhci autorun || npm test",
+    category: "Performance",
+    criticFocus: [
+      "Check for un-optimized dynamic imports and excessive JavaScript bundle size.",
+      "Verify that all newly introduced images have explicit width/height and loading='lazy' decoding='async'.",
+      "Ensure font preloading uses fetchpriority='high' and prevents Cumulative Layout Shift (CLS).",
+      "Verify that critical CSS is not blocked by third-party analytics or non-critical scripts."
+    ],
+    defaultParams: {
+      lcpMaxMs: 1200,
+      clsMax: 0.05,
+      inpMaxMs: 100,
+      targetPage: "/",
+      strategy: "mobile"
+    },
+    generatePrompt: (params = {}) => {
+      const page = params.targetPage || "/";
+      const lcp = params.lcpMaxMs || 1200;
+      const cls = params.clsMax || 0.05;
+      const inp = params.inpMaxMs || 100;
+      const customGoal = params.goal ? `\n- **Target Focus**: ${params.goal}` : "";
+
+      return `Audit and optimize Core Web Vitals & performance for '${page}'.${customGoal}
+
+### Quantitative Performance Budget:
+- **Largest Contentful Paint (LCP)**: < ${lcp}ms
+- **Cumulative Layout Shift (CLS)**: < ${cls}
+- **Interaction to Next Paint (INP)**: < ${inp}ms
+- **Render-Blocking Resources**: 0 non-critical render-blocking assets
+
+### Required Architectural Actions:
+1. Eliminate unused CSS and JavaScript chunks on '${page}'.
+2. Preload above-the-fold hero images / fonts using \`<link rel="preload">\` with correct \`fetchpriority\`.
+3. Wrap below-the-fold heavy components in dynamic imports / lazy-loading.
+4. Ensure zero content shifts during font swaps or dynamic component mounting.`;
+    }
+  },
+
+  "web-wcag": {
+    id: "web-wcag",
+    name: "WCAG 2.2 AA/AAA & Semantic A11y Audit",
+    description: "Eliminate accessibility violations, contrast defects, keyboard focus traps, and ARIA anti-patterns.",
+    defaultVerifyCmd: "npx axe-cli http://localhost:3000 || npx pa11y http://localhost:3000 || npm test",
+    category: "Accessibility",
+    criticFocus: [
+      "Check for redundant or incorrect role attributes on native HTML elements (e.g. role='button' on <button>).",
+      "Verify that all interactive modals properly trap focus and restore focus to the trigger element on close (Escape).",
+      "Ensure all dynamic content updates use appropriate aria-live regions ('polite' vs 'assertive').",
+      "Verify that color contrast ratios strictly meet WCAG AA (4.5:1 for normal text, 3:1 for large) or AAA."
+    ],
+    defaultParams: {
+      standard: "WCAG 2.2 AA",
+      targetComponentOrRoute: "all routes",
+      minContrastRatio: "4.5:1"
+    },
+    generatePrompt: (params = {}) => {
+      const target = params.targetComponentOrRoute || "all routes";
+      const standard = params.standard || "WCAG 2.2 AA";
+      const customGoal = params.goal ? `\n- **Target Focus**: ${params.goal}` : "";
+
+      return `Perform a comprehensive accessibility (a11y) audit and remediation for ${target} conforming to ${standard}.${customGoal}
+
+### Accessibility Hard Invariants:
+1. **Semantic HTML5**: Replace non-semantic \`<div>\`/\`<span>\` clickable elements with native \`<button>\`, \`<dialog>\`, or \`<a>\`.
+2. **Keyboard Navigation & Focus Management**:
+   - All interactive controls must have visible, high-contrast focus rings (\`:focus-visible\`).
+   - Modals and drawers must trap Tab navigation inside and close cleanly on \`Escape\` keypress.
+   - Screen reader announcements for state changes (loading, errors, notifications) via \`aria-live\`.
+3. **Form & Input Labels**:
+   - Every input element must be explicitly associated with a \`<label for="...">\` or have an unambiguous \`aria-label\`.
+   - Error messages must be linked via \`aria-describedby\` and \`aria-invalid="true"\`.
+4. **Color & Contrast**:
+   - Text elements must satisfy minimum ${params.minContrastRatio || "4.5:1"} contrast ratio in both Light and Dark themes.`;
+    }
+  },
+
+  "web-seo": {
+    id: "web-seo",
+    name: "Structured Data (JSON-LD), OpenGraph & Canonical SEO Guard",
+    description: "Audit and implement schema.org structured data, metadata tags, sitemaps, and canonical link integrity.",
+    defaultVerifyCmd: "npm run build && node scripts/validate-seo.mjs || npm test",
+    category: "SEO & Content",
+    criticFocus: [
+      "Validate that all JSON-LD schemas contain mandatory Schema.org fields (e.g. @context, @type, name, url).",
+      "Ensure canonical URLs use absolute HTTPS links without trailing slash inconsistencies.",
+      "Check that OpenGraph (og:title, og:description, og:image) and Twitter Card tags match page content.",
+      "Verify that dynamic routes generate corresponding valid sitemap.xml entries with valid lastmod ISO dates."
+    ],
+    defaultParams: {
+      schemaType: "Article, WebSite, BreadcrumbList",
+      targetRoutes: "public pages"
+    },
+    generatePrompt: (params = {}) => {
+      const schemas = params.schemaType || "Article, WebSite, BreadcrumbList";
+      const routes = params.targetRoutes || "public pages";
+      const customGoal = params.goal ? `\n- **Target Focus**: ${params.goal}` : "";
+
+      return `Audit and implement Schema.org structured data (JSON-LD) and metadata for ${routes}.${customGoal}
+
+### SEO Requirements & Acceptance Criteria:
+1. **Structured Data (JSON-LD)**:
+   - Inject schema.org compliant \`<script type="application/ld+json">\` blocks for: ${schemas}.
+   - Validate against Schema.org specifications with zero missing required fields.
+2. **Meta & Social Graph Tags**:
+   - Ensure every public page has a unique, descriptive \`<title>\` (50-60 chars) and \`<meta name="description">\` (120-155 chars).
+   - Provide complete OpenGraph tags (\`og:title\`, \`og:description\`, \`og:image\`, \`og:url\`, \`og:type\`) and Twitter Card tags.
+   - Guarantee image URLs in \`og:image\` are absolute HTTPS URLs.
+3. **Canonical URLs & Crawlability**:
+   - Implement consistent canonical tags (\`<link rel="canonical" href="...">\`).
+   - Validate sitemap generation and ensure zero 404 links or redirect loops.`;
+    }
+  },
+
+  "web-playwright": {
+    id: "web-playwright",
+    name: "Playwright Visual Regression & Responsive Breakpoint Oracle",
+    description: "Author and verify end-to-end visual stability and responsive layout integrity across viewports.",
+    defaultVerifyCmd: "npx playwright test || npm test",
+    category: "Frontend QA",
+    criticFocus: [
+      "Verify that Playwright tests use strict, accessible locators (getByRole, getByLabel, getByText) rather than brittle CSS selectors.",
+      "Ensure zero hard-coded arbitrary wait timeouts (e.g. page.waitForTimeout); use web assertions with automatic retries.",
+      "Check that mobile viewports (375px) do not introduce horizontal scrollbars (document.body.scrollWidth > window.innerWidth).",
+      "Confirm snapshot assertions use appropriate pixel threshold tolerance to avoid flaky anti-aliasing failures."
+    ],
+    defaultParams: {
+      viewports: "Mobile (375x667), Tablet (768x1024), Desktop (1440x900)",
+      targetFeature: "UI components and navigation"
+    },
+    generatePrompt: (params = {}) => {
+      const feature = params.targetFeature || "UI components and navigation";
+      const viewports = params.viewports || "Mobile (375px), Tablet (768px), Desktop (1440px)";
+      const customGoal = params.goal ? `\n- **Target Focus**: ${params.goal}` : "";
+
+      return `Implement and verify Playwright E2E visual regression and responsive test suite for ${feature}.${customGoal}
+
+### Test Harness & Assertion Criteria:
+1. **Multi-Viewport Coverage**: Test and capture snapshots across: ${viewports}.
+2. **Responsive Invariants**:
+   - Zero horizontal overflow on mobile viewports (\`overflow-x\` containment).
+   - Tap target sizes for mobile touch buttons >= 44x44px.
+   - Hamburger / collapsible navigation expands and closes with correct ARIA attributes.
+3. **Resilient Locators**:
+   - Use user-facing accessible locators (\`page.getByRole('button', { name: /submit/i })\`).
+   - Never use arbitrary \`waitForTimeout(3000)\` sleeps; use \`expect(locator).toBeVisible()\`.
+4. **Visual Snapshots**:
+   - Verify visual snapshots pass with \`expect(page).toHaveScreenshot()\`.`;
+    }
+  },
+
+  "web-flaky-heal": {
+    id: "web-flaky-heal",
+    name: "Playwright / Async Flakiness Auto-Healer",
+    description: "Eliminate timing oscillations, race conditions, unmocked network calls, and unstable locators in E2E tests.",
+    defaultVerifyCmd: "npx playwright test --repeat-each=5 || npm test",
+    category: "QA & Stability",
+    criticFocus: [
+      "Identify non-deterministic timers and replace with condition-based web assertions.",
+      "Verify all third-party network requests (analytics, CDNs) are intercepted or mocked during testing.",
+      "Ensure test state isolation so tests do not leak local storage or cookies to subsequent test runs.",
+      "Confirm that repeated test runs (--repeat-each=5) pass 100% cleanly without oscillation."
+    ],
+    defaultParams: {
+      testFileOrSuite: "test/e2e/",
+      repetitionCount: 5
+    },
+    generatePrompt: (params = {}) => {
+      const testTarget = params.testFileOrSuite || "test/e2e/";
+      const reps = params.repetitionCount || 5;
+      const customGoal = params.goal ? `\n- **Target Focus**: ${params.goal}` : "";
+
+      return `Isolate and eliminate flaky test oscillations in ${testTarget}.${customGoal}
+
+### Anti-Flakiness Rules & Remediation Invariants:
+1. **Eliminate Arbitrary Sleep Calls**:
+   - Replace all \`sleep()\`, \`setTimeout()\`, or \`page.waitForTimeout()\` with auto-retrying assertions like \`await expect(locator).toBeVisible()\`.
+2. **Deterministic Network Interception**:
+   - Mock all external API and analytics network requests using \`page.route()\` to prevent network latency spikes from failing tests.
+3. **Strict Accessible Locators**:
+   - Replace fragile DOM hierarchy selectors (e.g. \`div > div:nth-child(3)\`) with resilient role/text locators.
+4. **State Isolation**:
+   - Ensure every test operates in a clean browser context with isolated cookies and localStorage.
+5. **Stability Verification**:
+   - Test suite must pass cleanly across ${reps} consecutive runs without a single failure.`;
+    }
+  }
+};
+
+/**
+ * Returns metadata and generator for a web template by ID.
+ * @param {string} templateId
+ * @returns {object|null}
+ */
+export function getWebTemplate(templateId) {
+  if (!templateId || typeof templateId !== "string") return null;
+  const key = templateId.trim().toLowerCase();
+  return WEB_TEMPLATES[key] || null;
+}
+
+/**
+ * Lists all registered web development templates.
+ * @returns {Array<{ id: string, name: string, description: string, category: string, defaultVerifyCmd: string }>}
+ */
+export function listWebTemplates() {
+  return Object.values(WEB_TEMPLATES).map((tpl) => ({
+    id: tpl.id,
+    name: tpl.name,
+    description: tpl.description,
+    category: tpl.category,
+    defaultVerifyCmd: tpl.defaultVerifyCmd
+  }));
+}
+
+/**
+ * Synthesizes a structured task envelope from a web template with exploration budget and critic guidance.
+ * @param {string} templateId
+ * @param {object} [userParams={}]
+ * @param {object} [options={}]
+ * @returns {{
+ *   templateId: string,
+ *   title: string,
+ *   prompt: string,
+ *   verifyCmd: string,
+ *   explorationBudget: boolean,
+ *   criticFocus: Array<string>,
+ *   fullEnvelope: string
+ * }}
+ */
+export function synthesizeWebEnvelope(templateId, userParams = {}, options = {}) {
+  const tpl = getWebTemplate(templateId);
+  if (!tpl) {
+    throw new Error(`Unknown web template '${templateId}'. Available: ${Object.keys(WEB_TEMPLATES).join(", ")}`);
+  }
+
+  const mergedParams = { ...tpl.defaultParams, ...userParams };
+  const promptBody = tpl.generatePrompt(mergedParams);
+  const verifyCmd = options.verifyCmd || userParams.verifyCmd || tpl.defaultVerifyCmd;
+  const title = userParams.title || `[${tpl.category}] ${tpl.name}`;
+
+  const explorationBudget = options.explorationBudget !== false;
+  const criticGuidance = options.criticGuidance !== false;
+
+  const lines = [];
+  lines.push(`# ${title}`);
+  lines.push("");
+
+  if (explorationBudget) {
+    lines.push("## Google Labs Exploration Budget Protocol (3-Phase Discovery)");
+    lines.push("To maximize diagnostic accuracy (Hit@5 57%), execute this task in 3 distinct phases:");
+    lines.push("1. **PHASE 1: DISCOVERY & SYMBOL TRACING (Stay Silent, Write NO Code)**");
+    lines.push("   - Read target component files, CSS definitions, imports, and existing test specs.");
+    lines.push("   - Formulate diagnostic hypothesis and verify symbol signatures before planning edits.");
+    lines.push("2. **PHASE 2: ORACLE & TEST FORMULATION**");
+    lines.push(`   - Run baseline verification: \`${verifyCmd}\`.`);
+    lines.push("   - Identify exact assertions or metrics that must turn green.");
+    lines.push("3. **PHASE 3: IMPLEMENTATION & VERIFICATION**");
+    lines.push("   - Apply minimal, surgical code modifications.");
+    lines.push(`   - Execute \`${verifyCmd}\` and verify 100% clean exit code 0.`);
+    lines.push("");
+  }
+
+  lines.push("## Task Objective & Specifications");
+  lines.push(promptBody);
+  lines.push("");
+
+  if (criticGuidance && tpl.criticFocus && tpl.criticFocus.length > 0) {
+    lines.push("## Internal Critic Agent Focus Areas (Adversarial Pre-Review)");
+    lines.push("Before finalizing the pull request, verify that the patch satisfies:");
+    for (const item of tpl.criticFocus) {
+      lines.push(`- [ ] ${item}`);
+    }
+    lines.push("");
+  }
+
+  lines.push("## Hard Verification Gates");
+  lines.push(`- **Verification Command**: \`${verifyCmd}\` (Must exit cleanly with code 0)`);
+  lines.push("- **Asset Integrity**: Zero missing images, broken fonts (.woff2), or corrupted static assets.");
+  lines.push("- **Diff Payload Governor**: Keep total diff under 75 KB (\`git diff | wc -c\`).");
+  lines.push("- **No Test Weakening**: Never delete assertions or skip tests to force a pass.");
+
+  return {
+    templateId: tpl.id,
+    title,
+    prompt: promptBody,
+    verifyCmd,
+    explorationBudget,
+    criticFocus: tpl.criticFocus,
+    fullEnvelope: lines.join("\n")
+  };
+}

package/src/wizard-task.mjs

@@ -7,6 +7,7 @@ import { getQueueDir } from "./state.mjs";
 import { scanCodebaseForTodos } from "../scripts/jules-scan-todos.mjs";
 import { select, input, confirm, spinner, isTTY } from "./tui.mjs";
 import { scorePromptFalsifiability } from "./task-optimizer.mjs";
+import { getWebTemplate, synthesizeWebEnvelope } from "./web-templates.mjs";
 
 export const GUARDRAIL_FOOTER = `
 ---
@@ -22,6 +23,7 @@ const TRIVIAL_ORACLES = new Set(["true", "echo", ":", "false", "exit 0", "exit 1
 
 /**
  * Pure planning core for task creation & envelope synthesis.
+ * Supports web task templates, exploration budgets, and critic agent steering.
  * @param {string} root
  * @param {object} inputObj
  * @returns {{
@@ -39,9 +41,27 @@ const TRIVIAL_ORACLES = new Set(["true", "echo", ":", "false", "exit 0", "exit 1
 export function planTaskCreate(root = process.cwd(), inputObj = {}) {
   const config = loadConfig(root);
 
-  const title = inputObj.title || "Agent Task";
-  const rawPrompt = inputObj.prompt || "";
-  const verifyCmd = (inputObj.verifyCmd || config.verify.test || config.verify.build || "").trim();
+  let title = inputObj.title;
+  let rawPrompt = inputObj.prompt || "";
+  let verifyCmd = (inputObj.verifyCmd || config.verify.test || config.verify.build || "").trim();
+
+  // 0. Process Template if specified
+  if (inputObj.template) {
+    const tpl = getWebTemplate(inputObj.template);
+    if (!tpl) {
+      throw new Error(`Unknown task template '${inputObj.template}'.`);
+    }
+    const synthesized = synthesizeWebEnvelope(inputObj.template, inputObj.templateParams || {}, {
+      verifyCmd: inputObj.verifyCmd,
+      explorationBudget: inputObj.explorationBudget,
+      criticGuidance: inputObj.criticGuidance
+    });
+    rawPrompt = rawPrompt ? `${rawPrompt}\n\n${synthesized.prompt}` : synthesized.fullEnvelope;
+    if (!title) title = synthesized.title;
+    if (!verifyCmd) verifyCmd = synthesized.verifyCmd;
+  }
+
+  if (!title) title = "Agent Task";
 
   // 1. Falsifiability check
   if (!rawPrompt.trim()) {
@@ -61,7 +81,9 @@ export function planTaskCreate(root = process.cwd(), inputObj = {}) {
   if (!secretScan.ok) {
     secretScan.findings.forEach((f) => secretFindings.push({ id: f.type || f.id || "SECRET_LEAK", ...f }));
   }
-  if (shannonEntropy(rawPrompt) > 4.5 && !inputObj.allowHighEntropy) {
+  const hasHighEntropyToken = rawPrompt.split(/\s+/).some((token) => token.length >= 20 && shannonEntropy(token) > 4.3);
+  const isShortHighEntropy = rawPrompt.length <= 120 && shannonEntropy(rawPrompt) > 4.5;
+  if ((hasHighEntropyToken || isShortHighEntropy) && !inputObj.allowHighEntropy) {
     secretFindings.push({ id: "HIGH_ENTROPY_PROMPT", line: 1 });
   }