@awak-app/simy-cli 0.7.15 → 0.7.17

package/src/durable-local-task-worker.js

@@ -1,3 +1,6 @@
+import { readLocalPhotoSource } from "./local-photos.js";
+import { normalizeLocalTaskDestination, resolveLocalTaskDestination, saveLocalTaskDestination } from "./local-task-destination.js";
+import { nativeDelegationFromClaim, nativeDelegationResult, nativeContinuationInstruction, nativeDelegationFailureResult } from './native-delegation-contract.js';
 import { createHash, randomUUID } from "node:crypto";
 import { execFile } from "node:child_process";
 import { constants as fsConstants } from "node:fs";
@@ -33,6 +36,7 @@ import {
 import {
   LOCAL_TASK_FILE_CAPABILITY_VERSION,
   validateLocalTaskFile,
+  validateLocalTaskFileCollection,
 } from "./local-task-file-capabilities.js";
 import {
   normalizeLocalTaskScenarioPack,
@@ -51,6 +55,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import {
   normalizeDurableLocalTaskExecutionClaimV2,
+  normalizeParentUploadedRef,
 } from "./bounded-local-task-subtasks-contract.js";
 import {
   createBoundedLocalTaskSubtaskPool,
@@ -98,6 +103,7 @@ export function createDurableLocalTaskApi({
   requestTimeoutMs = REQUEST_TIMEOUT_MS,
   artifactUploadTimeoutMs = ARTIFACT_UPLOAD_TIMEOUT_MS,
 } = {}) {
+  let narrativeImageSupported = true;
   if (typeof getConnection !== "function") {
     throw new TypeError("getConnection is required");
   }
@@ -127,7 +133,7 @@ export function createDurableLocalTaskApi({
           method: "POST",
           headers: webApiHeaders(
             { token: connection.token },
-            { "Content-Type": "application/json" },
+            { "Content-Type": "application/json", "X-SIMY-Native-Delegation": "provider_delegation_result.v1", "X-SIMY-Device-IO": "local_device_io.v1" },
           ),
           body: JSON.stringify(body),
           signal: AbortSignal.timeout(requestTimeoutMs),
@@ -193,14 +199,22 @@ export function createDurableLocalTaskApi({
         worker_id: workerId,
         lease_seconds: leaseSeconds,
         turn_id: turnId,
-        fp_narrative_image: narrativeImageCapabilityMetadata(),
+        ...(narrativeImageSupported ? { fp_narrative_image: narrativeImageCapabilityMetadata() } : {}),
       };
       if (controlledPlan !== null) body.controlled_plan = controlledPlan;
-      const payload = await request(
-        "local-tasks/claim",
-        body,
-        { ambiguousOnTransport: controlledPlan !== null },
-      );
+      let payload;
+      try {
+        payload = await request("local-tasks/claim", body, { ambiguousOnTransport: controlledPlan !== null });
+      } catch (error) {
+        // Older gateways reject unknown fields before admission. Only that exact
+        // validation rejection permits a retry; uncertain claims never replay.
+        if (!narrativeImageSupported || error.status !== 400 ||
+            error.code !== "invalid_local_task_worker_request" ||
+            error.message !== "unsupported request field: fp_narrative_image") throw error;
+        narrativeImageSupported = false;
+        delete body.fp_narrative_image;
+        payload = await request("local-tasks/claim", body, { ambiguousOnTransport: controlledPlan !== null });
+      }
       if (isLocalTaskPlanOrchestration(payload)) return payload;
       return payload?.claim ?? null;
     },
@@ -242,6 +256,7 @@ export function createDurableLocalTaskApi({
       resultSummary = null,
       artifactRefs = [],
       failureCode = null,
+      delegationResult = null,
     }) {
       const payload = await request(
         `local-tasks/${encodeURIComponent(turnId)}/status`,
@@ -252,10 +267,11 @@ export function createDurableLocalTaskApi({
           result_summary: resultSummary,
           artifact_refs: artifactRefs,
           failure_code: failureCode,
+          ...(delegationResult ? { delegation_result: delegationResult } : {}),
         },
         { ambiguousOnTransport: true },
       );
-      return payload?.ok === true;
+      return payload?.ok === true && (!delegationResult || payload?.delegation_result_accepted === true);
     },
     async prepareArtifact({
       turnId,
@@ -277,7 +293,8 @@ export function createDurableLocalTaskApi({
           mime_type: mimeType,
           size_bytes: sizeBytes,
           sha256,
-          ...(nativeImageReceipt ? { native_image_receipt: nativeImageReceipt, worker_id: workerId, lease_epoch: leaseEpoch } : {}),
+          ...(workerId !== null ? { worker_id: workerId, lease_epoch: leaseEpoch } : {}),
+          ...(nativeImageReceipt ? { native_image_receipt: nativeImageReceipt } : {}),
         },
         { ambiguousOnTransport: true },
       );
@@ -338,7 +355,8 @@ export function createDurableLocalTaskApi({
           local_artifact_id: localArtifactId,
           sha256,
           size_bytes: sizeBytes,
-          ...(nativeImageReceipt ? { native_image_receipt: nativeImageReceipt, worker_id: workerId, lease_epoch: leaseEpoch } : {}),
+          ...(workerId !== null ? { worker_id: workerId, lease_epoch: leaseEpoch } : {}),
+          ...(nativeImageReceipt ? { native_image_receipt: nativeImageReceipt } : {}),
         },
         { ambiguousOnTransport: true },
       );
@@ -476,6 +494,28 @@ export function createDurableLocalTaskApi({
       );
       return payload;
     },
+    async download_local_task_source_v2({ turnId, workerId, leaseEpoch, source }) {
+      const payload = await request(`local-tasks/${encodeURIComponent(turnId)}/sources/download`, {
+        worker_id: workerId, lease_epoch: leaseEpoch,
+        source_id: source.source_id, upload_id: source.upload_id, sha256: source.sha256,
+      });
+      const prepared = validateSubtaskSourceDownload(payload, source, 'local_task_source_download.v2');
+      const response = await fetchImpl(prepared.url, {
+        method: 'GET', headers: prepared.headers, redirect: 'error',
+        signal: AbortSignal.timeout(artifactUploadTimeoutMs),
+      });
+      if (!response.ok) throw new DurableLocalTaskApiError('SIMY could not download the authorized source.',
+        { status: response.status, code: 'local_task_source_download_failed' });
+      const maxBytes = Number(source.size_bytes);
+      // Bound streamed bytes even if storage misreports Content-Length.
+      const chunks = []; let length = 0;
+      for await (const chunk of response.body ?? []) {
+        length += chunk.length;
+        if (length > maxBytes) throw new DurableLocalTaskApiError('Source size changed.', { code: 'local_task_source_integrity_failed' });
+        chunks.push(Buffer.from(chunk));
+      }
+      return Buffer.concat(chunks);
+    },
     async download_local_task_subtask_source_v2({
       turnId,
       batchId,
@@ -573,7 +613,7 @@ function boundedSubtaskFenceBody(input) {
   };
 }
 
-function validateSubtaskSourceDownload(value, expected) {
+function validateSubtaskSourceDownload(value, expected, schema = "local_task_subtask_source_download.v2") {
   const topKeys = new Set(["schema_version", "source", "download"]);
   const sourceKeys = new Set([
     "source_id",
@@ -594,7 +634,7 @@ function validateSubtaskSourceDownload(value, expected) {
     Array.isArray(value) ||
     Object.keys(value).some((key) => !topKeys.has(key)) ||
     Object.keys(value).length !== topKeys.size ||
-    value.schema_version !== "local_task_subtask_source_download.v2" ||
+    value.schema_version !== schema ||
     !value.source ||
     typeof value.source !== "object" ||
     Array.isArray(value.source) ||
@@ -639,10 +679,13 @@ export function createDurableLocalTaskWorker({
   materializeArtifacts = materializePipelineArtifacts,
   attachmentStore = null,
   getDeviceId = () => null,
+  readPhotoSource = readLocalPhotoSource,
   beginWork = () => () => {},
   workerId = `simy-cli-${randomUUID()}`,
   leaseSeconds = DEFAULT_LEASE_SECONDS,
+  enableBoundedSubtasks = true,
   heartbeatIntervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS,
+  now = Date.now,
   setIntervalImpl = setInterval,
   clearIntervalImpl = clearInterval,
   onError = () => {},
@@ -689,6 +732,7 @@ export function createDurableLocalTaskWorker({
     });
     task.durable_turn_id = runtime.parent_turn_id;
     task.durable_step_id = runtime.step_id;
+    task.durable_subtask_attempt_id = runtime.attempt_id;
     await persist(task);
     registry.create(task);
     boundedTasks.set(runtime.attempt_id, task);
@@ -734,6 +778,8 @@ export function createDurableLocalTaskWorker({
     let knownLeaseExpiry = Number.NaN;
     let boundary = "not_started";
     let leaseLost = false;
+    let resolveLeaseLoss;
+    const leaseLoss = new Promise(resolve => { resolveLeaseLoss = resolve; });
     let cancelRequested = false;
     let normalized = null;
     const executionStartedAt = Date.now();
@@ -748,13 +794,21 @@ export function createDurableLocalTaskWorker({
           "local_task_step_lease_lost",
         ),
       );
-      if (task) await stopTask(task).catch(() => undefined);
+      if (task) {
+        task.reason_code ||= "local_task_lease_lost";
+        await stopTask(task).catch(() => undefined);
+      }
+      resolveLeaseLoss();
     };
 
     try {
       normalized = normalizeDurableLocalTaskStepClaim(claim, {
+        nowMs: now(),
         leaseSeconds,
       });
+      if (claim.execution_spec?.local_destination !== undefined || claim.execution_spec?.local_photo_source !== undefined) {
+        throw workerError("Local destination delivery is not supported for stepped execution.", "local_task_destination_unconfirmed");
+      }
       if (normalized.disposition !== "execute") {
         throw workerError(
           normalized.disposition === "approval_required"
@@ -813,6 +867,16 @@ export function createDurableLocalTaskWorker({
       registry.create(task);
       if (active) active.task = task;
 
+      const checkLease = async () => {
+        if (!leaseLost && now() >= knownLeaseExpiry) {
+          await stopForLeaseLoss(workerError(
+            "The local execution lease expired while waiting for SIMY Web.",
+            "local_task_lease_expired",
+          ));
+        }
+        if (leaseLost) await leaseLoss;
+        return !leaseLost;
+      };
       const heartbeat = async () => {
         if (
           !active ||
@@ -821,6 +885,8 @@ export function createDurableLocalTaskWorker({
         ) {
           return;
         }
+        const renewalStartedAt = now();
+        if (!await checkLease()) return;
         try {
           const response = await api.heartbeatStep({
             turnId: normalized.turnId,
@@ -829,6 +895,7 @@ export function createDurableLocalTaskWorker({
             leaseEpoch: normalized.leaseEpoch,
             leaseSeconds,
           });
+          if (!await checkLease()) return;
           if (response.ok !== true) {
             await stopForLeaseLoss(
               workerError(
@@ -838,7 +905,7 @@ export function createDurableLocalTaskWorker({
             );
             return;
           }
-          knownLeaseExpiry = Date.now() + leaseSeconds * 1_000;
+          knownLeaseExpiry = renewalStartedAt + leaseSeconds * 1_000;
           if (response.cancelRequested) {
             cancelRequested = true;
             await stopTask(task);
@@ -860,7 +927,7 @@ export function createDurableLocalTaskWorker({
           );
           if (
             Number.isFinite(knownLeaseExpiry) &&
-            Date.now() + heartbeatIntervalMs >= knownLeaseExpiry
+            now() + heartbeatIntervalMs >= knownLeaseExpiry
           ) {
             await stopForLeaseLoss(error);
           }
@@ -872,16 +939,18 @@ export function createDurableLocalTaskWorker({
             heartbeatInFlight = null;
           });
         }
-        return heartbeatInFlight;
+        return Promise.race([heartbeatInFlight, leaseLoss]);
       };
 
       heartbeatTimer = setIntervalImpl(() => {
-        void runHeartbeat();
+        // Expiry must be checked even while a heartbeat request is still pending.
+        void checkLease().then((valid) => { if (valid) void runHeartbeat(); });
       }, heartbeatIntervalMs);
       heartbeatTimer?.unref?.();
 
       const completed = await runLocalTask(task, {
         beforeProviderInvocation: async () => {
+          await checkLease();
           if (leaseLost || cancelRequested || closed) {
             throw workerError(
               "The durable step was stopped before the Provider started.",
@@ -904,8 +973,13 @@ export function createDurableLocalTaskWorker({
               },
             );
             boundary = "started";
+            // The server ACK can arrive after cancellation or lease expiry.
+            if (!await checkLease() || cancelRequested || closed) {
+              throw workerError("The execution authority expired before Provider dispatch.",
+                "local_task_cancelled_before_invocation");
+            }
           } catch (error) {
-            boundary = error?.ambiguous ? "unknown" : "not_started";
+            boundary = boundary === "started" || error?.ambiguous ? "unknown" : "not_started";
             throw workerError(
               error?.ambiguous
                 ? "SIMY could not confirm the durable step Provider boundary. This step will not be started again."
@@ -919,12 +993,13 @@ export function createDurableLocalTaskWorker({
         },
       });
 
+      if (!await checkLease()) return;
+      await runHeartbeat();
+      if (leaseLost) return;
       if (heartbeatTimer) {
         clearIntervalImpl(heartbeatTimer);
         heartbeatTimer = null;
       }
-      await runHeartbeat();
-      if (leaseLost) return;
       const status = completed.status === "stopped"
         ? "cancelled"
         : boundary === "unknown"
@@ -1090,6 +1165,8 @@ export function createDurableLocalTaskWorker({
     let knownLeaseExpiry = Number.NaN;
     let boundary = "not_started";
     let leaseLost = false;
+    let resolveLeaseLoss;
+    const leaseLoss = new Promise(resolve => { resolveLeaseLoss = resolve; });
     let cancelRequested = false;
     let materializedAttachmentRefs = null;
 
@@ -1103,12 +1180,22 @@ export function createDurableLocalTaskWorker({
           "local_task_lease_lost",
         ),
       );
-      if (task) await stopTask(task).catch(() => undefined);
+      if (task) {
+        task.reason_code ||= "local_task_lease_lost";
+        await stopTask(task).catch(() => undefined);
+      }
+      resolveLeaseLoss();
     };
 
     try {
-      const normalized = normalizeClaim(claim, { leaseSeconds });
+      const normalized = normalizeClaim(claim, { leaseSeconds, nowMs: now() });
+      const native = nativeDelegationFromClaim(claim, deviceId);
       knownLeaseExpiry = normalized.leaseExpiresAtMs;
+      const requestedDestination = normalizeLocalTaskDestination(normalized.spec.local_destination);
+      if (requestedDestination && requestedDestination.device_id !== deviceId) throw workerError("The destination belongs to another device.", "local_task_destination_unconfirmed");
+      if (requestedDestination?.authorized_root && normalized.spec.delegation_target?.provider !== "codex") throw workerError("This folder requires an existing native workspace authorization.", "local_task_destination_unconfirmed");
+      let destination = requestedDestination && !requestedDestination.authorized_root ? await resolveLocalTaskDestination(normalized.spec, { deviceId, resolveRepository }) : null;
+      const photoContext = normalized.spec.local_photo_source ? await readPhotoSource(normalized.spec.local_photo_source, { deviceId }) : null;
       const workspace = await resolveWorkspace(normalized, {
         storageRoot,
         workspaceRoot,
@@ -1116,6 +1203,12 @@ export function createDurableLocalTaskWorker({
         resolveRepository,
       });
       let attachments = [];
+      if (normalized.uploadedRefs.length) {
+        if (!native || typeof api.download_local_task_source_v2 !== 'function')
+          throw workerError('Native uploaded source download is unavailable.', 'local_task_source_download_unavailable');
+        attachments = await materializeNativeUploadedInputs({ refs: normalized.uploadedRefs, inputsRoot: workspace.inputs_root,
+          download: source => api.download_local_task_source_v2({ turnId: normalized.turnId, workerId, leaseEpoch: normalized.leaseEpoch, source }) });
+      }
       if (normalized.attachmentRefs.length > 0) {
         if (!attachmentStore || typeof attachmentStore.materialize !== "function") {
           throw workerError(
@@ -1123,11 +1216,18 @@ export function createDurableLocalTaskWorker({
             "durable_local_task_attachments_unavailable",
           );
         }
-        attachments = await attachmentStore.materialize({
-          refs: normalized.attachmentRefs,
-          deviceId,
-          inputsRoot: workspace.inputs_root,
-        });
+        try {
+          attachments.push(...await attachmentStore.materialize({ refs: normalized.attachmentRefs, deviceId, inputsRoot: workspace.inputs_root }));
+        } catch (error) {
+          const parent = native && claim.execution_spec.continuation?.parent_turn_id;
+          const retained = parent && registry.list().find(prior => prior.durable_turn_id === parent &&
+            prior.native_identity?.device_id === deviceId && prior.native_identity?.account_id === native.nativeIdentity.account_id &&
+            prior.delegation?.origin_conversation_id === claim.thread_id);
+          if (!retained || !['ENOENT', 'local_task_attachment_ref_not_found'].includes(error.code) ||
+              typeof attachmentStore.materializeRetained !== 'function') throw error;
+          attachments.push(...await attachmentStore.materializeRetained({ refs: normalized.attachmentRefs, deviceId,
+            inputsRoot: workspace.inputs_root, retainedTask: retained }));
+        }
         materializedAttachmentRefs = normalized.attachmentRefs;
       }
       validateLocalTaskScenarioInputs(normalized.scenarioPack, {
@@ -1136,9 +1236,10 @@ export function createDurableLocalTaskWorker({
       });
       task = createLocalTask({
         id: workspace.localTaskId,
-        instruction: normalized.instruction,
+        instruction: native ? nativeContinuationInstruction(claim) : normalized.instruction,
         backend: normalized.spec.backend,
         model: normalized.spec.model ?? null,
+        ...(native ? { delegation: native.delegation, nativeIdentity: native.nativeIdentity } : {}),
         operation: normalized.spec.operation,
         permissionMode: normalized.spec.permission_mode,
         workspaceMode: normalized.spec.workspace_mode,
@@ -1149,6 +1250,9 @@ export function createDurableLocalTaskWorker({
         outputsRoot: workspace.outputs_root,
         outputsRootExpected: workspace.outputs_root_expected,
         attachments,
+        localDestination: requestedDestination,
+        localPhotoSource: normalized.spec.local_photo_source,
+        localPhotoContext: photoContext,
         expectedOutputs: normalized.spec.expected_outputs,
         scenarioPack: normalized.scenarioPack,
         providerTokenBudget: normalized.spec.provider_token_budget,
@@ -1161,8 +1265,20 @@ export function createDurableLocalTaskWorker({
       registry.create(task);
       if (active) active.task = task;
 
+      const checkLease = async () => {
+        if (!leaseLost && now() >= knownLeaseExpiry) {
+          await stopForLeaseLoss(workerError(
+            "The local execution lease expired while waiting for SIMY Web.",
+            "local_task_lease_expired",
+          ));
+        }
+        if (leaseLost) await leaseLoss;
+        return !leaseLost;
+      };
       const heartbeat = async () => {
-        if (!active || active.claim.turn_id !== normalized.turnId) return;
+        if (!active || active.claim.turn_id !== normalized.turnId || leaseLost) return;
+        const renewalStartedAt = now();
+        if (!await checkLease()) return;
         try {
           const response = await api.heartbeat({
             turnId: normalized.turnId,
@@ -1170,6 +1286,7 @@ export function createDurableLocalTaskWorker({
             leaseEpoch: normalized.leaseEpoch,
             leaseSeconds,
           });
+          if (!await checkLease()) return;
           if (response.ok !== true) {
             await stopForLeaseLoss(
               workerError(
@@ -1179,7 +1296,7 @@ export function createDurableLocalTaskWorker({
             );
             return;
           }
-          knownLeaseExpiry = Date.now() + leaseSeconds * 1_000;
+          knownLeaseExpiry = renewalStartedAt + leaseSeconds * 1_000;
           if (response.cancelRequested) {
             cancelRequested = true;
             await stopTask(task);
@@ -1201,7 +1318,7 @@ export function createDurableLocalTaskWorker({
           );
           if (
             Number.isFinite(knownLeaseExpiry) &&
-            Date.now() + heartbeatIntervalMs >= knownLeaseExpiry
+            now() + heartbeatIntervalMs >= knownLeaseExpiry
           ) {
             await stopForLeaseLoss(error);
           }
@@ -1213,17 +1330,32 @@ export function createDurableLocalTaskWorker({
             heartbeatInFlight = null;
           });
         }
-        return heartbeatInFlight;
+        return Promise.race([heartbeatInFlight, leaseLoss]);
       };
 
       heartbeatTimer = setIntervalImpl(() => {
-        void runHeartbeat();
+        // Expiry must be checked even while a heartbeat request is still pending.
+        void checkLease().then((valid) => { if (valid) void runHeartbeat(); });
       }, heartbeatIntervalMs);
       heartbeatTimer?.unref?.();
 
       const runner = normalized.narrativeImageRequest ? runNarrativeImageTask : runLocalTask;
       const completed = await runner(task, {
+        ...(native ? { delegationOptions: { onWorkspaceAuthorized: async roots => {
+          await runHeartbeat();
+          if (leaseLost || cancelRequested || closed || Date.now() >= knownLeaseExpiry)
+            throw workerError('The Local Task lease no longer permits destination access.', 'local_task_cancelled_before_invocation');
+          if (requestedDestination) destination = await resolveLocalTaskDestination(normalized.spec, {
+            deviceId, resolveRepository, nativeWritableRoots: roots,
+          });
+          task.native_writable_roots = [...roots];
+        } }, beforeSpawn: async () => {
+          await runHeartbeat();
+          if (leaseLost || cancelRequested || closed || Date.now() >= knownLeaseExpiry)
+            throw workerError('The Local Task lease no longer permits dispatch.', 'local_task_cancelled_before_invocation');
+        } } : {}),
         beforeProviderInvocation: async () => {
+          await checkLease();
           if (leaseLost || cancelRequested || closed) {
             throw workerError(
               "The Local Task was stopped before the Provider started.",
@@ -1237,8 +1369,13 @@ export function createDurableLocalTaskWorker({
               leaseEpoch: normalized.leaseEpoch,
             });
             boundary = "started";
+            // The server ACK can arrive after cancellation or lease expiry.
+            if (!await checkLease() || cancelRequested || closed) {
+              throw workerError("The execution authority expired before Provider dispatch.",
+                "local_task_cancelled_before_invocation");
+            }
           } catch (error) {
-            boundary = error?.ambiguous ? "unknown" : "not_started";
+            boundary = boundary === "started" || error?.ambiguous ? "unknown" : "not_started";
             throw workerError(
               error?.ambiguous
                 ? "SIMY could not confirm whether the Provider boundary was recorded. The task was not started again."
@@ -1252,16 +1389,17 @@ export function createDurableLocalTaskWorker({
         },
       });
 
+      if (!await checkLease()) return;
+      await runHeartbeat();
+      if (leaseLost) return;
       if (heartbeatTimer) {
         clearIntervalImpl(heartbeatTimer);
         heartbeatTimer = null;
       }
-      await runHeartbeat();
-      if (leaseLost) return;
       // Report the Provider operation's observed outcome. A cancellation that
       // arrives after Provider completion still cancels the parent Turn on the
       // server, but must not rewrite a known successful operation as cancelled.
-      const status = completed.native_image_unknown === true
+      const status = completed.native_image_unknown === true || completed.delegation_state === "result_unknown"
         ? "unknown"
         : completed.status === "stopped"
         ? "cancelled"
@@ -1278,15 +1416,41 @@ export function createDurableLocalTaskWorker({
       let reportFailureCode = failureCode;
       let reportSummary = durableResultSummary(completed, status, failureCode);
       let artifactRefs = [];
+      let deliveryStage = "artifacts";
       try {
         if (reportStatus === "succeeded" && normalized.narrativeImageRequest &&
             !completed.native_image_receipt) {
           throw workerError("Native image receipt is required before upload.", "narrative_image_receipt_missing");
         }
         artifactRefs = buildLocalTaskArtifactRefs(completed.artifacts, completed.id);
+        if (reportStatus === "succeeded" && requestedDestination) {
+          deliveryStage = "destination";
+          const currentDestination = await resolveLocalTaskDestination(normalized.spec, { deviceId, resolveRepository, nativeWritableRoots: completed.native_writable_roots });
+          if (destination && destination.root !== currentDestination.root) {
+            throw workerError("The save destination does not match this device and its authorized workspace.", "local_task_destination_unconfirmed");
+          }
+          destination = currentDestination;
+          completed.local_destination_receipts = [];
+          await saveLocalTaskDestination({
+            task: completed,
+            destination,
+            onReceipt: async (receipt) => {
+              completed.local_destination_receipts.push(receipt);
+              await persist(completed);
+            },
+            assertActive: () => {
+              if (leaseLost || cancelRequested || closed || Date.now() >= knownLeaseExpiry) {
+                throw workerError("The Local Task stopped before local file delivery.", "local_task_destination_unconfirmed");
+              }
+            },
+          });
+          await persist(completed);
+          reportSummary += `\nSaved and verified on the selected device: ${completed.local_destination_receipts.map((receipt) => receipt.local_path).join(", ")}`;
+        }
+        deliveryStage = "artifacts";
         if (
-          reportStatus === "succeeded" &&
-          (normalized.pipelineContext || normalized.narrativeImageRequest) &&
+          (reportStatus === "succeeded" || native) &&
+          (normalized.pipelineContext || normalized.narrativeImageRequest || native) &&
           artifactRefs.length > 0
         ) {
           artifactRefs = await materializeArtifacts({
@@ -1294,6 +1458,7 @@ export function createDurableLocalTaskWorker({
             turnId: normalized.turnId,
             task: completed,
             artifactRefs,
+            ...(native ? { preserveAmbiguity: true, workerId, leaseEpoch: normalized.leaseEpoch } : {}),
             ...(normalized.narrativeImageRequest ? { nativeImageReceipt: completed.native_image_receipt, workerId, leaseEpoch: normalized.leaseEpoch } : {}),
           });
         }
@@ -1306,19 +1471,26 @@ export function createDurableLocalTaskWorker({
         if (status !== "cancelled") {
           // A gateway 5xx can hide a committed image. Never present that outcome
           // as a clean failure that invites a second generation.
-          reportStatus = status === "unknown" || (normalized.narrativeImageRequest &&
+          reportStatus = status === "unknown" || ((normalized.narrativeImageRequest || native) &&
             (error?.ambiguous === true || error?.status >= 500)) ? "unknown" : "failed";
           reportFailureCode = normalized.narrativeImageRequest && error?.code === "narrative_image_receipt_missing"
             ? "narrative_image_receipt_missing"
+            : deliveryStage === "destination" || error?.code === "local_task_destination_unconfirmed"
+            ? "local_task_destination_unconfirmed"
             : contractFailure
             ? "artifact_verification_failed"
             : "artifact_materialization_failed";
           reportSummary =
-            normalized.narrativeImageRequest
+            native ? recoverySummary(reportStatus, reportFailureCode) : normalized.narrativeImageRequest
               ? "SIMY could not confirm the generated image delivery. Keep the local output for verification; do not regenerate it."
+              : deliveryStage === "destination"
+              ? "SIMY could not confirm delivery to the selected local folder. Existing files and local outputs were preserved."
               : contractFailure
               ? "SIMY could not safely verify the Local Task output files."
               : "SIMY created the output files locally but could not safely attach them to this Pipeline run. Keep SIMY CLI running, check the connection, and start a new Pipeline run.";
+          if (completed.local_destination_receipts?.length) {
+            reportSummary += `\nSaved and verified on the selected device: ${completed.local_destination_receipts.map((receipt) => receipt.local_path).join(", ")}`;
+          }
           completed.status = reportStatus === "failed" ? "failed" : completed.status;
           completed.reason_code = reportFailureCode;
           completed.error = error.message;
@@ -1342,18 +1514,40 @@ export function createDurableLocalTaskWorker({
               error,
             ));
       }
+      const terminalPayload = {
+        turnId: normalized.turnId,
+        workerId,
+        leaseEpoch: normalized.leaseEpoch,
+        status: reportStatus,
+        resultSummary: reportSummary,
+        artifactRefs,
+        failureCode: reportFailureCode,
+        ...(native ? { delegationResult: nativeDelegationResult(completed) } : {}),
+      };
+      completed.durable_pending_status = { device_id: deviceId, payload: terminalPayload };
+      await persist(completed);
       let statusConfirmed;
       try {
-        statusConfirmed = await updateStatusWithResolution(api, {
-          turnId: normalized.turnId,
-          workerId,
-          leaseEpoch: normalized.leaseEpoch,
-          status: reportStatus,
-          resultSummary: reportSummary,
-          artifactRefs,
-          failureCode: reportFailureCode,
-        });
+        statusConfirmed = await updateStatusWithResolution(api, terminalPayload);
+        completed.durable_pending_status = null;
+        await persist(completed);
       } catch (error) {
+        if (isProvenFinalStatusRejection(error)) {
+          // The final receipt was definitively rejected. Retain the completed
+          // task as unconfirmed evidence, but do not let an unresendable
+          // receipt block every later claim or invite a Provider replay.
+          completed.durable_pending_status = null;
+          completed.durable_status_unconfirmed = true;
+          await persist(completed);
+          onError(
+            recoveryError(
+              "SIMY completed the local Provider call but the final server state was rejected. It will not rerun the Provider.",
+              error,
+              "local_task_status_unconfirmed",
+            ),
+          );
+          return;
+        }
         onError(
           recoveryError(
             "SIMY completed the local Provider call but could not save its final server state. It will not rerun the Provider.",
@@ -1364,6 +1558,8 @@ export function createDurableLocalTaskWorker({
         return;
       }
       if (!statusConfirmed) {
+        completed.durable_status_unconfirmed = true;
+        await persist(completed);
         onError(
           recoveryError(
             "SIMY stopped this Local Task but could not confirm its final server state. It will not rerun the Provider.",
@@ -1383,6 +1579,10 @@ export function createDurableLocalTaskWorker({
         );
         const claimStatus =
           boundary === "not_started" ? "failed" : "unknown";
+        let rejectedNative = null;
+        if (boundary === 'not_started' && claim.execution_spec?.delegation_target) {
+          try { rejectedNative = nativeDelegationFailureResult(claim, deviceId); } catch { /* Unbound claims cannot produce an owner receipt. */ }
+        }
         const statusConfirmed = await updateStatusWithResolution(api, {
           turnId: claim.turn_id,
           workerId,
@@ -1396,6 +1596,7 @@ export function createDurableLocalTaskWorker({
                 ),
           artifactRefs: [],
           failureCode: safeMachineCode(error?.code, "durable_local_task_failed"),
+          ...(rejectedNative ? { delegationResult: rejectedNative } : {}),
         }).catch((statusError) => {
           onError(statusError);
           return false;
@@ -1459,9 +1660,59 @@ export function createDurableLocalTaskWorker({
       pollPromise = (async () => {
         const { api, attachmentStore, deviceId } = context;
         try {
+          // The provider operation and saved files are already known. After an
+          // offline result write, retry only that exact lease-bound receipt on
+          // the same paired device; never claim or rerun the provider here.
+          const pendingTask = registry.list?.().find(task => task.durable_pending_status);
+          if (pendingTask) {
+            const pending = pendingTask.durable_pending_status;
+            if (!deviceId || !pending.device_id) {
+              // Pairing state can be temporarily unavailable during a refresh.
+              // Keep the exact receipt pending until the original device can
+              // be identified; never reinterpret a missing device ID as a
+              // device change.
+              onError(workerError("The saved result is waiting for its original paired device.", "local_task_result_device_mismatch"));
+              releaseWork();
+              return false;
+            }
+            if (pending.device_id !== deviceId) {
+              // A receipt belongs to its original pairing. Keeping it pending
+              // on another device would permanently prevent that device from
+              // claiming unrelated work, while resending would violate the
+              // device-bound receipt contract.
+              pendingTask.durable_pending_status = null;
+              pendingTask.durable_status_unconfirmed = true;
+              await persist(pendingTask);
+              onError(workerError("The saved result belongs to a different paired device and will not be resent or replayed.", "local_task_result_device_mismatch"));
+            } else {
+              try {
+                const confirmed = await updateStatusWithResolution(api, pending.payload);
+                pendingTask.durable_pending_status = null;
+                if (!confirmed) pendingTask.durable_status_unconfirmed = true;
+                await persist(pendingTask);
+                if (!confirmed) onError(workerError("The original result lease was fenced; provider replay remains disabled.", "local_task_status_unconfirmed"));
+                releaseWork();
+                return confirmed;
+              } catch (error) {
+                if (!isProvenFinalStatusRejection(error)) throw error;
+                // A proven request/authorization/not-found/validation
+                // rejection cannot become valid by retrying this receipt.
+                // Preserve local evidence and continue to an unrelated claim.
+                pendingTask.durable_pending_status = null;
+                pendingTask.durable_status_unconfirmed = true;
+                await persist(pendingTask);
+                onError(recoveryError(
+                  "SIMY rejected the saved final result. It will not rerun the Provider.",
+                  error,
+                  "local_task_status_unconfirmed",
+                ));
+              }
+            }
+          }
           const requestedTurnId = pendingStepTurnId;
           if (
             !requestedTurnId &&
+            enableBoundedSubtasks &&
             typeof api.claimSubtaskParent === "function"
           ) {
             const parentEnvelope = await api.claimSubtaskParent({
@@ -1488,6 +1739,7 @@ export function createDurableLocalTaskWorker({
                 prepareWorkspace,
                 leaseSeconds,
                 heartbeatIntervalMs,
+                now,
                 setIntervalImpl,
                 clearIntervalImpl,
                 onError,
@@ -1535,6 +1787,9 @@ export function createDurableLocalTaskWorker({
             releaseWork();
             return false;
           }
+          if ((isLocalTaskPlanOrchestration(claim) || isDurableLocalTaskStepClaim(claim)) &&
+              (claim.execution_spec?.delegation || claim.execution_spec?.delegation_target || claim.execution_spec?.native_identity))
+            throw workerError('Native delegation requires the admitted single provider turn.', 'native_delegation_execution_mode_unsupported');
           if (isLocalTaskPlanOrchestration(claim)) {
             const orchestration = claim;
             const controlledPlan = buildControlledLocalTaskPlan(orchestration);
@@ -1572,6 +1827,20 @@ export function createDurableLocalTaskWorker({
               "local_task_plan_claim_mismatch",
             );
           }
+          if (registry.list?.().some(task =>
+            task.durable_status_unconfirmed === true && task.durable_turn_id === claim.turn_id
+          )) {
+            // This device has already completed this exact Provider turn but
+            // cannot prove the server accepted its terminal receipt. A lease
+            // replay must never cause a second Provider invocation; unrelated
+            // claims remain eligible on the following poll.
+            releaseWork();
+            onError(workerError(
+              "SIMY will not rerun a Local Task whose prior Provider result is unconfirmed.",
+              "local_task_status_unconfirmed",
+            ));
+            return false;
+          }
           if (isDurableLocalTaskStepClaim(claim)) {
             const normalized = normalizeDurableLocalTaskStepClaim(claim, {
               leaseSeconds,
@@ -1694,15 +1963,23 @@ async function updateStatusWithResolution(api, input) {
       if (error instanceof DurableLocalTaskApiError && error.status === 409) {
         return false;
       }
-      const retryable =
-        error?.ambiguous === true ||
-        (Number.isInteger(error?.status) && error.status >= 500);
+      const retryable = isRetryableStatusResolutionError(error);
       if (!retryable || attempt > 0) throw error;
     }
   }
   throw lastError;
 }
 
+function isRetryableStatusResolutionError(error) {
+  return error?.ambiguous === true ||
+    (Number.isInteger(error?.status) && error.status >= 500);
+}
+
+function isProvenFinalStatusRejection(error) {
+  return error instanceof DurableLocalTaskApiError &&
+    [400, 403, 404, 422].includes(error.status);
+}
+
 function normalizeClaim(claim, { leaseSeconds, nowMs = Date.now() } = {}) {
   const turnId = String(claim?.turn_id || "");
   const leaseEpoch = Number(claim?.lease_epoch);
@@ -1733,7 +2010,7 @@ function normalizeClaim(claim, { leaseSeconds, nowMs = Date.now() } = {}) {
   if (!instruction) {
     throw workerError("The Local Task has no instruction.", "local_task_instruction_required");
   }
-  const attachmentRefs = payload.attachment_refs ?? [];
+  let attachmentRefs = payload.attachment_refs ?? [];
   if (!Array.isArray(attachmentRefs)) {
     throw workerError(
       "SIMY Web returned invalid attached-file references.",
@@ -1741,6 +2018,16 @@ function normalizeClaim(claim, { leaseSeconds, nowMs = Date.now() } = {}) {
     );
   }
   validateExecutionSpec(spec);
+  const uploadedRefs = attachmentRefs.filter(ref => ref?.schema_version === 'simy_uploaded_attachment_ref.v1');
+  if (uploadedRefs.length) {
+    if (!spec.delegation_target || spec.uploaded_attachment_capability_version !== 'local_task_uploaded_sources.v2')
+      throw workerError('Unsupported uploaded source capability.', 'unsupported_local_task_attachment_capability');
+    uploadedRefs.forEach(ref => normalizeParentUploadedRef(ref));
+    if (new Set(uploadedRefs.map(ref => ref.source_id)).size !== uploadedRefs.length)
+      throw workerError('Duplicate uploaded source.', 'invalid_local_task_claim');
+    validateLocalTaskFileCollection(attachmentRefs, { direction: 'input' });
+    attachmentRefs = attachmentRefs.filter(ref => ref?.schema_version !== 'simy_uploaded_attachment_ref.v1');
+  }
   if (
     attachmentRefs.length > 0 &&
     spec.attachment_capability_version !== LOCAL_TASK_FILE_CAPABILITY_VERSION
@@ -1762,6 +2049,7 @@ function normalizeClaim(claim, { leaseSeconds, nowMs = Date.now() } = {}) {
     leaseExpiresAtMs,
     instruction,
     attachmentRefs,
+    uploadedRefs,
     spec,
     pipelineContext,
     scenarioPack,
@@ -1879,6 +2167,7 @@ async function resolveWorkspace(
     repositoryPath: repository.local_path,
     expectedRepository: normalized.spec.repository,
     localTaskId,
+    prepareOutputs: normalized.spec.permission_mode === "workspace_write",
   });
   return {
     ...prepared,
@@ -2174,10 +2463,11 @@ async function persistDurableStepAttachmentManifest({
   }
 }
 
-async function prepareRepositoryWorkspace({
+export async function prepareRepositoryWorkspace({
   repositoryPath,
   expectedRepository,
   localTaskId,
+  prepareOutputs = true,
 }) {
   const candidate = path.resolve(String(repositoryPath || ""));
   const candidateDetails = await lstat(candidate).catch(() => null);
@@ -2216,6 +2506,8 @@ async function prepareRepositoryWorkspace({
     );
   }
 
+  if (!prepareOutputs) return { workspace_path: repositoryRoot };
+
   const trackedOutputs = await gitOutput(repositoryRoot, [
     "ls-files",
     "--",
@@ -2364,6 +2656,7 @@ export async function materializePipelineArtifacts({
   task,
   artifactRefs,
   nativeImageReceipt = null,
+  preserveAmbiguity = false,
   workerId = null,
   leaseEpoch = null,
 }) {
@@ -2405,7 +2698,8 @@ export async function materializePipelineArtifacts({
         mimeType: ref.mime_type,
         sizeBytes: ref.size_bytes,
         sha256: ref.sha256.toLowerCase(),
-        ...(nativeImageReceipt ? { nativeImageReceipt, workerId, leaseEpoch } : {}),
+        ...(workerId !== null ? { workerId, leaseEpoch } : {}),
+        ...(nativeImageReceipt ? { nativeImageReceipt } : {}),
       }));
     validatePreparedArtifact(prepared);
     await retryAmbiguousArtifactStep(() =>
@@ -2422,8 +2716,9 @@ export async function materializePipelineArtifacts({
         localArtifactId: ref.id,
         sha256: ref.sha256.toLowerCase(),
         sizeBytes: ref.size_bytes,
-        ...(nativeImageReceipt ? { nativeImageReceipt, workerId, leaseEpoch } : {}),
-      }), { preserveAmbiguity: Boolean(nativeImageReceipt) });
+        ...(workerId !== null ? { workerId, leaseEpoch } : {}),
+        ...(nativeImageReceipt ? { nativeImageReceipt } : {}),
+      }), { preserveAmbiguity: Boolean(nativeImageReceipt) || preserveAmbiguity });
     materialized.push(validateCommittedArtifact(committed, ref));
   }
   return materialized;
@@ -2684,3 +2979,22 @@ function plainRecovery(error) {
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error || "");
 }
+
+async function materializeNativeUploadedInputs({ refs, inputsRoot, download }) {
+  const root = await realpath(inputsRoot), inputs = [];
+  for (const ref of refs) {
+    const bytes = await download(ref);
+    validateLocalTaskFile({ ...ref, size_bytes: Number(ref.size_bytes), bytes }, { direction: 'input', requireBytes: true });
+    if (!Buffer.isBuffer(bytes) || bytes.length !== Number(ref.size_bytes) || createHash('sha256').update(bytes).digest('hex') !== ref.sha256)
+      throw workerError('Uploaded source integrity failed.', 'local_task_source_integrity_failed');
+    const target = path.join(root, `${createHash('sha256').update(ref.source_id).digest('hex').slice(0, 16)}-${ref.name}`);
+    if (path.dirname(target) !== root) throw workerError('Unsafe uploaded source path.', 'local_task_source_path_unsafe');
+    await writeFile(target, bytes, { flag: 'wx', mode: 0o400 });
+    const details = await lstat(target), canonical = await realpath(target);
+    if (!details.isFile() || details.isSymbolicLink() || path.dirname(canonical) !== root ||
+        createHash('sha256').update(await readFile(canonical)).digest('hex') !== ref.sha256)
+      throw workerError('Uploaded source changed.', 'local_task_source_integrity_failed');
+    inputs.push({ ...ref, id: ref.source_id, local_path: canonical, integrity_status: 'verified' });
+  }
+  return inputs;
+}