@tomako/tools-runtime 0.1.5 → 0.1.7

package/src/features/tools/app-store-screenshot-generator/widget/asset-slots.ts

@@ -54,8 +54,9 @@ export function sortGeneratedAssets(assets: AppStoreScreenshotAsset[]) {
   });
 }
 
-export function widthForAssetFormat(format: AssetFormat) {
-  return format === "featureGraphic" ? "clamp(220px, 27vw, 340px)" : "clamp(112px, 12vw, 156px)";
+export function gridClassForAssetFormat(format: AssetFormat, isSoleResult = false) {
+  if (isSoleResult) return "mx-auto max-w-[340px]";
+  return format === "featureGraphic" ? "sm:col-span-2 xl:col-span-3" : "";
 }
 
 export function dimensionsForAssetFormat(format: AssetFormat) {

package/src/features/tools/app-store-screenshot-generator/widget/generation.test.ts

@@ -0,0 +1,126 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import { registerToolsRuntimeHostClient } from "../../../../host/client";
+import type { AppStoreScreenshotAgentResult } from "../../../../lib/tools/app-store-screenshot-generator-schema";
+
+import { waitForAgentResult } from "./generation";
+
+const prompt = "Generate a cohesive app store screenshot set from the supplied product UI. ".repeat(4);
+
+function agentResult(
+  assetCount: number,
+  reportStatus: AppStoreScreenshotAgentResult["reportStatus"] = "partial",
+): AppStoreScreenshotAgentResult {
+  return {
+    promptId: "tools.app-store-screenshot-generator.agent",
+    promptVersion: "2026-07-03.2",
+    reportStatus,
+    summary: `${assetCount} screenshots planned`,
+    prompt,
+    assets: Array.from({ length: assetCount }, (_, index) => ({
+      id: `asset-${index + 1}`,
+      platform: "apple" as const,
+      format: "iphone" as const,
+      title: `Screenshot ${index + 1}`,
+      width: 1290,
+      height: 2796,
+      slot: index + 1,
+      setSize: 10,
+      imageTaskId: `image-task-${index + 1}`,
+    })),
+    failures: [],
+    totalAssets: 10,
+    completedAssets: assetCount,
+    failedAssets: 0,
+  };
+}
+
+function registerTaskSequence(
+  responses: Array<{
+    status: string;
+    data: AppStoreScreenshotAgentResult | null;
+    errorCode?: "task_failed";
+    error?: string;
+  }>,
+) {
+  let calls = 0;
+  registerToolsRuntimeHostClient({
+    fetchAppStoreScreenshotSetTask: async () => {
+      const response = responses[Math.min(calls, responses.length - 1)];
+      calls += 1;
+      return response;
+    },
+  });
+  return () => calls;
+}
+
+const fastPolling = { pollIntervalMs: 0, timeoutMs: 1_000 };
+
+describe("waitForAgentResult", () => {
+  it("keeps following after the first partial batch until the expected asset count arrives", async () => {
+    const firstBatch = agentResult(4);
+    const completeBatch = agentResult(10);
+    const calls = registerTaskSequence([
+      { status: "SUCCEEDED", data: firstBatch },
+      { status: "SUCCEEDED", data: completeBatch },
+    ]);
+    const progressCounts: number[] = [];
+
+    const result = await waitForAgentResult(
+      "task-expected-count",
+      (progress) => progressCounts.push(progress.assets.length),
+      10,
+      fastPolling,
+    );
+
+    assert.equal(calls(), 2);
+    assert.deepEqual(progressCounts, [4, 10]);
+    assert.equal(result.assets.length, 10);
+    assert.equal(result.reportStatus, "partial");
+  });
+
+  it("stops on an explicit final snapshot even when it has fewer assets than expected", async () => {
+    const firstBatch = agentResult(4);
+    const finalBatch = agentResult(4, "final");
+    const calls = registerTaskSequence([
+      { status: "SUCCEEDED", data: firstBatch },
+      { status: "SUCCEEDED", data: finalBatch },
+    ]);
+
+    const result = await waitForAgentResult(
+      "task-final",
+      () => undefined,
+      10,
+      fastPolling,
+    );
+
+    assert.equal(calls(), 2);
+    assert.equal(result.reportStatus, "final");
+    assert.equal(result.assets.length, 4);
+  });
+
+  it("returns the last usable partial snapshot when the task fails terminally", async () => {
+    const firstBatch = agentResult(4);
+    const calls = registerTaskSequence([
+      { status: "RUNNING", data: firstBatch },
+      {
+        status: "FAILED",
+        data: null,
+        errorCode: "task_failed",
+        error: "background follower failed",
+      },
+    ]);
+
+    const result = await waitForAgentResult(
+      "task-terminal",
+      () => undefined,
+      10,
+      fastPolling,
+    );
+
+    assert.equal(calls(), 2);
+    assert.equal(result.reportStatus, "partial");
+    assert.equal(result.assets.length, 4);
+  });
+});

package/src/features/tools/app-store-screenshot-generator/widget/generation.ts

@@ -33,16 +33,30 @@ export async function generateStoreAssets(
   locale: AppLocale,
   onProgress: (progress: GeneratedStoreAssetsResult) => void,
   onPlanning: () => void,
+  options: {
+    taskId?: string;
+    startedAtMs?: number;
+    onTaskSubmitted?: (taskId: string, startedAtMs: number) => void;
+  } = {},
 ): Promise<GeneratedStoreAssetsResult> {
-  const submitted = await submitAppStoreScreenshotSet(input, locale);
+  const submitted = options.taskId
+    ? { taskId: options.taskId }
+    : await submitAppStoreScreenshotSet(input, locale);
+  const startedAtMs = options.startedAtMs ?? Date.now();
+  if (!options.taskId) options.onTaskSubmitted?.(submitted.taskId, startedAtMs);
   onPlanning();
-  const agentResult = await waitForAgentResult(submitted.taskId, (partialResult) => {
-    try {
-      onProgress(buildGeneratedStoreAssetsResult(partialResult, { allowMissingImageUrl: false }));
-    } catch {
-      // Ignore non-renderable intermediate snapshots and keep waiting for a usable result.
-    }
-  });
+  const agentResult = await waitForAgentResult(
+    submitted.taskId,
+    (partialResult) => {
+      try {
+        onProgress(buildGeneratedStoreAssetsResult(partialResult, { allowMissingImageUrl: false }));
+      } catch {
+        // Ignore non-renderable intermediate snapshots and keep waiting for a usable result.
+      }
+    },
+    expectedAssetCount(input),
+    { startedAtMs },
+  );
   return resolveGeneratedStoreAssetsResult(agentResult, input, onProgress);
 }
 
@@ -247,8 +261,17 @@ export function buildGeneratedStoreAssetsResult(
 export async function waitForAgentResult(
   taskId: string,
   onProgress: (result: AppStoreScreenshotAgentResult) => void,
+  expectedCount: number,
+  options: {
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    startedAtMs?: number;
+  } = {},
 ) {
-  const deadline = Date.now() + AGENT_RESULT_TIMEOUT_MS;
+  const deadline =
+    (options.startedAtMs ?? Date.now()) +
+    (options.timeoutMs ?? AGENT_RESULT_TIMEOUT_MS);
+  const pollIntervalMs = options.pollIntervalMs ?? AGENT_RESULT_POLL_INTERVAL_MS;
   let lastResult: AppStoreScreenshotAgentResult | null = null;
   let lastSignature = "";
 
@@ -261,7 +284,13 @@ export async function waitForAgentResult(
         lastSignature = signature;
         onProgress(task.data);
       }
-      if (task.data.reportStatus === "final" || hasResolvableAgentAssets(task.data)) {
+      // submit-only can finish the LLM task after writing the first partial batch while
+      // its background follower continues to append screenshot tasks. Do not treat the
+      // task's SUCCEEDED status or one resolvable asset as the completed image set.
+      if (
+        task.data.reportStatus === "final" ||
+        hasExpectedAgentAssetCount(task.data, expectedCount)
+      ) {
         return task.data;
       }
     }
@@ -269,15 +298,24 @@ export async function waitForAgentResult(
       if (lastResult) return lastResult;
       throw new AppStoreAgentGenerationError(task.errorCode, task.error);
     }
-    await wait(AGENT_RESULT_POLL_INTERVAL_MS);
+    await wait(pollIntervalMs);
   }
 
   if (lastResult) return lastResult;
   throw new AppStoreAgentGenerationError("task_failed", "Agent result timed out.");
 }
 
-export function hasResolvableAgentAssets(result: AppStoreScreenshotAgentResult) {
-  return result.assets.some((asset) => Boolean(asset.imageUrl || asset.imageTaskId));
+export function hasExpectedAgentAssetCount(
+  result: AppStoreScreenshotAgentResult,
+  expectedCount: number,
+) {
+  const settledAssetIds = new Set([
+    ...result.assets
+      .filter((asset) => Boolean(asset.imageUrl || asset.imageTaskId || asset.errorMessage))
+      .map((asset) => asset.id),
+    ...result.failures.map((failure) => failure.id),
+  ]);
+  return settledAssetIds.size >= clampAssetCount(expectedCount);
 }
 
 export function progressSignature(result: AppStoreScreenshotAgentResult) {
@@ -459,7 +497,7 @@ export function blobToImage(blob: Blob): Promise<HTMLImageElement> {
 }
 
 export function wait(ms: number): Promise<void> {
-  return new Promise((resolve) => window.setTimeout(resolve, ms));
+  return new Promise((resolve) => globalThis.setTimeout(resolve, ms));
 }
 
 export function formatGenerationError(

package/src/features/tools/app-store-screenshot-generator/widget/input-media.test.ts

@@ -0,0 +1,81 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import type {
+  AppStoreScreenshotAsset,
+  AppStoreScreenshotGeneratorInput,
+} from "../../../../lib/tools/app-store-screenshot-generator-schema";
+
+import { createGeneratedAssetZipEntries } from "./input-media";
+
+const input = {
+  source: "upload",
+  productUrl: "",
+  hasScreenshot: true,
+  screenshotName: "source.png",
+  screenshotDataUrl: "",
+  screenshotReferences: [],
+  logoName: "",
+  logoDataUrl: "",
+  productName: "Tomako",
+  productBenefits: "",
+  assetCount: 1,
+  outputLanguage: "en",
+  platform: "apple",
+  style: "clean",
+  palette: "auto",
+  layout: "mixed",
+  headline: "",
+  subheadline: "",
+} satisfies AppStoreScreenshotGeneratorInput;
+
+describe("app store screenshot ZIP entries", () => {
+  it("includes the PNG and existing SVG wrapper for each generated asset", async () => {
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg"><metadata>${"prompt ".repeat(20)}</metadata></svg>`;
+    const asset = {
+      id: "hero",
+      platform: "apple",
+      format: "iphone",
+      title: "Core benefit",
+      width: 1290,
+      height: 2796,
+      imageUrl: "https://example.com/hero.png",
+      svg,
+    } satisfies AppStoreScreenshotAsset;
+
+    const files = await createGeneratedAssetZipEntries(
+      [asset],
+      input,
+      async () => new Blob([new Uint8Array([137, 80, 78, 71])], { type: "image/png" }),
+    );
+
+    assert.deepEqual(
+      files.map((file) => file.path),
+      [
+        "01-tomako-apple-iphone-core-benefit.png",
+        "01-tomako-apple-iphone-core-benefit.svg",
+      ],
+    );
+    assert.deepEqual([...files[0]!.data], [137, 80, 78, 71]);
+    assert.equal(new TextDecoder().decode(files[1]!.data), svg);
+  });
+
+  it("does not advertise a missing SVG by adding an empty file", async () => {
+    const asset = {
+      id: "hero",
+      platform: "apple",
+      format: "iphone",
+      width: 1290,
+      height: 2796,
+      imageUrl: "https://example.com/hero.png",
+    } satisfies AppStoreScreenshotAsset;
+
+    const files = await createGeneratedAssetZipEntries(
+      [asset],
+      input,
+      async () => new Blob([new Uint8Array([1])], { type: "image/png" }),
+    );
+
+    assert.deepEqual(files.map((file) => file.path), ["01-tomako-apple-iphone-hero.png"]);
+  });
+});

package/src/features/tools/app-store-screenshot-generator/widget/input-media.ts

@@ -5,7 +5,7 @@ import type {
 
 import { renderAssetToPngBlob } from "./generation";
 import type { SourceKey } from "./types";
-import { createZipBlob, slugForFileName, type ZipFileInput } from "./zip";
+import { createZipBlob, encodeText, slugForFileName, type ZipFileInput } from "./zip";
 
 export function inferSource(input: AppStoreScreenshotGeneratorInput): SourceKey {
   const hasUrl = input.productUrl.trim().length > 0;
@@ -137,22 +137,34 @@ export async function createGeneratedAssetsZip(
   assets: readonly AppStoreScreenshotAsset[],
   input: AppStoreScreenshotGeneratorInput,
 ): Promise<Blob> {
+  return createZipBlob(await createGeneratedAssetZipEntries(assets, input));
+}
+
+export async function createGeneratedAssetZipEntries(
+  assets: readonly AppStoreScreenshotAsset[],
+  input: AppStoreScreenshotGeneratorInput,
+  renderPng: (asset: AppStoreScreenshotAsset) => Promise<Blob> = renderAssetToPngBlob,
+): Promise<ZipFileInput[]> {
   const files: ZipFileInput[] = [];
   const usedPaths = new Set<string>();
 
   for (const [index, asset] of assets.entries()) {
-    const blob = await renderAssetToPngBlob(asset);
-    const path = uniqueZipPath(
-      usedPaths,
-      `${String(index + 1).padStart(2, "0")}-${assetFileBase(input, asset)}-${slugForFileName(asset.title ?? asset.id)}.png`,
-    );
+    const fileStem = `${String(index + 1).padStart(2, "0")}-${assetFileBase(input, asset)}-${slugForFileName(asset.title ?? asset.id)}`;
+    const blob = await renderPng(asset);
     files.push({
-      path,
+      path: uniqueZipPath(usedPaths, `${fileStem}.png`),
       data: new Uint8Array(await blob.arrayBuffer()),
     });
+
+    if (asset.svg) {
+      files.push({
+        path: uniqueZipPath(usedPaths, `${fileStem}.svg`),
+        data: encodeText(asset.svg),
+      });
+    }
   }
 
-  return createZipBlob(files);
+  return files;
 }
 
 export function uniqueZipPath(usedPaths: Set<string>, path: string) {

package/src/features/tools/cold-start-channel-selector/widget/cold-start-channel-selector.tsx

@@ -28,6 +28,11 @@ import {
 } from "../../../../host/client";
 
 import { useLegacyLlmTaskWatch } from "../../../../components/tools/engine/use-legacy-llm-task";
+import {
+  clearToolTaskRecovery,
+  persistToolTaskRecovery,
+  readToolTaskRecovery,
+} from "../../../../components/tools/engine/task-recovery";
 import { GRACE_WINDOW_MS, initialInput } from "./constants";
 import { SelectField } from "./form-controls";
 import { EmptyPreview, RunningPanel } from "./preview-panels";
@@ -38,6 +43,8 @@ type FormFieldErrors = Partial<
   Record<"productUrl" | "productDescription", string>
 >;
 
+const RECOVERY_SLUG = "cold-start-channel-selector";
+
 export function ColdStartChannelSelector() {
   const t = useTranslations("toolsPages.coldStartChannelSelector.widget");
   const locale = useLocale() as AppLocale;
@@ -74,6 +81,22 @@ export function ColdStartChannelSelector() {
     };
   }, [taskWatch]);
 
+  useEffect(() => {
+    const recovered = readToolTaskRecovery(RECOVERY_SLUG, {
+      parseInput: (value) => {
+        const parsed = coldStartChannelSelectorInputSchema.safeParse(value);
+        return parsed.success ? parsed.data : null;
+      },
+    });
+    if (!recovered) return;
+    setInput(recovered.input);
+    cancelledRef.current = false;
+    settledRef.current = false;
+    watchAnalysis(recovered.taskId, recovered.startedAtMs);
+    // Restore only once for this mounted tool route.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [taskWatch]);
+
   function updateInput<K extends keyof ColdStartChannelSelectorInput>(
     key: K,
     value: ColdStartChannelSelectorInput[K],
@@ -117,6 +140,24 @@ export function ColdStartChannelSelector() {
     return { settled: false as const };
   }
 
+  function watchAnalysis(taskId: string, startedAtMs?: number) {
+    setState({ phase: "running", status: startedAtMs ? "RESTORING" : "PENDING" });
+    taskWatch.start(
+      taskId,
+      pollOnce,
+      {
+        onStatus: (status) => {
+          if (!cancelledRef.current && !settledRef.current) {
+            setState({ phase: "running", status });
+          }
+        },
+        onSuccess: (data) => finishDone(data),
+        onError: (category) => finishError(category === "timeout" ? "timeout" : category),
+      },
+      { graceWindowMs: GRACE_WINDOW_MS, startedAtMs },
+    );
+  }
+
   async function startAnalysis() {
     const parsed = coldStartChannelSelectorInputSchema.safeParse(input);
     if (!parsed.success) {
@@ -159,28 +200,16 @@ export function ColdStartChannelSelector() {
     }
 
     if (cancelledRef.current) return;
-    setState({ phase: "running", status: "PENDING" });
-
-    taskWatch.start(
-      taskId,
-      pollOnce,
-      {
-        onStatus: (status) => {
-          if (!cancelledRef.current && !settledRef.current) {
-            setState({ phase: "running", status });
-          }
-        },
-        onSuccess: (data) => finishDone(data),
-        onError: (category) => finishError(category === "timeout" ? "timeout" : category),
-      },
-      { graceWindowMs: GRACE_WINDOW_MS },
-    );
+    const startedAtMs = Date.now();
+    persistToolTaskRecovery(RECOVERY_SLUG, taskId, parsed.data, startedAtMs);
+    watchAnalysis(taskId, startedAtMs);
   }
 
   function resetResult() {
     cancelledRef.current = false;
     settledRef.current = false;
     cleanup();
+    clearToolTaskRecovery(RECOVERY_SLUG);
     setState({ phase: "idle" });
   }
 

package/src/features/tools/competitor-analysis/competitor-analysis.container.tsx

@@ -1,4 +1,4 @@
-import { ImageOff } from "lucide-react";
+import Image from "next/image";
 import { createToolGuideTranslator } from "../shared/tool-message-translator";
 
 import { CompetitorAnalysis } from "./widget";
@@ -17,30 +17,25 @@ import { ToolWorkspaceSection } from "../shared/tool-guide-section";
 import { ToolPageShell } from "../shared/tool-page-shell";
 import type { ToolPageProps } from "../types";
 
-/**
- * Gray-white image placeholder. The agent has no image-generation capability,
- * so first-pass bitmap assets are intentionally deferred (see release notes /
- * tool brief). Swap each placeholder for a real `public/tools/competitor-analysis-*.webp`
- * when assets are produced.
- */
-function ImagePlaceholder({
+function CompetitorVisual({
+  src,
   label,
   className = "",
 }: {
+  src: string;
   label: string;
   className?: string;
 }) {
   return (
-    <div
-      role="img"
-      aria-label={label}
-      className={`flex aspect-[16/10] w-full items-center justify-center rounded-[1.5rem] border border-dashed border-[#D7DCE3] bg-[#F4F5F7] text-[#A8B0BA] ${className}`}
-    >
-      <span className="flex flex-col items-center gap-2 text-xs font-medium">
-        <ImageOff className="size-6" aria-hidden />
-        {label}
-      </span>
-    </div>
+    <figure className={`relative aspect-[16/10] w-full overflow-hidden rounded-[1.5rem] border border-[#D7DCE3] bg-[#F4F5F7] ${className}`}>
+      <Image
+        src={src}
+        alt={label}
+        fill
+        sizes="(min-width: 1024px) 560px, 100vw"
+        className="object-cover"
+      />
+    </figure>
   );
 }
 
@@ -80,12 +75,18 @@ export async function CompetitorAnalysisContainer({ locale, spec }: ToolPageProp
             <p className="text-sm leading-6 text-[#777777]">{t("runtimeNote")}</p>
           </div>
         </div>
-        <ImagePlaceholder label={t("visualAlt.howToUse")} />
+        <CompetitorVisual
+          src="/tools/competitor-radar-how-it-works.webp"
+          label={t("visualAlt.howToUse")}
+        />
       </section>
 
       {/* Result guidance — visual-led split */}
       <section className="grid gap-8 border-t border-[#E8E4DB] py-12 md:grid-cols-[1.08fr_0.92fr] md:items-center md:py-16">
-        <ImagePlaceholder label={t("visualAlt.result")} />
+        <CompetitorVisual
+          src="/tools/competitor-radar-trust-boundary.webp"
+          label={t("visualAlt.result")}
+        />
         <div>
           <ToolSectionEyebrow tone="blue">{t("resultKicker")}</ToolSectionEyebrow>
           <h2 className="mt-3 text-3xl font-semibold leading-tight text-[#111111] md:text-4xl">
@@ -109,6 +110,11 @@ export async function CompetitorAnalysisContainer({ locale, spec }: ToolPageProp
           <p className="max-w-md text-sm leading-6 text-[#777777]">{t("useCasesIntro")}</p>
         </div>
         <ToolNumberedUseCaseGrid items={useCases} />
+        <CompetitorVisual
+          src="/tools/competitor-radar-use-cases.webp"
+          label={t("visualAlt.useCases")}
+          className="mt-8"
+        />
       </section>
 
       {/* FAQ + boundary */}

package/src/features/tools/competitor-analysis/widget/competitor-analysis.tsx

@@ -22,11 +22,18 @@ import {
 } from "../../../../host/client";
 
 import { useLegacyLlmTaskWatch } from "../../../../components/tools/engine/use-legacy-llm-task";
+import {
+  clearToolTaskRecovery,
+  persistToolTaskRecovery,
+  readToolTaskRecovery,
+} from "../../../../components/tools/engine/task-recovery";
 import { GRACE_WINDOW_MS } from "./constants";
 import { EmptyPanel, ErrorPanel, RunningPanel } from "./preview-panels";
 import { Dossier } from "./result-shell";
 import type { ErrorCategory, WidgetState } from "./types";
 
+const RECOVERY_SLUG = "competitor-analysis";
+
 export function CompetitorAnalysis() {
   const t = useTranslations("toolsPages.competitorAnalysis.widget");
   const locale = useLocale() as AppLocale;
@@ -53,6 +60,24 @@ export function CompetitorAnalysis() {
     };
   }, [taskWatch]);
 
+  useEffect(() => {
+    const recovered = readToolTaskRecovery(RECOVERY_SLUG, {
+      parseInput: (value) => {
+        const parsed = competitorAnalysisInputSchema.safeParse(value);
+        return parsed.success ? parsed.data : null;
+      },
+    });
+    if (!recovered) return;
+    setUrl(recovered.input.competitorUrl);
+    setName(recovered.input.competitorName ?? "");
+    setNotes(recovered.input.notes ?? "");
+    cancelledRef.current = false;
+    settledRef.current = false;
+    watchAnalysis(recovered.taskId, recovered.startedAtMs);
+    // Restore only once for this mounted tool route.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [taskWatch]);
+
   useEffect(() => {
     if (!activityBrief || state.phase !== "done") return;
     publishActivityArtifact(
@@ -93,6 +118,24 @@ export function CompetitorAnalysis() {
     return { settled: false as const };
   }
 
+  function watchAnalysis(taskId: string, startedAtMs?: number) {
+    setState({ phase: "running", status: startedAtMs ? "RESTORING" : "PENDING" });
+    taskWatch.start(
+      taskId,
+      pollOnce,
+      {
+        onStatus: (status) => {
+          if (!cancelledRef.current && !settledRef.current) {
+            setState({ phase: "running", status });
+          }
+        },
+        onSuccess: (data) => finishDone(data, taskId),
+        onError: (category) => finishError(category === "timeout" ? "timeout" : category),
+      },
+      { graceWindowMs: GRACE_WINDOW_MS, startedAtMs },
+    );
+  }
+
   async function startAnalysis() {
     const parsed = competitorAnalysisInputSchema.safeParse({
       competitorUrl: url,
@@ -119,28 +162,16 @@ export function CompetitorAnalysis() {
       return;
     }
     if (cancelledRef.current) return;
-    setState({ phase: "running", status: "PENDING" });
-
-    taskWatch.start(
-      taskId,
-      pollOnce,
-      {
-        onStatus: (status) => {
-          if (!cancelledRef.current && !settledRef.current) {
-            setState({ phase: "running", status });
-          }
-        },
-        onSuccess: (data) => finishDone(data, taskId),
-        onError: (category) => finishError(category === "timeout" ? "timeout" : category),
-      },
-      { graceWindowMs: GRACE_WINDOW_MS },
-    );
+    const startedAtMs = Date.now();
+    persistToolTaskRecovery(RECOVERY_SLUG, taskId, parsed.data, startedAtMs);
+    watchAnalysis(taskId, startedAtMs);
   }
 
   function reset() {
     cancelledRef.current = false;
     settledRef.current = false;
     cleanup();
+    clearToolTaskRecovery(RECOVERY_SLUG);
     setState({ phase: "idle" });
   }