@awak-app/simy-cli 0.7.17 → 0.7.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.7.17",
+  "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.17";
+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/desktop-host.js

@@ -773,7 +773,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       for (const session of status.sessionSupervision.sessions) {
         const key = teamThreadKey(agent.getTeamThreadsScope?.() || {}, session);
         const own = status.teamThreads?.own.find(item => item.threadKey === key);
-        session.teamSharing = { enabled: own?.enabled === true, pendingStop: status.teamThreads?.pendingStops.includes(key) === true };
+        session.teamSharing = { threadKey: key, enabled: own?.enabled === true, pendingStop: status.teamThreads?.pendingStops.includes(key) === true, confirmationRequired: status.teamThreads?.confirmationRequired.includes(key) === true };
       }
       const latestAccess = await accessSnapshot();
       if (JSON.stringify(await readProviderLinks(root)) !== requestedLinks ||
@@ -1138,9 +1138,20 @@ export async function startDesktopHost({ input = process.stdin, output = process
           else if(action === 'team_thread_open') ok = await teamThreads.open({memberId:command.memberId,threadKey:command.threadKey});
           else {
             if (command.organizationId !== undefined && command.organizationId !== access.organizationId) throw new Error('Sharing organization changed. Confirm again.');
-            const selected = sessionStatus.sessions.find(item => item.provider === command.provider && item.session === command.session);
-            if(!selected) throw new Error('Refresh and select your conversation again.');
-            ok = await teamThreads.setSharing(selected,command.enabled);
+            // Publication reads this host's provider context. Never reinterpret
+            // a remote or ambiguous identity as a same-ID local conversation.
+            if ((command.hostId && command.hostId !== 'local') || (!command.hostId && remoteHosts?.hasSession(command.session))) {
+              throw new Error('Team sharing requires an explicitly selected local conversation.');
+            }
+            const selected = sessionStatus.sessions.find(item => (!item.hostId || item.hostId === 'local') && item.provider === command.provider && item.session === command.session);
+            if (command.enabled === false) {
+              // Revocation uses authenticated own rows, never provider context.
+              const key = command.threadKey ?? teamThreadKey(agent.getTeamThreadsScope(), { provider: command.provider, session: command.session });
+              ok = await teamThreads.stopSharing(key);
+            } else {
+              if(!selected || command.threadKey) throw new Error('Refresh and select your conversation again.');
+              ok = await teamThreads.setSharing(selected,command.enabled);
+            }
           }
           emit({type:'result',id:command.id,ok:ok===true}); void publish().catch(() => {}); return;
         }
@@ -1457,6 +1468,22 @@ export async function startDesktopHost({ input = process.stdin, output = process
           await authorizeWork(commandScope);
           const result = await deadlines.decide(context, { ...command, requestId: command.requestId || command.decisionId });
           if (result.status === 'conflict') throw Object.assign(new Error('Deadline changed; refresh before deciding.'), { code: 'conflict' });
+        } else if (action === "session_set_pinned") {
+          if (typeof command.enabled !== 'boolean') throw new Error('Choose whether to pin this conversation.');
+          const candidate = await selectedSession(command, { preferObserved: true });
+          await authorizeWork(commandScope);
+          const pinScope = command.pinScope ?? 'legacy';
+          if (typeof pinScope !== 'string' || !pinScope || pinScope.length > 512) throw new Error('Invalid pin scope.');
+          await updateRecord(deliveryRoot, command.provider, command.session, previous => {
+            const scopes = new Set(Array.isArray(previous?.listPinScopes) ? previous.listPinScopes : previous?.listPinned ? ['legacy'] : []);
+            if (command.enabled) scopes.add(pinScope); else scopes.delete(pinScope);
+            return {
+              ...(previous || { schemaVersion: 1, provider: command.provider, session: command.session, cwd: candidate.cwd, observedAt: Date.now() }),
+              listPinned: scopes.size > 0, listPinScopes: [...scopes],
+              ...(command.enabled ? { listMetadata: { title: candidate.title || '', createdAt: candidate.createdAt ?? null, lastActivityAt: candidate.lastActivityAt ?? null } } : {}),
+            };
+          });
+          refreshSessions(true);
         } else if (action === "session_archive" || action === "session_restore") {
           const candidate = await selectedSession(command, { preferObserved: true });
           await authorizeWork(commandScope);

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/session-supervision/claude-sessions.js

@@ -25,7 +25,7 @@ function rememberMetadata(path, value) {
 function candidateMetadata(id, metadata, lastActivityAt, observedAt) {
   return {
     provider: 'claude', session: id, ...(metadata.parentSessionId ? { parentSession: { provider: 'claude', session: metadata.parentSessionId } } : {}), cwd: metadata.cwd, title: metadata.title,
-    source: 'claude_cli', lastActivityAt,
+    source: 'claude_cli', lastActivityAt, createdAt: metadata.createdAt ?? null,
     observation: { source: 'claude_local_index', observedAt },
     availability: 'unsupported', model: null,
     capabilities: { canMonitor: true, canEnroll: false, canAutoContinue: false },
@@ -62,7 +62,7 @@ function metadataFromPrefix(bytes, id) {
   const text = bytes.toString('utf8');
   const complete = text.slice(0, text.lastIndexOf('\n') + 1);
   if (!complete) return null;
-  let cwd = '', title = '', customTitle = '', parentSessionId = null, found = false;
+  let cwd = '', title = '', customTitle = '', parentSessionId = null, found = false, createdAt = null;
   for (const line of complete.split('\n').slice(0, MAX_LINES)) {
     if (!line) continue;
     let item;
@@ -73,6 +73,8 @@ function metadataFromPrefix(bytes, id) {
     if (item.type === 'custom-title' && item.isSidechain !== true) { customTitle = sessionTitle(item.customTitle); continue; }
     if (item.type !== 'user' && item.type !== 'assistant') continue;
     if (item.isSidechain === true) return null;
+    const timestamp = typeof item.timestamp === 'string' ? Date.parse(item.timestamp) : item.timestamp;
+    if (Number.isFinite(timestamp) && timestamp > 0) createdAt = createdAt === null ? timestamp : Math.min(createdAt, timestamp);
     if (typeof item.cwd !== 'string' || !isAbsolute(item.cwd)) continue;
     if (!cwd) cwd = resolve(item.cwd);
     // A conversation can cd into a child directory without changing identity.
@@ -80,7 +82,7 @@ function metadataFromPrefix(bytes, id) {
     if (!title) title = sessionTitle(item.slug);
     found = true;
   }
-  return found ? { cwd, title: customTitle || title, parentSessionId } : null;
+  return found ? { cwd, title: customTitle || title, parentSessionId, createdAt } : null;
 }
 
 // /rename appends a custom-title envelope, often beyond the bounded prefix.

package/src/session-supervision/codex-app-server.js

@@ -222,6 +222,7 @@ export function codexThreadMetadata(thread) {
     title: typeof thread.name === 'string' && thread.name.trim() ? thread.name.slice(0, 200) : '',
     source: typeof thread.source === 'string' ? thread.source : thread.source?.type || 'unknown',
     lastActivityAt: Number.isFinite(thread.updatedAt) ? thread.updatedAt * 1000 : null,
+    createdAt: Number.isFinite(thread.createdAt) && thread.createdAt > 0 ? thread.createdAt * 1000 : null,
     model: typeof thread.model === 'string' ? thread.model : null,
     // Preserve native wait flags for presentation without changing isRunning,
     // which also protects the provider writer lock. Unknown flags fail closed.

package/src/session-supervision/discovery-window.js

@@ -4,7 +4,7 @@ export const RECENT_SESSION_LIMIT = 200;
 
 // Explicit tracking and unsettled work remain visible outside recent history.
 // Completed, untracked records are history, not an unlimited extra catalog.
-export const retainedSession = record => Boolean(record?.autoContinue || record?.monitor || record?.tracked ||
+export const retainedSession = record => Boolean(record?.listPinned || record?.autoContinue || record?.monitor || record?.tracked ||
   record?.run && !TERMINAL.has(record.run.state));
 
 export function recentSessionWindow(items, { limit = RECENT_SESSION_LIMIT, priority = () => false } = {}) {

package/src/session-supervision/index.js

@@ -231,8 +231,8 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
     // A hook observation can belong to an AI-created worker. Only explicit
     // supervision may restore a conversation absent from provider discovery.
     if (!byKey.has(key) && (retainedSession(record) || includeArchived && record.listHidden === true || requiredAncestors.has(key) && (record.observedAt || record.admission?.validatedAt))) byKey.set(key, {
-      provider: record.provider, session: record.session, cwd: record.cwd, title: '', archived, source: record.admission?.source || 'hook',
-      lastActivityAt: record.observedAt || record.admission?.validatedAt || record.run?.updatedAt || null,
+      provider: record.provider, session: record.session, cwd: record.cwd, title: record.listMetadata?.title || '', createdAt: record.listMetadata?.createdAt ?? null, archived, source: record.admission?.source || 'hook',
+      lastActivityAt: record.listMetadata?.lastActivityAt ?? record.observedAt ?? record.admission?.validatedAt ?? record.run?.updatedAt ?? null,
       observation: { source: record.admission?.source || `${record.provider}_hook`, observedAt: record.observedAt || record.admission?.validatedAt || null },
       availability: 'unknown', model: record.admission?.model || null,
     });
@@ -327,7 +327,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
       autoContinueEpoch: record?.autoContinue === true ? record.autoContinueEpoch : null,
       autoContinueAvailability: availability,
       ...autoContinueState(record, isRunning, availability),
-      lastActivityAt: item.lastActivityAt, observation, availability: item.availability,
+      lastActivityAt: item.lastActivityAt, createdAt: item.createdAt ?? null, observation, availability: item.availability,
       taskId: run?.managed?.taskId || record?.associationTaskId || null,
       binding: { mode, taskId: run?.managed?.taskId || record?.associationTaskId || null },
       originalSessionTarget: originalSessionTarget(item.provider, item.session),

package/src/session-supervision/remote-hosts.js

@@ -13,7 +13,7 @@ export const remoteHostId = alias => `remote-ssh-discovered:${alias}`;
 const shellQuote = value => "'" + value.replaceAll("'", "'\\''") + "'";
 const bootstrap = 'import { realpathSync } from "node:fs"; import { dirname, join } from "node:path"; import { pathToFileURL } from "node:url"; const entry = join(dirname(realpathSync(process.argv[1])), "session-supervision", "remote-entry.js"); await import(pathToFileURL(entry).href);';
 export const REMOTE_HOST_COMMAND = `exec sh -lc ${shellQuote(`exec env SIMY_REMOTE_CHILD=1 SIMY_AUTO_UPDATE=0 node --input-type=module -e ${shellQuote(bootstrap)} "$(command -v simy)"`)}`;
-const allowedActions = new Set(['refresh', 'session_statistics', 'session_archive', 'session_restore', 'session_track', 'session_untrack',
+const allowedActions = new Set(['refresh', 'session_set_pinned', 'session_statistics', 'session_archive', 'session_restore', 'session_track', 'session_untrack',
   'session_monitor', 'session_unmonitor', 'session_enroll', 'session_set_auto_continue', 'session_analyze', 'session_continue', 'session_answer',
   'session_deadline_decide', 'session_action_refresh', 'session_action_select', 'session_action_unlink',
   'delivery_pause', 'delivery_stop', 'delivery_reject', 'delivery_resume', 'delivery_replan', 'delivery_approve',

package/src/team-threads.js

@@ -113,6 +113,7 @@ export function createTeamThreads({
     selected = null,
     memberFilter = null,
     pending = new Map(),
+    publicationGrants = new Map(),
     storageFailed = false,
     lastAllowed = false;
   function scope() {
@@ -122,11 +123,12 @@ export function createTeamThreads({
       generation++;
       const sameIdentity = scopeKey === current.key;
       scopeKey = current.key;
-      const own = sameIdentity ? value.own : [];
+      const own = sameIdentity && current.authenticated ? value.own : [];
       value = { ...empty(), own };
       selected = null;
       memberFilter = null;
       if (!sameIdentity) pending = new Map();
+      publicationGrants.clear();
       lastPoll = -Infinity;
     }
     lastAllowed = current.allowed;
@@ -135,7 +137,7 @@ export function createTeamThreads({
   }
   const snapshot = () => {
     scope();
-    return structuredClone({ ...value, pendingStops: [...pending.keys()] });
+    return structuredClone({ ...value, pendingStops: [...pending.keys()], confirmationRequired: value.own.filter(row => row.enabled && publicationGrants.get(row.threadKey) !== row.version).map(row => row.threadKey) });
   };
   const fenceKey = (current, key) => digest(`${current.fenceKey}:${key}`);
   async function run(fn, allowOff = false) {
@@ -272,6 +274,11 @@ export function createTeamThreads({
       incomplete: result.incomplete,
     };
   }
+  function sourceObservedAt(candidate) {
+    const observed = candidate.observation?.observedAt;
+    if (!Number.isFinite(observed) || observed <= 0 || observed > now()) invalid();
+    return new Date(observed).toISOString();
+  }
   async function payload(candidate, signal) {
     const result = await readContext(candidate, { signal });
     if (!Array.isArray(result?.messages) || !result.messages.length) invalid();
@@ -295,7 +302,7 @@ export function createTeamThreads({
         240,
       ),
       state: running ? "running" : "unknown",
-      observedAt: new Date(now()).toISOString(),
+      observedAt: sourceObservedAt(candidate),
       messages,
       truncated: result.truncated === true,
       incomplete: result.incomplete === true,
@@ -322,13 +329,18 @@ export function createTeamThreads({
         const fence = await fenceStore.read(fenceKey(current, item.threadKey));
         if (!valid()) return;
         if (fence) {
-          pending.set(item.threadKey, fence.expectedVersion);
-          await stop(send, current, item.threadKey, fence.expectedVersion);
+          // A lost OFF response (or intervening version) must reconcile against
+          // authenticated current state, rather than retry a stale CAS forever.
+          pending.set(item.threadKey, item.version);
+          if (item.enabled) await stop(send, current, item.threadKey, item.version);
+          else await clearStop(current, item.threadKey);
         }
       }
       if (publish && !storageFailed)
         for (const item of [...value.own]) {
-          if (!item.enabled || pending.has(item.threadKey)) continue;
+          // Server consent alone cannot re-arm publication after a process restart:
+          // an OFF may have failed both durable storage and the network.
+          if (!item.enabled || pending.has(item.threadKey) || publicationGrants.get(item.threadKey) !== item.version) continue;
           const candidate = candidates.find(
             (c) => teamThreadKey(current, c) === item.threadKey,
           );
@@ -384,9 +396,23 @@ export function createTeamThreads({
         if (valid()) onChange();
       });
     },
-    async setSharing(candidate, enabled) {
+    async stopSharing(threadKey) {
+      scope();
+      if (!keyPattern.test(threadKey) || !value.own.some(row => row.threadKey === threadKey)) return false;
+      return setSharing(null, false, threadKey);
+    },
+    setSharing,
+    close() {
+      closed = true;
+      controller?.abort();
+      generation++;
+      publicationGrants.clear();
+      value = empty();
+    },
+  };
+  async function setSharing(candidate, enabled, existingKey) {
       const current = scope(),
-        key = teamThreadKey(current, candidate),
+        key = existingKey ?? teamThreadKey(current, candidate),
         item = value.own.find((row) => row.threadKey === key),
         version = item?.version ?? 0;
       if (
@@ -408,6 +434,7 @@ export function createTeamThreads({
         storageFailed = false;
       }
       if (!enabled) {
+        publicationGrants.delete(key);
         pending.set(key, version);
         controller?.abort();
         generation++;
@@ -442,16 +469,10 @@ export function createTeamThreads({
             receipt.version !== version + 1
           )
             invalid();
+          if (valid() && !pending.has(key)) publicationGrants.set(key, receipt.version);
         }
         if (current.allowed) await context(send);
         if (valid()) onChange();
       }, !enabled);
-    },
-    close() {
-      closed = true;
-      controller?.abort();
-      generation++;
-      value = empty();
-    },
-  };
+  }
 }