jules-orchestrator-kit 0.38.2 → 0.41.0

package/src/web-templates.mjs

@@ -14,7 +14,8 @@ export const WEB_TEMPLATES = {
       "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."
+      "Verify that critical CSS is not blocked by third-party analytics or non-critical scripts.",
+      "Ensure server:defer / dynamic deferrals are NOT applied to static marketing prose or static landing components."
     ],
     defaultParams: {
       lcpMaxMs: 1200,
@@ -41,8 +42,9 @@ export const WEB_TEMPLATES = {
 ### 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.`;
+3. Wrap below-the-fold heavy dynamic components in lazy-loading.
+4. Ensure zero content shifts during font swaps or dynamic component mounting.
+5. Invariant: Do NOT apply server-deferral / streaming to static marketing text; reserve for heavy dynamic data.`;
     }
   },
 
@@ -131,7 +133,8 @@ export const WEB_TEMPLATES = {
       "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."
+      "Confirm snapshot assertions use appropriate pixel threshold tolerance to avoid flaky anti-aliasing failures.",
+      "Ensure tests execute cleanly in headless CI environments without requiring active X11/Wayland display servers."
     ],
     defaultParams: {
       viewports: "Mobile (375x667), Tablet (768x1024), Desktop (1440x900)",
@@ -146,18 +149,54 @@ export const WEB_TEMPLATES = {
 
 ### Test Harness & Assertion Criteria:
 1. **Multi-Viewport Coverage**: Test and capture snapshots across: ${viewports}.
-2. **Responsive Invariants**:
+2. **Headless Sandbox Invariant**: Ensure all Playwright runs specify headless execution compatible with remote CI sandboxes.
+3. **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**:
+4. **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**:
+5. **Visual Snapshots**:
    - Verify visual snapshots pass with \`expect(page).toHaveScreenshot()\`.`;
     }
   },
 
