Update SDK pages

Author: tailor-docs-bot[bot]

docs/sdk/cli/function.md

@@ -152,7 +152,7 @@ tailor-sdk function test-run [options] <file>
 **Run a resolver with input arguments**
 
 ```bash
-$ tailor-sdk function test-run resolvers/add.ts --arg '{"input":{"a":1,"b":2}}'
+$ tailor-sdk function test-run resolvers/add.ts --arg '{"a":1,"b":2}'
 ```
 
 **Run a specific workflow job by name**
@@ -164,7 +164,7 @@ $ tailor-sdk function test-run workflows/sample.ts --name validate-order
 **Run a pre-bundled .js file directly**
 
 ```bash
-$ tailor-sdk function test-run build/resolvers/add.js --arg '{"input":{"a":1,"b":2}}'
+$ tailor-sdk function test-run build/resolvers/add.js --arg '{"a":1,"b":2}'
 ```
 
 <!-- politty:command:function test-run:examples:end -->

docs/sdk/services/resolver.md

@@ -13,7 +13,7 @@ Resolvers provide:
 
 ## Comparison with Tailor Platform Pipeline Resolver
 
-The SDK's Resolver is a simplified version of Tailor Platform's [Pipeline Resolver](/guides/pipeline).
+The SDK's Resolver is a simplified version of Tailor Platform's [Pipeline Resolver](/guides/resolver).
 
 | Pipeline Resolver                        | SDK Resolver                      |
 | ---------------------------------------- | --------------------------------- |

docs/sdk/services/workflow.md

@@ -115,6 +115,54 @@ export const mainJob = createWorkflowJob({
 
 **Important:** On the Tailor runtime, job triggers are executed synchronously. This means `Promise.all([jobA.trigger(), jobB.trigger()])` will not run jobs in parallel.
 
+### Deterministic Execution Requirement
+
+Workflow jobs use a **suspend/resume execution model**. When a job calls `.trigger()`, the runtime suspends the current job, executes the triggered job, and then **re-executes the calling job from the beginning** with cached results from previous triggers.
+
+This means that **job code must be deterministic** — every re-execution must produce the same sequence of `.trigger()` calls with the same arguments in the same order.
+
+Using `.trigger()` inside a loop works correctly, as long as the loop is deterministic:
+
+```typescript
+// ✅ OK: deterministic loop — same calls in the same order on every execution
+const regions = ["us", "eu", "ap"];
+for (const region of regions) {
+  const result = await fetchData.trigger({ region });
+  results.push(result);
+}
+```
+
+```typescript
+// ❌ Bad: non-deterministic — argument changes between executions
+await processJob.trigger({ timestamp: Date.now() });
+
+// ✅ OK: call Date.now() in separated job
+const timestamp = await timestampJob.trigger();
+await processJob.trigger({ timestamp });
+```
+
+```typescript
+// ❌ Bad: non-deterministic — external data may change between executions
+const items = await fetch("https://api.example.com/items").then((r) => r.json());
+for (const item of items) {
+  await processItem.trigger({ id: item.id });
+}
+
+// ✅ OK: call fetch("https://api.example.com/items").then((r) => r.json()); in separated job
+const items = await fetchItemsJob.trigger();
+for (const item of items) {
+  await processItem.trigger({ id: item.id });
+}
+```
+
+If the runtime detects that a `.trigger()` call at the same position has different arguments than the previous execution, it will throw an **argument hash mismatch error**.
+
+**Guidelines:**
+
+- Do not use non-deterministic values (random numbers, timestamps, external API responses) as `.trigger()` arguments.
+- Do not use conditions that may change between executions to decide whether to call `.trigger()`.
+- Any data that varies between executions should be fetched **inside the triggered job**, not passed as an argument from the calling job.
+
 ## Workflow Definition
 
 Define a workflow using `createWorkflow` and export it as default: