@oqtopus-team/pi-qdash 0.1.10 → 0.1.11-beta.20

package/README.md

@@ -16,7 +16,7 @@ It uses [`@oqtopus-team/qdash-client`](https://www.npmjs.com/package/@oqtopus-te
 
 ## Key Features
 
-- **Read-only investigation**: dedicated tools to inspect chips, qubits, couplings, calibration task results, task knowledge (`qdash_get_task_knowledge`), executions, issues, and Forum posts. Secrets are redacted from tool output.
+- **Read-only investigation**: dedicated tools to inspect chips, qubits, couplings, calibration task results, task knowledge (`qdash_get_task_knowledge`), executions, and Forum posts. Secrets are redacted from tool output.
 - **Dashboards and insights**: compact dashboards, triage overviews, target-level incident reports, degradation reports, and wiring insights.
 - **Agent calibration workflow**: create agent sessions, submit and track agent actions, and commit/apply calibration candidates. Write operations are approval-gated.
 - **Calibration pipelines**: compose a declarative pipeline spec from QDash's step catalog (`qdash_get_pipeline_catalog`), validate it (`qdash_plan_pipeline`), and run it as one execution (`qdash_run_pipeline`, approval-gated).

package/extensions/lib/links.ts

@@ -44,12 +44,10 @@ export function qdashObjectLinks(client: QDashClient, object: Record<string, unk
   const executionId = firstString(object, ["execution_id", "executionId"]);
   const chipId = firstString(object, ["chip_id", "chipId"]);
   const postId = firstString(object, ["post_id", "forum_post_id", "id"]);
-  const issueId = firstString(object, ["issue_id"]);
   const sessionId = firstString(object, ["session_id", "sessionId"]);
   if (taskId) links.task_result = qdashWebUrl(client, `/task-results/${encodeURIComponent(taskId)}`);
   if (executionId) links.execution = qdashWebUrl(client, executionPagePath(executionId, chipId));
   if (postId) links.forum_post = qdashWebUrl(client, forumPostPagePath(postId));
-  if (issueId) links.issue = qdashWebUrl(client, `/issues/${encodeURIComponent(issueId)}`);
   if (sessionId) links.agent_session = qdashWebUrl(client, `/agent-sessions/${encodeURIComponent(sessionId)}`);
   return links;
 }

package/extensions/lib/qcal-evidence.ts

@@ -0,0 +1,164 @@
+/**
+ * Evidence text for pi-qcaleval's `qcal_evaluate`: what a task result's
+ * measurement settings were, read from the run parameters QDash records.
+ *
+ * The evaluation model is meant to read the plot, so the context names the
+ * task, the target and the sweep (what was varied, over which range, in how
+ * many points), not the fitted results. The numbers come from the recorded
+ * parameters, so they are exact and need no hand-written summary.
+ */
+
+/** One parameter as QDash records it on a task result. */
+export interface RecordedParameter {
+  value: unknown;
+  unit: string;
+  value_type: string;
+  description: string;
+}
+
+/** A swept parameter: the axis a plot was taken along. */
+export interface Sweep {
+  name: string;
+  unit: string;
+  description: string;
+  /** How the points are spaced. */
+  spacing: "linear" | "log" | "list";
+  /** First and last point, in the parameter's unit. */
+  start: number;
+  stop: number;
+  points: number;
+  /** Spacing between points for a linear sweep. */
+  step?: number;
+}
+
+/** The recorded parameters of a task result, as a name → record map. */
+export function recordedParameters(value: unknown): Record<string, RecordedParameter> {
+  const output: Record<string, RecordedParameter> = {};
+  const input = value && typeof value === "object" ? (value as Record<string, unknown>) : {};
+  for (const [name, raw] of Object.entries(input)) {
+    if (raw && typeof raw === "object" && "value" in raw) {
+      const record = raw as Record<string, unknown>;
+      output[name] = {
+        value: record.value,
+        unit: typeof record.unit === "string" ? record.unit : "",
+        value_type: typeof record.value_type === "string" ? record.value_type : "",
+        description: typeof record.description === "string" ? record.description : "",
+      };
+    } else if (typeof raw === "number" || typeof raw === "string" || typeof raw === "boolean" || Array.isArray(raw)) {
+      output[name] = { value: raw, unit: "", value_type: Array.isArray(raw) ? "list" : typeof raw, description: "" };
+    }
+  }
+  return output;
+}
+
+function numbers(value: unknown): number[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const list = value.map((item) => (typeof item === "number" ? item : typeof item === "string" ? Number(item) : Number.NaN));
+  return list.length > 0 && list.every((item) => Number.isFinite(item)) ? list : undefined;
+}
+
+/**
+ * The sweeps among the recorded parameters, in record order, read the way
+ * QDash's `get_value` expands them: `range` / `np.arange` as (start, stop,
+ * step), `np.linspace` as (start, stop, num), `np.logspace` as (log10 start,
+ * log10 stop, num), and `list` as the points themselves.
+ */
+export function sweepsOf(parameters: Record<string, RecordedParameter>): Sweep[] {
+  const sweeps: Sweep[] = [];
+  for (const [name, parameter] of Object.entries(parameters)) {
+    const values = numbers(parameter.value);
+    if (!values) continue;
+    const base = { name, unit: parameter.unit, description: parameter.description };
+    const type = parameter.value_type;
+    if ((type === "range" || type === "np.arange") && values.length === 3) {
+      const [start, stop, step] = values as [number, number, number];
+      if (step === 0 || (stop - start) / step <= 0) continue;
+      const points = Math.ceil((stop - start) / step - 1e-9);
+      sweeps.push({ ...base, spacing: "linear", start, stop: start + (points - 1) * step, points, step });
+    } else if (type === "np.linspace" && values.length === 3) {
+      const [start, stop, num] = values as [number, number, number];
+      const points = Math.max(1, Math.round(num));
+      sweeps.push({ ...base, spacing: "linear", start, stop, points, ...(points > 1 ? { step: (stop - start) / (points - 1) } : {}) });
+    } else if (type === "np.logspace" && values.length === 3) {
+      const [start, stop, num] = values as [number, number, number];
+      sweeps.push({ ...base, spacing: "log", start: 10 ** start, stop: 10 ** stop, points: Math.max(1, Math.round(num)) });
+    } else if (type === "list" || type === "" || values.length !== 3) {
+      if (values.length < 2) continue;
+      sweeps.push({ ...base, spacing: "list", start: Math.min(...values), stop: Math.max(...values), points: values.length });
+    }
+  }
+  return sweeps;
+}
+
+/** A number for the model: up to four significant digits, no trailing zeros. */
+export function formatNumber(value: number): string {
+  if (!Number.isFinite(value)) return String(value);
+  if (Number.isInteger(value) && Math.abs(value) < 1e15) return String(value);
+  const text = Math.abs(value) >= 1e6 || Math.abs(value) < 1e-4 ? value.toExponential(3) : value.toPrecision(4);
+  return text.includes("e") ? text.replace(/\.?0+e/, "e") : text.replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "");
+}
+
+function withUnit(value: number, unit: string): string {
+  const text = formatNumber(value);
+  return unit && unit !== "a.u." ? `${text} ${unit}` : text;
+}
+
+/** One sweep as text, e.g. "time_range 0 to 400 ns in steps of 8 ns (51 points)". */
+export function formatSweep(sweep: Sweep): string {
+  const range = `${sweep.name} ${formatNumber(sweep.start)} to ${withUnit(sweep.stop, sweep.unit)}`;
+  if (sweep.spacing === "log") return `${range}, ${sweep.points} points log-spaced`;
+  if (sweep.spacing === "list") return `${range}, ${sweep.points} points`;
+  return sweep.step === undefined ? `${range}, ${sweep.points} points` : `${range} in steps of ${withUnit(sweep.step, sweep.unit)} (${sweep.points} points)`;
+}
+
+/** Scalar settings as "name value unit" items, numbers and short strings only. */
+export function formatSettings(parameters: Record<string, RecordedParameter>, skip: ReadonlySet<string> = new Set()): string[] {
+  const items: string[] = [];
+  for (const [name, parameter] of Object.entries(parameters)) {
+    if (skip.has(name)) continue;
+    const value = parameter.value;
+    if (typeof value === "number") items.push(`${name} ${withUnit(value, parameter.unit)}`);
+    else if (typeof value === "boolean") items.push(`${name} ${value}`);
+    else if (typeof value === "string" && value.length <= 40) items.push(`${name} ${value}`);
+  }
+  return items;
+}
+
+export interface QcalContext {
+  taskName?: string;
+  status?: string;
+  targetKind?: string;
+  targetId?: string;
+  chipId?: string;
+  runParameters: Record<string, RecordedParameter>;
+  /** Calibration inputs (previous values), shown only on request. */
+  inputParameters?: Record<string, RecordedParameter>;
+  /** Fitted results, shown only on request. */
+  metrics?: Record<string, RecordedParameter>;
+  message?: string;
+}
+
+/**
+ * The context for `qcal_evaluate`: the task and target, then the sweep and
+ * the other run settings. Inputs and fitted results are added only when the
+ * caller asks, since the model is meant to read the plot.
+ */
+export function qcalContextText(context: QcalContext): string {
+  let head = `Task ${context.taskName ?? "unknown"}`;
+  if (context.targetId) {
+    head += ` on ${context.targetKind && context.targetKind !== "system" ? `${context.targetKind} ${context.targetId}` : context.targetId}`;
+  }
+  if (context.chipId) head += ` (chip ${context.chipId})`;
+  if (context.status) head += `, status ${context.status}`;
+  const lines = [`${head}.`];
+  const sweeps = sweepsOf(context.runParameters);
+  if (sweeps.length > 0) lines.push(`Sweep: ${sweeps.map(formatSweep).join("; ")}.`);
+  const settings = formatSettings(context.runParameters, new Set(sweeps.map((sweep) => sweep.name)));
+  if (settings.length > 0) lines.push(`Settings: ${settings.join("; ")}.`);
+  const inputs = context.inputParameters ? formatSettings(context.inputParameters) : [];
+  if (inputs.length > 0) lines.push(`Calibration inputs: ${inputs.join("; ")}.`);
+  const metrics = context.metrics ? formatSettings(context.metrics) : [];
+  if (metrics.length > 0) lines.push(`Fitted results: ${metrics.join("; ")}.`);
+  if (context.message?.trim()) lines.push(`Task message: ${context.message.trim()}`);
+  return lines.join("\n");
+}

