Merge remote-tracking branch 'origin/main' into garrytan/workspace-aware-ship

Rebumped v1.8.0.0 -> v1.11.0.0 (minor-past main's v1.10.1.0) using
bin/gstack-next-version — the same queue-aware path this branch introduces.
CHANGELOG repositioned so v1.11.0.0 sits above main's new entries
(v1.10.1.0 / v1.10.0.0 / v1.9.0.0).

Conflicts resolved:
- VERSION, package.json: rebumped to v1.11.0.0 (util-picked)
- bin/gstack-config: merged both lists (workspace_root + gbrain keys)
- CHANGELOG.md: hoisted v1.11.0.0 entry above main's new entries

Pre-existing failures in main (4) documented but not fixed in this PR:
1. gstack-brain-sync secret scan > blocks bearer-json (brain-sync tests)
2. no files larger than 2MB (security-bench fixture, already TODO'd)
3. selectTests > skill-specific change (touchfiles scoping)
4. Opus 4.7 overlay pacing directive (expectation stale after v1.10.1.0
   removed the Fan out nudge)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

test/helpers/agent-sdk-runner.ts

@@ -0,0 +1,509 @@
+/**
+ * Claude Agent SDK wrapper for the overlay-efficacy harness.
+ *
+ * This sits alongside session-runner.ts (which drives `claude -p` as a
+ * subprocess) but runs the model via the published @anthropic-ai/claude-agent-sdk
+ * instead. The SDK exposes the same harness primitives Claude Code itself uses,
+ * so overlay-driven behavior change is measured against a closer approximation
+ * of real Claude Code than the `claude -p` subprocess path provides.
+ *
+ * Explicit design rules (from plan review):
+ *   - Use SDK-exported SDKMessage types. No `| unknown` union collapse.
+ *   - Permission surface is explicit: bypassPermissions + settingSources:[] +
+ *     disallowedTools inverse. Without these, the SDK inherits user settings,
+ *     project .claude/, and local hooks, and arms are no longer comparable.
+ *   - Binary pinning via pathToClaudeCodeExecutable. Resolve with `which claude`
+ *     at setup time; the SDK would otherwise use its bundled binary.
+ *   - 3-shape rate-limit detection: thrown error, result-message error subtype,
+ *     mid-stream SDKRateLimitEvent. All three recover on retry.
+ *   - On retry, caller resets workspace via a setupWorkspace callback so
+ *     partial Bash side-effects don't contaminate the next attempt.
+ *   - Process-level semaphore caps concurrent queries across all callers in
+ *     the same bun-test process. Composes with bun's own --concurrent flag.
+ */
+
+import {
+  query,
+  type SDKMessage,
+  type SDKAssistantMessage,
+  type SDKResultMessage,
+  type SDKSystemMessage,
+  type PermissionMode,
+  type SettingSource,
+  type Options,
+} from '@anthropic-ai/claude-agent-sdk';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import type { SkillTestResult } from './session-runner';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface AgentSdkResult {
+  /** Full raw event stream for forensic recovery. */
+  events: SDKMessage[];
+  /** Assistant-typed subset, in order. */
+  assistantTurns: SDKAssistantMessage[];
+  /** Flat tool-call list, in order of emission. */
+  toolCalls: Array<{ tool: string; input: unknown; output: string }>;
+  /** Concatenated assistant text, newline-joined. */
+  output: string;
+  /** 'success' | 'error_during_execution' | 'error_max_turns' | ... */
+  exitReason: string;
+  turnsUsed: number;
+  durationMs: number;
+  firstResponseMs: number;
+  maxInterTurnMs: number;
+  costUsd: number;
+  model: string;
+  sdkVersion: string;
+  /** claude_code_version from the SDK's system/init event (authoritative). */
+  sdkClaudeCodeVersion: string;
+  /** Path to the claude binary we pinned. */
+  resolvedBinaryPath: string;
+  /** browse-error pattern scan for SkillTestResult parity. Always empty here. */
+  browseErrors: string[];
+}
+
+/** Signature matching `query()` from the SDK. DI hook for unit tests. */
+export type QueryProvider = typeof query;
+
+/** Subset of SDK Options['systemPrompt'] we support. */
+export type SystemPromptOption =
+  | string
+  | { type: 'preset'; preset: 'claude_code'; append?: string; excludeDynamicSections?: boolean };
+
+export interface RunAgentSdkOptions {
+  /**
+   * System prompt surface.
+   *   - bare string "" -> omit entirely (SDK default: no system prompt)
+   *   - bare string "...text..." -> REPLACE default with given text (use sparingly)
+   *   - { type:'preset', preset:'claude_code' } -> use Claude Code default
+   *   - { type:'preset', preset:'claude_code', append: "..." } -> default + append
+   *
+   * For overlay-efficacy measurement, the preset+append pattern is the right
+   * one: it measures "does adding overlay text to the REAL Claude Code system
+   * prompt change behavior" rather than "does the overlay alone (stripped of
+   * base scaffolding) change behavior".
+   */
+  systemPrompt: SystemPromptOption;
+  userPrompt: string;
+  workingDirectory: string;
+  model?: string;
+  maxTurns?: number;
+  allowedTools?: string[];
+  disallowedTools?: string[];
+  permissionMode?: PermissionMode;
+  settingSources?: SettingSource[];
+  env?: Record<string, string>;
+  pathToClaudeCodeExecutable?: string;
+  testName?: string;
+  runId?: string;
+  fixtureId?: string;
+  queryProvider?: QueryProvider;
+  /** Max 429 retries per call. Default 3. */
+  maxRetries?: number;
+  /**
+   * Caller provides this when retry should reset the workspace. The harness
+   * invokes it with a fresh dir after a rate-limit failure. When omitted,
+   * retries reuse the original workingDirectory (fine for read-only tests).
+   */
+  onRetry?: (freshDir: string) => void;
+}
+
+export class RateLimitExhaustedError extends Error {
+  readonly attempts: number;
+  constructor(attempts: number, cause?: unknown) {
+    super(`rate limit exhausted after ${attempts} attempts`);
+    this.name = 'RateLimitExhaustedError';
+    this.attempts = attempts;
+    if (cause !== undefined) (this as { cause?: unknown }).cause = cause;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Process-level semaphore for API concurrency
+// ---------------------------------------------------------------------------
+
+/**
+ * Bounded token bucket. Shared across all runAgentSdkTest calls in this
+ * process so that bun's --concurrent flag does not compound with in-test
+ * concurrency to blow past Anthropic's rate limits.
+ *
+ * Default capacity 3. Override via GSTACK_SDK_MAX_CONCURRENCY env var.
+ */
+class Semaphore {
+  private available: number;
+  private readonly queue: Array<() => void> = [];
+  constructor(capacity: number) {
+    this.available = capacity;
+  }
+  async acquire(): Promise<void> {
+    if (this.available > 0) {
+      this.available--;
+      return;
+    }
+    await new Promise<void>((resolve) => this.queue.push(resolve));
+  }
+  release(): void {
+    const next = this.queue.shift();
+    if (next) {
+      next();
+    } else {
+      this.available++;
+    }
+  }
+  /** For tests. Returns tokens currently in-flight. */
+  inFlight(): number {
+    // Not introspectable from outside without tracking; approximate.
+    return this.queue.length;
+  }
+}
+
+const DEFAULT_SDK_CONCURRENCY = Number(process.env.GSTACK_SDK_MAX_CONCURRENCY ?? 3);
+let _apiSemaphore: Semaphore | null = null;
+function getApiSemaphore(): Semaphore {
+  if (!_apiSemaphore) _apiSemaphore = new Semaphore(DEFAULT_SDK_CONCURRENCY);
+  return _apiSemaphore;
+}
+
+/** Test-only. Resets the process-level semaphore. */
+export function __resetSemaphoreForTests(capacity: number): void {
+  _apiSemaphore = new Semaphore(capacity);
+}
+
+// ---------------------------------------------------------------------------
+// Rate-limit detection
+// ---------------------------------------------------------------------------
+
+/** True if `err` looks like a rate-limit thrown from the SDK. */
+export function isRateLimitThrown(err: unknown): boolean {
+  if (!err || typeof err !== 'object') return false;
+  const msg = (err as { message?: string }).message ?? '';
+  const name = (err as { name?: string }).name ?? '';
+  const status = (err as { status?: number }).status;
+  return (
+    status === 429 ||
+    /rate.?limit|429|too many requests/i.test(msg) ||
+    /RateLimit/i.test(name)
+  );
+}
+
+/** True if a SDKResultMessage is a rate-limit-shaped error. */
+export function isRateLimitResult(msg: SDKMessage): boolean {
+  if (msg.type !== 'result') return false;
+  const r = msg as SDKResultMessage;
+  if (r.subtype === 'success') return false;
+  // subtype === 'error_during_execution' | 'error_max_turns' | 'error_max_budget_usd' | ...
+  if (r.subtype !== 'error_during_execution') return false;
+  const errs = (r as { errors?: string[] }).errors ?? [];
+  return errs.some((e) => /rate.?limit|429|too many requests/i.test(e));
+}
+
+/** True if mid-stream SDKRateLimitEvent indicates a blocking rate-limit. */
+export function isRateLimitEvent(msg: SDKMessage): boolean {
+  if (msg.type !== 'rate_limit_event') return false;
+  const info = (msg as { rate_limit_info?: { status?: string } }).rate_limit_info;
+  return info?.status === 'rejected';
+}
+
+/**
+ * True if `err` is the SDK's "max turns reached" throw. Some SDK versions
+ * raise this as an exception from the generator instead of emitting a
+ * result message with subtype='error_max_turns'. We treat it as terminal-
+ * but-recoverable: record what we collected and continue, rather than
+ * failing the whole run.
+ */
+export function isMaxTurnsError(err: unknown): boolean {
+  if (!err || typeof err !== 'object') return false;
+  const msg = (err as { message?: string }).message ?? '';
+  return /reached maximum number of turns|max.?turns/i.test(msg);
+}
+
+// ---------------------------------------------------------------------------
+// Version resolution (cached)
+// ---------------------------------------------------------------------------
+
+let _sdkVersionCache: string | null = null;
+function resolveSdkVersion(): string {
+  if (_sdkVersionCache) return _sdkVersionCache;
+  try {
+    const pkgPath = require.resolve('@anthropic-ai/claude-agent-sdk/package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8')) as { version?: string };
+    _sdkVersionCache = pkg.version ?? 'unknown';
+  } catch {
+    _sdkVersionCache = 'unknown';
+  }
+  return _sdkVersionCache;
+}
+
+export function resolveClaudeBinary(): string | null {
+  try {
+    return execSync('which claude', { encoding: 'utf-8' }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main runner
+// ---------------------------------------------------------------------------
+
+/**
+ * Execute a single SDK query with retries. Returns a typed result.
+ *
+ * The retry loop treats 429 as recoverable and any other error as fatal.
+ * Exponential backoff: 1s, 2s, 4s. After maxRetries failures, throws
+ * RateLimitExhaustedError so the caller can decide what to do with the run.
+ */
+export async function runAgentSdkTest(
+  opts: RunAgentSdkOptions,
+): Promise<AgentSdkResult> {
+  const sem = getApiSemaphore();
+  const maxRetries = opts.maxRetries ?? 3;
+  const queryImpl: QueryProvider = opts.queryProvider ?? query;
+  const model = opts.model ?? 'claude-opus-4-7';
+
+  let attempt = 0;
+  let lastErr: unknown = null;
+
+  while (attempt <= maxRetries) {
+    await sem.acquire();
+    const startMs = Date.now();
+
+    // Hoisted so the max-turns catch branch can synthesize a result from
+    // whatever we captured before the SDK threw.
+    const events: SDKMessage[] = [];
+    const assistantTurns: SDKAssistantMessage[] = [];
+    const toolCalls: Array<{ tool: string; input: unknown; output: string }> = [];
+    const assistantTextParts: string[] = [];
+    let firstResponseMs = 0;
+    let lastEventMs = startMs;
+    let maxInterTurnMs = 0;
+    let systemInitVersion = 'unknown';
+    let rateLimited: unknown = null;
+    let terminalResult: SDKResultMessage | null = null;
+
+    try {
+      const sdkOpts: Options = {
+        model,
+        cwd: opts.workingDirectory,
+        maxTurns: opts.maxTurns ?? 5,
+        tools: opts.allowedTools ?? ['Read', 'Glob', 'Grep', 'Bash'],
+        disallowedTools: opts.disallowedTools,
+        allowedTools: opts.allowedTools ?? ['Read', 'Glob', 'Grep', 'Bash'],
+        permissionMode: opts.permissionMode ?? 'bypassPermissions',
+        allowDangerouslySkipPermissions:
+          (opts.permissionMode ?? 'bypassPermissions') === 'bypassPermissions',
+        settingSources: opts.settingSources ?? [],
+        env: opts.env,
+        pathToClaudeCodeExecutable: opts.pathToClaudeCodeExecutable,
+      };
+      // Empty bare string means "omit entirely" (SDK runs with no override).
+      // Any object or non-empty string is passed through.
+      if (typeof opts.systemPrompt === 'object' || opts.systemPrompt !== '') {
+        sdkOpts.systemPrompt = opts.systemPrompt;
+      }
+
+      const q = queryImpl({
+        prompt: opts.userPrompt,
+        options: sdkOpts,
+      });
+
+      for await (const ev of q) {
+        const now = Date.now();
+        if (firstResponseMs === 0) firstResponseMs = now - startMs;
+        const interTurn = now - lastEventMs;
+        if (interTurn > maxInterTurnMs) maxInterTurnMs = interTurn;
+        lastEventMs = now;
+
+        events.push(ev);
+
+        if (ev.type === 'system' && (ev as SDKSystemMessage).subtype === 'init') {
+          systemInitVersion =
+            (ev as SDKSystemMessage).claude_code_version ?? 'unknown';
+        } else if (ev.type === 'assistant') {
+          const am = ev as SDKAssistantMessage;
+          assistantTurns.push(am);
+          const content = am.message?.content;
+          if (Array.isArray(content)) {
+            for (const block of content as Array<
+              | { type: 'text'; text?: string }
+              | { type: 'tool_use'; name?: string; input?: unknown }
+              | { type: string }
+            >) {
+              if (block.type === 'text') {
+                const t = (block as { text?: string }).text;
+                if (t) assistantTextParts.push(t);
+              } else if (block.type === 'tool_use') {
+                const tb = block as { name?: string; input?: unknown };
+                toolCalls.push({
+                  tool: tb.name ?? 'unknown',
+                  input: tb.input ?? {},
+                  output: '',
+                });
+              }
+            }
+          }
+        } else if (isRateLimitEvent(ev)) {
+          rateLimited = new Error(
+            `mid-stream rate limit: ${JSON.stringify(
+              (ev as { rate_limit_info?: unknown }).rate_limit_info,
+            )}`,
+          );
+        } else if (ev.type === 'result') {
+          terminalResult = ev as SDKResultMessage;
+          if (isRateLimitResult(ev)) {
+            rateLimited = new Error(
+              `result-message rate limit: ${((ev as { errors?: string[] }).errors ?? []).join('; ')}`,
+            );
+          }
+        }
+      }
+
+      if (rateLimited) {
+        throw rateLimited;
+      }
+      if (!terminalResult) {
+        throw new Error('query stream ended without a result event');
+      }
+
+      const durationMs = Date.now() - startMs;
+      const costUsd =
+        (terminalResult as { total_cost_usd?: number }).total_cost_usd ?? 0;
+      const turnsUsed =
+        (terminalResult as { num_turns?: number }).num_turns ??
+        assistantTurns.length;
+      const exitReason =
+        (terminalResult as { subtype?: string }).subtype ?? 'unknown';
+
+      return {
+        events,
+        assistantTurns,
+        toolCalls,
+        output: assistantTextParts.join('\n'),
+        exitReason,
+        turnsUsed,
+        durationMs,
+        firstResponseMs,
+        maxInterTurnMs,
+        costUsd,
+        model,
+        sdkVersion: resolveSdkVersion(),
+        sdkClaudeCodeVersion: systemInitVersion,
+        resolvedBinaryPath: opts.pathToClaudeCodeExecutable ?? 'sdk-default',
+        browseErrors: [],
+      };
+    } catch (err) {
+      lastErr = err;
+
+      // "Max turns reached" is the SDK's way of saying "this session ran
+      // out of turns." It's thrown from the generator instead of emitted
+      // as a result message. Treat as a successful-but-capped trial: the
+      // assistant turns we collected are real and carry a metric. Record
+      // them with exitReason='error_max_turns' rather than failing the
+      // whole run.
+      if (isMaxTurnsError(err)) {
+        const durationMs = Date.now() - startMs;
+        return {
+          events,
+          assistantTurns,
+          toolCalls,
+          output: assistantTextParts.join('\n'),
+          exitReason: 'error_max_turns',
+          turnsUsed: assistantTurns.length,
+          durationMs,
+          firstResponseMs,
+          maxInterTurnMs,
+          costUsd: 0, // unknown from thrown-error path
+          model,
+          sdkVersion: resolveSdkVersion(),
+          sdkClaudeCodeVersion: systemInitVersion,
+          resolvedBinaryPath: opts.pathToClaudeCodeExecutable ?? 'sdk-default',
+          browseErrors: [],
+        };
+      }
+
+      const isRetryable = isRateLimitThrown(err);
+      if (!isRetryable || attempt >= maxRetries) {
+        if (isRetryable) {
+          throw new RateLimitExhaustedError(attempt + 1, err);
+        }
+        throw err;
+      }
+      attempt++;
+      // backoff: 1s, 2s, 4s
+      await new Promise((r) => setTimeout(r, 1000 * Math.pow(2, attempt - 1)));
+      // Let caller reset workspace since prior attempt may have partially
+      // mutated files via Bash.
+      if (opts.onRetry) {
+        opts.onRetry(opts.workingDirectory);
+      }
+    } finally {
+      sem.release();
+    }
+  }
+
+  throw new RateLimitExhaustedError(attempt + 1, lastErr);
+}
+
+// ---------------------------------------------------------------------------
+// Legacy shape mapper
+// ---------------------------------------------------------------------------
+
+/**
+ * Adapt AgentSdkResult to the legacy SkillTestResult shape so helpers that
+ * expect the old `claude -p` output (extractToolSummary, etc) work unchanged.
+ */
+export function toSkillTestResult(r: AgentSdkResult): SkillTestResult {
+  // Cost estimate: use SDK's authoritative cost; back-compute chars.
+  // session-runner.ts:30 requires inputChars/outputChars/estimatedTokens.
+  // These are rough; real consumers of CostEstimate use cost + turns.
+  const outputChars = r.output.length;
+  const inputChars = 0; // unknown from SDK path; not used for pass/fail
+  const estimatedTokens = Math.round((inputChars + outputChars) / 4);
+
+  // Build a flat transcript list mimicking the NDJSON shape:
+  // parseNDJSON emits [{ type: 'assistant', message: {...} }, ...].
+  // Use the SDK's assistantTurns directly since their shape matches.
+  const transcript: unknown[] = r.events.slice();
+
+  return {
+    toolCalls: r.toolCalls,
+    browseErrors: r.browseErrors,
+    exitReason: r.exitReason,
+    duration: r.durationMs,
+    output: r.output,
+    costEstimate: {
+      inputChars,
+      outputChars,
+      estimatedTokens,
+      estimatedCost: r.costUsd,
+      turnsUsed: r.turnsUsed,
+    },
+    transcript,
+    model: r.model,
+    firstResponseMs: r.firstResponseMs,
+    maxInterTurnMs: r.maxInterTurnMs,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Metric helpers (re-exported for fixtures)
+// ---------------------------------------------------------------------------
+
+/**
+ * Count `tool_use` blocks in the first assistant turn of an SDK result.
+ * Returns 0 if there is no first turn or no content array.
+ *
+ * This is the core "fanout" metric. A turn with N tool_use blocks = N
+ * parallel tool invocations.
+ */
+export function firstTurnParallelism(firstTurn: SDKAssistantMessage | undefined): number {
+  if (!firstTurn) return 0;
+  const content = firstTurn.message?.content;
+  if (!Array.isArray(content)) return 0;
+  return (content as Array<{ type: string }>).filter((b) => b.type === 'tool_use').length;
+}

test/helpers/touchfiles.ts

@@ -84,10 +84,27 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
 
   // AskUserQuestion format regression (RECOMMENDATION + Completeness: N/10)
   // Fires when either template OR the two preamble resolvers change.
-  'plan-ceo-review-format-mode':      ['plan-ceo-review/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble/generate-completeness-section.ts', 'scripts/resolvers/preamble.ts'],
-  'plan-ceo-review-format-approach':  ['plan-ceo-review/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble/generate-completeness-section.ts', 'scripts/resolvers/preamble.ts'],
-  'plan-eng-review-format-coverage':  ['plan-eng-review/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble/generate-completeness-section.ts', 'scripts/resolvers/preamble.ts'],
-  'plan-eng-review-format-kind':      ['plan-eng-review/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble/generate-completeness-section.ts', 'scripts/resolvers/preamble.ts'],
+  'plan-ceo-review-format-mode':      ['plan-ceo-review/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble/generate-completeness-section.ts', 'scripts/resolvers/preamble.ts', 'model-overlays/opus-4-7.md'],
+  'plan-ceo-review-format-approach':  ['plan-ceo-review/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble/generate-completeness-section.ts', 'scripts/resolvers/preamble.ts', 'model-overlays/opus-4-7.md'],
+  'plan-eng-review-format-coverage':  ['plan-eng-review/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble/generate-completeness-section.ts', 'scripts/resolvers/preamble.ts', 'model-overlays/opus-4-7.md'],
+  'plan-eng-review-format-kind':      ['plan-eng-review/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble/generate-completeness-section.ts', 'scripts/resolvers/preamble.ts', 'model-overlays/opus-4-7.md'],
+
+  // v1.7.0.0 Pros/Cons format cadence + format + negative-escape evals.
+  // Dependencies: same as format-mode + the 4 plan-review templates + overlay.
+  // All periodic-tier (non-deterministic Opus 4.7 behavior).
+  'plan-ceo-review-prosons-cadence':  ['plan-ceo-review/**', 'plan-eng-review/**', 'plan-design-review/**', 'plan-devex-review/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble.ts', 'model-overlays/opus-4-7.md'],
+  'plan-review-prosons-format':       ['plan-ceo-review/**', 'plan-eng-review/**', 'plan-design-review/**', 'plan-devex-review/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble.ts', 'model-overlays/opus-4-7.md'],
+  'plan-review-prosons-hardstop-neg': ['plan-ceo-review/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble.ts', 'model-overlays/opus-4-7.md'],
+  'plan-review-prosons-neutral-neg':  ['plan-ceo-review/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble.ts', 'model-overlays/opus-4-7.md'],
+
+  // Expanded coverage (CT3) — 6 non-plan-review skills inherit Pros/Cons via preamble
+  'ship-prosons-format':              ['ship/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble.ts', 'model-overlays/opus-4-7.md'],
+  'office-hours-prosons-format':      ['office-hours/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble.ts', 'model-overlays/opus-4-7.md'],
+  'investigate-prosons-format':       ['investigate/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble.ts', 'model-overlays/opus-4-7.md'],
+  'qa-prosons-format':                ['qa/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble.ts', 'model-overlays/opus-4-7.md'],
+  'review-prosons-format':            ['review/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble.ts', 'model-overlays/opus-4-7.md'],
+  'design-review-prosons-format':     ['design-review/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble.ts', 'model-overlays/opus-4-7.md'],
+  'document-release-prosons-format':  ['document-release/**', 'scripts/resolvers/preamble/generate-ask-user-format.ts', 'scripts/resolvers/preamble.ts', 'model-overlays/opus-4-7.md'],
 
   // /plan-tune (v1 observational)
   'plan-tune-inspect':         ['plan-tune/**', 'scripts/question-registry.ts', 'scripts/psychographic-signals.ts', 'scripts/one-way-doors.ts', 'bin/gstack-question-log', 'bin/gstack-question-preference', 'bin/gstack-developer-profile'],
@@ -222,6 +239,24 @@ export const E2E_TOUCHFILES: Record<string, string[]> = {
     ['model-overlays/claude.md', 'model-overlays/opus-4-7.md', 'scripts/models.ts', 'scripts/resolvers/model-overlay.ts'],
   'fanout-arm-overlay-off':
     ['model-overlays/claude.md', 'model-overlays/opus-4-7.md', 'scripts/models.ts', 'scripts/resolvers/model-overlay.ts'],
+
+  // Overlay efficacy harness (SDK) — measures whether overlay nudges change
+  // behavior under @anthropic-ai/claude-agent-sdk (closer to real Claude Code
+  // than `claude -p`). testNames in the file are template literals so the
+  // completeness scanner doesn't require them; these entries exist for
+  // diff-based selection accuracy.
+  'overlay-harness-opus-4-7-fanout-toy': [
+    'model-overlays/**',
+    'test/fixtures/overlay-nudges.ts',
+    'test/helpers/agent-sdk-runner.ts',
+    'scripts/resolvers/model-overlay.ts',
+  ],
+  'overlay-harness-opus-4-7-fanout-realistic': [
+    'model-overlays/**',
+    'test/fixtures/overlay-nudges.ts',
+    'test/helpers/agent-sdk-runner.ts',
+    'scripts/resolvers/model-overlay.ts',
+  ],
 };
 
 /**
@@ -288,6 +323,21 @@ export const E2E_TIERS: Record<string, 'gate' | 'periodic'> = {
   'plan-eng-review-format-coverage': 'periodic',
   'plan-eng-review-format-kind': 'periodic',
 
+  // v1.7.0.0 Pros/Cons format — cadence + negative-escape evals (all periodic)
+  'plan-ceo-review-prosons-cadence': 'periodic',
+  'plan-review-prosons-format': 'periodic',
+  'plan-review-prosons-hardstop-neg': 'periodic',
+  'plan-review-prosons-neutral-neg': 'periodic',
+
+  // CT3 expanded coverage — non-plan-review skills inheriting Pros/Cons (all periodic)
+  'ship-prosons-format': 'periodic',
+  'office-hours-prosons-format': 'periodic',
+  'investigate-prosons-format': 'periodic',
+  'qa-prosons-format': 'periodic',
+  'review-prosons-format': 'periodic',
+  'design-review-prosons-format': 'periodic',
+  'document-release-prosons-format': 'periodic',
+
   // /plan-tune — gate (core v1 DX promise: plain-English intent routing)
   'plan-tune-inspect': 'gate',
 
@@ -398,6 +448,10 @@ export const E2E_TIERS: Record<string, 'gate' | 'periodic'> = {
   // Opus 4.7 overlay evals — periodic (non-deterministic LLM behavior + Opus cost)
   'fanout-arm-overlay-on': 'periodic',
   'fanout-arm-overlay-off': 'periodic',
+
+  // Overlay efficacy harness (SDK, paid) — periodic only
+  'overlay-harness-opus-4-7-fanout-toy': 'periodic',
+  'overlay-harness-opus-4-7-fanout-realistic': 'periodic',
 };
 
 /**