@oqtopus-team/pi-qdash 0.1.4 → 0.1.6

package/extensions/qdash.ts

@@ -4,19 +4,28 @@ 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";
 
 import { analyzePlotlyFigure, figureAnalysisText } from "./lib/figure-analysis.js";
 import { fetchFigureDetails, figureComponent, figureResultText, mediaTypeForPath, type FigureDetails } from "./lib/figures.js";
+import { forumImageReplyContent, forumImageReplyPreview, loadLocalForumImages, type LocalForumImage } from "./lib/forum-images.js";
 import { forumDetailComponent, forumDetailLines, forumListLines, forumPostTitle, forumPostsFromPayload } from "./lib/forum-render.js";
+import { investigationContextSummary, validateInvestigationContext, type TimeseriesInvestigationContext } from "./lib/investigation-context.js";
 import { qdashObjectLinks, qdashWebBaseUrl, qdashWebUrl, safeConfig, withQDashLinks } from "./lib/links.js";
 import { arrayFromPayload, compactItems, firstNumber, firstString, formatItem, payloadTotal, statusIcon } from "./lib/payload.js";
 import { toTextToolResult, toToolResult } from "./lib/results.js";
 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 { registerTimeseriesComparisonTool } from "./tools/timeseries.js";
 import { analyzeWiringMarkdown, wiringInsightLines, type WiringInsights } from "./lib/wiring-analysis.js";
 
 type QDashQueryParams = {
@@ -131,6 +140,7 @@ type QDashContextState = {
   taskName?: string;
   lastExecutionId?: string;
   lastTaskId?: string;
+  investigation?: TimeseriesInvestigationContext;
 };
 
 const CONTEXT_ENTRY_TYPE = "qdash-context";
@@ -151,7 +161,8 @@ function contextSummary(): string {
   const chip = currentContext.chipId ?? "auto-chip";
   const session = currentContext.agentSessionId ? ` session:${shortId(currentContext.agentSessionId)}` : "";
   const target = currentContext.qid ? ` q${currentContext.qid}` : currentContext.couplingId ? ` c${currentContext.couplingId}` : "";
-  return `qdash ${profile} ${chip}${target}${session}`;
+  const investigation = currentContext.investigation?.name ? ` investigation:${currentContext.investigation.name}` : "";
+  return `qdash ${profile} ${chip}${target}${session}${investigation}`;
 }
 
 function contextStatusLine(theme?: Theme): string {
@@ -179,8 +190,16 @@ function contextStatusLine(theme?: Theme): string {
 function isQDashContextState(value: unknown): value is QDashContextState {
   if (!value || typeof value !== "object") return false;
   const context = value as QDashContextState;
-  return [context.profile, context.chipId, context.agentSessionId, context.qid, context.couplingId, context.taskName, context.lastExecutionId, context.lastTaskId]
+  const stringsValid = [context.profile, context.chipId, context.agentSessionId, context.qid, context.couplingId, context.taskName, context.lastExecutionId, context.lastTaskId]
     .every((item) => item === undefined || typeof item === "string");
+  if (!stringsValid) return false;
+  if (context.investigation === undefined) return true;
+  try {
+    validateInvestigationContext(context.investigation);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 function loadGlobalContext(): QDashContextState {
@@ -194,8 +213,9 @@ function loadGlobalContext(): QDashContextState {
 }
 
 function saveGlobalContext(context: QDashContextState): void {
+  const { investigation: _investigation, ...globalContext } = context;
   mkdirSync(dirname(GLOBAL_CONTEXT_PATH), { recursive: true });
-  writeFileSync(GLOBAL_CONTEXT_PATH, `${JSON.stringify(context, null, 2)}\n`, "utf8");
+  writeFileSync(GLOBAL_CONTEXT_PATH, `${JSON.stringify(globalContext, null, 2)}\n`, "utf8");
 }
 
 function adoptContextFromToolInput(input: unknown): boolean {
@@ -383,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));
 }
@@ -458,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;
@@ -488,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;
@@ -500,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,
     });
@@ -517,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";
   }
 
@@ -525,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.
   }
@@ -580,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) };
@@ -724,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) {
@@ -925,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");
@@ -1109,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
@@ -1242,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>();
@@ -1340,6 +1350,56 @@ function taskFigurePaths(task: Record<string, unknown>, maxFigures: number): str
   return Array.isArray(paths) ? paths.filter((item): item is string => typeof item === "string").slice(0, maxFigures) : [];
 }
 
+type ForumImageReplyParams = {
+  parentPostId: string;
+  imagePaths: string[];
+  interpretation: string;
+  title?: string;
+};
+
+type PreparedForumImageReply = {
+  parent: Record<string, unknown>;
+  images: LocalForumImage[];
+  title: string;
+  preview: string;
+};
+
+async function prepareForumImageReply(client: QDashClient, params: ForumImageReplyParams): Promise<PreparedForumImageReply> {
+  const parent = await client.getForumPost(params.parentPostId) as unknown as Record<string, unknown>;
+  const images = loadLocalForumImages(params.imagePaths);
+  const title = params.title ?? `${new Date().toISOString().slice(0, 10)} 追加分析画像`;
+  const preview = forumImageReplyPreview(title, images, params.interpretation);
+  return { parent, images, title, preview };
+}
+
+async function createForumImageReply(client: QDashClient, params: ForumImageReplyParams, prepared: PreparedForumImageReply) {
+  const uploaded = [];
+  for (const image of prepared.images) {
+    const result = await client.uploadForumImage(image.blob, image.filename);
+    uploaded.push({ ...image, url: result.url });
+  }
+  const content = forumImageReplyContent(prepared.title, uploaded, params.interpretation);
+  const parent = prepared.parent;
+  const request = {
+    category: firstString(parent, ["category"]) ?? "other",
+    title: null,
+    content,
+    content_blocks: [],
+    parent_id: params.parentPostId,
+    chip_id: firstString(parent, ["chip_id", "chipId"]),
+    target_type: firstString(parent, ["target_type", "targetType"]),
+    target_id: firstString(parent, ["target_id", "targetId"]),
+    cooldown_id: firstString(parent, ["cooldown_id", "cooldownId"]),
+    status: firstString(parent, ["status"]) ?? "open",
+  };
+  const reply = await client.createForumPost(request as never);
+  return {
+    reply,
+    content,
+    images: uploaded.map(({ blob: _blob, ...image }) => image),
+  };
+}
+
 async function buildForumEvidenceReply(client: QDashClient, params: ForumEvidenceReplyParams) {
   const [parent, task] = await Promise.all([
     client.getForumPost(params.parentPostId) as unknown as Promise<Record<string, unknown>>,
@@ -1421,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();
@@ -1443,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"));
   }
@@ -1728,6 +1791,12 @@ export default function qdashExtension(pi: ExtensionAPI) {
     },
   });
 
+  registerTimeseriesComparisonTool(pi, {
+    makeClient,
+    defaultChipId,
+    investigationContext: () => currentContext.investigation,
+  });
+
   registerQueryTool({
     name: "qdash_list_task_results",
     label: "QDash List Task Results",
@@ -2239,6 +2308,65 @@ export default function qdashExtension(pi: ExtensionAPI) {
     },
   });
 