package/extensions/qdash.ts

@@ -25,6 +25,7 @@ import { toFigureToolResult, toTextToolResult, toToolResult } from "./lib/result
 import { ansi, boxLinesToWidth, boxed, formatNumber, textComponent } from "./lib/render.js";
 import { plotSeriesLines, timeseriesPlotComponent, timeseriesPoints } from "./lib/timeseries-plot.js";
 import { installQDashWriteGate } from "./lib/write-gate.js";
+import { qcalContextText, recordedParameters, sweepsOf, type RecordedParameter, type Sweep } from "./lib/qcal-evidence.js";
 import { registerCalibrationPipelineTools } from "./tools/calibration-pipeline.js";
 import { registerTaskKnowledgeTool } from "./tools/task-knowledge.js";
 import { registerTimeseriesComparisonTool } from "./tools/timeseries.js";
@@ -52,7 +53,6 @@ type QDashQueryParams = {
     | "task_results"
     | "task_result"
     | "task_note"
-    | "task_result_issues"
     | "qubit_latest"
     | "qubit_history"
     | "coupling_latest"
@@ -65,8 +65,6 @@ type QDashQueryParams = {
     | "files_tree"
     | "file_content"
     | "git_status"
-    | "issues"
-    | "issue_knowledge"
     | "flows"
     | "flow"
     | "flow_templates"
@@ -108,7 +106,6 @@ type QDashQueryParams = {
   endAt?: string;
   startFrom?: string;
   startTo?: string;
-  isClosed?: boolean;
   withinHours?: number;
   limit?: number;
   skip?: number;
@@ -294,7 +291,6 @@ const QueryAction = Type.Union([
   Type.Literal("task_results"),
   Type.Literal("task_result"),
   Type.Literal("task_note"),
-  Type.Literal("task_result_issues"),
   Type.Literal("qubit_latest"),
   Type.Literal("qubit_history"),
   Type.Literal("coupling_latest"),
@@ -307,8 +303,6 @@ const QueryAction = Type.Union([
   Type.Literal("files_tree"),
   Type.Literal("file_content"),
   Type.Literal("git_status"),
-  Type.Literal("issues"),
-  Type.Literal("issue_knowledge"),
   Type.Literal("flows"),
   Type.Literal("flow"),
   Type.Literal("flow_templates"),
@@ -371,7 +365,6 @@ const querySchema = Type.Object({
   endAt: Type.Optional(Type.String()),
   startFrom: Type.Optional(Type.String()),
   startTo: Type.Optional(Type.String()),
-  isClosed: Type.Optional(Type.Boolean()),
   withinHours: Type.Optional(Type.Number()),
   limit: Type.Optional(Type.Number()),
   skip: Type.Optional(Type.Number()),
@@ -413,6 +406,14 @@ type CalibrationEvidence = {
   task?: Record<string, unknown>;
   metrics?: Record<string, number | string | boolean | null>;
   parameters?: Record<string, number | string | boolean | null>;
+  /** The run parameters as recorded, with units and value types. */
+  runParameters?: Record<string, RecordedParameter>;
+  /** The calibration inputs as recorded (previous values), with units. */
+  inputParameters?: Record<string, RecordedParameter>;
+  /** The output parameters as recorded (fitted results), with units. */
+  metricRecords?: Record<string, RecordedParameter>;
+  /** The swept parameters among them: the axes the plot was taken along. */
+  sweeps?: Sweep[];
   resultJson?: unknown;
   figures?: Array<Record<string, unknown>>;
   logs?: string[];
@@ -439,23 +440,24 @@ function firstStringField(object: Record<string, unknown>, keys: string[]): stri
   return undefined;
 }
 
-function qcalEvidenceText(evidence: CalibrationEvidence): string {
-  const metrics = Object.entries(evidence.metrics ?? {}).slice(0, 8).map(([key, value]) => `  - ${key}: ${String(value)}`);
-  const figures = evidence.figures ?? [];
-  return boxed("QDash QCal Evidence", [
-    `id ${evidence.id ?? "n/a"}`,
-    `source ${evidence.source}`,
-    `target ${evidence.target?.id ?? evidence.target?.couplingId ?? evidence.target?.qids ?? "n/a"}`,
-    `task ${evidence.task?.name ?? "n/a"} (${evidence.task?.status ?? "unknown"})`,
-    "",
-    "Metrics",
-    ...(metrics.length ? metrics : ["  - none"]),
-    "",
-    `Figures ${figures.length}`,
-    ...figures.map((figure, index) => `  - #${index + 1} ${String(figure.role ?? "plot")} ${String(figure.path ?? figure.url ?? "")}`),
-    "",
-    "Pass this summary as the context of qcal_evaluate; the embedded figure is the measured result to judge.",
-  ]).join("\n");
+/**
+ * The evidence text, used as the context of `qcal_evaluate`: the task, the
+ * target, the sweep and the run settings. Fitted results and calibration
+ * inputs are left out unless asked for, since the evaluation model is meant
+ * to read them off the plot.
+ */
+function qcalEvidenceText(evidence: CalibrationEvidence, include: { inputs?: boolean; metrics?: boolean } = {}): string {
+  return qcalContextText({
+    taskName: typeof evidence.task?.name === "string" ? evidence.task.name : undefined,
+    status: typeof evidence.task?.status === "string" ? evidence.task.status : undefined,
+    targetKind: typeof evidence.target?.kind === "string" ? evidence.target.kind : undefined,
+    targetId: typeof evidence.target?.id === "string" ? evidence.target.id : undefined,
+    chipId: typeof evidence.target?.chipId === "string" ? evidence.target.chipId : undefined,
+    runParameters: evidence.runParameters ?? {},
+    ...(include.inputs ? { inputParameters: recordedParameters(evidence.inputParameters) } : {}),
+    ...(include.metrics ? { metrics: recordedParameters(evidence.metricRecords) } : {}),
+    message: typeof evidence.task?.message === "string" ? evidence.task.message : undefined,
+  });
 }
 
 function cleanQuery(values: Record<string, unknown> = {}): Record<string, unknown> {
@@ -578,25 +580,25 @@ async function buildDashboard(params: { profile?: string; configPath?: string; u
   const limit = params.limit ?? 5;
   const client = await makeClient(params);
   const chipId = await defaultChipId(client, params.chipId);
-  const [chips, openIssues, recentExecutions, failedTaskResults, provenanceStats] = await Promise.allSettled([
+  const [chips, openThreads, recentExecutions, failedTaskResults, provenanceStats] = await Promise.allSettled([
     client.listChips(),
-    client.api.listIssues({ is_closed: false, limit }),
+    client.listForumPosts({ chipId, status: "open", 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) };
-  const issuesPayload = value(openIssues);
+  const threadsPayload = value(openThreads);
   const executionsPayload = value(recentExecutions);
   const failedTasksPayload = value(failedTaskResults);
   return {
     context: { ...currentContext, profile: params.profile ?? currentContext.profile, chipId },
     chips: value(chips),
-    openIssues: {
-      count: payloadTotal(issuesPayload),
-      shown: arrayFromPayload(issuesPayload).length,
-      items: compactItems(issuesPayload, ["issue_id", "id", "title", "task_id", "is_closed", "severity", "created_at"], limit),
-      raw: issuesPayload,
+    openThreads: {
+      count: payloadTotal(threadsPayload),
+      shown: arrayFromPayload(threadsPayload).length,
+      items: compactItems(threadsPayload, ["number", "title", "category", "target_type", "target_id", "created_at"], limit),
+      raw: threadsPayload,
     },
     recentExecutions: {
       count: payloadTotal(executionsPayload),
@@ -624,14 +626,14 @@ function dashboardLines(dashboard: Awaited<ReturnType<typeof buildDashboard>>, c
   const success = (text: string) => color ? ansi("32", text) : text;
   const warning = (text: string) => color ? ansi("33", text) : text;
   const error = (text: string) => color ? ansi("31", text) : text;
-  const issueCount = dashboard.openIssues.count > 0 ? warning(String(dashboard.openIssues.count)) : success(String(dashboard.openIssues.count));
+  const threadCount = dashboard.openThreads.count > 0 ? warning(String(dashboard.openThreads.count)) : success(String(dashboard.openThreads.count));
   const failedCount = dashboard.failedTaskResults.count > 0 ? error(`${dashboard.failedTaskResults.shown}/${dashboard.failedTaskResults.count}`) : success(`${dashboard.failedTaskResults.shown}/${dashboard.failedTaskResults.count}`);
   return boxed("QDash Harness", [
     `${muted("profile")} ${accent(profile)}   ${muted("chip")} ${accent(dashboard.context.chipId)}   ${muted("session")} ${dim(session)}`,
-    `${muted("chips")} ${success(String(chips.length))}   ${muted("open issues")} ${issueCount}   ${muted("executions")} ${accent(`${dashboard.recentExecutions.shown}/${dashboard.recentExecutions.count}`)}   ${muted("failed tasks")} ${failedCount}`,
+    `${muted("chips")} ${success(String(chips.length))}   ${muted("open threads")} ${threadCount}   ${muted("executions")} ${accent(`${dashboard.recentExecutions.shown}/${dashboard.recentExecutions.count}`)}   ${muted("failed tasks")} ${failedCount}`,
     "",
-    accent("Open issues"),
-    ...(dashboard.openIssues.items.length > 0 ? dashboard.openIssues.items.map((item, index) => `  ${warning(formatItem(item, `issue-${index + 1}`))}`) : [`  ${dim("none")}`]),
+    accent("Open Forum threads"),
+    ...(dashboard.openThreads.items.length > 0 ? dashboard.openThreads.items.map((item, index) => `  ${warning(formatItem(item, `thread-${index + 1}`))}`) : [`  ${dim("none")}`]),
     "",
     accent("Recent executions"),
     ...(dashboard.recentExecutions.items.length > 0 ? dashboard.recentExecutions.items.map((item, index) => `  ${muted(formatItem(item, `exec-${index + 1}`))}`) : [`  ${dim("none")}`]),
@@ -645,7 +647,7 @@ function styledDashboardLines(dashboard: Awaited<ReturnType<typeof buildDashboar
   const chips = arrayFromPayload(dashboard.chips);
   const profile = dashboard.context.profile ?? "env/default";
   const session = dashboard.context.agentSessionId ? shortId(dashboard.context.agentSessionId) : "none";
-  const issueColor = dashboard.openIssues.count > 0 ? "warning" : "success";
+  const threadColor = dashboard.openThreads.count > 0 ? "warning" : "success";
   const failedColor = dashboard.failedTaskResults.count > 0 ? "error" : "success";
   return [
     theme.fg("accent", theme.bold("QDash Harness")),
@@ -653,14 +655,14 @@ function styledDashboardLines(dashboard: Awaited<ReturnType<typeof buildDashboar
     "",
     [
       `${theme.fg("muted", "chips")} ${theme.fg("success", String(chips.length))}`,
-      `${theme.fg("muted", "open issues")} ${theme.fg(issueColor, String(dashboard.openIssues.count))}`,
+      `${theme.fg("muted", "open threads")} ${theme.fg(threadColor, String(dashboard.openThreads.count))}`,
       `${theme.fg("muted", "executions")} ${theme.fg("accent", `${dashboard.recentExecutions.shown}/${dashboard.recentExecutions.count}`)}`,
       `${theme.fg("muted", "failed tasks")} ${theme.fg(failedColor, `${dashboard.failedTaskResults.shown}/${dashboard.failedTaskResults.count}`)}`,
     ].join("   "),
     "",
-    theme.fg("borderAccent", "Open issues"),
-    ...(dashboard.openIssues.items.length > 0
-      ? dashboard.openIssues.items.map((item, index) => `  ${theme.fg("warning", formatItem(item, `issue-${index + 1}`))}`)
+    theme.fg("borderAccent", "Open Forum threads"),
+    ...(dashboard.openThreads.items.length > 0
+      ? dashboard.openThreads.items.map((item, index) => `  ${theme.fg("warning", formatItem(item, `thread-${index + 1}`))}`)
       : [`  ${theme.fg("dim", "none")}`]),
     "",
     theme.fg("borderAccent", "Recent executions"),
@@ -871,7 +873,6 @@ type TargetOperationsReport = {
   latestTarget: unknown;
   recentResults: Record<string, unknown>[];
   failures: Record<string, unknown>[];
-  issues: Record<string, unknown>[];
   forumPosts: Record<string, unknown>[];
   recommendation: RecommendedNextAction | null;
 };
@@ -922,19 +923,12 @@ async function buildTargetOperationsReport(params: { profile?: string; configPat
   const end = new Date();
   const start = new Date(end.getTime() - (params.withinHours ?? 168) * 3600_000);
   const limit = Math.max(1, Math.min(100, params.limit ?? 10));
-  const [latestTarget, results, issues, forumPosts] = await Promise.all([
+  const [latestTarget, results, 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 }),
-    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");
-  const taskIds = new Set(recentResults.map((item) => firstString(item, ["task_id", "taskId"])).filter((item): item is string => Boolean(item)));
-  const targetIssues = arrayFromPayload(issues).filter((item): item is Record<string, unknown> => {
-    if (!item || typeof item !== "object") return false;
-    const issue = item as Record<string, unknown>;
-    return (firstString(issue, ["task_id", "taskId"]) && taskIds.has(firstString(issue, ["task_id", "taskId"])!)) || targetFromText(firstString(issue, ["title", "summary"]) ?? "") === label;
-  });
   const summary: RecentCalibrationSummary = { context: { profile: params.profile ?? currentContext.profile, chipId, webBaseUrl: qdashWebBaseUrl(client) }, items: recentResults, groups: [] };
   const groups = new Map<string, Record<string, unknown>[]>();
   groups.set(label, recentResults);
@@ -946,7 +940,6 @@ async function buildTargetOperationsReport(params: { profile?: string; configPat
     latestTarget,
     recentResults,
     failures: recentResults.filter((item) => firstString(item, ["status"])?.toLowerCase() === "failed"),
-    issues: targetIssues,
     forumPosts: forumPostsFromPayload(forumPosts),
     recommendation,
   };
@@ -965,7 +958,7 @@ function targetOperationsReportLines(report: TargetOperationsReport, color = fal
   };
   return boxed(`QDash Target Report ${report.target.label}`, [
     `${muted("profile")} ${accent(report.context.profile ?? "env/default")}  ${muted("chip")} ${accent(report.context.chipId)}`,
-    `${muted("results")} ${report.recentResults.length}  ${muted("failures")} ${report.failures.length ? error(String(report.failures.length)) : "0"}  ${muted("issues")} ${report.issues.length ? warn(String(report.issues.length)) : "0"}  ${muted("forum")} ${report.forumPosts.length}`,
+    `${muted("results")} ${report.recentResults.length}  ${muted("failures")} ${report.failures.length ? error(String(report.failures.length)) : "0"}  ${muted("forum")} ${report.forumPosts.length ? warn(String(report.forumPosts.length)) : "0"}`,
     "",
     accent("Recent results"),
     ...(report.recentResults.length ? report.recentResults.slice(0, 10).map(resultLine) : [`  ${muted("none")}`]),
@@ -1097,7 +1090,6 @@ type CalibrationValidation = {
   status: "passed" | "failed" | "needs_review" | "unknown";
   gates: Array<{ name: string; passed: boolean; detail: string }>;
   figurePaths: string[];
-  issues: Record<string, unknown>[];
   comparison?: unknown;
   next: string;
   links: Record<string, string>;
@@ -1109,8 +1101,6 @@ 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 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
     ? await client.compareExecutions(params.beforeExecutionId, afterExecutionId).catch(() => undefined)
@@ -1119,18 +1109,17 @@ async function buildCalibrationValidation(params: { profile?: string; configPath
   const changedParameters = comparisonRecord ? firstNumber(comparisonRecord, ["changed_count"]) ?? (Array.isArray(comparisonRecord.changed_parameters) ? (comparisonRecord.changed_parameters as unknown[]).length : undefined) : undefined;
   const gates = [
     { name: "task completed", passed: ["completed", "success", "succeeded"].includes(status), detail: status },
-    { name: "no task issues", passed: issues.length === 0, detail: issues.length ? `${issues.length} issue(s) require review` : "none" },
     { name: "figures available", passed: figurePaths.length > 0, detail: figurePaths.length ? `${figurePaths.length} figure(s)` : "no figures attached" },
     ...(params.beforeExecutionId ? [{ name: "execution comparison", passed: comparison !== undefined, detail: comparison === undefined ? "comparison unavailable" : `${changedParameters ?? 0} changed parameter(s)` }] : []),
   ];
-  const passed = gates[0].passed && gates[1].passed;
+  const figuresGate = gates.find((gate) => gate.name === "figures available");
   const comparisonGate = gates.find((gate) => gate.name === "execution comparison");
-  const validationStatus: CalibrationValidation["status"] = !gates[0].passed ? "failed" : issues.length > 0 || !gates[2].passed || comparisonGate?.passed === false ? "needs_review" : "passed";
+  const validationStatus: CalibrationValidation["status"] = !gates[0].passed ? "failed" : figuresGate?.passed === false || comparisonGate?.passed === false ? "needs_review" : "passed";
   const next = validationStatus === "passed"
     ? "Inspect candidates and ask for explicit confirmation before commit/apply. Preserve evidence in the target Forum thread when appropriate."
     : validationStatus === "failed"
       ? "Stop the recovery sequence; inspect the task message and figures before another operational action."
-      : "Review the listed issues/figures before treating this result as authoritative.";
+      : "Review the figures and execution comparison before treating this result as authoritative.";
   return {
     context: { profile: params.profile ?? currentContext.profile, chipId: firstString(task, ["chip_id", "chipId"]) ?? currentContext.chipId, webBaseUrl: qdashWebBaseUrl(client) },
     taskId: params.taskId,
@@ -1138,7 +1127,6 @@ async function buildCalibrationValidation(params: { profile?: string; configPath
     status: validationStatus,
     gates,
     figurePaths,
-    issues,
     comparison,
     next,
     links: qdashObjectLinks(client, task),
@@ -1240,9 +1228,8 @@ async function buildDashboardInsights(params: { profile?: string; configPath?: s
   const limit = params.limit ?? 30;
   const end = new Date();
   const start = new Date(end.getTime() - (params.withinHours ?? 168) * 3600_000);
-  const [forums, issues, failed, metrics] = await Promise.allSettled([
+  const [forums, failed, metrics] = await Promise.allSettled([
     client.listForumPosts({ chipId, status: "open", 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),
   ]);
@@ -1260,13 +1247,6 @@ async function buildDashboardInsights(params: { profile?: string; configPath?: s
     addEvidence(insightMap, target, severity, title, `forum: ${title}`, "Open forum context should be reviewed before calibration changes.", qdashObjectLinks(client, post));
   }
 
-  for (const issue of arrayFromPayload(value(issues)).filter((item): item is Record<string, unknown> => Boolean(item) && typeof item === "object")) {
-    const title = firstString(issue, ["title", "summary"]) ?? "open issue";
-    const target = targetFromText(title) ?? firstString(issue, ["qid"]);
-    if (!target) continue;
-    addEvidence(insightMap, target.startsWith("q") || target.startsWith("c") ? target : `q${target}`, "warning", title, `open issue: ${title}`, "Resolve or account for the open issue before trusting metrics.", qdashObjectLinks(client, issue));
-  }
-
   for (const task of arrayFromPayload(value(failed)).filter((item): item is Record<string, unknown> => Boolean(item) && typeof item === "object")) {
     const target = calibrationTarget(task);
     const taskName = firstString(task, ["task_name", "name"]) ?? "task";
@@ -1465,7 +1445,6 @@ async function executeQuery(params: QDashQueryParams) {
     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 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 client.api.getLatestCouplingTaskResults({ chip_id: await defaultChipId(client, params.chipId), task: requireValue(params.task ?? params.taskName, "task") });
@@ -1478,8 +1457,6 @@ 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 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();
@@ -1532,7 +1509,7 @@ export default function qdashExtension(pi: ExtensionAPI) {
     description: "Run common read-only QDash queries via @oqtopus-team/qdash-client.",
     promptSnippet: "Query QDash chips, cryostats, cooldown wiring, metrics, tasks, files, flows, executions, projects, forum posts, and provenance",
     promptGuidelines: [
-      "Prefer dedicated QDash tools such as qdash_list_chips, qdash_get_chip_metrics, qdash_list_task_results, qdash_list_issues, qdash_list_flows, and qdash_list_executions when they match the task.",
+      "Prefer dedicated QDash tools such as qdash_list_chips, qdash_get_chip_metrics, qdash_list_task_results, qdash_list_forum_posts, qdash_list_flows, and qdash_list_executions when they match the task.",
       "Use qdash_query for read-only QDash data access not covered by a dedicated tool, instead of curl or scraping the UI.",
       "Ask for confirmation before using operational or write APIs; qdash_query intentionally exposes read-only operations only.",
       "Never expose QDash tokens, passwords, or Cloudflare Access secrets.",
@@ -1808,15 +1785,6 @@ export default function qdashExtension(pi: ExtensionAPI) {
     parameters: Type.Object({ ...connectionParams, taskId: Type.String() }),
   });
 
-  registerQueryTool({
-    name: "qdash_list_issues",
-    label: "QDash List Issues",
-    description: "List QDash issues with optional task/closed filters.",
-    promptSnippet: "List QDash issues",
-    action: "issues",
-    parameters: Type.Object({ ...connectionParams, taskId: Type.Optional(Type.String()), isClosed: Type.Optional(Type.Boolean()), limit: Type.Optional(Type.Number()), skip: Type.Optional(Type.Number()) }),
-  });
-
   registerQueryTool({
     name: "qdash_list_flows",
     label: "QDash List Flows",
@@ -2094,21 +2062,24 @@ export default function qdashExtension(pi: ExtensionAPI) {
   pi.registerTool({
     name: "qdash_execute_agent_action",
     label: "QDash Execute Agent Action",
-    description: "Link/execute a QDash agent action from a source execution. This is a write operation and requires confirmation.",
-    promptSnippet: "Execute or link a QDash agent action after explicit user confirmation",
-    promptGuidelines: ["Use qdash_execute_agent_action only after the user confirms the exact source execution and action."],
+    description: "Run an authorized QDash agent action's task the way the Task Workbench runs it: inputs from the current calibration state, outputs staged for the candidate gate. This is a write operation and requires confirmation.",
+    promptSnippet: "Run a QDash agent action's task after explicit user confirmation",
+    promptGuidelines: [
+      "Use qdash_execute_agent_action only after the user confirms the action, its task, target, and overrides.",
+      "The task runs on the current calibration state; pass sourceExecutionId only to record which execution the action was decided from.",
+    ],
     parameters: Type.Object({
       ...connectionParams,
       sessionId: Type.String(),
       actionId: Type.String(),
-      sourceExecutionId: Type.String(),
+      sourceExecutionId: Type.Optional(Type.String({ description: "Execution the action was decided from, recorded for provenance. The run does not restore it." })),
       updateParams: Type.Optional(Type.Boolean()),
       reconfigure: Type.Optional(Type.Boolean()),
       confirmWrite: Type.Optional(Type.Boolean()),
     }),
-    async execute(_toolCallId, params: ConfirmableParams & { profile?: string; configPath?: string; useEnv?: boolean; sessionId: string; actionId: string; sourceExecutionId: string; updateParams?: boolean; reconfigure?: boolean }, _signal, _onUpdate, ctx) {
+    async execute(_toolCallId, params: ConfirmableParams & { profile?: string; configPath?: string; useEnv?: boolean; sessionId: string; actionId: string; sourceExecutionId?: string; updateParams?: boolean; reconfigure?: boolean }, _signal, _onUpdate, ctx) {
       if (!params.confirmWrite) {
-        if (!ctx.hasUI || !(await ctx.ui.confirm("Execute QDash agent action?", `Execute action '${params.actionId}' from execution '${params.sourceExecutionId}'?`))) {
+        if (!ctx.hasUI || !(await ctx.ui.confirm("Execute QDash agent action?", `Run action '${params.actionId}' on the current calibration state? Outputs stay staged until a candidate is committed.`))) {
           throw new Error("qdash_execute_agent_action requires explicit confirmation");
         }
       }
@@ -2613,7 +2584,7 @@ export default function qdashExtension(pi: ExtensionAPI) {
   pi.registerTool({
     name: "qdash_build_qcal_evidence",
     label: "QDash Build QCal Evidence",
-    description: "Summarize a QDash task result (target, parameters, metrics, figure analysis) as evidence for pi-qcaleval's qcal_evaluate, returning the task figure as image content.",
+    description: "Summarize a QDash task result (target, sweep and run settings) as evidence for pi-qcaleval's qcal_evaluate, returning the task figure as image content. Fitted results are left out unless includeMetrics is set.",
     promptSnippet: "Summarize a QDash calibration task result as evidence for qcal_evaluate",
     promptGuidelines: [
       "Use qdash_build_qcal_evidence before qcal_evaluate when the user asks to evaluate a QDash calibration task with pi-qcaleval; pass the returned summary as the context of qcal_evaluate.",
@@ -2627,8 +2598,10 @@ export default function qdashExtension(pi: ExtensionAPI) {
       includeFigureAnalysis: Type.Optional(Type.Boolean({ description: "Analyze Plotly JSON figures and include summaries/warnings in notes. Defaults to true." })),
       maxFigures: Type.Optional(Type.Number({ description: "Maximum image figures to embed. Defaults to 1." })),
       includeRawTaskResult: Type.Optional(Type.Boolean({ description: "Include the full raw task result in resultJson. Defaults to false." })),
+      includeInputs: Type.Optional(Type.Boolean({ description: "Add the calibration inputs (previous values) to the evidence text. Defaults to false: the evaluation model reads the plot." })),
+      includeMetrics: Type.Optional(Type.Boolean({ description: "Add the fitted output parameters to the evidence text. Defaults to false: the evaluation model reads the plot." })),
     }),
-    async execute(_toolCallId, params: { profile?: string; configPath?: string; useEnv?: boolean; taskId: string; includeFigures?: boolean; includeFigureAnalysis?: boolean; maxFigures?: number; includeRawTaskResult?: boolean }) {
+    async execute(_toolCallId, params: { profile?: string; configPath?: string; useEnv?: boolean; taskId: string; includeFigures?: boolean; includeFigureAnalysis?: boolean; maxFigures?: number; includeRawTaskResult?: boolean; includeInputs?: boolean; includeMetrics?: boolean }) {
       const client = await makeClient(params);
       const task = await client.getTaskResult(params.taskId) as unknown as Record<string, unknown>;
       const figures: Array<Record<string, unknown>> = [];
@@ -2673,6 +2646,7 @@ export default function qdashExtension(pi: ExtensionAPI) {
 
       const couplingId = firstStringField(task, ["coupling_id", "couplingId", "qid"]);
       const qid = firstStringField(task, ["qid"]);
+      const runParameters = recordedParameters(task.run_parameters);
       const evidence: CalibrationEvidence = {
         id: params.taskId,
         source: "external",
@@ -2690,9 +2664,14 @@ export default function qdashExtension(pi: ExtensionAPI) {
           startedAt: firstStringField(task, ["start_at", "startAt"]),
           completedAt: firstStringField(task, ["end_at", "endAt"]),
           status: firstStringField(task, ["status"]),
+          message: typeof task.message === "string" && task.message.trim() ? task.message.trim() : undefined,
         },
         metrics: parameterValueRecord(task.output_parameters),
         parameters: { ...parameterValueRecord(task.input_parameters), ...parameterValueRecord(task.run_parameters) },
+        runParameters,
+        sweeps: sweepsOf(runParameters),
+        inputParameters: recordedParameters(task.input_parameters),
+        metricRecords: recordedParameters(task.output_parameters),
         figures: figures.length ? figures : undefined,
         notes: [
           typeof task.message === "string" ? `Task message: ${task.message}` : undefined,
@@ -2708,7 +2687,11 @@ export default function qdashExtension(pi: ExtensionAPI) {
         },
       };
 
-      const result = toTextToolResult(qcalEvidenceText(evidence), { evidence }, { tool: "qdash_build_qcal_evidence", taskId: params.taskId, evidence });
+      const result = toTextToolResult(
+        qcalEvidenceText(evidence, { inputs: params.includeInputs === true, metrics: params.includeMetrics === true }),
+        { evidence },
+        { tool: "qdash_build_qcal_evidence", taskId: params.taskId, evidence },
+      );
       return { ...result, content: [...result.content, ...images] };
     },
   });
@@ -2753,7 +2736,7 @@ export default function qdashExtension(pi: ExtensionAPI) {
   pi.registerTool({
     name: "qdash_validate_calibration",
     label: "QDash Validate Calibration",
-    description: "Validate a calibration task result with explicit gates for status, issues, and figures. Read-only; does not commit or apply candidates.",
+    description: "Validate a calibration task result with explicit gates for status and figures. Read-only; does not commit or apply candidates.",
     promptSnippet: "Validate a QDash calibration result before continuing or committing parameters",
     promptGuidelines: [
       "Use qdash_validate_calibration after an operational task completes or fails.",
@@ -2807,7 +2790,7 @@ export default function qdashExtension(pi: ExtensionAPI) {
   pi.registerTool({
     name: "qdash_target_report",
     label: "QDash Target Report",
-    description: "Build a read-only operational report for one qubit or coupling, correlating recent results, failures, issues, forum context, and a safe next-action recommendation.",
+    description: "Build a read-only operational report for one qubit or coupling, correlating recent results, failures, Forum context, and a safe next-action recommendation.",
     promptSnippet: "Inspect one QDash qubit or coupling as an operational incident report",
     promptGuidelines: [
       "Use qdash_target_report before calibration changes when a specific qubit or coupling is under investigation.",
@@ -2836,7 +2819,7 @@ export default function qdashExtension(pi: ExtensionAPI) {
     name: "qdash_dashboard",
     label: "QDash Dashboard",
     description: "Build a compact read-only QDash dashboard for the current profile/chip context.",
-    promptSnippet: "Show QDash harness dashboard: chips, open issues, recent executions, failed task results, and provenance stats",
+    promptSnippet: "Show QDash harness dashboard: chips, open Forum threads, recent executions, failed task results, and provenance stats",
     promptGuidelines: [
       "Use qdash_dashboard when the user asks for QDash status, overview, triage, or a dashboard.",
       "Summarize dashboard data instead of dumping large raw payloads.",
@@ -2860,9 +2843,9 @@ export default function qdashExtension(pi: ExtensionAPI) {
   pi.registerTool({
     name: "qdash_dashboard_insights",
     label: "QDash Dashboard Insights",
-    description: "Correlate dashboard metrics, open forum posts, notes/issues, and failed tasks into target-level insights with links.",
+    description: "Correlate dashboard metrics, open Forum posts, and failed tasks into target-level insights with links.",
     promptSnippet: "Generate QDash target insights from dashboard metrics, forum links, notes, and failed tasks",
-    promptGuidelines: ["Use qdash_dashboard_insights when the user asks for insights across dashboard metrics, target summaries, forum posts, notes, issues, or anomalous targets."],
+    promptGuidelines: ["Use qdash_dashboard_insights when the user asks for insights across dashboard metrics, target summaries, Forum posts, or anomalous targets."],
     parameters: Type.Object({
       ...connectionParams,
       chipId: Type.Optional(Type.String()),
@@ -2907,8 +2890,8 @@ export default function qdashExtension(pi: ExtensionAPI) {
   pi.registerTool({
     name: "qdash_investigate",
     label: "QDash Investigate",
-    description: "Run a read-only natural-language-friendly QDash investigation combining recent calibration results, target history, failures, issues, forum context, and safe recommendations.",
-    promptSnippet: "Investigate a QDash target or recent calibration by correlating results, figures, issues, and Forum context",
+    description: "Run a read-only natural-language-friendly QDash investigation combining recent calibration results, target history, failures, Forum context, and safe recommendations.",
+    promptSnippet: "Investigate a QDash target or recent calibration by correlating results, figures, and Forum context",
     promptGuidelines: [
       "Use qdash_investigate when the user asks to investigate, compare, or understand a QDash target or recent calibration in natural language.",
       "This tool is read-only; do not execute tasks or change parameters based on its recommendation without explicit confirmation.",
@@ -2985,19 +2968,19 @@ export default function qdashExtension(pi: ExtensionAPI) {
   pi.registerTool({
     name: "qdash_triage_overview",
     label: "QDash Triage Overview",
-    description: "Create a read-only triage overview from open issues and failed task results for the current QDash context.",
-    promptSnippet: "Summarize QDash open issues and failed task results for triage",
+    description: "Create a read-only triage overview from open Forum threads and failed task results for the current QDash context.",
+    promptSnippet: "Summarize QDash open Forum threads and failed task results for triage",
     promptGuidelines: ["Use qdash_triage_overview when the user asks what to investigate next in QDash."],
     parameters: Type.Object({ ...connectionParams, ...chipScopedParams, limit: Type.Optional(Type.Number()), color: Type.Optional(Type.Boolean({ description: "Emit ANSI colors in text output for terminal display." })) }),
     async execute(_toolCallId, params: { profile?: string; configPath?: string; useEnv?: boolean; chipId?: string; limit?: number; color?: boolean }) {
       const dashboard = await buildDashboard(params);
       const triage = {
         context: dashboard.context,
-        openIssues: dashboard.openIssues,
+        openThreads: dashboard.openThreads,
         failedTaskResults: dashboard.failedTaskResults,
         suggestedFocus: [
           dashboard.failedTaskResults.count > 0 ? "Review failed task results first." : undefined,
-          dashboard.openIssues.count > 0 ? "Review open issues and correlate with recent executions." : undefined,
+          dashboard.openThreads.count > 0 ? "Review open Forum threads and correlate with recent executions." : undefined,
         ].filter(Boolean),
       };
       const accent = (text: string) => params.color ? ansi("1;36", text) : text;
@@ -3005,7 +2988,7 @@ export default function qdashExtension(pi: ExtensionAPI) {
       const success = (text: string) => params.color ? ansi("32", text) : text;
       const error = (text: string) => params.color ? ansi("31", text) : text;
       const lines = boxed("QDash Triage", [
-        `open issues ${triage.openIssues.count > 0 ? ansi("33", String(triage.openIssues.count)) : success(String(triage.openIssues.count))}`,
+        `open threads ${triage.openThreads.count > 0 ? ansi("33", String(triage.openThreads.count)) : success(String(triage.openThreads.count))}`,
         `failed tasks ${triage.failedTaskResults.count > 0 ? error(`${triage.failedTaskResults.shown}/${triage.failedTaskResults.count}`) : success(`${triage.failedTaskResults.shown}/${triage.failedTaskResults.count}`)}`,
         "",
         accent("Suggested focus"),
@@ -3017,11 +3000,11 @@ export default function qdashExtension(pi: ExtensionAPI) {
       return toTextToolResult(lines.join("\n"), triage, { tool: "qdash_triage_overview" });
     },
     renderResult(result, _options, theme) {
-      const data = (result.details as { data?: { openIssues?: { count?: number }; failedTaskResults?: { count?: number }; suggestedFocus?: string[] } } | undefined)?.data;
+      const data = (result.details as { data?: { openThreads?: { count?: number }; failedTaskResults?: { count?: number }; suggestedFocus?: string[] } } | undefined)?.data;
       if (!data) return new Text(theme.fg("dim", "QDash triage unavailable"), 0, 0);
       const lines = [
         theme.fg("accent", theme.bold("QDash Triage")),
-        `${theme.fg("muted", "open issues")} ${theme.fg((data.openIssues?.count ?? 0) > 0 ? "warning" : "success", String(data.openIssues?.count ?? 0))}`,
+        `${theme.fg("muted", "open threads")} ${theme.fg((data.openThreads?.count ?? 0) > 0 ? "warning" : "success", String(data.openThreads?.count ?? 0))}`,
         `${theme.fg("muted", "failed tasks")} ${theme.fg((data.failedTaskResults?.count ?? 0) > 0 ? "error" : "success", String(data.failedTaskResults?.count ?? 0))}`,
         "",
         theme.fg("borderAccent", "Suggested focus"),
@@ -3293,7 +3276,7 @@ export default function qdashExtension(pi: ExtensionAPI) {
       const dashboard = await buildDashboard({ limit: Number.isFinite(limit) ? limit : undefined });
       refreshContextUi(ctx);
       ctx.ui.setWidget("qdash", (_tui, theme) => dashboardComponent(dashboard, theme));
-      ctx.ui.notify(`QDash dashboard updated: ${dashboard.openIssues.count} open issues, ${dashboard.failedTaskResults.count} failed tasks`, "info");
+      ctx.ui.notify(`QDash dashboard updated: ${dashboard.openThreads.count} open Forum threads, ${dashboard.failedTaskResults.count} failed tasks`, "info");
     },
   });
 

package/extensions/tools/calibration-pipeline.ts

@@ -250,10 +250,12 @@ export function registerCalibrationPipelineTools(pi: Pick<ExtensionAPI, "registe
   pi.registerTool({
     name: "qdash_run_pipeline",
     label: "QDash Run Pipeline",
-    description: "Run a calibration pipeline spec as one QDash execution. Confirmation-gated write operation. Validate with qdash_plan_pipeline first; the spec runs exactly as validated.",
+    description: "Run a calibration pipeline spec as one QDash execution. Completed tasks write their calibrated parameters to QDash directly, without an agent candidate gate. Confirmation-gated write operation. Validate with qdash_plan_pipeline first; the spec runs exactly as validated.",
     promptSnippet: "Run a validated QDash calibration pipeline spec",
     promptGuidelines: [
       "Use qdash_run_pipeline only for a spec that qdash_plan_pipeline reported valid.",
+      "Tell the user before running that completed tasks update calibrated parameters in QDash directly.",
+      "Do not use qdash_run_pipeline to run a task an agent session action failed to run; that skips the session's candidate gate. Report the failure instead.",
       "After it starts, follow the execution with qdash_wait_execution and summarize failed targets.",
     ],
     parameters: Type.Object({
@@ -265,7 +267,7 @@ export function registerCalibrationPipelineTools(pi: Pick<ExtensionAPI, "registe
     }),
     async execute(_toolCallId, params: ConnectionParams & { chipId: string; spec: Record<string, unknown>; backendName?: string; confirmWrite?: boolean }, _signal, _onUpdate, ctx) {
       if (!params.confirmWrite) {
-        if (!ctx.hasUI || !(await ctx.ui.confirm("Run QDash calibration pipeline?", `This starts a calibration execution on chip ${params.chipId}.`))) {
+        if (!ctx.hasUI || !(await ctx.ui.confirm("Run QDash calibration pipeline?", `This starts a calibration execution on chip ${params.chipId}. Completed tasks update calibrated parameters in QDash directly.`))) {
           throw new Error("qdash_run_pipeline requires explicit confirmation");
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oqtopus-team/pi-qdash",
-  "version": "0.1.10",
+  "version": "0.1.11-beta.20",
   "description": "Pi extension for querying QDash via @oqtopus-team/qdash-client",
   "type": "module",
   "license": "Apache-2.0",
@@ -27,7 +27,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@oqtopus-team/qdash-client": "1.9.21-beta.171"
+    "@oqtopus-team/qdash-client": "1.9.21-beta.203"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",

package/skills/qdash/SKILL.md

@@ -22,7 +22,6 @@ Prefer the dedicated tool that matches the question. Use `qdash_query` only as a
    - `qdash_inspect_timeseries_csv`, `qdash_compare_timeseries` — validate and compare multiple QDash or CSV timeseries
    - `qdash_list_task_results`, `qdash_get_task_result` — find and inspect calibration results
    - `qdash_get_task_knowledge` — interpret a task's purpose, expected result, failure modes, and check questions
-   - `qdash_list_issues` — inspect tracked issues
    - `qdash_list_flows`, `qdash_get_flow` — list or inspect calibration flows
    - `qdash_get_pipeline_catalog`, `qdash_plan_pipeline` — compose and check a calibration pipeline spec before running it
    - `qdash_list_executions`, `qdash_get_execution`, `qdash_wait_execution`, `qdash_compare_executions` — inspect, await, or compare executions
@@ -57,7 +56,7 @@ Workflow:
 1. `qdash_get_pipeline_catalog` — read the step types (with what each needs from an earlier step and its default task list), the one-qubit modes, and the task names by type. Use only names from this catalog.
 2. Turn the request into steps. Start from the catalog defaults and the flow templates (`qdash_query` with `flow_templates`, then `flow_template` for one template's task list): `OneQubitCheck` and `OneQubitFineTune` carry the standard one-qubit sequences, `TwoQubitCalibration` the two-qubit chain. Use `CustomOneQubit` / `CustomTwoQubit` only where the user wants a different task list, and keep the task order the templates use.
 3. `qdash_plan_pipeline` — validate. A result with problems is not an error: each problem carries a path into the spec (`steps[2].tasks[0]`, `targets.qids[1]`); fix it and plan again until it is valid.
-4. Show the user the resolved steps and task counts from the plan, then `qdash_run_pipeline` with the same `chipId` and `spec`. The execution is confirmation-gated.
+4. Show the user the resolved steps and task counts from the plan, then `qdash_run_pipeline` with the same `chipId` and `spec`. The execution is confirmation-gated. Say that completed tasks write their calibrated parameters to QDash directly; there is no candidate gate, so inside an agent calibration session use the session's actions instead.
 5. `qdash_wait_execution` with the returned `execution_id`. It returns when the whole run has finished, not just its first step. Then summarize which targets passed and which failed, fetch the figures of failed tasks with `qdash_get_task_figures` so the user sees them, and read `qdash_get_task_knowledge` for any task whose result needs interpretation.
 
 Rules:
@@ -160,7 +159,7 @@ When the user wants to preserve an investigated observation in QDash forum/notes
 - Never print tokens, passwords, Cloudflare Access secrets, or full profile contents.
 - Treat write/operational endpoints (agent session/action creation, candidate commits, forum create/update, flow execute, git push/pull, re-execute, admin/auth APIs) as sensitive and ask the user before any write workflow.
 - Write-oriented QDash tools are approval-gated. In interactive pi, let the extension prompt for confirmation. In non-interactive runs, set `confirmWrite: true` only after explicit user confirmation.
-- Use `qdash_investigate` for natural-language requests to investigate, compare, or understand a target or recent calibration; it is read-only and combines recent results with target, Forum, issue, and recommendation context.
+- Use `qdash_investigate` for natural-language requests to investigate, compare, or understand a target or recent calibration; it is read-only and combines recent results with target, Forum, and recommendation context.
 - Use `qdash_compare_calibration` when the user asks what changed between recent calibration experiments; treat differences as evidence, not automatic approval to commit/apply parameters.
 - Use `qdash_recent_calibration_figure` when the user asks to see recent experiment images without a task ID.
 - Use `qdash_analyze_figure_json` for read-only numeric summaries of Plotly JSON calibration figures; keep domain-specific interpretation in the matching skill.

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

@@ -47,7 +47,7 @@ This skill defines how pi should behave as a conservative, confirmation-gated ca
    - any in-cooldown wiring changes relevant to the target
    - failed task(s)
    - qid/coupling_id
-   - recent executions and open forum/issue context
+   - recent executions and open Forum context
 2. Read evidence:
    - `qdash_list_task_results`
    - `qdash_get_task_result`
@@ -144,3 +144,7 @@ Stop and request human review when:
 - the same target fails after `CheckChevron` and `Configure`
 - figures suggest TLS, frequency collision, leakage, or multi-level behavior
 - the next action would require broad parameter sweeps or hardware-risky changes
+- QDash refuses to run an agent action's task before it measures anything (a platform or
+  configuration error, not a calibration result). Report the error with the task result and
+  execution links; do not rerun the task through another path such as `qdash_run_pipeline`,
+  which writes parameters without the session's candidate gate