feat: echo job-specific output promise in action session loading state

Author: marian2js

apps/desktop/src/features/action-session/components/ActionSessionProgress.test.ts

@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+const src = readFileSync(
+  resolve(import.meta.dirname, "ActionSessionProgress.tsx"),
+  "utf-8",
+);
+
+// ---------------------------------------------------------------------------
+// ActionSessionProgress: accepts actionPromise and actionOutputType props
+// ---------------------------------------------------------------------------
+
+void test("ActionSessionProgress accepts actionPromise prop", () => {
+  assert.ok(
+    src.includes("actionPromise"),
+    "Expected actionPromise prop in the component interface",
+  );
+});
+
+void test("ActionSessionProgress accepts actionOutputType prop", () => {
+  assert.ok(
+    src.includes("actionOutputType"),
+    "Expected actionOutputType prop in the component interface",
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Starting state: shows job-specific loading text when actionOutputType is set
+// ---------------------------------------------------------------------------
+
+void test("Starting state shows job-specific preparing message when actionOutputType is provided", () => {
+  assert.ok(
+    src.includes("Preparing your"),
+    "Expected 'Preparing your' prefix for job-specific loading message",
+  );
+  assert.ok(
+    src.includes("actionOutputType"),
+    "Expected actionOutputType used in the loading message",
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Starting state: shows deliverables list when actionPromise is provided
+// ---------------------------------------------------------------------------
+
+void test("Starting state shows deliverables from actionPromise", () => {
+  assert.ok(
+    src.includes("actionPromise"),
+    "Expected actionPromise rendered as deliverables list",
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Starting state: falls back to generic message when no job data
+// ---------------------------------------------------------------------------
+
+void test("Starting state falls back to generic loading message", () => {
+  assert.ok(
+    src.includes("Analyzing your company and preparing outputs"),
+    "Expected generic fallback message preserved",
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Starting state: preserves time estimate
+// ---------------------------------------------------------------------------
+
+void test("Starting state preserves time estimate", () => {
+  assert.ok(
+    src.includes("First output in"),
+    "Expected time estimate preserved in starting state",
+  );
+});

apps/desktop/src/features/action-session/components/ActionSessionProgress.tsx

@@ -5,6 +5,10 @@ interface ActionSessionProgressProps {
   state: ActionSessionState;
   hasOutputs: boolean;
   outputCount?: number;
+  /** Output promise text from the job card, e.g. "Tagline, one-liner, launch post draft, checklist" */
+  actionPromise?: string | undefined;
+  /** Short deliverable label from the job card, e.g. "Launch copy bundle" */
+  actionOutputType?: string | undefined;
 }
 
 /** Indeterminate progress bar with shimmer animation */
@@ -38,6 +42,8 @@ export function ActionSessionProgress({
   state,
   hasOutputs,
   outputCount = 0,
+  actionPromise,
+  actionOutputType,
 }: ActionSessionProgressProps) {
   if (state === "ready-to-review" || state === "saved-to-board" || state === "done") {
     return null;
@@ -53,8 +59,15 @@ export function ActionSessionProgress({
           </div>
           <div className="flex-1 space-y-0.5">
             <p className="text-sm font-medium text-foreground">
-              Analyzing your company and preparing outputs…
+              {actionOutputType
+                ? `Preparing your ${actionOutputType.toLowerCase()}…`
+                : "Analyzing your company and preparing outputs…"}
             </p>
+            {actionPromise && (
+              <p className="text-xs text-muted-foreground/70">
+                {actionPromise}
+              </p>
+            )}
             <p className="text-xs text-muted-foreground">
               First output in ~30–90s
             </p>

apps/desktop/src/features/action-session/components/ActionSessionView.tsx

@@ -29,6 +29,7 @@ import { ActionSessionFooter } from "./ActionSessionFooter";
 import {
   clearPersistedActionContext,
   readPersistedActionContext,
+  readActionOutputPromise,
 } from "../lib/action-session-persistence";
 import { useAutoArtifacts } from "@/features/chat/hooks/useAutoArtifacts";
 
@@ -76,6 +77,9 @@ export function ActionSessionView({
   const effectivePrompt = pendingActionPrompt ?? recovered?.prompt ?? null;
   const effectiveTitle = actionTitle ?? recovered?.title ?? "Action";
 
+  // Read output promise data from sessionStorage (persisted by useIntakeForm)
+  const outputPromise = useMemo(() => readActionOutputPromise(), []);
+
   // If there's absolutely no session ID (no props AND nothing persisted),
   // redirect to dashboard — we can't render an action session without one.
   useEffect(() => {
@@ -174,6 +178,8 @@ export function ActionSessionView({
       client={client}
       pendingActionPrompt={effectivePrompt}
       actionTitle={effectiveTitle}
+      actionPromise={outputPromise?.promise}
+      actionOutputType={outputPromise?.outputType}
       onPendingPromptConsumed={() => {
         clearPersistedActionContext();
         onPendingPromptConsumed?.();
@@ -197,6 +203,8 @@ function ActionSessionInner({
   client,
   pendingActionPrompt,
   actionTitle,
+  actionPromise,
+  actionOutputType,
   onPendingPromptConsumed,
   onViewChat,
   onBackToDashboard,
@@ -206,6 +214,8 @@ function ActionSessionInner({
   client: SidecarClient | null;
   pendingActionPrompt?: string | null | undefined;
   actionTitle: string;
+  actionPromise?: string | undefined;
+  actionOutputType?: string | undefined;
   onPendingPromptConsumed?: (() => void) | undefined;
   onViewChat: (sessionId: string) => void;
   onBackToDashboard: () => void;
@@ -419,6 +429,8 @@ function ActionSessionInner({
           state={sessionState}
           hasOutputs={outputs.length > 0}
           outputCount={outputs.length}
+          actionPromise={actionPromise}
+          actionOutputType={actionOutputType}
         />
 
         {/* Error banner when sendMessage fails */}

apps/desktop/src/features/action-session/lib/action-session-persistence.test.ts

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+const src = readFileSync(
+  resolve(import.meta.dirname, "action-session-persistence.ts"),
+  "utf-8",
+);
+
+// ---------------------------------------------------------------------------
+// Output promise persistence: sessionStorage keys exist
+// ---------------------------------------------------------------------------
+
+void test("persistence module defines sessionStorage key for action promise", () => {
+  assert.ok(
+    src.includes("opengoat:actionPromise"),
+    "Expected sessionStorage key for actionPromise",
+  );
+});
+
+void test("persistence module defines sessionStorage key for action output type", () => {
+  assert.ok(
+    src.includes("opengoat:actionOutputType"),
+    "Expected sessionStorage key for actionOutputType",
+  );
+});
+
+// ---------------------------------------------------------------------------
+// persistActionOutputPromise: stores promise and outputType
+// ---------------------------------------------------------------------------
+
+void test("persistActionOutputPromise function exists and stores both fields", () => {
+  assert.ok(
+    src.includes("export function persistActionOutputPromise"),
+    "Expected persistActionOutputPromise export",
+  );
+  // Should accept promise and outputType parameters
+  assert.ok(
+    src.includes("promise: string"),
+    "Expected promise parameter of type string",
+  );
+  assert.ok(
+    src.includes("outputType: string"),
+    "Expected outputType parameter of type string",
+  );
+});
+
+// ---------------------------------------------------------------------------
+// readActionOutputPromise: reads promise and outputType
+// ---------------------------------------------------------------------------
+
+void test("readActionOutputPromise function exists and returns both fields", () => {
+  assert.ok(
+    src.includes("export function readActionOutputPromise"),
+    "Expected readActionOutputPromise export",
+  );
+});
+
+// ---------------------------------------------------------------------------
+// clearPersistedActionContext: also clears output promise keys
+// ---------------------------------------------------------------------------
+
+void test("clearPersistedActionContext removes output promise keys", () => {
+  assert.ok(
+    src.includes("SS_ACTION_PROMISE"),
+    "Expected SS_ACTION_PROMISE constant used in clear",
+  );
+  assert.ok(
+    src.includes("SS_ACTION_OUTPUT_TYPE"),
+    "Expected SS_ACTION_OUTPUT_TYPE constant used in clear",
+  );
+});

apps/desktop/src/features/action-session/lib/action-session-persistence.ts

@@ -12,6 +12,8 @@
 const SS_PENDING_PROMPT = "opengoat:pendingActionPrompt";
 const SS_ACTION_SESSION_ID = "opengoat:actionSessionId";
 const SS_ACTION_TITLE = "opengoat:actionTitle";
+const SS_ACTION_PROMISE = "opengoat:actionPromise";
+const SS_ACTION_OUTPUT_TYPE = "opengoat:actionOutputType";
 
 /** Persist action context so it survives HMR / page reloads. */
 export function persistActionContext(
@@ -34,6 +36,8 @@ export function clearPersistedActionContext(): void {
     sessionStorage.removeItem(SS_PENDING_PROMPT);
     sessionStorage.removeItem(SS_ACTION_SESSION_ID);
     sessionStorage.removeItem(SS_ACTION_TITLE);
+    sessionStorage.removeItem(SS_ACTION_PROMISE);
+    sessionStorage.removeItem(SS_ACTION_OUTPUT_TYPE);
   } catch {
     // best-effort
   }
@@ -57,3 +61,33 @@ export function readPersistedActionContext(): {
   }
   return null;
 }
+
+/** Persist the output promise from the action card so the loading state can echo it. */
+export function persistActionOutputPromise(
+  promise: string,
+  outputType: string,
+): void {
+  try {
+    sessionStorage.setItem(SS_ACTION_PROMISE, promise);
+    sessionStorage.setItem(SS_ACTION_OUTPUT_TYPE, outputType);
+  } catch {
+    // best-effort
+  }
+}
+
+/** Read persisted output promise (returns null if nothing stored). */
+export function readActionOutputPromise(): {
+  promise: string;
+  outputType: string;
+} | null {
+  try {
+    const promise = sessionStorage.getItem(SS_ACTION_PROMISE);
+    const outputType = sessionStorage.getItem(SS_ACTION_OUTPUT_TYPE);
+    if (promise && outputType) {
+      return { promise, outputType };
+    }
+  } catch {
+    // best-effort
+  }
+  return null;
+}

apps/desktop/src/features/dashboard/hooks/useIntakeForm.ts

@@ -3,6 +3,7 @@ import type { ActionCard } from "@/features/dashboard/data/actions";
 import { starterActions } from "@/features/dashboard/data/actions";
 import { getIntakeFields, type IntakeFieldSet } from "@/features/dashboard/data/intake-fields";
 import { buildActionPromptWithIntake } from "@/features/dashboard/data/prompt-builder";
+import { persistActionOutputPromise } from "@/features/action-session/lib/action-session-persistence";
 
 export interface UseIntakeFormOptions {
   suggestedActions: ActionCard[];
@@ -37,6 +38,9 @@ export function useIntakeForm({
       if (!pendingIntakeAction) return;
       const enrichedPrompt = buildActionPromptWithIntake(pendingIntakeAction, values);
       closeIntakeForm();
+      if (pendingIntakeAction.promise && pendingIntakeAction.outputType) {
+        persistActionOutputPromise(pendingIntakeAction.promise, pendingIntakeAction.outputType);
+      }
       void onSubmitAction(pendingIntakeAction.id, enrichedPrompt, pendingIntakeAction.title);
     },
     [pendingIntakeAction, onSubmitAction, closeIntakeForm],
@@ -58,6 +62,11 @@ export function useIntakeForm({
         }
       }
 
+      // Persist output promise for the action session loading state
+      if (card?.promise && card?.outputType) {
+        persistActionOutputPromise(card.promise, card.outputType);
+      }
+
       void onSubmitAction(actionId, prompt, label);
     },
     [suggestedActions, onSubmitAction],