@oqtopus-team/pi-qdash 0.1.5 → 0.1.6

package/README.md

@@ -43,7 +43,9 @@ Or try it without installing:
 pi -e npm:@oqtopus-team/pi-qdash
 ```
 
-Requires pi v0.74.0 or later.
+Requires Node.js 20 or later and pi v0.74.0 or later. The extension tracks
+`@oqtopus-team/qdash-client` 1.9.x and uses its authenticated high-level and
+generated API clients.
 
 ## Quick Start
 

package/extensions/qdash.ts

@@ -4,7 +4,13 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 
 import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
-import { QDashClient, defaultConfigPath, type DownloadedFile, type TaskResultFigureOptions } from "@oqtopus-team/qdash-client";
+import {
+  QDashClient,
+  defaultConfigPath,
+  type CooldownResponse,
+  type DownloadedFile,
+  type TaskResultFigureOptions,
+} from "@oqtopus-team/qdash-client";
 import { Text, truncateToWidth } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
@@ -397,6 +403,9 @@ async function defaultChipId(client: QDashClient, chipId?: string): Promise<stri
   return chipId ?? currentContext.chipId ?? client.getDefaultChipId();
 }
 
+// Keep arbitrary GET access isolated for qdash_raw_get and legacy filters that are
+// not represented in the generated OpenAPI surface. Normal operations should use
+// QDashClient's high-level methods or client.api so upgrades remain type-checked.
 async function rawGet<T>(client: QDashClient, path: string, query?: Record<string, unknown>): Promise<T> {
   return (client as unknown as { get<T>(path: string, query?: Record<string, unknown>): Promise<T> }).get(path, cleanQuery(query));
 }
@@ -472,19 +481,6 @@ function requireValue(value: string | undefined, name: string): string {
   return value;
 }
 
-type CooldownRecord = {
-  cooldown_id: string;
-  cryo_id: string;
-  description?: string;
-  started_at: string;
-  ended_at?: string | null;
-  chip_ids?: string[];
-  wiring_info?: string;
-  wiring_blocks?: Record<string, unknown>[];
-};
-
-type CooldownListResponse = { cooldowns?: CooldownRecord[] };
-
 type CooldownWiringParams = {
   profile?: string;
   configPath?: string;
@@ -502,7 +498,7 @@ type WiringInsightParams = CooldownWiringParams & {
   color?: boolean;
 };
 
-function newestCooldown(cooldowns: CooldownRecord[]): CooldownRecord | undefined {
+function newestCooldown(cooldowns: CooldownResponse[]): CooldownResponse | undefined {
   return [...cooldowns].sort((a, b) => {
     const activeDifference = Number(a.ended_at != null) - Number(b.ended_at != null);
     if (activeDifference !== 0) return activeDifference;
@@ -514,15 +510,15 @@ async function resolveCooldownWiring(params: CooldownWiringParams) {
   params = applyQDashContext(params);
   const client = await makeClient(params);
   let selection: string;
-  let cooldown: CooldownRecord;
+  let cooldown: CooldownResponse;
   let resolvedChipId = params.chipId ?? currentContext.chipId;
 
   if (params.cooldownId) {
-    cooldown = await rawGet<CooldownRecord>(client, `/cooldowns/${pathPart(params.cooldownId)}`);
+    cooldown = await client.api.getCooldown(params.cooldownId);
     selection = "explicit cooldownId";
   } else {
     resolvedChipId = params.chipId ?? (params.cryoId ? undefined : await defaultChipId(client));
-    const response = await rawGet<CooldownListResponse>(client, "/cooldowns", {
+    const response = await client.api.listCooldowns({
       cryo_id: params.cryoId,
       chip_id: resolvedChipId,
     });
@@ -531,7 +527,7 @@ async function resolveCooldownWiring(params: CooldownWiringParams) {
       const scope = params.cryoId ? `cryo ${params.cryoId}` : `chip ${resolvedChipId}`;
       throw new Error(`No cooldown containing wiring information was found for ${scope}`);
     }
-    cooldown = await rawGet<CooldownRecord>(client, `/cooldowns/${pathPart(selected.cooldown_id)}`);
+    cooldown = await client.api.getCooldown(selected.cooldown_id);
     selection = params.cryoId ? "active/newest cooldown for cryo" : "active/newest cooldown for chip";
   }
 
@@ -539,14 +535,14 @@ async function resolveCooldownWiring(params: CooldownWiringParams) {
   const wiringInfo = typeof cooldown.wiring_info === "string" ? cooldown.wiring_info.trim() : "";
   const includeBlocks = params.includeBlocks === true || !wiringInfo;
   const history = params.includeHistory
-    ? await rawGet(client, `/cooldowns/${pathPart(cooldown.cooldown_id)}/wiring-events`, {
+    ? await client.api.listCooldownWiringEvents(cooldown.cooldown_id, {
         limit: params.historyLimit ?? 20,
         skip: 0,
       })
     : undefined;
   let cryostat: unknown;
   try {
-    cryostat = await rawGet(client, `/cryostats/${pathPart(cooldown.cryo_id)}`);
+    cryostat = await client.api.getCryostat(cooldown.cryo_id);
   } catch {
     // Wiring remains useful on servers where cryostat detail is not accessible.
   }
@@ -594,9 +590,9 @@ async function buildDashboard(params: { profile?: string; configPath?: string; u
   const chipId = await defaultChipId(client, params.chipId);
   const [chips, openIssues, recentExecutions, failedTaskResults, provenanceStats] = await Promise.allSettled([
     client.listChips(),
-    rawGet(client, "/issues", { is_closed: false, limit }),
-    rawGet(client, "/executions", { chip_id: chipId, limit }),
-    rawGet(client, "/task-results", { chip_id: chipId, status: "failed", limit }),
+    client.api.listIssues({ is_closed: false, limit }),
+    client.api.listExecutions({ chip_id: chipId, limit }),
+    client.api.listTaskResults({ chip_id: chipId, status: "failed", limit }),
     client.getProvenanceStats(),
   ]);
   const value = <T>(result: PromiseSettledResult<T>): T | { error: string } => result.status === "fulfilled" ? result.value : { error: result.reason instanceof Error ? result.reason.message : String(result.reason) };
@@ -738,7 +734,7 @@ async function buildRecentCalibrationSummary(params: { profile?: string; configP
   const chipId = await defaultChipId(client, params.chipId);
   const end = new Date();
   const start = new Date(end.getTime() - (params.withinHours ?? 24) * 3600_000);
-  const payload = await rawGet(client, "/task-results", { chip_id: chipId, start_from: start.toISOString(), start_to: end.toISOString(), limit: params.limit ?? 30 });
+  const payload = await client.api.listTaskResults({ chip_id: chipId, start_from: start.toISOString(), start_to: end.toISOString(), limit: params.limit ?? 30 });
   const items = arrayFromPayload(payload).filter((item): item is Record<string, unknown> => Boolean(item) && typeof item === "object");
   const byTarget = new Map<string, Record<string, unknown>[]>();
   for (const item of items) {
@@ -939,7 +935,7 @@ async function buildTargetOperationsReport(params: { profile?: string; configPat
   const [latestTarget, results, issues, forumPosts] = await Promise.all([
     kind === "qubit" ? client.getChipQubit(chipId, id) : client.getChipCoupling(chipId, id),
     client.listTaskResults({ chipId, qid, couplingId, startAt: start.toISOString(), endAt: end.toISOString(), limit }),
-    rawGet(client, "/issues", { is_closed: false, limit: 100 }),
+    client.api.listIssues({ is_closed: false, limit: 100 }),
     client.listForumPosts({ chipId, status: "open", targetType: kind, targetId: id, limit }),
   ]);
   const recentResults = arrayFromPayload(results).filter((item): item is Record<string, unknown> => Boolean(item) && typeof item === "object");
@@ -1123,7 +1119,7 @@ async function buildCalibrationValidation(params: { profile?: string; configPath
   const task = await client.getTaskResult(params.taskId) as unknown as Record<string, unknown>;
   const status = firstString(task, ["status"])?.toLowerCase() ?? "unknown";
   const figurePaths = taskFigurePaths(task, 20);
-  const issuesPayload = await rawGet(client, `/task-results/${pathPart(params.taskId)}/issues`).catch(() => []);
+  const issuesPayload = await client.api.getTaskResultIssues(params.taskId).catch(() => []);
   const issues = arrayFromPayload(issuesPayload).filter((item): item is Record<string, unknown> => Boolean(item) && typeof item === "object");
   const afterExecutionId = firstString(task, ["execution_id", "executionId"]);
   const comparison = params.beforeExecutionId && afterExecutionId
@@ -1256,10 +1252,10 @@ async function buildDashboardInsights(params: { profile?: string; configPath?: s
   const start = new Date(end.getTime() - (params.withinHours ?? 168) * 3600_000);
   const [forums, issues, failed, metrics, aiInsights] = await Promise.allSettled([
     client.listForumPosts({ chipId, status: "open", limit }),
-    rawGet(client, "/issues", { is_closed: false, limit }),
-    rawGet(client, "/task-results", { chip_id: chipId, status: "failed", start_from: start.toISOString(), start_to: end.toISOString(), limit }),
+    client.api.listIssues({ is_closed: false, limit }),
+    client.api.listTaskResults({ chip_id: chipId, status: "failed", start_from: start.toISOString(), start_to: end.toISOString(), limit }),
     client.getChipMetrics(chipId),
-    rawGet(client, `/chips/${pathPart(chipId)}/ai-insights`, { latest_only: true, start_at: start.toISOString(), end_at: end.toISOString() }),
+    client.api.getDashboardAiInsights(chipId, { latest_only: true, start_at: start.toISOString(), end_at: end.toISOString() }),
   ]);
   const value = <T>(result: PromiseSettledResult<T>): T | undefined => result.status === "fulfilled" ? result.value : undefined;
   const insightMap = new Map<string, DashboardInsight>();
@@ -1485,19 +1481,19 @@ async function executeQuery(params: QDashQueryParams) {
     case "chip_qubit": return client.getChipQubit(await defaultChipId(client, params.chipId), requireValue(params.qid, "qid"));
     case "chip_couplings": return client.listChipCouplings(await defaultChipId(client, params.chipId), { limit: params.limit, offset: params.offset });
     case "chip_coupling": return client.getChipCoupling(await defaultChipId(client, params.chipId), requireValue(params.couplingId, "couplingId"));
-    case "cryostats": return rawGet(client, "/cryostats");
-    case "cryostat": return rawGet(client, `/cryostats/${pathPart(requireValue(params.cryoId, "cryoId"))}`);
-    case "cooldowns": return rawGet(client, "/cooldowns", { cryo_id: params.cryoId, chip_id: params.chipId });
-    case "cooldown": return rawGet(client, `/cooldowns/${pathPart(requireValue(params.cooldownId, "cooldownId"))}`);
-    case "cooldown_wiring_events": return rawGet(client, `/cooldowns/${pathPart(requireValue(params.cooldownId, "cooldownId"))}/wiring-events`, { limit: params.limit, skip: params.skip });
+    case "cryostats": return client.api.listCryostats();
+    case "cryostat": return client.api.getCryostat(requireValue(params.cryoId, "cryoId"));
+    case "cooldowns": return client.api.listCooldowns({ cryo_id: params.cryoId, chip_id: params.chipId });
+    case "cooldown": return client.api.getCooldown(requireValue(params.cooldownId, "cooldownId"));
+    case "cooldown_wiring_events": return client.api.listCooldownWiringEvents(requireValue(params.cooldownId, "cooldownId"), { limit: params.limit, skip: params.skip });
     case "timeseries": return client.getTaskResultsTimeseries({ chipId: await defaultChipId(client, params.chipId), parameter: requireValue(params.parameter, "parameter"), tag: params.tag, qid: params.qid, startAt: requireValue(params.startAt, "startAt"), endAt: requireValue(params.endAt, "endAt") });
     case "task_results": return rawGet(client, "/task-results", { chip_id: params.chipId, task_name: params.taskName, qid: params.qid, coupling_id: params.couplingId, execution_id: params.executionId, username: params.username, status: params.status, start_from: params.startFrom ?? params.startAt, start_to: params.startTo ?? params.endAt, message_contains: params.messageContains, limit: params.limit, skip: params.skip });
     case "task_result": return client.getTaskResult(requireValue(params.taskId, "taskId"));
-    case "task_note": return rawGet(client, `/task-results/${pathPart(requireValue(params.taskId, "taskId"))}/note`);
-    case "task_result_issues": return rawGet(client, `/task-results/${pathPart(requireValue(params.taskId, "taskId"))}/issues`);
-    case "qubit_latest": return rawGet(client, "/task-results/qubits/latest", { chip_id: await defaultChipId(client, params.chipId), task: requireValue(params.task ?? params.taskName, "task") });
+    case "task_note": return client.api.getTaskNote(requireValue(params.taskId, "taskId"));
+    case "task_result_issues": return client.api.getTaskResultIssues(requireValue(params.taskId, "taskId"));
+    case "qubit_latest": return client.api.getLatestQubitTaskResults({ chip_id: await defaultChipId(client, params.chipId), task: requireValue(params.task ?? params.taskName, "task") });
     case "qubit_history": return rawGet(client, `/task-results/qubits/${pathPart(requireValue(params.qid, "qid"))}/history`, { chip_id: await defaultChipId(client, params.chipId), task: requireValue(params.task ?? params.taskName, "task"), date: requireValue(params.date, "date") });
-    case "coupling_latest": return rawGet(client, "/task-results/couplings/latest", { chip_id: await defaultChipId(client, params.chipId), task: requireValue(params.task ?? params.taskName, "task") });
+    case "coupling_latest": return client.api.getLatestCouplingTaskResults({ chip_id: await defaultChipId(client, params.chipId), task: requireValue(params.task ?? params.taskName, "task") });
     case "coupling_history": return rawGet(client, `/task-results/couplings/${pathPart(requireValue(params.couplingId, "couplingId"))}/history`, { chip_id: await defaultChipId(client, params.chipId), task: requireValue(params.task ?? params.taskName, "task"), date: requireValue(params.date, "date") });
     case "tasks": return client.listTasks(params.backend);
     case "task_knowledge": return params.taskName ? client.getTaskKnowledge(params.taskName) : client.listTaskKnowledge();
@@ -1507,23 +1503,26 @@ async function executeQuery(params: QDashQueryParams) {
     case "files_tree": return client.getFilesTree();
     case "file_content": return client.getFileContent(requireValue(params.path, "path"));
     case "git_status": return client.getGitStatus();
-    case "issues": return rawGet(client, "/issues", { task_id: params.taskId, is_closed: params.isClosed, limit: params.limit, skip: params.skip });
-    case "issue_knowledge": return rawGet(client, "/issue-knowledge", { status: params.status, task_name: params.taskName, limit: params.limit, skip: params.skip });
+    case "issues": return client.api.listIssues({ task_id: params.taskId, is_closed: params.isClosed, limit: params.limit, skip: params.skip });
+    case "issue_knowledge": return client.api.listIssueKnowledge({ status: params.status, task_name: params.taskName, limit: params.limit, skip: params.skip });
     case "flows": return client.listFlows();
     case "flow": return client.getFlow(requireValue(params.flowName, "flowName"));
     case "flow_templates": return client.listFlowTemplates();
     case "flow_template": return client.getFlowTemplate(requireValue(params.templateId, "templateId"));
-    case "flow_helper_files": return rawGet(client, "/flows/helpers");
-    case "flow_helper_file": return rawGet(client, `/flows/helpers/${pathPart(requireValue(params.filename, "filename"))}`);
+    case "flow_helper_files": return client.api.listFlowHelperFiles();
+    case "flow_helper_file": return client.api.getFlowHelperFile(requireValue(params.filename, "filename"));
     case "executions": return rawGet(client, "/executions", { chip_id: params.chipId, flow_name: params.flowName, status: params.status, skip: params.skip, limit: params.limit });
     case "execution": return client.getExecution(requireValue(params.executionId, "executionId"));
-    case "ai_reviews": return rawGet(client, "/task-results/ai-review", { chip_id: params.chipId, task_name: params.taskName, status: params.status, decision: params.decision, latest_only: params.latestOnly, skip: params.skip, limit: params.limit });
-    case "ai_review_runs": return rawGet(client, "/task-results/ai-review/runs", { chip_id: params.chipId, task_name: params.taskName, skip: params.skip, limit: params.limit });
-    case "ai_review_run": return rawGet(client, `/task-results/ai-review/runs/${pathPart(requireValue(params.reviewRunId, "reviewRunId"))}`);
+    case "ai_reviews": return client.api.listTaskResultAiReviews({ chip_id: params.chipId, task_name: params.taskName, status: params.status, decision: params.decision, latest_only: params.latestOnly, skip: params.skip, limit: params.limit });
+    case "ai_review_runs": return client.api.listTaskResultAiReviewRuns({ chip_id: params.chipId, task_name: params.taskName, skip: params.skip, limit: params.limit });
+    case "ai_review_run": return client.api.getTaskResultAiReviewRun(requireValue(params.reviewRunId, "reviewRunId"));
     case "forum_posts": return client.listForumPosts({ status: params.status, chipId: params.chipId, limit: params.limit, skip: params.skip });
     case "provenance_stats": return client.getProvenanceStats();
-    case "provenance_history": return rawGet(client, "/provenance/history", { parameter_name: params.parameterName ?? params.parameter, qid: params.qid, limit: params.limit });
-    case "provenance_changes": return rawGet(client, "/provenance/changes", { parameter_names: params.parameterName ?? params.parameter, within_hours: params.withinHours, limit: params.limit });
+    case "provenance_history": return client.api.getParameterHistory({ parameter_name: requireValue(params.parameterName ?? params.parameter, "parameterName"), qid: requireValue(params.qid, "qid"), limit: params.limit });
+    case "provenance_changes": {
+      const parameterName = params.parameterName ?? params.parameter;
+      return client.getRecentChanges({ parameterNames: parameterName ? [parameterName] : undefined, withinHours: params.withinHours, limit: params.limit });
+    }
     case "provenance_lineage": return client.getProvenanceLineage(requireValue(params.entityId, "entityId"));
     case "provenance_impact": return client.getProvenanceImpact(requireValue(params.entityId, "entityId"));
   }

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@oqtopus-team/pi-qdash",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Pi extension for querying QDash via @oqtopus-team/qdash-client",
   "type": "module",
   "license": "Apache-2.0",
   "author": "OQTOPUS Team <oqtopus-team@googlegroups.com>",
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/oqtopus-team/pi-qdash.git"
@@ -24,7 +27,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@oqtopus-team/qdash-client": "^0.1.4"
+    "@oqtopus-team/qdash-client": "^1.9.11"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",

package/skills/qdash/SKILL.md

@@ -76,6 +76,20 @@ Use these commands to make pi behave like a QDash-specific harness with persiste
 
 Prefer the current context when the user has already selected a profile/chip/session. Tools use that context when parameters are omitted.
 
+## Cooldown-aware investigations
+
+Treat cooldown identity as mandatory investigation context whenever comparing calibration results, coherence metrics, drift, failures, or Forum evidence across time:
+
+1. Call `qdash_list_cooldowns` for the chip early in the investigation and record the relevant `cooldown_id`, `started_at`, and `ended_at` boundaries.
+2. Assign every result or Forum observation used in a comparison to a cooldown. Prefer an explicit `cooldown_id`; when it is absent, infer membership only from the chip association and timestamp boundaries, and label it as inferred.
+3. Do not describe values from different cooldowns as one continuous degradation, recovery, or before/after trend. Partition the evidence by cooldown first. Cross-cooldown comparison is allowed only when it is explicitly identified as such.
+4. State plainly whether the compared evidence comes from the same cooldown, different cooldowns, or an unresolved cooldown context. Include the cooldown IDs in the report and in Forum evidence replies when relevant.
+5. Same cooldown does not guarantee identical measurement conditions. If cabling, attenuation, instruments, or wiring may have changed, inspect `qdash_get_cooldown_wiring` with history or `qdash_list_cooldown_wiring_events`, then distinguish a cooldown boundary from an in-cooldown wiring change.
+6. Do not treat a temporary disconnect/reconnect as a new cooldown unless QDash records a new cooldown. Describe it as an in-cooldown wiring event and report whether the wiring was nominally restored.
+7. Prefer same-cooldown, temporally adjacent measurements for physical interpretation. Older-cooldown evidence may provide context but must not be used to explain a current-cooldown anomaly without an explicit caveat.
+
+Before publishing investigated evidence, verify that every date-based claim respects these rules.
+
 ## Generic timeseries comparison
 
 Use `qdash_compare_timeseries` when the investigation needs to align multiple
@@ -116,8 +130,8 @@ If `QDASH_BASE_URL` is set and no profile is specified, the tools default to env
 
 When the user wants to preserve an investigated observation in QDash forum/notes:
 
-1. Inspect the task result, task figure, timeseries/history, and related forum context first.
-2. Summarize the observation as evidence, not as an automatic calibration decision.
+1. Inspect the task result, task figure, timeseries/history, related Forum context, and cooldown membership first.
+2. Summarize the observation as evidence, not as an automatic calibration decision. State whether compared observations are from the same cooldown, and separate in-cooldown wiring changes from cooldown boundaries.
 3. Prefer replying to an existing target/coupling forum thread when one exists.
 4. Use `qdash_create_forum_evidence_reply` for task-result evidence so figures are embedded as QDash UI image blocks (`/api/executions/figure?path=...`) and visible in the forum.
 5. For locally generated analysis images, call `qdash_preview_forum_image_reply` first, show the exact paths and reply text, then use `qdash_create_forum_image_reply` only after explicit confirmation. Supported images are PNG, JPEG, GIF, and WebP up to 5 MB each.

package/skills/qdash-calibration-agent/SKILL.md

@@ -32,7 +32,8 @@ This skill defines how pi should behave as a conservative, confirmation-gated ca
 
 - Work one target at a time: one qubit or one coupling per action/session when possible.
 - Diagnose before changing parameters.
-- Prefer read-only inspection first: dashboard, failed task results, history, figures, forum posts, and task knowledge when available.
+- Establish cooldown identity before interpreting history: partition evidence by `cooldown_id`, never present different cooldowns as one continuous trend, and distinguish cooldown boundaries from in-cooldown wiring changes.
+- Prefer read-only inspection first: dashboard, cooldowns and wiring events, failed task results, history, figures, forum posts, and task knowledge when available.
 - Use narrow agent session policies with the smallest allowed task/action/parameter scope.
 - Do not commit or apply parameter candidates until a validation task succeeds and the user explicitly confirms.
 - Avoid blind parameter sweeps. If two conservative probes fail, step back to a diagnostic task.
@@ -42,6 +43,8 @@ This skill defines how pi should behave as a conservative, confirmation-gated ca
 
 1. Establish context:
    - profile and chip
+   - active/relevant `cooldown_id` and its time boundaries via `qdash_list_cooldowns`
+   - any in-cooldown wiring changes relevant to the target
    - failed task(s)
    - qid/coupling_id
    - recent executions and open forum/issue context

package/skills/qdash-timeseries-diagnosis/SKILL.md

@@ -22,6 +22,7 @@ checks.
   move together. The sensor itself may be a proxy for an unmeasured actuator,
   vibration, electrical noise, magnetic noise, or control cycle.
 - Count observed cycles, not raw sample points, when judging periodic evidence.
+- Resolve cooldown boundaries before interpreting drift or shared periodicity. Analyze each cooldown separately by default; never smooth, interpolate, correlate, or fit a period across a cooldown boundary unless an explicit cross-cooldown comparison is intended and clearly reported.
 
 ## Workflow
 
@@ -32,6 +33,8 @@ comparison passes are expected. The JSON context accepts arbitrary QDash
 series, CSV mappings, window/timezone, and transform defaults. Record:
 
 - QDash profile and chip
+- cooldown IDs and start/end boundaries from `qdash_list_cooldowns`
+- any in-cooldown wiring events that overlap the window
 - metrics and target IDs
 - tags
 - start/end timestamps
@@ -45,7 +48,9 @@ a timezone from the host machine.
 ### 2. Inspect source integrity
 
 Before comparing, use `qdash_inspect_timeseries_csv` for local files whose
-schema or time encoding is not already established. Then:
+schema or time encoding is not already established. Use `qdash_list_cooldowns`
+to split the requested window at cooldown boundaries, and inspect cooldown
+wiring events when hardware conditions may have changed. Then:
 
 - verify first/last timestamps and overlap
 - check source point counts and cadence

package/skills/qdash-two-qubit-calibration-diagnosis/SKILL.md

@@ -17,7 +17,8 @@ Use this skill when investigating coupling-level calibration quality, especially
 
 - Treat `completed` as execution status, not proof of calibration quality.
 - Diagnose from evidence before suggesting operational actions.
-- Prefer read-only tools first: `qdash_target_report`, `qdash_list_task_results`, `qdash_get_task_result`, `qdash_analyze_figure_json`, and `qdash_get_task_figures`.
+- Resolve cooldown membership before comparing calibrations or coherence limits. Keep different cooldowns separate, and distinguish a cooldown boundary from an in-cooldown wiring change.
+- Prefer read-only tools first: `qdash_list_cooldowns`, `qdash_target_report`, `qdash_list_task_results`, `qdash_get_task_result`, `qdash_analyze_figure_json`, and `qdash_get_task_figures`.
 - Do not rerun RB first when validation quality is suspicious. Walk back through prerequisites.
 - Do not commit or apply candidates without explicit user confirmation, and only after downstream validation.
 
@@ -25,8 +26,8 @@ Use this skill when investigating coupling-level calibration quality, especially
 
 For a coupling `cA-B`:
 
-1. Build context with `qdash_target_report` and recent task results for the coupling.
-2. Inspect the latest tasks in this chain:
+1. Build context with `qdash_list_cooldowns`, `qdash_target_report`, and recent task results for the coupling. Record the cooldown ID for each result and inspect wiring events when measurement conditions may have changed.
+2. Inspect the latest same-cooldown tasks in this chain by default:
    - `CheckCrossResonance`
    - `CreateZX90`
    - `CheckZX90`