@awak-app/simy-cli 0.7.18 → 0.7.20

package/README.md

@@ -248,15 +248,19 @@ Closing the window keeps the agent running. Open the app again or choose
 **Show SIMY** from its menu bar icon to return. **Quit SIMY** asks before
 interrupting active tasks. The normal `simy` command remains available.
 
-Signed patch/minor updates wait for idle and verify the new runtime before
-handoff; failed startup restores the previous installed version. After a runtime
-update, choose **Restart to update** to load the updated native interface. This
-action asks to stop running tasks before restarting. **Stop task…** in a task
+The macOS **Automatic updates** switch saves this Mac's choice across restarts.
+Compatible signed installations enable it by default. Patch/minor updates wait
+for idle and verify the new runtime before handoff; failed startup restores the
+previous installed version. The app then switches to the verified new interface
+when no unfinished work or confirmation is pending. Turning the switch off keeps
+manual checks and **Download DMG** available. An explicit `SIMY_AUTO_UPDATE=0`
+remains authoritative, and major updates continue to use the DMG.
+**Stop task…** in a task
 detail asks for confirmation and terminates its local Provider process, keeping
 existing output and history. An explicit update can likewise stop active work
 after confirmation; automatic updates still wait for idle. **⌘Q** exits SIMY and
-its background services directly, including when work is running. The window reports App and runtime versions separately while they
-differ, and normal app launches select the newer installed interface.
+its background services directly, including when work is running. The window shows
+the app version, and normal app launches select the newer installed interface.
 
 Older installers that predate native app relaunch support need a one-time
 reinstallation from the official download page to update their Applications

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.7.18",
+  "version": "0.7.20",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {

package/src/auto-update.js

@@ -86,6 +86,7 @@ export class CliAutoUpdater extends EventEmitter {
       install_mode: options.installMode,
       automatic: Boolean(
         !options.disabled &&
+          options.autoUpdatesEnabled !== false &&
           options.daemon &&
           (options.installMode === "global_npm" ||
             (options.installMode === MACOS_INSTALLER_MODE && options.installerMarker?.teamId)) &&
@@ -101,7 +102,20 @@ export class CliAutoUpdater extends EventEmitter {
   }
 
   snapshot() {
-    return structuredClone({ ...this.#snapshot, requires_task_stop: !this.#isIdle() });
+    const supported = !this.#options.disabled && this.#options.daemon && this.#options.requestedPort === 0 &&
+      (this.#options.installMode === 'global_npm' || this.#options.installMode === MACOS_INSTALLER_MODE && Boolean(this.#options.installerMarker?.teamId));
+    return structuredClone({ ...this.#snapshot, auto_update_supported: Boolean(supported),
+      auto_update_enabled: this.#snapshot.automatic, auto_update_busy: Boolean(this.#applying || this.#confirmedUpdate), requires_task_stop: !this.#isIdle() });
+  }
+
+  setAutomaticUpdates(enabled) {
+    if (typeof enabled !== 'boolean') throw new Error('Choose whether automatic updates are enabled.');
+    if (enabled && !this.snapshot().auto_update_supported) throw new Error('Automatic updates are unavailable for this installation.');
+    if (this.#applying || this.#confirmedUpdate) throw new Error('Wait for the current update to finish.');
+    this.#options.autoUpdatesEnabled = enabled;
+    if (!enabled) this.#clearIdleTimer();
+    this.#setState(!enabled && this.#snapshot.state === 'waiting_for_idle' ? 'update_available' : this.#snapshot.state,
+      { automatic: enabled, error: null });
   }
 
   // Close admission before cancellation begins. The same transaction owns the
@@ -435,6 +449,7 @@ export async function createCliAutoUpdater({
   interactive,
   requestedPort = 0,
   disabled = false,
+  autoUpdatesEnabled = true,
   packageRoot = PACKAGE_ROOT,
   webOrigin,
   dependencies = {},
@@ -458,6 +473,7 @@ export async function createCliAutoUpdater({
     interactive: Boolean(interactive),
     requestedPort,
     disabled,
+    autoUpdatesEnabled,
     currentVersion: packageInfo.version,
     installMode,
     installerMarker,

package/src/cli-contract.js

@@ -10,10 +10,11 @@ import {
   LOCAL_TASK_STEP_CONTEXT_SCHEMA,
   LOCAL_TASK_STEP_SCHEMA,
   MAX_LOCAL_TASK_PLAN_STEPS,
+  WORKFLOW_LOCAL_TASK_ARTIFACT_DELIVERY,
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.7.18";
+export const CLI_VERSION = "0.7.20";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function narrativeImageCapabilityMetadata() {
@@ -43,6 +44,7 @@ export function withCliContract(
       plan_schema_version: LOCAL_TASK_PLAN_SCHEMA,
       step_schema_version: LOCAL_TASK_STEP_SCHEMA,
       context_schema_version: LOCAL_TASK_STEP_CONTEXT_SCHEMA,
+      workflow_artifact_delivery: WORKFLOW_LOCAL_TASK_ARTIFACT_DELIVERY,
       max_steps: MAX_LOCAL_TASK_PLAN_STEPS,
     },
     execution_capabilities: buildExecutionCapabilityContract({

package/src/desktop-access.js

@@ -8,7 +8,7 @@ export function validDesktopAccessPath(path, slug) {
 }
 export const desktopAccessReady = value => value?.state === 'ready';
 const recoveryActions = new Set(['refresh', 'reconnect', 'login', 'authorization_open', 'organization_select', 'organization_cancel', 'organizations_refresh',
-  'check_update', 'update', 'prepare_update_restart', 'quit', 'task_stop', 'delivery_stop', 'delivery_pause', 'delivery_reject',
+  'check_update', 'auto_update_set_enabled', 'update', 'prepare_update_restart', 'quit', 'task_stop', 'delivery_stop', 'delivery_pause', 'delivery_reject',
   'provider_disconnect', 'desktop_access_refresh', 'desktop_access_settings', 'desktop_access_members']);
 export function desktopActionAllowed(access, command) {
   return desktopAccessReady(access) || recoveryActions.has(command?.action) ||

package/src/desktop-host.js

@@ -1,4 +1,5 @@
 import { createRemoteHostManager } from './session-supervision/remote-hosts.js';
+import { readDesktopAutoUpdate, writeDesktopAutoUpdate } from './desktop-update-settings.js';
 import { createUpdateRuntime } from './update-detachment/runtime.js';
 import { createCoordinatorReconciler } from "./update-detachment/reconciliation-adapter.js";
 import { createLedgerCoordinatorAdapters } from "./update-detachment/ledger-adapter.js";
@@ -169,6 +170,11 @@ export async function startDesktopHost({ input = process.stdin, output = process
   let encodedStatus = null, lastStatus = null, updateProgress = null;
   let remoteHosts;
   const emitStatus = status => {
+    const updateSettings = updater?.snapshot?.() || {};
+    status = { ...status, update: { ...status.update,
+      auto_update_supported: updateSettings.auto_update_supported === true,
+      auto_update_enabled: updateSettings.auto_update_enabled === true,
+      auto_update_busy: updateSettings.auto_update_busy === true } };
     if (env.SIMY_REMOTE_CHILD === "1") status = { ...status, remoteSessionProtocol: 1 };
     if (remoteHosts) {
       void remoteHosts.update(providerLinks.codex.connected ? status : { ...status, access: { state: "unavailable" } }).catch(() => {});
@@ -644,8 +650,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       const sampledAccess = structuredClone(status.access || { state: 'unavailable', organizationId: null, organizationName: null });
       if (!await acceptStatusAccess(sampledAccess)) { publishAgain = true; return; }
       status.access = sampledAccess;
-      status.updateDetachment = updateRuntime.snapshot(coordinator.snapshot(),updater?.snapshot?.());
-      if(!desktopAccessReady(sampledAccess))status.updateDetachment={...status.updateDetachment,tasks:[],actions:status.updateDetachment.actions.filter(action=>action==='cancel_detach_update')};
+      status.updateDetachment = updateRuntime.snapshot(coordinator.snapshot(),updater?.snapshot?.(),{accessReady:desktopAccessReady(sampledAccess)});
       const requestedLinks = await decorateProviderSettings(status);
       const sameScope = desktopAccessReady(currentAccess) &&
         accessScope(lastStatus?.access) === accessScope(currentAccess);
@@ -694,8 +699,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       const sampledAccess = structuredClone(status.access || { state: 'unavailable', organizationId: null, organizationName: null });
       if (!await acceptStatusAccess(sampledAccess)) { publishAgain = true; return; }
       status.access = sampledAccess;
-      status.updateDetachment = updateRuntime.snapshot(coordinator.snapshot(),updater?.snapshot?.());
-      if(!desktopAccessReady(sampledAccess))status.updateDetachment={...status.updateDetachment,tasks:[],actions:status.updateDetachment.actions.filter(action=>action==='cancel_detach_update')};
+      status.updateDetachment = updateRuntime.snapshot(coordinator.snapshot(),updater?.snapshot?.(),{accessReady:desktopAccessReady(sampledAccess)});
       const requestedScope = accessScope(currentAccess);
       const requestedLinks = await decorateProviderSettings(status);
       const allRecords = await recordReader.list();
@@ -841,6 +845,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     updater = await (dependencies.createUpdater || (process.platform === "win32" ? (() => createWindowsDesktopUpdater({ version: packageInfo.version, disabled: env.SIMY_AUTO_UPDATE === "0" })) : createCliAutoUpdater))({
       daemon: true, interactive: true, webOrigin,
       disabled: env.SIMY_AUTO_UPDATE === "0",
+      autoUpdatesEnabled: readDesktopAutoUpdate(root),
       ...(updatePackageRoot ? { packageRoot: updatePackageRoot } : {}),
       dependencies: { packageInfo: updatePackageRoot ? await readCliPackageInfo(updatePackageRoot) : packageInfo,
         logger: message => diagnostics.write(`update: ${message}`) },
@@ -1055,7 +1060,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       return;
     }
     if(command.action==='cancel_detach_update') {
-      try {updateRuntime.validate(command,coordinator.snapshot(),updater?.snapshot?.());coordinator.cancel();emit({type:'result',id:command.id,ok:true});}
+      try {updateRuntime.validate(command,coordinator.snapshot(),updater?.snapshot?.(),{accessReady:desktopAccessReady(currentAccess)});coordinator.cancel();emit({type:'result',id:command.id,ok:true});}
       catch {emit({type:'result',id:command.id,ok:false,message:'This update operation changed. Refresh its status.'});}
       return;
     }
@@ -1124,7 +1129,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
         const access = await accessSnapshot();
         const commandScope = accessScope(access);
         if (!desktopActionAllowed(access, command)) throw Object.assign(new Error('Desktop access is required.'), { code: 'desktop_access_required' });
-        const recoveryControl = ['provider_disconnect', 'session_unmonitor'].includes(action) ||
+        const recoveryControl = ['provider_disconnect', 'session_unmonitor'].includes(action) || action === 'auto_update_set_enabled' && command.enabled === false ||
           ['session_set_auto_continue', 'session_set_email_reports', 'team_thread_share'].includes(action) && command.enabled === false;
         if (['detach_update', 'update_reconnect'].includes(action)) requireDesktopAccess(access);
         else if (!recoveryControl && desktopAccessReady(access) && !desktopActionAllowed({ state: 'unavailable' }, command)) await authorizeWork();
@@ -1278,6 +1283,16 @@ export async function startDesktopHost({ input = process.stdin, output = process
               if (!result.opened) throw new Error('Browser unavailable.');
             } catch { throw Object.assign(new Error('Browser unavailable.'), { code: 'desktop_browser_unavailable' }); }
           }
+        } else if (action === 'auto_update_set_enabled') {
+          if (typeof command.enabled !== 'boolean' || typeof updater.setAutomaticUpdates !== 'function') throw new Error('Automatic updates are unavailable.');
+          const previous = updater.snapshot().auto_update_enabled === true;
+          updater.setAutomaticUpdates(command.enabled);
+          try { writeDesktopAutoUpdate(root, command.enabled); }
+          catch (error) { updater.setAutomaticUpdates(previous); throw error; }
+          emit({ type: 'result', id: command.id, ok: true });
+          await publish();
+          if (command.enabled) setImmediate(() => { if (!closed && !relay) void updater.checkNow().catch(() => {}); });
+          return;
         } else if (action === "check_update") await updater.checkNow();
         else if (action === "update") {
           const status = await agent.getDesktopStatus();

package/src/desktop-update-settings.js

@@ -0,0 +1,15 @@
+import { join } from 'node:path';
+import { readState, atomicSave } from './update-detachment/state-store.js';
+
+export function readDesktopAutoUpdate(root) {
+  try {
+    const settings = readState(join(root, 'desktop-update-settings.json'));
+    return settings === null ? true : settings.enabled === true;
+  }
+  catch { return false; }
+}
+
+export function writeDesktopAutoUpdate(root, enabled) {
+  if (typeof enabled !== 'boolean') throw new Error('Choose whether automatic updates are enabled.');
+  atomicSave(join(root, 'desktop-update-settings.json'), { schemaVersion: 1, enabled });
+}

package/src/durable-local-task-steps-contract.js

@@ -20,6 +20,11 @@ export const LOCAL_TASK_PLAN_ORCHESTRATION_SCHEMA =
 export const LOCAL_TASK_PLAN_SCHEMA = "local_task_plan.v1";
 export const LOCAL_TASK_STEP_SCHEMA = "local_task_step.v1";
 export const LOCAL_TASK_STEP_CONTEXT_SCHEMA = "local_task_step_context.v1";
+// This optional field stays on the existing closed claim schema. Backend only
+// emits it to devices that advertise the matching capability, so older strict
+// clients never receive a field they cannot parse.
+export const WORKFLOW_LOCAL_TASK_ARTIFACT_DELIVERY =
+  "workflow_local_task_artifact.v1";
 export const MAX_LOCAL_TASK_PLAN_STEPS = 8;
 
 const UUID_PATTERN =
@@ -254,6 +259,9 @@ export function normalizeDurableLocalTaskStepClaim(
       "lease_expires_at",
       "claim_replayed",
       ...(Object.hasOwn(claim, "model") ? ["model"] : []),
+      ...(Object.hasOwn(claim, "workflow_artifact_delivery")
+        ? ["workflow_artifact_delivery"]
+        : []),
     ]),
     "claim",
   );
@@ -264,6 +272,15 @@ export function normalizeDurableLocalTaskStepClaim(
     fail("Unsupported durable Local Task step disposition.");
   }
   const model = claim.model == null ? null : requiredString(claim.model, "model", 160);
+  const workflowArtifactDelivery = claim.workflow_artifact_delivery === undefined
+    ? false
+    : claim.workflow_artifact_delivery === WORKFLOW_LOCAL_TASK_ARTIFACT_DELIVERY;
+  if (
+    claim.workflow_artifact_delivery !== undefined &&
+    !workflowArtifactDelivery
+  ) {
+    fail("Unsupported durable Local Task WorkFlow artifact delivery contract.");
+  }
   const turnId = requiredUuid(claim.turn_id, "turn_id");
   const plan = normalizePlan(claim.plan);
   const currentStepId = requiredStepId(claim.current_step_id, "current_step_id");
@@ -309,6 +326,7 @@ export function normalizeDurableLocalTaskStepClaim(
       leaseEpoch: null,
       leaseExpiresAtMs: null,
       claimReplayed: false,
+      workflowArtifactDelivery,
     };
   }
 
@@ -366,6 +384,7 @@ export function normalizeDurableLocalTaskStepClaim(
     leaseEpoch,
     leaseExpiresAtMs,
     claimReplayed: claim.claim_replayed,
+    workflowArtifactDelivery,
     remainingProviderTokens: remainingTokens,
     remainingTimeoutMs: remainingMs,
   };

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

@@ -361,6 +361,19 @@ export function createDurableLocalTaskApi({
         { ambiguousOnTransport: true },
       );
     },
+    async prepareWorkflowArtifact({ turnId, workerId, leaseEpoch, localArtifactId, name, mimeType, sizeBytes, sha256 }) {
+      return request(`local-tasks/${encodeURIComponent(turnId)}/workflow-artifacts/prepare`, {
+        turn_id: turnId, worker_id: workerId, lease_epoch: leaseEpoch,
+        local_artifact_id: localArtifactId, name, mime_type: mimeType,
+        size_bytes: sizeBytes, sha256,
+      }, { ambiguousOnTransport: true });
+    },
+    async commitWorkflowArtifact({ uploadId, turnId, workerId, leaseEpoch, localArtifactId, sha256, sizeBytes }) {
+      return request(`local-tasks/${encodeURIComponent(turnId)}/workflow-artifacts/commit`, {
+        upload_id: uploadId, turn_id: turnId, worker_id: workerId, lease_epoch: leaseEpoch,
+        local_artifact_id: localArtifactId, sha256, size_bytes: sizeBytes,
+      }, { ambiguousOnTransport: true });
+    },
     async heartbeatStep(input) {
       const contract = stepContract.heartbeat(input);
       const payload = await request(
@@ -677,6 +690,7 @@ export function createDurableLocalTaskWorker({
   persist = persistLocalTask,
   stopTask = stopLocalTask,
   materializeArtifacts = materializePipelineArtifacts,
+  materializeWorkflowArtifacts = materializeWorkflowLocalTaskArtifacts,
   attachmentStore = null,
   getDeviceId = () => null,
   readPhotoSource = readLocalPhotoSource,
@@ -996,10 +1010,6 @@ export function createDurableLocalTaskWorker({
       if (!await checkLease()) return;
       await runHeartbeat();
       if (leaseLost) return;
-      if (heartbeatTimer) {
-        clearIntervalImpl(heartbeatTimer);
-        heartbeatTimer = null;
-      }
       const status = completed.status === "stopped"
         ? "cancelled"
         : boundary === "unknown"
@@ -1017,25 +1027,59 @@ export function createDurableLocalTaskWorker({
         status,
         reportFailureCode,
       );
+      const workflowArtifactDelivery =
+        normalized.workflowArtifactDelivery ||
+        context.workflowArtifactDelivery === true;
       let artifactRefs = [];
       try {
         artifactRefs = buildLocalTaskArtifactRefs(
           completed.artifacts,
           completed.id,
         );
+        // Durable step claims intentionally have a closed contract and do not
+        // repeat the parent execution spec.  Preserve the parent-scoped
+        // WorkFlow delivery contract in the same worker context so each
+        // step's verified bytes are materialized before its terminal receipt.
+        if (
+          reportStatus === "succeeded" &&
+          workflowArtifactDelivery &&
+          artifactRefs.length > 0
+        ) {
+          artifactRefs = await materializeWorkflowArtifacts({
+            api,
+            turnId: normalized.turnId,
+            task: completed,
+            artifactRefs,
+            workerId,
+            leaseEpoch: normalized.leaseEpoch,
+          });
+        }
       } catch (error) {
         artifactRefs = [];
         if (status !== "cancelled") {
-          reportStatus = status === "unknown" ? "unknown" : "failed";
-          reportFailureCode = "artifact_verification_failed";
-          reportSummary =
-            "SIMY could not safely verify this durable step's output files.";
+          const contractFailure = error instanceof LocalTaskArtifactContractError;
+          const ambiguousDelivery =
+            workflowArtifactDelivery &&
+            (error?.ambiguous === true || error?.status >= 500);
+          reportStatus = status === "unknown" || ambiguousDelivery
+            ? "unknown"
+            : "failed";
+          reportFailureCode = contractFailure
+            ? "artifact_verification_failed"
+            : "artifact_materialization_failed";
+          reportSummary = workflowArtifactDelivery && ambiguousDelivery
+            ? workflowArtifactRecoverySummary()
+            : reportFailureCode === "artifact_verification_failed"
+              ? "SIMY could not safely verify this durable step's output files."
+              : "SIMY created the durable step output files locally but could not safely attach them to this WorkFlow run.";
           completed.status =
             reportStatus === "failed" ? "failed" : completed.status;
           completed.reason_code = reportFailureCode;
           completed.error = error.message;
-          completed.artifacts = [];
-          if (completed.result) completed.result.artifacts = [];
+          if (contractFailure) {
+            completed.artifacts = [];
+            if (completed.result) completed.result.artifacts = [];
+          }
           await persist(completed);
         }
         onError(
@@ -1450,17 +1494,16 @@ export function createDurableLocalTaskWorker({
         deliveryStage = "artifacts";
         if (
           (reportStatus === "succeeded" || native) &&
-          (normalized.pipelineContext || normalized.narrativeImageRequest || native) &&
+          (normalized.pipelineContext || normalized.workflowArtifactDelivery || normalized.narrativeImageRequest || native) &&
           artifactRefs.length > 0
         ) {
-          artifactRefs = await materializeArtifacts({
-            api,
-            turnId: normalized.turnId,
-            task: completed,
-            artifactRefs,
-            ...(native ? { preserveAmbiguity: true, workerId, leaseEpoch: normalized.leaseEpoch } : {}),
-            ...(normalized.narrativeImageRequest ? { nativeImageReceipt: completed.native_image_receipt, workerId, leaseEpoch: normalized.leaseEpoch } : {}),
-          });
+          artifactRefs = normalized.workflowArtifactDelivery
+            ? await materializeWorkflowArtifacts({ api, turnId: normalized.turnId, task: completed,
+              artifactRefs, workerId, leaseEpoch: normalized.leaseEpoch })
+            : await materializeArtifacts({ api, turnId: normalized.turnId, task: completed, artifactRefs,
+              ...(native ? { preserveAmbiguity: true, workerId, leaseEpoch: normalized.leaseEpoch } : {}),
+              ...(normalized.narrativeImageRequest ? { nativeImageReceipt: completed.native_image_receipt, workerId, leaseEpoch: normalized.leaseEpoch } : {}),
+            });
         }
       } catch (error) {
         const contractFailure = error instanceof LocalTaskArtifactContractError;
@@ -1471,7 +1514,7 @@ 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 || native) &&
+          reportStatus = status === "unknown" || ((normalized.narrativeImageRequest || native || normalized.workflowArtifactDelivery) &&
             (error?.ambiguous === true || error?.status >= 500)) ? "unknown" : "failed";
           reportFailureCode = normalized.narrativeImageRequest && error?.code === "narrative_image_receipt_missing"
             ? "narrative_image_receipt_missing"
@@ -1483,6 +1526,8 @@ export function createDurableLocalTaskWorker({
           reportSummary =
             native ? recoverySummary(reportStatus, reportFailureCode) : normalized.narrativeImageRequest
               ? "SIMY could not confirm the generated image delivery. Keep the local output for verification; do not regenerate it."
+              : normalized.workflowArtifactDelivery && reportStatus === "unknown"
+              ? workflowArtifactRecoverySummary()
               : deliveryStage === "destination"
               ? "SIMY could not confirm delivery to the selected local folder. Existing files and local outputs were preserved."
               : contractFailure
@@ -1507,7 +1552,7 @@ export function createDurableLocalTaskWorker({
               reportFailureCode,
             )
           : workerError(
-              normalized.narrativeImageRequest
+              normalized.narrativeImageRequest || (normalized.workflowArtifactDelivery && reportStatus === "unknown")
                 ? reportSummary
                 : `SIMY could not persist the Local Task output files for this Pipeline run. ${errorMessage(error)} Keep SIMY CLI running, check the connection, and start a new Pipeline run.`,
               reportFailureCode,
@@ -1787,11 +1832,18 @@ 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');
+          // An orchestration envelope only authorizes the CLI to submit a
+          // controlled plan. It does not dispatch a Provider. Its follow-up
+          // may be the existing single-provider native claim, but must never
+          // become a durable step: executeStepClaim has no native delegation
+          // receipt contract.
+          const orchestrationCarriesNativeDelegation = isLocalTaskPlanOrchestration(claim) &&
+            Boolean(claim.execution_spec?.delegation || claim.execution_spec?.delegation_target || claim.execution_spec?.native_identity);
           if (isLocalTaskPlanOrchestration(claim)) {
             const orchestration = claim;
+            context.workflowArtifactDelivery =
+              orchestration.execution_spec?.workflow_artifact_delivery ===
+              "workflow_local_task_artifact.v1";
             const controlledPlan = buildControlledLocalTaskPlan(orchestration);
             await prepareDurableStepAttachments({
               orchestration,
@@ -1820,6 +1872,9 @@ export function createDurableLocalTaskWorker({
                 "local_task_plan_claim_mismatch",
               );
             }
+            if (orchestrationCarriesNativeDelegation && isDurableLocalTaskStepClaim(claim)) {
+              throw workerError('Native delegation requires the admitted single provider turn.', 'native_delegation_execution_mode_unsupported');
+            }
           }
           if (requestedTurnId && claim.turn_id !== requestedTurnId) {
             throw workerError(
@@ -2042,6 +2097,7 @@ function normalizeClaim(claim, { leaseSeconds, nowMs = Date.now() } = {}) {
     throw workerError("Unsupported narrative image execution scope.", "invalid_narrative_image_execution_scope");
   }
   const pipelineContext = normalizePipelineContext(spec);
+  const workflowArtifactDelivery = spec.workflow_artifact_delivery === "workflow_local_task_artifact.v1";
   const scenarioPack = normalizeLocalTaskScenarioPack(spec.scenario_pack);
   return {
     turnId,
@@ -2052,6 +2108,7 @@ function normalizeClaim(claim, { leaseSeconds, nowMs = Date.now() } = {}) {
     uploadedRefs,
     spec,
     pipelineContext,
+    workflowArtifactDelivery,
     scenarioPack,
     narrativeImageRequest,
   };
@@ -2724,6 +2781,61 @@ export async function materializePipelineArtifacts({
   return materialized;
 }
 
+export async function materializeWorkflowLocalTaskArtifacts({
+  api, turnId, task, artifactRefs, workerId, leaseEpoch,
+}) {
+  if (
+    !api || typeof api.prepareWorkflowArtifact !== "function" ||
+    typeof api.uploadArtifact !== "function" || typeof api.commitWorkflowArtifact !== "function"
+  ) {
+    throw workerError(
+      "This SIMY CLI cannot persist WorkFlow output files. Update SIMY CLI and retry the WorkFlow run.",
+      "artifact_materialization_unsupported",
+    );
+  }
+  const materialized = [];
+  for (const ref of artifactRefs) {
+    const artifact = await localTaskArtifact(task, ref.id);
+    if (!artifact) throw workerError("The WorkFlow output changed before it could be attached.", "artifact_materialization_source_changed");
+    const bytes = await readFile(artifact.local_path);
+    const digest = createHash("sha256").update(bytes).digest("hex");
+    if (bytes.byteLength !== ref.size_bytes || digest !== ref.sha256.toLowerCase()) {
+      throw workerError("The WorkFlow output changed before it could be attached.", "artifact_materialization_source_changed");
+    }
+    const prepared = await retryAmbiguousArtifactStep(() => api.prepareWorkflowArtifact({
+      turnId, workerId, leaseEpoch, localArtifactId: ref.id, name: ref.name,
+      mimeType: ref.mime_type, sizeBytes: ref.size_bytes, sha256: ref.sha256.toLowerCase(),
+    }), { preserveAmbiguity: true });
+    validatePreparedArtifact(prepared);
+    await uploadWorkflowArtifactForCommitVerification(api, {
+      uploadUrl: prepared.upload_url, method: prepared.method, headers: prepared.headers, bytes,
+    });
+    const committed = await retryAmbiguousArtifactStep(() => api.commitWorkflowArtifact({
+      uploadId: prepared.upload_id, turnId, workerId, leaseEpoch, localArtifactId: ref.id,
+      sha256: ref.sha256.toLowerCase(), sizeBytes: ref.size_bytes,
+    }), { preserveAmbiguity: true });
+    materialized.push(validateWorkflowCommittedArtifact(committed, ref));
+  }
+  return materialized;
+}
+
+async function uploadWorkflowArtifactForCommitVerification(api, input) {
+  try {
+    await retryAmbiguousArtifactStep(
+      () => api.uploadArtifact(input),
+      { preserveAmbiguity: true },
+    );
+  } catch (error) {
+    // An immutable signed S3 PUT may have stored the exact bytes before its
+    // response was lost.  A later precondition failure only permits the
+    // lease-fenced commit to verify that possibility; it is never publish
+    // confirmation by itself.
+    if (!(error instanceof DurableLocalTaskApiError) || error.status !== 412) {
+      throw error;
+    }
+  }
+}
+
 async function retryAmbiguousArtifactStep(operation, { preserveAmbiguity = false } = {}) {
   let lastError = null;
   let ambiguous = false;
@@ -2791,6 +2903,26 @@ function validateCommittedArtifact(value, expected) {
   };
 }
 
+function validateWorkflowCommittedArtifact(value, expected) {
+  const artifact = value?.workflow_artifact;
+  if (
+    !artifact || typeof artifact !== "object" || !isUuid(String(artifact.artifact_id || "")) ||
+    artifact.name !== expected.name || artifact.mime_type !== expected.mime_type ||
+    artifact.size_bytes !== expected.size_bytes ||
+    String(artifact.sha256 || "").toLowerCase() !== expected.sha256.toLowerCase()
+  ) {
+    throw workerError(
+      "SIMY could not confirm the persisted WorkFlow output file.",
+      "artifact_materialization_invalid_response",
+    );
+  }
+  return {
+    id: expected.id, local_task_id: expected.local_task_id, name: expected.name,
+    relative_path: expected.relative_path, mime_type: expected.mime_type,
+    size_bytes: expected.size_bytes, sha256: expected.sha256.toLowerCase(), verified: true,
+  };
+}
+
 function trustedArtifactUploadUrl(value) {
   let target;
   try {
@@ -2938,6 +3070,10 @@ function recoverySummary(status, failureCode) {
   return `The Local Task failed (${failureCode || "unknown error"}).`;
 }
 
+function workflowArtifactRecoverySummary() {
+  return "SIMY could not confirm WorkFlow output delivery. Existing local output files were preserved. Keep SIMY CLI running while delivery is reconciled; do not rerun this WorkFlow.";
+}
+
 function durableResultSummary(completed, status, failureCode) {
   // Process exit details such as signal-derived code 130 are useful only in
   // the local technical record. A user-requested stop has one stable public

package/src/provider-delegation.js

@@ -156,7 +156,17 @@ async function runCodexDelegation({ selection, instruction, getInstruction, repo
     if (!accountMatches(account.account?.email)) throw fail('provider_account_mismatch');
     const metadata = await readCodexSession(client, selection.session_id, { signal });
     if (metadata.isRunning === true) throw fail('provider_session_busy');
-    const configuration = await client.request('thread/resume', { threadId: selection.session_id, excludeTurns: true });
+    if (metadata.model !== selection.model) throw fail('provider_session_mismatch');
+    // A fresh app-server process otherwise resolves a resumed read-only
+    // session against the local default sandbox. Reapply only the already
+    // bound, narrower read contract before inspecting it; this never grants
+    // workspace-write authority or changes the selected session identity.
+    const resumeParams = { threadId: selection.session_id, excludeTurns: true };
+    if (permissionMode === 'read_only') {
+      resumeParams.model = selection.model;
+      resumeParams.sandbox = 'read-only';
+    }
+    const configuration = await client.request('thread/resume', resumeParams);
     if (configuration.thread?.id !== selection.session_id || configuration.model !== selection.model ||
         !configuration.cwd || await realpath(configuration.cwd) !== await realpath(nativeIdentity ? metadata.cwd : repositoryPath) ||
         workspaceMode === 'repository' && await realpath(configuration.cwd) !== await realpath(repositoryPath)) throw fail('provider_session_mismatch');

package/src/update-detachment/runtime.js

@@ -259,18 +259,22 @@ export function createUpdateRuntime({ root, origin, readContext, listRecords, ob
   };
   return {bind,boundary,reconcile,store,gate:adapters.gate,
     async initialize() {if(!transaction)write({connectionState:readDispatchGate(root).connection,phase:'startup',updateState:'pending'});},
-    snapshot(base,update) {
+    snapshot(base,update,{accessReady=true}={}) {
       if(ownerTransferred)transaction=readState(file);
       const action=base.state==='connected' && update?.state==='waiting_for_idle'?'detach_update':base.state==='detaching'?'cancel_detach_update':!base.busy && ['detached','recovery_required'].includes(base.state)?'update_reconnect':null;
       const frame={...base,schemaVersion:1,connectionState:base.state,
-        updateState:transaction?.updateState || 'pending',tasks:rows(),actions:action?[action]:[]};
+        updateState:transaction?.updateState || 'pending',updaterState:update?.state || 'unknown',tasks:rows(),actions:action?[action]:[]};
+      // Revision the exact frame the native client sees. Filtering after the
+      // fingerprint makes an access change look like conflicting data at the
+      // same revision, which correctly fences all native update actions.
+      if(!accessReady) {frame.tasks=[];frame.actions=frame.actions.filter(action=>action==='cancel_detach_update');}
       const fingerprint=digest(frame);
       if(!ownerTransferred && transaction && transaction.presentation!==fingerprint)write({presentation:fingerprint});
       presented={...frame,operationId:transaction?.operationId,revision:transaction?.revision || 0};
       return presented;
     },
-    validate(command,base,update) {
-      const frame=this.snapshot(base,update);
+    validate(command,base,update,options) {
+      const frame=this.snapshot(base,update,options);
       if(command.operationId!==frame.operationId || command.revision!==frame.revision || !frame.actions.includes(command.action) || transaction?.claimedCommands?.includes(command.id))throw failure('stale_operation');
       write({claimedCommands:[...(transaction?.claimedCommands || []).slice(-255),command.id]});
     },