@awak-app/simy-cli 0.7.18 → 0.7.19

package/package.json

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

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.19";
 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/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');