@@ -88,7 +88,11 @@ An ordinary recording eligible for active-session publication has three states:
 A filesystem or target-collision failure leaves the recording ARMED, including its path and same-target `--force` authorization.
 Thus, the caller can correct the target or permissions and retry.
 ABORTED and PUBLISHED are terminal until the session is destroyed.
-In either state, `session save-script` fails with an explicit error and never writes.
+In either state, `session save-script` never records or publishes new script content.
+A PUBLISHED remote recording may return its retained immutable artifact for another caller-side download.
+This exception does not change the terminal recording state.
+A retry may choose another caller destination; overwrite permission applies only to the authorized destination.
+Local PUBLISHED recordings and all ABORTED recordings still refuse the command.
 
 Every existing arming entry point respects terminality.
 On any existing session, `open --save-script` is rejected before app dispatch.
 
@@ -148,8 +148,16 @@ export function retargetActivePublication(
 }
 
 /** Active publication succeeded: PUBLISHED is terminal, which is what stops recording. */
-export function markActivePublicationDone(session: SessionState, writtenPath: string): void {
-  session.scriptPublication = markAuthoringPublished(publicationState(session), writtenPath);
+export function markActivePublicationDone(
+  session: SessionState,
+  writtenPath: string,
+  actionCount: number,
+): void {
+  session.scriptPublication = markAuthoringPublished(
+    publicationState(session),
+    writtenPath,
+    actionCount,
+  );
 }
 
 /** Ordinary close publication succeeded: the authoring lifecycle reached `published`. */
 
@@ -46,6 +46,7 @@ export type SessionScriptPublicationState =
   | Readonly<{
       kind: 'authoring';
       status: 'armed' | 'aborted' | 'published';
+      publishedActionCount?: number;
       target: SessionScriptTarget;
     }>
   | Readonly<{
@@ -221,11 +222,13 @@ export function abortAuthoring(
 export function markAuthoringPublished(
   state: SessionScriptPublicationState,
   writtenPath: string,
+  actionCount?: number,
 ): SessionScriptPublicationState {
   if (state.kind !== 'authoring') return state;
   return {
     kind: 'authoring',
     status: 'published',
+    ...(actionCount !== undefined ? { publishedActionCount: actionCount } : {}),
     target: {
       kind: 'explicit',
       path: writtenPath,
 
@@ -1,4 +1,5 @@
 import path from 'node:path';
+import fs from 'node:fs';
 import type { DaemonResponse } from '@agent-device/kernel/contracts';
 import { INTERNAL_COMMANDS } from '@agent-device/command-registry/catalog';
 import { AppError, normalizeError } from '@agent-device/kernel/errors';
@@ -36,6 +37,8 @@ export function handleSessionScriptPublication(params: {
     );
   }
   const session = sessionStore.requireCurrent(ref);
+  const retained = retainedPublication(req, session);
+  if (retained) return retained;
   const eligibilityError = validatePublicationEligibility(session);
   if (eligibilityError) return failure(eligibilityError);
 
@@ -67,30 +70,82 @@ export function handleSessionScriptPublication(params: {
     );
   }
 
-  markActivePublicationDone(session, result.path);
+  markActivePublicationDone(session, result.path, result.actionCount);
+  return publicationResponse(session, result.path, result.actionCount);
+}
+
+function retainedPublication(
+  req: DaemonRequest,
+  session: SessionState,
+): DaemonResponse | undefined {
+  const state = session.scriptPublication;
+  if (
+    state?.kind !== 'authoring' ||
+    state.status !== 'published' ||
+    state.target.kind !== 'explicit' ||
+    !state.target.clientPath
+  )
+    return undefined;
+  if (!fs.existsSync(state.target.path)) {
+    return failure(
+      new AppError(
+        'COMMAND_FAILED',
+        'The published script artifact has expired or is unavailable.',
+        {
+          reason: 'script_artifact_unavailable',
+          hint: 'The recording is terminal. Start a fresh authoring session to record another journey.',
+        },
+      ),
+    );
+  }
+  const requested = req.meta?.clientArtifactPaths?.savedScript;
+  if ((req.positionals?.length ?? 0) > 0 && !requested) {
+    return failure(
+      new AppError(
+        'INVALID_ARGS',
+        'A published remote script accepts only a caller-side download destination.',
+      ),
+    );
+  }
+  const force =
+    req.flags?.force === true ||
+    ((!requested || requested === state.target.clientPath) && state.target.force);
+  return publicationResponse(session, state.target.path, state.publishedActionCount ?? 0, {
+    path: requested ?? state.target.clientPath,
+    force,
+  });
+}
+
+function publicationResponse(
+  session: SessionState,
+  writtenPath: string,
+  actionCount: number,
+  download?: { path: string; force: boolean },
+): DaemonResponse {
   const state = session.scriptPublication;
   const target = state?.kind === 'authoring' ? state.target : undefined;
+  const localPath = download?.path ?? (target?.kind === 'explicit' ? target.clientPath : undefined);
   return {
     ok: true,
     data: {
       session: session.name,
-      savedScript: result.path,
-      ...(target?.kind === 'explicit' && target.clientPath
+      savedScript: writtenPath,
+      actionCount,
+      ...(localPath && target?.kind === 'explicit'
         ? {
             artifacts: [
               {
                 field: 'savedScript',
                 artifactType: 'session-script',
-                path: result.path,
-                localPath: target.clientPath,
-                fileName: path.basename(target.clientPath),
-                force: target.force,
+                path: writtenPath,
+                localPath,
+                fileName: path.basename(localPath),
+                force: download?.force ?? target.force,
               },
             ],
           }
         : {}),
-      actionCount: result.actionCount,
-      ...successText(`Published script: ${result.path}`),
+      ...successText(`Published script: ${writtenPath}`),
     },
   };
 }
 
@@ -245,7 +245,7 @@ async function materializeScriptArtifact(
             : 'script_download_failed',
         path: destination,
         artifactId,
-        hint: 'The daemon already published the script. Retry downloading the retained artifact by ID; do not repeat the device journey.',
+        hint: 'The daemon already published the script. Retry session save-script with --force to replace the caller file, or choose another caller path. The command downloads the retained script without repeating the device journey.',
       },
       error instanceof Error ? error : undefined,
     );
 
@@ -8,7 +8,7 @@ import { createAndroidSettingsWorld } from './android-world.ts';
 import { withProviderScenarioResource } from './harness.ts';
 import { createProviderScenarioProxy } from './harness-proxy.ts';
 
-for (const publication of ['active', 'active-force'] as const) {
+for (const publication of ['active', 'active-force', 'retry-existing'] as const) {
   test(`remote ${publication} publication downloads a reusable script through the owning proxy`, async () => {
     await withProviderScenarioResource(
       () => createAndroidSettingsWorld({ nativeTextInjection: true }),
@@ -30,10 +30,29 @@ for (const publication of ['active', 'active-force'] as const) {
         });
         try {
           await recordRemoteJourney(world, client, publication, destination);
+          if (publication === 'retry-existing') {
+            fs.mkdirSync(path.dirname(destination), { recursive: true });
+            fs.writeFileSync(destination, 'protected');
+            await assert.rejects(
+              client.sessions.saveScript({ path: destination }),
+              (error: unknown) =>
+                (error as { details?: { reason?: string } }).details?.reason ===
+                'script_target_exists',
+            );
+            assert.equal(fs.readFileSync(destination, 'utf8'), 'protected');
+          }
           const published = await client.sessions.saveScript(
-            publication === 'active-force' ? { path: destination } : {},
+            publication === 'retry-existing'
+              ? { path: destination, force: true }
+              : publication === 'active-force'
+                ? { path: destination }
+                : {},
           );
           assert.equal(published.savedScript, destination);
+          fs.unlinkSync(destination);
+          const retry = await client.sessions.saveScript();
+          assert.equal(retry.actionCount, published.actionCount);
+          assert.equal(retry.savedScript, destination);
           const text = fs.readFileSync(destination, 'utf8');
           assert.match(text, /open/);
           assert.match(text, /agent-device:target-v1/);