+  pi.registerTool({
+    name: "qdash_preview_forum_image_reply",
+    label: "QDash Preview Forum Image Reply",
+    description: "Preview a QDash forum reply that will upload and embed locally generated analysis images. Read-only; no image or post is created.",
+    promptSnippet: "Preview local analysis images and forum reply content before uploading",
+    promptGuidelines: [
+      "Use qdash_preview_forum_image_reply before uploading locally generated analysis images to a forum thread.",
+      "Show the image paths and reply content, then require explicit confirmation before publishing.",
+    ],
+    parameters: Type.Object({
+      ...connectionParams,
+      parentPostId: Type.String(),
+      imagePaths: Type.Array(Type.String(), { minItems: 1, maxItems: 8 }),
+      interpretation: Type.String({ description: "Human-readable interpretation or context shown after the images." }),
+      title: Type.Optional(Type.String()),
+    }),
+    async execute(_toolCallId, params: { profile?: string; configPath?: string; useEnv?: boolean; parentPostId: string; imagePaths: string[]; interpretation: string; title?: string }) {
+      const client = await makeClient(params);
+      const prepared = await prepareForumImageReply(client, params);
+      return toTextToolResult(prepared.preview, {
+        preview: prepared.preview,
+        parent: prepared.parent,
+        images: prepared.images.map(({ blob: _blob, ...image }) => image),
+      }, { tool: "qdash_preview_forum_image_reply" });
+    },
+  });
+
+  pi.registerTool({
+    name: "qdash_create_forum_image_reply",
+    label: "QDash Create Forum Image Reply",
+    description: "Upload locally generated analysis images and create a QDash forum reply embedding them. This is a write operation and requires confirmation.",
+    promptSnippet: "Upload local analysis images and create a forum reply after explicit confirmation",
+    promptGuidelines: [
+      "Use qdash_create_forum_image_reply only after previewing the exact image paths and reply content with qdash_preview_forum_image_reply.",
+      "Require explicit confirmation before uploading images or creating the reply.",
+    ],
+    parameters: Type.Object({
+      ...connectionParams,
+      parentPostId: Type.String(),
+      imagePaths: Type.Array(Type.String(), { minItems: 1, maxItems: 8 }),
+      interpretation: Type.String({ description: "Human-readable interpretation or context shown after the images." }),
+      title: Type.Optional(Type.String()),
+      confirmWrite: Type.Optional(Type.Boolean()),
+    }),
+    async execute(_toolCallId, params: ConfirmableParams & { profile?: string; configPath?: string; useEnv?: boolean; parentPostId: string; imagePaths: string[]; interpretation: string; title?: string }, _signal, _onUpdate, ctx) {
+      const client = await makeClient(params);
+      const prepared = await prepareForumImageReply(client, params);
+      if (!params.confirmWrite) {
+        const confirmed = ctx.hasUI && await ctx.ui.confirm("Upload images and create QDash forum reply?", prepared.preview.slice(0, 1800));
+        if (!confirmed) throw new Error("qdash_create_forum_image_reply requires explicit confirmation");
+      }
+      const created = await createForumImageReply(client, params, prepared);
+      const postId = firstString(created.reply as unknown as Record<string, unknown>, ["id"]);
+      const parentUrl = qdashWebUrl(client, `/forum/posts/${encodeURIComponent(params.parentPostId)}`);
+      const text = [`created forum image reply${postId ? ` ${postId}` : ""}`, `parent ${parentUrl}`, "", created.content].join("\n");
+      return toTextToolResult(text, created, { tool: "qdash_create_forum_image_reply", url: parentUrl });
+    },
+  });
+
   pi.registerTool({
     name: "qdash_create_forum_evidence_reply",
     label: "QDash Create Forum Evidence Reply",
@@ -3067,8 +3195,49 @@ export default function qdashExtension(pi: ExtensionAPI) {
     },
   });
 
+  pi.registerCommand("qdash-investigation-setup", {
+    description: "Create or edit a reusable generic timeseries investigation context; accepts optional JSON",
+    handler: async (args, ctx) => {
+      const template: TimeseriesInvestigationContext = currentContext.investigation ?? {
+        name: "timeseries-investigation",
+        timezoneOffsetMinutes: 540,
+        qdashSeries: currentContext.qid ? [
+          { parameter: "metric_a", qid: currentContext.qid },
+          { parameter: "metric_b", qid: currentContext.qid },
+        ] : [
+          { parameter: "metric_a" },
+          { parameter: "metric_b" },
+        ],
+        analysis: { resampleMinutes: 1, detrend: "none", normalize: "none" },
+      };
+      const source = args.trim() || await ctx.ui.editor("QDash investigation context (JSON)", JSON.stringify(template, null, 2));
+      if (!source) return;
+      try {
+        const investigation = validateInvestigationContext(JSON.parse(source));
+        currentContext = { ...currentContext, investigation };
+        persistContext();
+        refreshContextUi(ctx);
+        ctx.ui.setWidget("qdash", ["QDash Investigation", investigationContextSummary(investigation)]);
+        ctx.ui.notify(`Investigation context saved: ${investigationContextSummary(investigation)}`, "info");
+      } catch (error) {
+        ctx.ui.notify(`Invalid investigation context: ${error instanceof Error ? error.message : String(error)}`, "error");
+      }
+    },
+  });
+
+  pi.registerCommand("qdash-clear-investigation", {
+    description: "Clear the reusable timeseries investigation context without changing profile/chip context",
+    handler: async (_args, ctx) => {
+      const { investigation: _investigation, ...rest } = currentContext;
+      currentContext = rest;
+      persistContext();
+      refreshContextUi(ctx);
+      ctx.ui.notify("QDash investigation context cleared", "info");
+    },
+  });
+
   pi.registerCommand("qdash-clear-context", {
-    description: "Clear the current QDash profile/chip/agent-session context",
+    description: "Clear the current QDash profile/chip/agent-session/investigation context",
     handler: async (_args, ctx) => {
       currentContext = {};
       persistContext();
@@ -3180,6 +3349,7 @@ export default function qdashExtension(pi: ExtensionAPI) {
         `last execution ${currentContext.lastExecutionId ?? "none"}`,
         `last task ${currentContext.lastTaskId ?? "none"}`,
         `agent session ${currentContext.agentSessionId ?? "none"}`,
+        `investigation ${currentContext.investigation ? investigationContextSummary(currentContext.investigation) : "none"}`,
       ]);
       ctx.ui.notify(contextSummary(), "info");
     },