+  "agent-dead-code-audit": {
+    id: "agent-dead-code-audit",
+    name: "Dead Code Audit & Safe Removal Protocol",
+    description: "Audit unused exports and dead code with the Audit-First Principle to prevent deleting dynamic runtime dependencies.",
+    defaultVerifyCmd: "npm test",
+    category: "Refactoring & Audit",
+    criticFocus: [
+      "Verify that flagged 'unused' exports are not dynamically imported at runtime or registered in dynamic router/plugin maps.",
+      "Ensure the audit generates a structured report (.agent/reports/dead-code-audit.md) with confidence ratings before applying destructive file deletions.",
+      "Check that zero core library entry points or framework-specific file-based routes are accidentally removed.",
+      "Confirm all surviving test suites and typechecks pass with 0 errors after any proposed removal."
+    ],
+    defaultParams: {
+      targetScope: "apps/ or src/",
+      toolName: "Knip / ts-prune"
+    },
+    generatePrompt: (params = {}) => {
+      const scope = params.targetScope || "src/";
+      const tool = params.toolName || "Knip";
+      const customGoal = params.goal ? `\n- **Target Focus**: ${params.goal}` : "";
+
+      return `Perform an Audit-First dead code inspection and safe cleanup for ${scope} using ${tool}.${customGoal}
+
+### Audit-First Safe Refactoring Invariants:
+1. **Report Before Delete (Audit-First Principle)**:
+   - Generate a markdown audit report at \`.agent/reports/dead-code-audit.md\` detailing suspected unused files/exports and confidence levels (High / Medium / Low).
+   - DO NOT delete files or exports with dynamic runtime references (e.g. Astro/Next.js dynamic routes, plugin registries, CMS schemas).
+2. **Conservative Scope**:
+   - Only remove files verified to have 0 dynamic or static references.
+   - When in doubt, document the finding in the audit report rather than deleting.
+3. **Verification**:
+   - Run typecheck and unit tests to ensure zero broken call sites.`;
+    }
+  },
+
   "web-flaky-heal": {
     id: "web-flaky-heal",
     name: "Playwright / Async Flakiness Auto-Healer",
@@ -320,6 +359,332 @@ Add a repository-local test (no network access) that:
 
 The test must fail on a hand-broken fixture before you consider it done.`;
     }
+  },
+
+  "agent-qa-mutation": {
+    id: "agent-qa-mutation",
+    name: "Agent Test Quality & Mutation Falsification",
+    description: "Audit agent-authored tests by deliberately mutating code under test to prove assertions fail on real defects.",
+    defaultVerifyCmd: "npm test",
+    category: "Quality & Testing",
+    criticFocus: [
+      "Ensure tests assert actual returned values and behaviors, not trivial shape checks (e.g. toBeDefined, assertTrue, status == 200).",
+      "Verify that no test mocks the unit or function under test (mocking the subject under test measures only the mock).",
+      "Confirm that every newly added test was proven to fail (turn red) when the underlying production logic was deliberately mutated.",
+      "Ensure collected test count matches actual test count, and reconcile any skipped or deleted tautological tests."
+    ],
+    defaultParams: {
+      targetTestDir: "test/",
+      mutationStrategy: "invert conditions, drop return fields, alter numeric constants"
+    },
+    generatePrompt: (params = {}) => {
+      const testDir = params.targetTestDir || "test/";
+      const strategy = params.mutationStrategy || "invert conditions, drop return fields, alter numeric constants";
+      const customGoal = params.goal ? `\n- **Target Focus**: ${params.goal}` : "";
+
+      return `Audit and falsify agent-authored tests in '${testDir}'.${customGoal}
+
+### Mutation & Assertion Quality Invariants:
+1. **Prove Each Test Can Fail (Mutation Falsification)**:
+   - For every test in scope, deliberately introduce a defect into the code under test (${strategy}), run only that test, and confirm it turns red.
+   - Immediately revert every deliberate code mutation before proceeding to the next test.
+   - A test nobody has seen fail is an unverified assumption; delete or rewrite tests that remain green under deliberate mutation.
+2. **Eliminate Vacuous & Tautological Checks**:
+   - Strip tests that mock the subject under test (measuring the mock rather than the implementation).
+   - Replace shallow shape assertions (\`toBeDefined()\`, \`assertTrue(result)\`, \`is not None\`) with precise value assertions derived from requirements.
+3. **Reconcile Collected vs Passed Counts**:
+   - Compare test runner collected test count against actual test function count to detect uncollected or silently ignored test files.
+   - Document every deleted tautological test with its specific failure mode.`;
+    }
+  },
+
+  "agent-ci-falsify": {
+    id: "agent-ci-falsify",
+    name: "CI Pipeline Falsification & Exit Code Guard",
+    description: "Audit CI pipeline steps to eliminate swallowed exit codes, vacuous passes, or skipped checks.",
+    defaultVerifyCmd: "npm test",
+    category: "CI & Infrastructure",
+    criticFocus: [
+      "Verify no command discards exit codes via un-guarded pipes (e.g. \`cmd | tee out.txt\` without pipefail) or \`|| true\`.",
+      "Check that test runners fail when matching 0 test files instead of exiting cleanly with code 0.",
+      "Ensure CI matrix legs and path filters (\`paths:\`, \`if:\`) have not silently excluded required verification checks.",
+      "Confirm every CI check prints explicit item counts/coverage rather than bare unverified pass status."
+    ],
+    defaultParams: {
+      workflowPath: ".github/workflows/"
+    },
+    generatePrompt: (params = {}) => {
+      const workflowPath = params.workflowPath || ".github/workflows/";
+      const customGoal = params.goal ? `\n- **Target Focus**: ${params.goal}` : "";
+
+      return `Audit and harden CI/CD workflows in '${workflowPath}' against silent passes and swallowed exit codes.${customGoal}
+
+### Pipeline Integrity Invariants:
+1. **Zero Swallowed Exit Codes**:
+   - Eliminate \`|| true\`, \`continue-on-error: true\` (unless justified in an adjacent comment), and \`set +e\` workarounds.
+   - Ensure all shell pipes preserve non-zero exit statuses (e.g. \`set -o pipefail\` in bash steps).
+2. **Falsifiable Step Execution**:
+   - Verify test discovery patterns do not exit 0 on empty matches (e.g. runners reporting '0 tests collected' must fail).
+   - Ensure every check step logs explicit processed item counts (tests executed, files linted, types checked).
+3. **Trigger & Filter Integrity**:
+   - Audit \`paths:\` and \`if:\` conditional expressions to ensure no critical security, typecheck, or test jobs are bypassed.`;
+    }
+  },
+
+  "agent-service-isolate": {
+    id: "agent-service-isolate",
+    name: "Cold Sandbox Test Isolation & Service Decoupling",
+    description: "Decouple test suites from live databases, external network services, or background daemons at existing architecture seams.",
+    defaultVerifyCmd: "npm test",
+    category: "Testing & Architecture",
+    criticFocus: [
+      "Verify default test runner executes cleanly from cold with zero live databases, Docker daemons, or network connections.",
+      "Ensure assertions are never weakened or deleted to simulate passing service calls.",
+      "Confirm tests that genuinely require live external services are explicitly marked/tagged and documented.",
+      "Verify test isolation seams use existing repository abstractions/interfaces rather than brute monkey-patching."
+    ],
+    defaultParams: {
+      targetServices: "databases, caches, third-party network APIs"
+    },
+    generatePrompt: (params = {}) => {
+      const services = params.targetServices || "databases, caches, third-party network APIs";
+      const customGoal = params.goal ? `\n- **Target Focus**: ${params.goal}` : "";
+
+      return `Decouple test suite from external service dependencies (${services}) for reliable sandbox execution.${customGoal}
+
+### Sandbox Decoupling Invariants:
+1. **Zero Live Service Requirement for Default Suite**:
+   - The default test command must pass from cold with zero background daemons, databases, or external network connectivity.
+   - Fake external dependencies at existing boundary seams and repository interfaces.
+2. **No Test Assertion Weakening**:
+   - Never weaken assertions or delete checks to simulate service responses; retain exact expectation semantics.
+3. **Explicit Isolation Markers**:
+   - Categorize and tag integration tests requiring live services with explicit test runner markers (e.g. \`@integration\`, \`[live-service]\`).
+   - Provide a separate, documented command for executing live integration suites.`;
+    }
+  },
+
+  "agent-error-paths": {
+    id: "agent-error-paths",
+    name: "Error Path & Failure Recovery Stress Test",
+    description: "Exercise unexecuted error paths, catch blocks, and retry loops by intentionally inducing real failure conditions.",
+    defaultVerifyCmd: "npm test",
+    category: "Resilience & Security",
+    criticFocus: [
+      "Verify broad \`catch (e)\` or \`except Exception\` blocks do not swallow fatal runtime bugs or misspellings.",
+      "Confirm retry loops are bounded, backoff properly, and only operate on strictly idempotent actions.",
+      "Ensure error fallbacks fail in the safe/restrictive direction (e.g. denying permissions if auth check is unreachable).",
+      "Check that error messages clearly state the failed component, input, and actionable remedy."
+    ],
+    defaultParams: {
+      targetModules: "src/"
+    },
+    generatePrompt: (params = {}) => {
+      const modules = params.targetModules || "src/";
+      const customGoal = params.goal ? `\n- **Target Focus**: ${params.goal}` : "";
+
+      return `Audit, exercise, and harden error recovery paths and catch handlers in '${modules}'.${customGoal}
+
+### Resilience & Error Handling Invariants:
+1. **Execute Every Catch Block Under Real Failure Conditions**:
+   - Test error handlers by inducing real failure conditions (closed socket, invalid schema, full disk, revoked token) rather than only reasoning about them.
+   - Narrow overly broad \`catch (e)\` / \`except Exception\` blocks to catch only expected operational error types.
+2. **Safe Fallback Direction**:
+   - Ensure fallback branches fail in the restrictive/safe direction (e.g. permission checks must deny access on error, never allow).
+3. **Bounded Idempotent Retries**:
+   - Verify all retry mechanisms enforce maximum attempt caps, exponential backoff with jitter, and only retry idempotent operations.
+4. **Actionable Error Telemetry**:
+   - Ensure logged error messages specify the failed subsystem, input context, and actionable diagnostic guidance.
+5. **Standalone Schema & Validation Testing**:
+   - When asserting schema validation error messages, export and test standalone validation schemas (e.g. \`schema.safeParse()\`) directly in unit tests rather than relying on heavyweight framework action mocks that may mask validation errors.`;
+    }
+  },
+
+  "agent-security-audit": {
+    id: "agent-security-audit",
+    name: "Agent-Authored Code Security & Permission Audit",
+    description: "Audit agent changes for TLS validation bypasses, hardcoded test credentials in repo history, and excessive workflow permissions.",
+    defaultVerifyCmd: "npm test",
+    category: "Security & Permissions",
+    criticFocus: [
+      "Verify zero TLS certificate verification bypasses (\`rejectUnauthorized: false\`, \`NODE_TLS_REJECT_UNAUTHORIZED=0\`, \`verify=False\`).",
+      "Check that no synthetic API keys, tokens, or private keys are committed in fixtures, configs, or git history.",
+      "Ensure GitHub Actions workflows and tokens are scoped to minimum necessary permissions (never \`permissions: write-all\`).",
+      "Confirm all string interpolations in SQL queries, shell commands, or HTML templates are properly escaped or parameterized."
+    ],
+    defaultParams: {
+      diffRange: "HEAD~1..HEAD"
+    },
+    generatePrompt: (params = {}) => {
+      const diffRange = params.diffRange || "HEAD~1..HEAD";
+      const customGoal = params.goal ? `\n- **Target Focus**: ${params.goal}` : "";
+
+      return `Conduct a targeted security audit of agent-authored modifications in diff '${diffRange}'.${customGoal}
+
+### Agent Code Security Invariants:
+1. **Zero Transport & TLS Bypasses**:
+   - Strictly prohibit disabling TLS validation (\`rejectUnauthorized: false\`, \`NODE_TLS_REJECT_UNAUTHORIZED=0\`, \`verify=False\`, \`--no-check-certificate\`).
+2. **Credential & Secret Scrubbing**:
+   - Verify zero synthetic or real API tokens, passwords, or private keys in test fixtures, examples, or commit history.
+3. **Least Privilege CI Permissions**:
+   - Ensure CI workflows declare minimum explicit permissions; flag any \`permissions: write-all\` or unconstrained token scopes.
+4. **Injection Prevention**:
+   - Verify zero un-sanitized string concatenations in database queries, child process executions, file path resolutions, or HTML rendering.`;
+    }
+  },
+
+  "deep-debug": {
+    id: "deep-debug",
+    name: "Deep Debug & Concurrency Race Condition Resolver",
+    description: "Deep root-cause exploration, async call-graph mapping, and deterministic reproduction of race conditions.",
+    defaultVerifyCmd: "npm test",
+    category: "Deep Think",
+    criticFocus: [
+      "Verify that async race conditions or timing bugs are deterministically reproduced with a failing test before applying fixes.",
+      "Check for lock contention, unhandled promise rejections, and memory retention in async state buffers.",
+      "Confirm mutation falsification: inverting the fix logic turns the reproduction test red.",
+      "Ensure zero new third-party dependencies and complete cross-platform timing parity (Linux/macOS/Windows)."
+    ],
+    defaultParams: {
+      targetPath: "src/",
+      issueSummary: "state desynchronization or race condition"
+    },
+    generatePrompt: (params = {}) => {
+      const target = params.targetPath || "src/";
+      const issue = params.issueSummary || params.goal || "state desynchronization or race condition";
+      const customGoal = params.goal && params.goal !== issue ? `\n- **Target Focus**: ${params.goal}` : "";
+
+      return `Diagnose and surgically resolve concurrency/state race condition in '${target}': ${issue}.${customGoal}
+
+### Deep Debug Protocol (Exploration & Oracle First):
+1. **Silent Discovery & Call-Graph Tracing**:
+   - Trace the lifecycle, state transitions, and async call graph across '${target}'.
+   - Map out all concurrent read/write paths, shared buffers, or event-loop ticks where state desync occurs.
+   - Do NOT write production code until the root-cause hypothesis is verified.
+2. **Deterministic Reproduction Oracle**:
+   - Formulate a deterministic test in the test suite reproducing the race condition under load or async delay.
+   - Verify the reproduction test FAILS cleanly (RED) against current code.
+3. **Surgical Implementation & Positive Perimeter**:
+   - Implement the minimal, zero-dependency fix using native runtime built-ins only.
+   - Confine modifications strictly to the identified faulty module and its test suite.
+4. **Mutation Falsification**:
+   - Invert the boolean or lock condition in your fix to prove the reproduction test turns RED (falsifiability proof).`;
+    }
+  },
+
+  "deep-feature": {
+    id: "deep-feature",
+    name: "Deep Feature TDD & Oracle Architecture",
+    description: "Oracle-first TDD architecture, contract discovery, and positive perimeter implementation.",
+    defaultVerifyCmd: "npm test",
+    category: "Deep Think",
+    criticFocus: [
+      "Ensure contract discovery aligns with existing repo error patterns ({ ok, code, error }) and JSDoc.",
+      "Verify boundary condition coverage (null/undefined, oversized buffers, empty inputs, proto-pollution).",
+      "Confirm positive operational perimeter: no edits outside designated target and test files.",
+      "Ensure clean type check, linting, and 100% test pass rate."
+    ],
+    defaultParams: {
+      featureName: "New Module Feature",
+      targetModule: "src/"
+    },
+    generatePrompt: (params = {}) => {
+      const feature = params.featureName || params.goal || "New Module Feature";
+      const modulePath = params.targetModule || "src/";
+      const customGoal = params.goal && params.goal !== feature ? `\n- **Target Focus**: ${params.goal}` : "";
+
+      return `Implement '${feature}' in '${modulePath}' using Oracle-First TDD Architecture.${customGoal}
+
+### Deep Feature TDD Protocol:
+1. **Contract & Interface Discovery**:
+   - Inspect adjacent modules in '${modulePath}' to match conventions, error schemas, and signatures.
+   - Define the public API contract before writing code.
+2. **TDD Oracle Formulation (Red Phase)**:
+   - Author comprehensive unit tests covering happy paths, boundary conditions, and invalid inputs.
+   - Run the test suite and confirm that newly added tests fail with expected assertions (RED).
+3. **Surgical Implementation (Green Phase)**:
+   - Implement the feature using native built-in modules only (zero new third-party dependencies).
+   - Normalize all filesystem paths for cross-platform support.
+4. **Adversarial Critic Review**:
+   - Verify memory allocations, recursion depth, and stream backpressure.
+   - Ensure 100% clean test passes with 0 lint errors across all supported platforms.`;
+    }
+  },
+
+  "deep-optimize": {
+    id: "deep-optimize",
+    name: "Deep Benchmark-Gated Performance Optimization",
+    description: "Profiling-first optimization with 5-run median benchmark gate (>=20% throughput or >=30% RAM improvement).",
+    defaultVerifyCmd: "npm test",
+    category: "Deep Think",
+    criticFocus: [
+      "Verify 5-run median benchmark comparison before and after the change.",
+      "Ensure byte-for-byte behavioral parity and zero regressions in the existing test suite.",
+      "Check for memory leaks, recursion stack limits, and catastrophic regex backtracking (O(N^2)).",
+      "Validate that hot loop optimizations do not sacrifice readability or error handling."
+    ],
+    defaultParams: {
+      targetModule: "src/",
+      metricTarget: ">=20% throughput improvement or >=30% memory reduction"
+    },
+    generatePrompt: (params = {}) => {
+      const target = params.targetModule || "src/";
+      const metric = params.metricTarget || ">=20% throughput improvement or >=30% memory reduction";
+      const customGoal = params.goal ? `\n- **Target Focus**: ${params.goal}` : "";
+
+      return `Optimize runtime execution time and memory footprint of '${target}'.${customGoal}
+
+### Benchmark-Gated Optimization Protocol:
+1. **Profiling & Baseline Measurement**:
+   - Trace hot paths, object allocations inside loops, and redundant I/O in '${target}'.
+   - Establish a reproducible benchmark measuring execution time (median of 5 runs) and heap memory.
+2. **Algorithmic Refactoring**:
+   - Eliminate redundant cloning, regex re-compilations, synchronous disk roundtrips, or O(N^2) lookups.
+   - Maintain 100% byte-for-byte behavioral parity with the existing implementation.
+3. **Benchmark Gate Verification**:
+   - Target Metric: ${metric}.
+   - Execute 5 consecutive benchmark runs to confirm statistically significant gains over baseline.
+4. **Behavioral Integrity Check**:
+   - Run the full test suite to guarantee zero regression or semantic drift.`;
+    }
+  },
+
+  "deep-harden": {
+    id: "deep-harden",
+    name: "Deep Adversarial Hardening & Chaos Mutation",
+    description: "Threat modeling, atomic I/O (safeAtomicWrite), chaos/fuzz injection, and structured error invariant gates.",
+    defaultVerifyCmd: "npm test",
+    category: "Deep Think",
+    criticFocus: [
+      "Verify TOCTOU safety and atomic file operations (temporary file + rename) for state persistence.",
+      "Check resistance to unicode smuggling, escape code stripping, and path traversal (<traversal>).",
+      "Ensure zero empty catch blocks or optimistic defaults returned from corrupt state.",
+      "Confirm mutation falsification: deliberately invalidating security checks triggers instant test failure."
+    ],
+    defaultParams: {
+      targetSubsystem: "src/",
+      threatFocus: "malformed inputs, torn writes, unhandled runtime exceptions"
+    },
+    generatePrompt: (params = {}) => {
+      const target = params.targetSubsystem || "src/";
+      const threat = params.threatFocus || "malformed inputs, torn writes, unhandled runtime exceptions";
+      const customGoal = params.goal ? `\n- **Target Focus**: ${params.goal}` : "";
+
+      return `Adversarially harden '${target}' against ${threat}.${customGoal}
+
+### Adversarial Hardening Protocol:
+1. **Threat Modeling & Vulnerability Tracing**:
+   - Audit atomic I/O: Ensure file writes use safe atomic writes (temp file + rename) to prevent torn state on crash.
+   - Audit sanitization: Verify resistance against Unicode smuggling, ANSI escape injections, and traversal paths.
+   - Audit error propagation: Replace silent catch blocks with clinical, structured error objects.
+2. **Chaos & Fuzz Test Authorship**:
+   - Author stress tests feeding proto-pollution payloads, oversized binary buffers, and simulated SIGKILL interruptions.
+   - Verify that all failure conditions emit structured error codes rather than crashing.
+3. **Mutation Falsification Gate**:
+   - Invert security checks deliberately to prove the new tests fail immediately (kill the mutant).
+4. **Regression Verification**:
+   - Ensure 100% of existing and new tests pass cleanly with zero errors.`;
+    }
   }
 };
 

