@@ -599,12 +599,12 @@ function buildSucceededSummaryNextStep(
     // so we don't recommend it as `nextStep` — but `kv.summarySuffix` keeps it visible in the summary
     // when records exist, so callers can still discover them. Surface the upstream statusMessage so
     // a text-only reader sees the actor's own diagnostic (often the only signal here). The nextStep
-    // stays generic ("re-run the Actor"): this builder is shared by get-actor-run / abort-actor-run,
-    // which only have a runId and can't know whether the run came from call-actor or a native Actor
-    // tool — naming a specific tool would mislead callers (see #1007).
+    // keeps any retry conditional on the user's intent (see #1559).
     return {
         summary: `SUCCEEDED in ${runTimeSecs}s. No dataset items found.${statusMessageLine(statusMessage)}${kv.summarySuffix}`,
-        nextStep: `Inspect statusMessage and stats in this response; if the missing output was unexpected, re-run the Actor with adjusted input.`,
+        nextStep:
+            'Inspect statusMessage and stats in this response. ' +
+            'If the user wants another attempt, adjust the input before retrying.',
     };
 }
 
@@ -686,12 +686,16 @@ export function buildStatusSummaryNextStep(params: {
         case 'FAILED':
             return {
                 summary: `FAILED after ${runTimeSecs}s.${statusMessageLine(statusMessage)}`,
-                nextStep: `Diagnose using statusMessage and exitCode in this response; re-run the Actor with adjusted input if the cause is fixable.`,
+                nextStep:
+                    'Diagnose using statusMessage and exitCode in this response. ' +
+                    'If the user wants another attempt, fix the cause before retrying.',
             };
         case 'ABORTED':
             return {
                 summary: `ABORTED after ${runTimeSecs}s.${statusMessageLine(statusMessage)}`,
-                nextStep: `Re-run the Actor if you want to retry.`,
+                nextStep:
+                    `Items written before the abort, if any, remain in the run's default dataset${dataset ? ` (datasetId=${dataset.id})` : ''}. ` +
+                    'Retry only if the user wants another run.',
             };
         case 'TIMED-OUT':
             return buildTimedOutSummaryNextStep(runTimeSecs, dataset, keyValueStore);
 
@@ -49,7 +49,9 @@ describe('abort-actor-run', () => {
             keyValueStores: { default: { id: 'kv-xyz' } },
         });
         expect(structuredContent.summary).toBeDefined();
-        expect(structuredContent.nextStep).toBeDefined();
+        expect(structuredContent.nextStep).toBe(
+            "Items written before the abort, if any, remain in the run's default dataset (datasetId=dataset-xyz). Retry only if the user wants another run.",
+        );
 
         // Billing/internal fields must NOT leak.
         const dump = JSON.stringify(structuredContent);
 
@@ -28,8 +28,8 @@ vi.mock('../../src/utils/userid_cache.js', () => ({
  * Default mode `get-actor-run` returns: runId, actorId, status, storages, summary, nextStep
  * — with no inlined dataset items or KV record bodies, except RAG Web Browser's reserved `TIP` key.
  * Tests cover shape invariants and the branching status templates (SUCCEEDED, TIMED-OUT).
- * Pure-template states (READY, RUNNING, TIMING-OUT, ABORTING, FAILED, ABORTED) are intentionally
- * not asserted here — see the comment above `describe('buildStatusTemplate', ...)` below.
+ * Pure-template states are asserted only where a rule applies (FAILED and ABORTED only for their
+ * nextStep) — see the comment above `describe('buildStatusTemplate', ...)` below.
  */
 
 const ACTOR = { username: 'apify', name: 'rag-web-browser' };
@@ -130,6 +130,40 @@ describe('get-actor-run default response', () => {
         });
     });
 
+    it.each([
+        [
+            'SUCCEEDED',
+            { defaultDatasetId: undefined },
+            'Inspect statusMessage and stats in this response. If the user wants another attempt, adjust the input before retrying.',
+        ],
+        [
+            'FAILED',
+            { exitCode: 1 },
+            'Diagnose using statusMessage and exitCode in this response. If the user wants another attempt, fix the cause before retrying.',
+        ],
+        [
+            'ABORTED',
+            {},
+            "Items written before the abort, if any, remain in the run's default dataset (datasetId=dataset-xyz). Retry only if the user wants another run.",
+        ],
+    ])(
+        'returns a nextStep that leaves a retry to the user for %s without dataset items',
+        async (status, overrides, nextStep) => {
+            const run = mockSucceededRun({ status, ...overrides });
+            const result = await (getActorRun as HelperTool).call(
+                stubToolCallContext(
+                    { runId: 'run-1', waitSecs: 0 },
+                    stubClient({ run, dataset: mockDataset({ itemCount: 0 }) }),
+                ),
+            );
+
+            const { structuredContent, content } = result as TextToolResult & { structuredContent: RunResponse };
+            expect(structuredContent.nextStep).toBe(nextStep);
+            expect(content[1].text).toContain(nextStep);
+            expect(content[1].text).toContain('the user wants');
+        },
+    );
+
     it('surfaces dataset inflatedBytes from stats in structuredContent', async () => {
         // The single-dataset GET does not return `inflatedBytes` (only the dataset-list endpoint does);
         // this stub injects it to verify the wiring.
@@ -426,12 +460,12 @@ describe('get-actor-run default response', () => {
         expect(structuredContent.storages.datasets?.default.itemCount).toBeUndefined();
         expect(structuredContent.storages.datasets?.default.fields).toBeUndefined();
 
-        // nextStep points at get-dataset-items, not the "no output / re-run" branch.
+        // nextStep points at get-dataset-items, not the "no output" branch.
         expect(structuredContent.nextStep).toContain('get-dataset-items');
         expect(structuredContent.nextStep).toContain('datasetId=dataset-xyz');
-        // Narrative (content[1]) avoids the "re-run" branch wording.
+        // Narrative (content[1]) avoids the "no output" branch wording.
         expect(content[1].text).not.toContain('No dataset items and no key-value records were found');
-        expect(content[1].text).not.toMatch(/re-run/i);
+        expect(content[1].text).not.toContain('No dataset items found');
     });
 
     it('degrades gracefully when KV listKeys fails: keeps dataset, omits KV', async () => {
@@ -1087,9 +1121,10 @@ const kvWithRecords: RunKeyValueStore = { id: 'kv-1', keys: ['result-a', 'result
 /**
  * Tests below cover real branching in buildSucceededSummaryNextStep / buildTimedOutSummaryNextStep
  * (3 branches each) and the dataset-vs-KV priority + truncation-labelling rules. Pure template
- * re-statements (READY/RUNNING/TIMING-OUT/ABORTING/FAILED/ABORTED) are deliberately not tested
- * here — they would just spell-check the format string and would change in lockstep with any
- * wording tweak. Default-mode integration coverage exercises the dispatch path.
+ * re-statements (READY/RUNNING/TIMING-OUT/ABORTING) are deliberately not tested here — they would
+ * just spell-check the format string and would change in lockstep with any wording tweak. FAILED
+ * and ABORTED are pinned because their nextStep must not ask for a new run (#1559). Default-mode
+ * integration coverage exercises the dispatch path.
  */
 describe('buildStatusTemplate', () => {
     it('SUCCEEDED with dataset items routes to dataset-items nextStep', () => {
@@ -1163,7 +1198,31 @@ describe('buildStatusTemplate', () => {
         const t = buildStatusSummaryNextStep({ run: makeRun('SUCCEEDED') });
         expect(t.summary).toContain('No dataset items found');
         expect(t.summary).not.toContain('Key-value store');
-        expect(t.nextStep).toContain('re-run');
+        expect(t.nextStep).toBe(
+            'Inspect statusMessage and stats in this response. If the user wants another attempt, adjust the input before retrying.',
+        );
+    });
+
+    it.each([
+        [
+            'FAILED',
+            'Diagnose using statusMessage and exitCode in this response. If the user wants another attempt, fix the cause before retrying.',
+        ],
+        [
+            'ABORTED',
+            "Items written before the abort, if any, remain in the run's default dataset (datasetId=ds-1). Retry only if the user wants another run.",
+        ],
+    ])('%s nextStep leaves a retry to the user and names no tool', (status, expected) => {
+        const t = buildStatusSummaryNextStep({ run: makeRun(status), dataset: datasetWithItems });
+        expect(t.nextStep).toBe(expected);
+        expect(t.nextStep).toContain('the user wants');
+    });
+
+    it('ABORTED nextStep without a dataset gives no datasetId', () => {
+        const t = buildStatusSummaryNextStep({ run: makeRun('ABORTED') });
+        expect(t.nextStep).toBe(
+            "Items written before the abort, if any, remain in the run's default dataset. Retry only if the user wants another run.",
+        );
     });
 
     it('SUCCEEDED with both dataset items and KV records picks dataset for nextStep, mentions both in summary', () => {