@dailephd/my-dev-kit-lab 0.4.8 → 0.5.0

package/dist/src/report/experiments/renderPluginExperimentReportText.js

@@ -256,6 +256,77 @@ function renderV043Section(lines, section) {
         renderStrategy(lines, section.strategies[index], index);
     }
 }
+function formatWarmMetric(metric) {
+    const method = metric.tokenCountMethod ? `, method ${metric.tokenCountMethod}` : "";
+    if (metric.availability === "available") {
+        return `${metric.value} ${metric.unit} (${metric.source}${method})`;
+    }
+    return `${metric.availability} (${metric.reason ?? ""})`;
+}
+function formatWarmAgent(agent) {
+    if (agent === null)
+        return "not run (no context evidence for this side)";
+    const passed = agent.passed === null ? "unavailable" : String(agent.passed);
+    const issues = [...agent.errors, ...agent.warnings].slice(0, 3).join("; ");
+    return `status ${agent.status}, passed ${passed}, token source ${agent.tokenUsageSource}, reliability ${agent.tokenUsageReliability}${issues ? `, notes: ${issues}` : ""}`;
+}
+function renderWarmIndexReuseSection(lines, section) {
+    if (section === null) {
+        lines.push("Not applicable to this plugin.");
+        return;
+    }
+    lines.push(fieldLine("Project Count", section.summary.projectCount));
+    lines.push(fieldLine("Task Count", section.summary.taskCount));
+    lines.push(fieldLine("Prepared Session Project Count", section.summary.preparedSessionProjectCount));
+    lines.push(fieldLine("Incomplete Or Failed Project Count", section.summary.incompleteProjectCount));
+    lines.push(fieldLine("Fake-Agent Correctness Available (task sides)", `${section.summary.agentCorrectnessAvailableCount} of ${section.summary.agentSideCount}`));
+    lines.push(fieldLine("Fake-Agent Token Totals Available (task sides)", `${section.summary.agentTotalTokensAvailableCount} of ${section.summary.agentSideCount}`));
+    lines.push("Cold Start And Warm Reuse:");
+    pushDashList(lines, section.costModel);
+    lines.push("Limitations:");
+    pushDashList(lines, section.limitations);
+    if (section.projects.length === 0) {
+        lines.push("No warm-index project evidence was recorded.");
+        return;
+    }
+    section.projects.forEach((project, index) => {
+        pushSection(lines, `Warm Index Project ${index + 1}: ${sanitizeScalar(project.benchmarkProject)}`);
+        lines.push(fieldLine("Session Key", project.sessionKey));
+        lines.push(fieldLine("Status", project.status));
+        lines.push(fieldLine("Session Prepared", project.sessionPrepared));
+        lines.push(fieldLine("Index Build Duration", formatWarmMetric(project.indexBuildDurationMs)));
+        lines.push(fieldLine("Task Count", project.taskCount));
+        for (const task of project.tasks) {
+            pushSection(lines, `Task ${task.taskOrdinal}: ${sanitizeScalar(task.caseId)}`);
+            const rows = [
+                ["Raw Status", task.rawStatus],
+                ["Warm Status", task.warmStatus],
+                ["Raw Context Characters", formatWarmMetric(task.raw.contextCharacters)],
+                ["Warm Context Characters", formatWarmMetric(task.warm.contextCharacters)],
+                ["Raw Estimated Context Tokens (estimate)", formatWarmMetric(task.raw.contextEstimatedTokens)],
+                ["Warm Estimated Context Tokens (estimate)", formatWarmMetric(task.warm.contextEstimatedTokens)],
+                ["Raw Operation Duration", formatWarmMetric(task.raw.operationDurationMs)],
+                ["Warm Retrieval Duration", formatWarmMetric(task.warm.retrievalDurationMs)],
+                ["Amortized Index Build Duration", formatWarmMetric(task.warm.amortizedIndexBuildDurationMs)],
+                ["Cumulative Raw Duration", formatWarmMetric(task.raw.cumulativeDurationMs)],
+                ["Cumulative Warm Component Duration", formatWarmMetric(task.warm.cumulativeComponentDurationMs)],
+                ["Cumulative Raw Estimated Context Tokens (estimate)", formatWarmMetric(task.raw.cumulativeEstimatedContextTokens)],
+                ["Cumulative Warm Estimated Context Tokens (estimate)", formatWarmMetric(task.warm.cumulativeEstimatedContextTokens)],
+                ["Raw Fake-Agent Evaluation", formatWarmAgent(task.rawAgent)],
+                ["Warm Fake-Agent Evaluation", formatWarmAgent(task.warmAgent)],
+                ["Raw Agent Correctness (fake agent)", formatWarmMetric(task.raw.agentCorrectness)],
+                ["Warm Agent Correctness (fake agent)", formatWarmMetric(task.warm.agentCorrectness)],
+                ["Raw Agent Total Tokens (fake-agent simulated)", formatWarmMetric(task.raw.agentTotalTokens)],
+                ["Warm Agent Total Tokens (fake-agent simulated)", formatWarmMetric(task.warm.agentTotalTokens)],
+                ["Cumulative Raw Agent Total Tokens (fake-agent simulated)", formatWarmMetric(task.raw.cumulativeAgentTotalTokens)],
+                ["Cumulative Warm Agent Total Tokens (fake-agent simulated)", formatWarmMetric(task.warm.cumulativeAgentTotalTokens)],
+            ];
+            for (const [label, value] of rows) {
+                lines.push(fieldLine(label, value));
+            }
+        }
+    });
+}
 export function renderPluginExperimentReportText(report) {
     const lines = [];
     pushSection(lines, "Plugin Experiment Report");
@@ -284,6 +355,8 @@ export function renderPluginExperimentReportText(report) {
     pushDashList(lines, report.metrics.map((metric) => `${metric.name} (${metric.id}) value=${metric.value ?? "unavailable"} unit=${metric.unit ?? ""}`));
     pushSection(lines, "V0.4.3 Stage-Context Evidence");
     renderV043Section(lines, report.contextStrategyComparisonV043);
+    pushSection(lines, "Warm Index Reuse Evidence");
+    renderWarmIndexReuseSection(lines, report.warmIndexReuse);
     pushSection(lines, "Warnings, Skips, And Failures");
     pushDashList(lines, report.findings.map((finding) => `${finding.severity} ${finding.code} ${finding.message} variant=${finding.variantId ?? ""} case=${finding.caseId ?? ""}`));
     pushSection(lines, "Artifacts");

package/dist/src/report/experiments/renderWarmIndexReuseHtml.js

@@ -0,0 +1,150 @@
+const UNIT_LABELS = {
+    ms: "ms",
+    characters: "chars",
+    "estimated-tokens": "est. tokens",
+    tokens: "tokens",
+    score: "score",
+};
+export function renderWarmIndexReuseHtml(section) {
+    if (section === null) {
+        return `<section>
+    <h2>Warm Index Reuse Evidence</h2>
+    <p>Not applicable to this plugin.</p>
+  </section>`;
+    }
+    return `<section>
+    <h2>Warm Index Reuse Evidence</h2>
+    ${table(["Field", "Value"], [
+        ["Projects", String(section.summary.projectCount)],
+        ["Tasks", String(section.summary.taskCount)],
+        ["Projects with a prepared index session", String(section.summary.preparedSessionProjectCount)],
+        ["Incomplete or failed projects", String(section.summary.incompleteProjectCount)],
+        ["Fake-agent correctness available (task sides)", `${section.summary.agentCorrectnessAvailableCount} of ${section.summary.agentSideCount}`],
+        ["Fake-agent token totals available (task sides)", `${section.summary.agentTotalTokensAvailableCount} of ${section.summary.agentSideCount}`],
+    ])}
+    <h3>Cold Start And Warm Reuse</h3>
+    ${list(section.costModel)}
+    <h3>Limitations</h3>
+    ${list(section.limitations)}
+    ${section.projects.length === 0 ? "<p>No warm-index project evidence was recorded.</p>" : section.projects.map(renderProject).join("\n")}
+  </section>`;
+}
+function renderProject(project, index) {
+    const unavailableRows = project.tasks.flatMap((task) => [
+        ["Raw context characters", task.raw.contextCharacters],
+        ["Warm context characters", task.warm.contextCharacters],
+        ["Raw estimated context tokens", task.raw.contextEstimatedTokens],
+        ["Warm estimated context tokens", task.warm.contextEstimatedTokens],
+        ["Raw operation duration", task.raw.operationDurationMs],
+        ["Warm retrieval duration", task.warm.retrievalDurationMs],
+        ["Amortized index build duration", task.warm.amortizedIndexBuildDurationMs],
+        ["Cumulative raw duration", task.raw.cumulativeDurationMs],
+        ["Cumulative warm component duration", task.warm.cumulativeComponentDurationMs],
+        ["Cumulative raw estimated context tokens", task.raw.cumulativeEstimatedContextTokens],
+        ["Cumulative warm estimated context tokens", task.warm.cumulativeEstimatedContextTokens],
+        ["Raw fake-agent correctness", task.raw.agentCorrectness],
+        ["Warm fake-agent correctness", task.warm.agentCorrectness],
+        ["Raw fake-agent total tokens", task.raw.agentTotalTokens],
+        ["Warm fake-agent total tokens", task.warm.agentTotalTokens],
+        ["Cumulative raw fake-agent total tokens", task.raw.cumulativeAgentTotalTokens],
+        ["Cumulative warm fake-agent total tokens", task.warm.cumulativeAgentTotalTokens],
+    ]
+        .filter(([, metric]) => metric.availability !== "available")
+        .map(([label, metric]) => [String(task.taskOrdinal), task.caseId, label, metric.availability, metric.reason ?? ""]));
+    return `<h3>Project ${index + 1}: ${escapeHtml(project.benchmarkProject)}</h3>
+    ${table(["Field", "Value"], [
+        ["Session key", project.sessionKey],
+        ["Project status", project.status],
+        ["Session prepared", String(project.sessionPrepared)],
+        ["Index build duration", formatMetric(project.indexBuildDurationMs)],
+        ["Index build duration availability", withReason(project.indexBuildDurationMs)],
+        ["Tasks", String(project.taskCount)],
+    ])}
+    ${table([
+        "Task",
+        "Raw status",
+        "Warm status",
+        "Raw chars",
+        "Warm chars",
+        "Raw est. tokens",
+        "Warm est. tokens",
+        "Raw duration",
+        "Warm retrieval duration",
+        "Amortized index cost",
+        "Cumulative raw duration",
+        "Cumulative warm duration",
+        "Cumulative raw est. tokens",
+        "Cumulative warm est. tokens",
+    ], project.tasks.map((task) => [
+        `${task.taskOrdinal}. ${task.caseId}`,
+        task.rawStatus,
+        task.warmStatus,
+        formatMetric(task.raw.contextCharacters),
+        formatMetric(task.warm.contextCharacters),
+        formatMetric(task.raw.contextEstimatedTokens),
+        formatMetric(task.warm.contextEstimatedTokens),
+        formatMetric(task.raw.operationDurationMs),
+        formatMetric(task.warm.retrievalDurationMs),
+        formatMetric(task.warm.amortizedIndexBuildDurationMs),
+        formatMetric(task.raw.cumulativeDurationMs),
+        formatMetric(task.warm.cumulativeComponentDurationMs),
+        formatMetric(task.raw.cumulativeEstimatedContextTokens),
+        formatMetric(task.warm.cumulativeEstimatedContextTokens),
+    ]))}
+    <p class="muted">Estimated tokens are character-based context-size estimates, not provider token usage.</p>
+    <p class="muted">Agent columns are deterministic fake-agent evidence; token totals are simulated harness telemetry, not provider billing telemetry.</p>
+    ${table([
+        "Task",
+        "Raw fake-agent status",
+        "Warm fake-agent status",
+        "Raw correctness",
+        "Warm correctness",
+        "Raw agent tokens",
+        "Warm agent tokens",
+        "Cumulative raw agent tokens",
+        "Cumulative warm agent tokens",
+        "Token source / reliability",
+    ], project.tasks.map((task) => [
+        `${task.taskOrdinal}. ${task.caseId}`,
+        formatAgent(task.rawAgent),
+        formatAgent(task.warmAgent),
+        formatMetric(task.raw.agentCorrectness),
+        formatMetric(task.warm.agentCorrectness),
+        formatMetric(task.raw.agentTotalTokens),
+        formatMetric(task.warm.agentTotalTokens),
+        formatMetric(task.raw.cumulativeAgentTotalTokens),
+        formatMetric(task.warm.cumulativeAgentTotalTokens),
+        [task.rawAgent, task.warmAgent]
+            .map((agent) => (agent ? `${agent.tokenUsageSource} / ${agent.tokenUsageReliability}` : "not run"))
+            .join("; "),
+    ]))}
+    ${unavailableRows.length === 0 ? "" : table(["Task", "Case", "Metric", "Availability", "Reason"], unavailableRows)}`;
+}
+function formatAgent(agent) {
+    if (agent === null)
+        return "not run";
+    const passed = agent.passed === null ? "" : agent.passed ? ", passed" : ", not passed";
+    return `${agent.status}${passed}${agent.errors[0] ? ` (${agent.errors[0]})` : ""}`;
+}
+function formatMetric(metric) {
+    return metric.availability === "available" ? `${metric.value} ${UNIT_LABELS[metric.unit]}` : metric.availability;
+}
+function withReason(metric) {
+    return metric.availability === "available" ? formatMetric(metric) : `${metric.availability}: ${metric.reason ?? ""}`;
+}
+function list(items) {
+    return `<ul>${items.map((item) => `<li>${escapeHtml(item)}</li>`).join("")}</ul>`;
+}
+function table(headers, rows) {
+    return `<table><thead><tr>${headers.map((header) => `<th>${escapeHtml(header)}</th>`).join("")}</tr></thead><tbody>${rows
+        .map((row) => `<tr>${row.map((cell) => `<td>${escapeHtml(cell)}</td>`).join("")}</tr>`)
+        .join("")}</tbody></table>`;
+}
+function escapeHtml(value) {
+    return String(value ?? "")
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}

package/dist/src/report/experiments/warmIndexReuseReportModel.js

@@ -0,0 +1 @@
+export const WARM_INDEX_REUSE_REPORT_SCHEMA_VERSION = "my-dev-kit-lab-warm-index-report-v1";

package/dist/src/tutorial/scenarioValidation.js

@@ -266,6 +266,17 @@ export function validateAction(errors, location, value) {
             validateLocator(errors, `${location}.target`, value.target);
             validateOptionalTimeout(errors, `${location}.timeoutMs`, value.timeoutMs);
             break;
+        case "select-option":
+            // Closed to `value` alone: `label`, `index` and `values` are unknown
+            // fields here, so a scenario cannot reach a selection mode the runtime
+            // does not implement by guessing at Playwright's wider API.
+            rejectUnknownKeys(errors, location, value, ["type", "locator", "value", "timeoutMs"]);
+            validateLocator(errors, `${location}.locator`, value.locator);
+            if (!isNonEmptyString(value.value)) {
+                errors.add(`${location}.value`, `expected a non-empty option value string after trimming, received ${describeValue(value.value)}.`);
+            }
+            validateOptionalTimeout(errors, `${location}.timeoutMs`, value.timeoutMs);
+            break;
         case "pointer-click":
             rejectUnknownKeys(errors, location, value, ["type", "locator", "position", "coordinateSpace", "timeoutMs"]);
             validateLocator(errors, `${location}.locator`, value.locator);

package/dist/src/tutorial/tutorialActions.js

@@ -99,6 +99,18 @@ async function performAction(page, action, context) {
             await runWithMouseDown(page.mouse, () => page.mouse.move(end.x, end.y, { steps: POINTER_DRAG_MOVE_STEPS }));
             return;
         }
+        case "select-option": {
+            const locator = resolveTutorialLocator(page, action.locator);
+            const selected = await locator.selectOption({ value: action.value }, { timeout: timeoutFor(action.timeoutMs) });
+            // Playwright resolves to the values it actually selected. A mismatched or
+            // empty result means the intended option was not chosen, so it is a
+            // failure rather than a silently-accepted no-op; more than one value
+            // would mean a multi-select, which this contract does not express.
+            if (selected.length !== 1 || selected[0] !== action.value) {
+                throw new Error(`expected exactly one selected value ${JSON.stringify(action.value)}, but the select reported ${JSON.stringify(selected)}`);
+            }
+            return;
+        }
         case "wait-for":
             await resolveTutorialLocator(page, action.locator).waitFor({
                 ...(action.state !== undefined ? { state: action.state } : {}),
@@ -159,6 +171,8 @@ function describeActionError(action, error) {
             return `pointer-click on ${describeTutorialLocator(action.locator)} at fraction ${describeFractionPoint(action.position)} failed: ${message}`;
         case "pointer-drag":
             return `pointer-drag on ${describeTutorialLocator(action.locator)} from fraction ${describeFractionPoint(action.from)} to ${describeFractionPoint(action.to)} failed: ${message}`;
+        case "select-option":
+            return `select-option on ${describeTutorialLocator(action.locator)} for value ${JSON.stringify(action.value)} failed: ${message}`;
         case "click":
         case "fill":
         case "press":

package/dist/src/tutorial/tutorialSession.js

@@ -239,6 +239,9 @@ export function cursorLocatorForAction(action) {
         case "fill":
         case "press":
         case "hover":
+        // The cursor rests on the select itself; the native popup is OS-drawn and
+        // is deliberately not animated through.
+        case "select-option":
         case "pointer-click":
         case "pointer-drag":
             return action.locator;

package/dist/src/tutorial/types.js

@@ -31,6 +31,7 @@ export const TUTORIAL_ACTION_TYPES = [
     "press",
     "hover",
     "drag",
+    "select-option",
     "wait-for",
     "pointer-click",
     "pointer-drag"

package/docs/METRICS.md

@@ -441,3 +441,67 @@ Implemented in `src/evaluation/stageContextMetrics` and composed once per run by
 - Determinism and fixture self-immutability
   Meaning: reuses `calculateStageContextDeterminism`/`canonicalizeStageContextRun` (`v0.4.3`) to confirm repeated evaluations of the same fixture produce identical canonicalized results, and re-runs fixture hash verification to confirm the frozen bytes were not mutated by evaluation.
   Caveat: this is fixture-level self-immutability, not the `v0.4.3` live-target-mutation check — no live target repository is exercised by this evaluation path.
+
+## Warm-index reuse metrics
+
+Implemented in the current release v0.5.0. The `warm-index-reuse` plugin calculates these metrics once, in `src/experiments/plugins/warmIndexReuse/metrics.ts`, from bounded execution summaries and bounded fake-agent evidence. The report section (`report.warmIndexReuse` in `report.json`, and the text and HTML "Warm Index Reuse Evidence" sections) and the four warm-index plots render these precomputed values; they never recalculate a formula.
+
+**Availability contract.** Every warm-index metric carries `availability`, `value`, `unit`, `source`, `reason`, and `tokenCountMethod`:
+
+- `available`: `value` is a finite number and `reason` is `null`. Zero is a valid available value.
+- `unavailable`: `value` is `null` and `reason` explains the missing or invalid evidence. Missing evidence is never reported as zero, and a non-finite upstream number becomes `unavailable` with an invalid-input reason.
+- `not-applicable`: `value` is `null` and `reason` explains why the metric does not apply. The contract supports it; the current warm-index metrics do not emit it.
+
+Units are `ms`, `characters`, `estimated-tokens`, `tokens`, and `score`. Sources are `measured`, `derived`, `estimated-chars-div-4`, and `agent`. `tokenCountMethod` is set only for estimated-token metrics (currently `estimated_chars_div_4`).
+
+**Task ordinal.** Tasks keep their filtered source order inside each benchmark project and are numbered `1, 2, 3, …` per project. Ordinals, amortization, and every cumulative sum restart for each benchmark project.
+
+**Direct measurements (per task):**
+
+- Raw context characters / warm retrieved context characters (`characters`, `measured`)
+  Meaning: characters in the raw full-file context and in the retrieved my-dev-kit context.
+  Caveat: unavailable when that side produced no evidence (for example, a raw baseline failure, or no warm retrieval because the project index was not prepared).
+- Raw estimated context tokens / warm estimated context tokens (`estimated-tokens`, `estimated-chars-div-4`)
+  Meaning: the character-based context-size estimate, `ceil(characters / 4)`.
+  Caveat: a context-size estimate, not provider token usage and not fake-agent token usage.
+- Raw context-construction duration (`ms`, `measured`)
+  Meaning: time to build the raw full-file context for the task. It is not agent duration.
+- Warm retrieval duration (`ms`, `measured`)
+  Meaning: search, lookup, slice, and source against the already prepared index. It never includes the index build.
+  Caveat: a skipped retrieval (no usable context) still reports its measured duration and sizes; its outcome remains `skipped`.
+- Index build duration (per project, `ms`, `measured`)
+  Meaning: the measured duration of the project's single my-dev-kit `index` command.
+  Caveat: available whenever a build was attempted and measured, even if the build failed. Unavailable, never zero, when the project group was structurally inconsistent and no index setup was attempted.
+
+**Derived measurements (per task):**
+
+- Amortized index build duration (`ms`, `derived`)
+  Formula: `amortizedIndexBuildDurationMs(N) = indexBuildDurationMs / N` for task ordinal `N`, without rounding.
+  Caveat: available only when the project prepared a valid index session. A failed or never-attempted index is not amortized.
+- Cumulative raw component duration (`ms`, `measured`)
+  Formula: sum of raw context-construction durations for tasks `1..N`.
+- Cumulative warm component duration (`ms`, `derived`)
+  Formula: `indexBuildDurationMs` (counted once) plus the warm retrieval durations for tasks `1..N`. At `N = 1` this is the cold-start warm cost: index build plus the first retrieval.
+  Caveat: requires a prepared index session. It is a sum of measured components, not wall-clock or end-to-end latency, and it is not a speedup claim.
+- Cumulative raw / warm estimated context tokens (`estimated-tokens`, `estimated-chars-div-4`)
+  Formula: sum of that side's estimated context tokens for tasks `1..N`. No index-token cost is added; indexing is a local repository operation, not model context.
+  Caveat: if different token-count methods appear within one prefix, the cumulative value is unavailable rather than summed.
+
+**Strict-prefix rule.** A cumulative metric at ordinal `N` is available only when every task `1..N` has the required input. After the first missing or invalid input, that cumulative metric stays unavailable for every later task in the project, with a reason naming the first incomplete task. The later tasks' direct metrics remain available.
+
+**Fake-agent evidence (per task side):**
+
+The plugin evaluates each task side that has context evidence once with the deterministic fake agent, through the existing prompt generator, answer parser, run classifier, and correctness scorer. A side with no context evidence is not evaluated, and its agent metrics are unavailable with that reason.
+
+- Fake-agent correctness score (`score`, `agent`)
+  Meaning: `correctnessScore` from the existing benchmark answer-key scorer (see "Experiment and run metrics" above).
+  Caveat: available only when the fake-agent answer was scoreable (classified `completed` or `invalid-output`); a failed agent run reports `unavailable` with its status and error. It is deterministic benchmark-harness evidence, not real-model correctness, and retrieval success is never used as correctness.
+- Fake-agent total tokens (`tokens`, `agent`)
+  Meaning: `tokenUsage.totalTokens` exactly as reported by the fake agent (its prompt estimate plus a fixed simulated output count), with the reported token-usage source and reliability kept in the agent evidence.
+  Caveat: simulated harness telemetry, not provider billing telemetry. When the fake agent reports no total (for example `FAKE_AGENT_MODE=missing-token-usage`), the value is unavailable; estimated context tokens are never substituted.
+- Cumulative fake-agent total tokens (`tokens`, `agent`)
+  Formula: sum of fake-agent total tokens for tasks `1..N` on that side, under the strict-prefix rule.
+
+**Generic outcome metrics.** Available values also appear as `ExperimentMetric` entries on each outcome, with `variantId`, `caseId`, `unit`, and `description`. Both the `raw-full-file` and `warm-index-reuse` outcomes can carry `context-character-count`, `context-estimated-token-count`, `operation-duration-ms` (raw context construction or warm retrieval), `cumulative-component-duration-ms`, `cumulative-context-estimated-token-count`, `agent-correctness-score`, `agent-total-tokens`, and `cumulative-agent-total-tokens`. The warm outcome also carries `amortized-index-build-duration-ms`. Unavailable metrics are omitted rather than emitted as zero. Run-level metrics are limited to `warm-index-project-count`, `warm-index-task-count`, and `warm-index-session-prepared-project-count`.
+
+**Interpretation.** The report separates the one-time index cost from per-task retrieval cost and shows the fixed cost falling per task as more tasks reuse the index. It calculates no token-savings percentage, duration-reduction percentage, break-even task, composite score, winner, or ranking. Warm-index plots map the same precomputed values: amortized index build duration, raw versus retrieved estimated context tokens, fake-agent correctness, and cumulative fake-agent total tokens. Unavailable values become skipped plot points with their reason.

package/examples/tutorial-browser/index.html

@@ -12,6 +12,7 @@
       button { font: inherit; padding: 8px 16px; border-radius: 6px; border: 1px solid #5a6270; background: #fff; cursor: pointer; }
       button:hover { background: #eef1f5; }
       input { font: inherit; padding: 8px; border: 1px solid #b8bec8; border-radius: 6px; width: 100%; box-sizing: border-box; }
+      select { font: inherit; padding: 8px; border: 1px solid #b8bec8; border-radius: 6px; }
       .dropzone { min-height: 72px; border: 2px dashed #9aa3af; border-radius: 8px; padding: 12px; }
       .card { background: #dde7ff; border: 1px solid #5f7fd6; border-radius: 6px; padding: 10px; width: 140px; }
       #pointer-surface { display: block; width: 400px; height: 240px; background: #eef4ff; box-shadow: inset 0 0 0 2px #7890c2; touch-action: none; user-select: none; }
@@ -26,6 +27,7 @@
     <div class="panel"><p id="intro-text">Welcome to the generic tutorial fixture.</p><button id="primary-action" data-testid="primary-action" data-state="idle">Activate</button> <span id="activation-count" data-testid="activation-count">0</span></div>
     <div class="panel"><label for="name-field">Your name</label><input id="name-field" data-testid="name-field" aria-label="Your name" /><p id="greeting" data-testid="greeting"></p></div>
     <div class="panel"><button id="hover-target" data-testid="hover-target">Hover me</button><p id="hover-readout" data-testid="hover-readout">not hovered</p></div>
+    <div class="panel"><label for="operation-select">Operation</label> <select id="operation-select" data-testid="operation-select" aria-label="Operation"><option value="inspect">Inspect</option><option value="move">Move</option><option value="resize">Resize</option><option value="remove">Remove</option><option value="preserve">Preserve</option></select> <span id="selected-operation" data-testid="selected-operation" data-selected-value="inspect">inspect</span></div>
     <div class="panel"><div id="status-banner" data-testid="status-banner" class="hidden">Delayed banner is now visible</div></div>
     <script>
       (() => {
@@ -37,6 +39,9 @@
         nameField.addEventListener("input", () => { greeting.textContent = nameField.value ? `Hello, ${nameField.value}` : ""; });
         nameField.addEventListener("keydown", event => { if (event.key === "Enter") greeting.textContent = `Submitted: ${nameField.value}`; });
         document.getElementById("hover-target").addEventListener("mouseenter", () => { document.getElementById("hover-readout").textContent = "hovered"; });
+        const operationSelect = document.getElementById("operation-select");
+        const selectedOperation = document.getElementById("selected-operation");
+        operationSelect.addEventListener("change", () => { selectedOperation.textContent = operationSelect.value; selectedOperation.setAttribute("data-selected-value", operationSelect.value); });
         const dragCard = document.getElementById("drag-card");
         const dropZone = document.getElementById("drop-zone");
         dragCard.addEventListener("dragstart", event => event.dataTransfer.setData("text/plain", "drag-card"));

package/examples/tutorial-browser/scenario.json

@@ -14,6 +14,7 @@
     { "id": "drag-card", "narration": "Drag the card onto the drop target.", "action": { "type": "drag", "source": { "kind": "test-id", "testId": "drag-card" }, "target": { "kind": "test-id", "testId": "drop-zone" } }, "highlight": { "kind": "test-id", "testId": "drop-zone" }, "screenshot": { "id": "dropped" }, "assertions": [ { "type": "attribute-equals", "locator": { "kind": "test-id", "testId": "drop-zone" }, "name": "data-dropped", "expected": "true" } ] },
     { "id": "pointer-click-surface", "narration": "Click a deliberate position inside the pointer gesture surface.", "action": { "type": "pointer-click", "locator": { "kind": "test-id", "testId": "pointer-surface" }, "position": { "x": 0.25, "y": 0.25 }, "coordinateSpace": "fraction" }, "highlight": { "kind": "test-id", "testId": "pointer-surface" }, "screenshot": { "id": "pointer-clicked" }, "assertions": [ { "type": "attribute-equals", "locator": { "kind": "test-id", "testId": "pointer-surface" }, "name": "data-pointer-click-count", "expected": "1" }, { "type": "attribute-equals", "locator": { "kind": "test-id", "testId": "pointer-surface" }, "name": "data-last-pointer-click-zone", "expected": "upper-left" } ] },
     { "id": "pointer-drag-surface", "narration": "Drag across two distinct positions inside the same pointer gesture surface.", "action": { "type": "pointer-drag", "locator": { "kind": "test-id", "testId": "pointer-surface" }, "from": { "x": 0.20, "y": 0.25 }, "to": { "x": 0.80, "y": 0.75 }, "coordinateSpace": "fraction" }, "screenshot": { "id": "pointer-dragged" }, "assertions": [ { "type": "attribute-equals", "locator": { "kind": "test-id", "testId": "pointer-surface" }, "name": "data-pointer-drag-count", "expected": "1" }, { "type": "attribute-equals", "locator": { "kind": "test-id", "testId": "pointer-surface" }, "name": "data-pointer-drag-start-zone", "expected": "upper-left" }, { "type": "attribute-equals", "locator": { "kind": "test-id", "testId": "pointer-surface" }, "name": "data-pointer-drag-end-zone", "expected": "lower-right" }, { "type": "attribute-equals", "locator": { "kind": "test-id", "testId": "pointer-surface" }, "name": "data-pointer-drag-intermediate", "expected": "true" } ] },
+    { "id": "select-operation", "narration": "Select the preserve operation from the native selector.", "action": { "type": "select-option", "locator": { "kind": "role", "role": "combobox", "name": "Operation" }, "value": "preserve" }, "highlight": { "kind": "role", "role": "combobox", "name": "Operation" }, "screenshot": { "id": "operation-selected" }, "assertions": [ { "type": "text-equals", "locator": { "kind": "test-id", "testId": "selected-operation" }, "expected": "preserve" }, { "type": "attribute-equals", "locator": { "kind": "test-id", "testId": "selected-operation" }, "name": "data-selected-value", "expected": "preserve" } ] },
     { "id": "wait-banner", "narration": "Wait for the delayed status banner to appear.", "action": { "type": "wait-for", "locator": { "kind": "text", "text": "Delayed banner is now visible" }, "state": "visible", "timeoutMs": 5000 }, "callout": { "text": "The banner appears after a short delay." }, "screenshot": { "id": "banner-visible" }, "assertions": [ { "type": "element-visible", "locator": { "kind": "test-id", "testId": "status-banner" } } ] }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dailephd/my-dev-kit-lab",
-  "version": "0.4.8",
+  "version": "0.5.0",
   "type": "module",
   "description": "Evidence, benchmark, and evaluation companion for my-dev-kit.",
   "bin": {