package/src/wizard-init.mjs

@@ -116,7 +116,11 @@ export const BUILTIN_PRESETS = [
  */
 export function planInit(root = process.cwd(), options = {}) {
   const oracle = detectStackOracles(root);
-  const tierName = options.tier || "pro";
+  // Scaffolding `pro` for a caller who never stated a plan hands a free account
+  // a 100-task budget and 8 concurrent workers it does not have. The same
+  // reasoning makes FALLBACK_TIER conservative in loadConfig(); the wizard has
+  // to agree with it or the manifest guards a ceiling the runtime does not.
+  const tierName = options.tier || FALLBACK_TIER;
   // An unrecognised name resolves the same way loadConfig() resolves it, so the
   // scaffolded limits always match what the runtime will later enforce.
   const limits = TIER_PROFILES[tierName] || TIER_PROFILES[FALLBACK_TIER];
@@ -233,7 +237,7 @@ export async function runInitWizard(root = process.cwd(), options = {}) {
     throw new Error("Non-interactive init requires explicit options or allowDefaults: true");
   }
 
-  let selectedTier = options.tier || existingConfig.tier || "pro";
+  let selectedTier = options.tier || existingConfig.tier || FALLBACK_TIER;
   let testCmd = options.testCmd;
   let buildCmd = options.buildCmd;
   let selectedPresets = options.presets;
@@ -290,12 +294,18 @@ export async function runInitWizard(root = process.cwd(), options = {}) {
     }
   }
 
+  // `...options` first, for the same reason as in wizard-task.mjs: spreading it
+  // last let a caller-supplied `tier` overwrite the plan the user picked from
+  // the menu, so selecting Free or Ultra silently wrote whatever the CLI had
+  // passed. `selectedTier` is seeded from `options.tier`, so an explicit
+  // `--tier` still wins — it just wins by seeding the menu instead of by
+  // discarding the answer.
   const plan = planInit(root, {
+    ...options,
     tier: selectedTier,
     testCmd,
     buildCmd,
     presets: selectedPresets,
-    ...options,
   });
 
   // Atomic write plan

package/src/wizard-task.mjs

@@ -9,15 +9,78 @@ 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 = `
+/**
+ * Maximum protected paths to name in a prompt before summarising.
+ *
+ * The list is there to steer the agent, not to be exhaustive — the gate is what
+ * enforces it. Past ~12 entries the footer starts crowding the task itself,
+ * which is the attention-drift failure `.agent/rules/jules-protocol.md` rule 16
+ * warns about.
+ */
+const FOOTER_PROTECTED_LIMIT = 12;
+
+/**
+ * Builds the hard-constraints footer appended to every dispatched task.
+ *
+ * The protected-path line is derived from the repository's resolved scope
+ * rather than written as a literal. It used to read "Do NOT modify
+ * package.json, pnpm-lock.yaml, tsconfig.json" for every project, which was
+ * both wrong and misleading in a Rust, Go, Python or PHP repo — while
+ * `BUILTIN_PROTECT` in config.mjs already listed `Cargo.toml`, `go.mod`,
+ * `pyproject.toml` and `composer.json` for the gate. The kit knew the right
+ * answer and told the agent a different one, so the agent could edit a file the
+ * gate would then reject, burning a repair turn on an avoidable violation.
+ *
+ * @param {object} [config] - Loaded config; `scope.protect`/`scope.deny` drive the output.
+ * @param {object} [opts]
+ * @param {string} [opts.baseBranch] - Branch to rebase onto before opening the PR.
+ * @param {number} [opts.diffKb] - Diff payload ceiling in KB.
+ * @returns {string}
+ */
+export function buildGuardrailFooter(config = {}, opts = {}) {
+  const baseBranch = opts.baseBranch || config.baseBranch || "main";
+  const diffKb = opts.diffKb || config.limits?.diffKb || 75;
+
+  const scope = config.scope || {};
+
+  // Key material and git internals are enforced by the gate but pointless to
+  // name here: no agent was going to edit `id_rsa`, and each entry spends
+  // footer budget that the build manifests actually need.
+  const NOT_WORTH_NAMING = /^(\.git\/|\*\*\/\.env|\*\*\/\*\.(pem|key|p12|pfx)$|\*\*\/id_rsa|\*\*\/\.npmrc|\*\*\/\.netrc|\*\.(pem|key)$|id_rsa)/;
+
+  // `protect` comes first because that is where the stack's build manifests
+  // live — `Cargo.toml`, `go.mod`, `pyproject.toml`, `composer.json` — and
+  // those are the files an agent actually reaches for and must be warned off.
+  const paths = [...new Set(
+    [...(scope.protect || []), ...(scope.deny || [])]
+      .filter((p) => typeof p === "string" && p.trim() && !NOT_WORTH_NAMING.test(p))
+      .map((p) => p.replace(/^\*\*\//, ""))
+  )];
+
+  const shown = paths.slice(0, FOOTER_PROTECTED_LIMIT);
+  const remainder = paths.length - shown.length;
+  const protectedLine = shown.length
+    ? `- Do NOT modify these protected paths: ${shown.join(", ")}${remainder > 0 ? `, and ${remainder} more (run \`agentctl gate\` to see the full set)` : ""}.`
+    : "- Do NOT modify build configuration, lockfiles, or CI workflow files.";
+
+  return `
 ---
 HARD CONSTRAINTS:
-- Do NOT modify package.json, pnpm-lock.yaml, tsconfig.json, or .github/ files.
-- Diff Payload Governor: Keep total diff payload under 75 KB (\`git diff | wc -c\`).
+${protectedLine}
+- Diff Payload Governor: Keep total diff payload under ${diffKb} KB (\`git diff | wc -c\`).
 - Falsifiable & Evidence-Based: Attach full terminal verification output to PR. Never weaken assertions or delete failing tests to force a pass.
 - Read-Before-Write: Inspect existing symbol signatures, definitions, and call sites before making edits.
-- BEFORE opening the PR: Run \`git fetch origin main && git rebase origin/main\`, then re-verify.
+- Remove any scratch files you created for debugging before submitting. Do not delete files that are part of the project.
+- BEFORE opening the PR: Run \`git fetch origin ${baseBranch} && git rebase origin/${baseBranch}\`, then re-verify.
 `;
+}
+
+/**
+ * Stack-neutral fallback for callers with no config in hand.
+ * Prefer `buildGuardrailFooter(config)`, which names the repository's real
+ * protected paths instead of guessing at an ecosystem.
+ */
+export const GUARDRAIL_FOOTER = buildGuardrailFooter();
 
 const TRIVIAL_ORACLES = new Set(["true", "echo", ":", "false", "exit 0", "exit 1", "echo ok"]);
 
@@ -139,7 +202,7 @@ ${rawPrompt}
 [VERIFICATION ORACLE]
 Test/Verification Command: ${verifyCmd || "(None)"}
 
-${GUARDRAIL_FOOTER}`;
+${buildGuardrailFooter(config)}`;
 
   const promptAnalysis = scorePromptFalsifiability(rawPrompt, { rootDir: root, verifyCmd });
 
@@ -245,14 +308,21 @@ export async function runTaskCreateWizard(root = process.cwd(), options = {}) {
     repoless = await confirm("Dispatch in Repoless mode (no repo source context)?", false, options);
   }
 
+  // `...options` must come first. It used to come last, and because the CLI
+  // builds its options object from parseArgs — every key present, every unpassed
+  // flag `undefined` — spreading it afterwards overwrote each answer the user
+  // had just typed with `undefined`. `agentctl task create` then died on
+  // "Task prompt cannot be empty" no matter what was entered. The locals below
+  // are all seeded from `options`, so putting them last preserves flag values
+  // while letting an interactive answer win.
   const plan = planTaskCreate(root, {
+    ...options,
     title,
     prompt: promptText,
     verifyCmd,
     autoPr,
     requirePlanApproval,
     repoless,
-    ...options,
   });
 
   // Perform Gate Preflight