@awak-app/simy-cli 0.7.15 → 0.7.17

package/src/agent.js

@@ -1,3 +1,7 @@
+import { readLocalPhotoSource } from "./local-photos.js";
+import { resolveLocalTaskDestination, saveLocalTaskDestination } from "./local-task-destination.js";
+import { observePairedNativeIdentities } from './native-provider-identity.js';
+import { providerDelegationFromRequest } from './provider-delegation.js';
 import { createLedgerExecutionWorker, discoverLedgerWorkers } from './update-detachment/worker-ledger.js';
 import { normalizeProviderModelSelection } from "./provider-model-selection.js";
 import { assertConnectionScope, connectionScope, connectionDiagnostic } from "./connection-diagnostics.js";
@@ -147,6 +151,7 @@ import {
 import {
   createDurableLocalTaskApi,
   createDurableLocalTaskWorker,
+  prepareRepositoryWorkspace,
 } from "./durable-local-task-worker.js";
 import { createLocalTaskAttachmentStore } from "./local-task-attachment-store.js";
 import {
@@ -297,12 +302,20 @@ export async function startAgent({
     if (!link?.connected || expected && link.epoch !== expected.epoch) throw Object.assign(new Error("Reconnect this provider to SIMY before using it."), { code: "provider_link_disconnected" });
     return link;
   };
+  let nativeIdentityCapability = null, nativeIdentityActor = null, nativeIdentityObservedAt = 0, nativeIdentityReadInFlight = null;
+  const nativeActor = () => JSON.stringify([apiOrigin, session?.account_id, session?.organization_id, session?.device_id]);
   let providerStatuses = { codex: { state: "unknown" }, claude: { state: "unknown" } };
   const providerRecoveryRevisions = { codex: 0, claude: 0 };
   const refreshAvailableCapabilities = () => {
     const features = contractSourceCapabilities.features;
     availableCapabilities = withCliContract({
       ...contractSourceCapabilities,
+      ...(features?.native_delegation === true || dependencies.observePairedNativeIdentities ? {
+        native_delegation: nativeIdentityActor === nativeActor() && isSessionValid(session, Date.now(), apiOrigin)
+          ? { ...nativeIdentityCapability, identities: (nativeIdentityCapability?.identities || []).filter(identity =>
+            providerLinks[identity.provider]?.connected && (providerLinks[identity.provider]?.epoch ?? null) === identity.connection_epoch) }
+          : { schema_version: 'native_delegation_capability.v1', device_id: session?.device_id || null, identities: [] },
+      } : {}),
       ...(purposeSigner ? { purpose_verification: purposeSigner } : {}),
       ...(features ? { features: { ...features, purpose_host_verification: Boolean(purposeSigner) && isSessionValid(session, Date.now(), apiOrigin), ...(Object.hasOwn(features, "sqm_local_review")
         ? { sqm_local_review: features.sqm_local_review === true && sqmEnabled && !pendingOrganization && desktopWorkAllowed() } : {}) } } : {}),
@@ -489,6 +502,24 @@ export async function startAgent({
           notifyDesktopStatusChange();
         }
       })]);
+      if ((contractSourceCapabilities.features?.native_delegation === true || dependencies.observePairedNativeIdentities) && session?.device_id && !nativeIdentityReadInFlight && (force || nativeIdentityActor !== nativeActor() || Date.now() - nativeIdentityObservedAt > 60000)) {
+        const actor = nativeActor();
+        const observation = (async () => {
+          const observed = await (dependencies.observePairedNativeIdentities || observePairedNativeIdentities)({
+            deviceId: session.device_id, providerStatuses, providerLinks });
+          if (!shuttingDown && actor === nativeActor()) {
+            nativeIdentityCapability = observed; nativeIdentityActor = actor; nativeIdentityObservedAt = Date.now();
+            refreshAvailableCapabilities();
+            notifyDesktopStatusChange();
+            // Official account observation must not delay the existing desktop
+            // startup/status path. Publish its catalog when it is actually ready.
+            if (deferStartupSynchronization) void heartbeat().catch(error => reportHeartbeatError(error, quiet));
+          }
+        })();
+        nativeIdentityReadInFlight = observation;
+        void observation.finally(() => { if (nativeIdentityReadInFlight === observation) nativeIdentityReadInFlight = null; }).catch(() => {});
+        if (!deferStartupSynchronization) await observation;
+      }
       const binaryStateChanged = ["codex", "claude"].some((provider) =>
         previous[provider]?.version !== providerStatuses[provider]?.version ||
         previous[provider]?.state !== providerStatuses[provider]?.state);
@@ -544,7 +575,21 @@ export async function startAgent({
       await callback?.(...args);
       await guard();
     };
-    return { ...options, sessionRoot, beforeProviderInvocation: wrap(options.beforeProviderInvocation), beforeSpawn: wrap(options.beforeSpawn) };
+    return { ...options, sessionRoot, delegationOptions: { supervisionRoot: join(sessionRoot, "delivery-hooks"), pairedDeviceId: session?.device_id, providerLinkEpoch: link?.epoch ?? null, ...options.delegationOptions,
+        onWorkspaceAuthorized: async roots => {
+          await guard();
+          if (task.local_destination?.authorized_root) {
+            await resolveLocalTaskDestination({ local_destination: task.local_destination, operation: task.operation,
+              permission_mode: task.permission_mode, workspace_mode: task.workspace_mode, repository: task.repository }, {
+              deviceId: session?.device_id, resolveRepository: ensureRepositoryIndexed, nativeWritableRoots: roots,
+            });
+          }
+          task.native_writable_roots = [...roots];
+          await options.delegationOptions?.onWorkspaceAuthorized?.(roots);
+          await guard();
+        } },
+      beforeCompletion: options.beforeCompletion ? wrap(options.beforeCompletion) : null,
+      beforeProviderInvocation: wrap(options.beforeProviderInvocation), beforeSpawn: wrap(options.beforeSpawn) };
   };
   const codingRuntimeOptions = run => {
     const wrap = (custom, marker) => async context => {
@@ -856,7 +901,7 @@ export async function startAgent({
     notifyDesktopStatusChange();
     let deviceHeartbeatSucceeded = false;
     const requestedSession = session;
-    const advertisedProviders = JSON.stringify(providerStatuses);
+    const advertisedProviders = JSON.stringify([providerStatuses, nativeIdentityCapability]);
     heartbeatInFlight = Promise.resolve()
       .then(async () => { if (enforceDesktopAccess) await desktopAccess.refresh(true); })
       .then(() =>
@@ -878,7 +923,7 @@ export async function startAgent({
         // browser authorization. Publish verified readiness after their probe.
         const publishVerifiedProviders = async () => {
           await readProviderStatuses();
-          if (!shuttingDown && JSON.stringify(providerStatuses) !== advertisedProviders) {
+          if (!shuttingDown && JSON.stringify([providerStatuses, nativeIdentityCapability]) !== advertisedProviders) {
             await heartbeatDevice({ apiOrigin, apiBaseUrl: session.api_base_url, token: session.token,
               port, capabilities: refreshAvailableCapabilities(), repoInventory: repositoryInventory });
           }
@@ -1011,6 +1056,8 @@ export async function startAgent({
       createDurableLocalTaskWorker;
     durableLocalTaskWorker = createWorker({
       api: durableApi,
+      enableBoundedSubtasks:
+        availableCapabilities.features.bounded_local_task_subtasks === true,
       registry: localTaskRegistry,
       storageRoot: taskStorageRoot,
       workspaceRoot: dependencies.localTaskWorkspaceRoot,
@@ -1029,6 +1076,7 @@ export async function startAgent({
         return (dependencies.runLocalTask || startLocalTask)(task, providerRuntimeOptions(task, options, scope, link));
       },
       attachmentStore: localTaskAttachmentStore,
+      readPhotoSource: dependencies.readLocalPhotoSource || readLocalPhotoSource,
       getDeviceId: () => session?.device_id || null,
       beginWork: () => acquireUpdateWork(updateManager),
       onError: (error) => reportDurableLocalTaskError(error, quiet),
@@ -1777,12 +1825,17 @@ export async function startAgent({
           });
           return;
         }
-        let requestFingerprint;
+        let requestFingerprint, providerDelegation;
         try {
+          providerDelegation = providerDelegationFromRequest(body, idempotencyKey);
           requestFingerprint = createLocalTaskRequestFingerprint({
             instruction,
             backend: body.backend,
             model: body.model,
+            delegation: providerDelegation,
+            localDestination: body.local_destination,
+            localPhotoSource: body.local_photo_source,
+            nativeIdentity: body.native_identity,
             operation: guardrail.operation,
             permissionMode: guardrail.permission_mode,
             workspaceMode,
@@ -1882,7 +1935,7 @@ export async function startAgent({
             workspace = {
               ...prepared,
               id,
-              workspace_path: indexedRepository.local_path,
+              ...(await prepareRepositoryWorkspace({ repositoryPath: indexedRepository.local_path, expectedRepository: repository, localTaskId: id, prepareOutputs: body.permission_mode === "workspace_write" })),
             };
           } else {
             const id = createLocalTaskId();
@@ -1895,6 +1948,19 @@ export async function startAgent({
               })),
             };
           }
+          if (body.local_destination?.authorized_root && providerDelegation?.provider !== "codex") {
+            throw Object.assign(new Error("The selected folder requires an already authorized native Codex workspace."), { code: "local_task_destination_unconfirmed" });
+          }
+          let deliveryTask = null;
+          const destinationSpec = { ...body, workspace_mode: workspaceMode, repository };
+          const resolveDestination = () => resolveLocalTaskDestination(destinationSpec, {
+            deviceId: session?.device_id,
+            resolveRepository: ensureRepositoryIndexed,
+            nativeWritableRoots: deliveryTask?.native_writable_roots,
+          });
+          let destination = body.local_destination && !body.local_destination.authorized_root ? await resolveDestination() : null;
+          const photoContext = body.local_photo_source ? await (dependencies.readLocalPhotoSource || readLocalPhotoSource)(body.local_photo_source, { deviceId: session?.device_id }) : null;
+          await authorizeDesktopWork(requestAccessScope);
           const stagedAttachments = await stagePreparedRunAttachments({
             runId: workspace.id,
             prepared: preparedAttachments,
@@ -1905,6 +1971,10 @@ export async function startAgent({
             instruction,
             backend: body.backend,
             model: body.model,
+            delegation: providerDelegation,
+            localDestination: body.local_destination,
+            localPhotoSource: body.local_photo_source,
+            nativeIdentity: body.native_identity,
             operation: guardrail.operation,
             permissionMode: guardrail.permission_mode,
             workspaceMode,
@@ -1915,6 +1985,7 @@ export async function startAgent({
             outputsRoot: workspace.outputs_root,
             outputsRootExpected: workspace.outputs_root_expected,
             attachments: stagedAttachments,
+            localPhotoContext: photoContext,
             expectedOutputs: body.expected_outputs,
             scenarioPack,
             providerTokenBudget: body.provider_token_budget,
@@ -1927,6 +1998,7 @@ export async function startAgent({
             workflowStartIntent,
             purposeVerification,
           });
+          deliveryTask = task;
           if (purposeVerification) await preparePurposeVerification(task, { session, apiOrigin, clientRequestId: idempotencyKey, keyPath: purposeKeyPath,
             authorize: async () => {
               await authorizeDesktopWork(requestAccessScope);
@@ -1937,7 +2009,27 @@ export async function startAgent({
           requestClaim.complete(task);
           requestClaimCompleted = true;
           const runLocalTask = dependencies.runLocalTask || startLocalTask;
-          const runtimeOptions = providerRuntimeOptions(task, { session, apiOrigin, beforeSpawn: async localTask => {
+          const runtimeOptions = providerRuntimeOptions(task, { session, apiOrigin,
+            beforeCompletion: body.local_destination ? async completed => {
+              await authorizeDesktopWork(requestAccessScope);
+              const current = await resolveDestination();
+              if (destination && (current.root !== destination.root || current.directory !== destination.directory)) {
+                throw Object.assign(new Error("The authorized save folder changed."), { code: "local_task_destination_unconfirmed" });
+              }
+              destination ||= current;
+              completed.local_destination_receipts = [];
+              await saveLocalTaskDestination({ task: completed, destination: current,
+                assertActive: async () => {
+                  await authorizeDesktopWork(requestAccessScope);
+                  if (completed.stop_requested) throw Object.assign(new Error("Local delivery was stopped."), { code: "local_task_destination_unconfirmed" });
+                },
+                onReceipt: async receipt => {
+                  completed.local_destination_receipts.push(receipt);
+                  await persistLocalTask(completed);
+                },
+              });
+            } : null,
+            beforeSpawn: async localTask => {
               if (purposeWorkspaceBusy(localTask.workspace_path)) throw Object.assign(new Error("Independent verification owns this workspace."), { code: "purpose_verification_workspace_busy" });
               if (purposeVerification) {
                 await authorizeDesktopWork(requestAccessScope);
@@ -1999,6 +2091,10 @@ export async function startAgent({
           return;
         }
         const body = await readJson(req);
+        if (body.delegation || body.delegation_target) {
+          json(res, 409, { error: 'Provider delegation requires the existing Local Task admission.', code: 'delegation_local_task_required' });
+          return;
+        }
         const instruction = String(body.instruction || "").trim();
         if (!instruction) {
           json(res, 400, { error: "instruction is required" });
@@ -2256,6 +2352,7 @@ export async function startAgent({
               ? body.expected_evidence
               : [],
             required_checks: Array.isArray(body.required_checks) ? body.required_checks : [],
+            independent_review_required: body.independent_review_required === true,
             require_human_approval: body.require_human_approval !== false,
             design_summary:
               typeof body.design_summary === "string" ? body.design_summary : "",
@@ -2704,7 +2801,7 @@ export async function startAgent({
       if (codingRunMonitorTimer) clearInterval(codingRunMonitorTimer);
       updateManager?.stop?.();
       await Promise.all([stopDesktopTasks(), codexWorkPatternSync?.close?.(),
-        codexWorkPatternSyncInFlight, codingRunMonitorInFlight]);
+        codexWorkPatternSyncInFlight, codingRunMonitorInFlight, nativeIdentityReadInFlight?.catch(() => {})]);
       try {
         await (dependencies.removeConnectionDiscovery || removeConnectionDiscovery)(
           connectionDiscovery,
@@ -2829,6 +2926,29 @@ export async function startAgent({
       sqmLocalReviewWorker?.retry?.(); notifyDesktopStatusChange();
     },
     async retrySqmEnvironment() { await authorizeDesktopWork(); sqmLocalReviewWorker?.retry?.(); notifyDesktopStatusChange(); },
+    getTeamThreadsScope() {
+      return { key: desktopScopeRevision(),
+        fenceKey: createHash('sha256').update(JSON.stringify([apiOrigin, session?.account_id ?? null, session?.organization_id ?? null, session?.device_id ?? null])).digest('hex'),
+        organizationId: session?.organization_id ?? null,
+        authenticated: !shuttingDown && !pendingOrganization && isSessionValid(session, Date.now(), apiOrigin) && Boolean(session?.device_id),
+        allowed: !shuttingDown && desktopWorkAllowed() && desktopAccessReady(desktopAccess.snapshot()) };
+    },
+    async requestTeamThreads(body, signal) {
+      const selected = session;
+      const scope = desktopScopeRevision();
+      const off = body?.operation === 'consent' && body.enabled === false;
+      if (!off) await authorizeDesktopWork(scope);
+      if (shuttingDown || pendingOrganization || !isSessionValid(selected, Date.now(), apiOrigin) || selected !== session) throw new Error('Team sign-in required');
+      const response = await (dependencies.fetch || globalThis.fetch)(webApiUrl('team-threads', { webOrigin: apiOrigin, apiBaseUrl: selected.api_base_url }), {
+        method: body ? 'POST' : 'GET', headers: webApiHeaders({ token: selected.token }, body ? { 'Content-Type': 'application/json' } : {}),
+        ...(body ? { body: JSON.stringify(body) } : {}), signal: AbortSignal.any([signal, AbortSignal.timeout(10_000)]), cache: 'no-store', redirect: 'error',
+      });
+      if (scope !== desktopScopeRevision() || selected !== session || signal.aborted) throw new Error('Team sign-in changed');
+      if (!response.ok) throw Object.assign(new Error('Shared conversations unavailable'), { status: response.status });
+      const raw = await response.text();
+      if (raw.length > 1_048_576) throw new Error('Team response too large');
+      return JSON.parse(raw);
+    },
     async createDesktopWebSession() {
       const scope = await authorizeDesktopWork();
       const selected = session;
@@ -3297,6 +3417,7 @@ function capabilitiesFromInspections(codex, claude) {
       },
     },
     features: {
+      team_threads: true,
       repository_scan_approval: true,
       executor_version_preflight: true,
       desktop_executor: true,
@@ -3307,6 +3428,7 @@ function capabilitiesFromInspections(codex, claude) {
       local_task_streaming: true,
       local_task_idempotency: true,
       local_task_model: true,
+      native_delegation: true,
       progress_continuation_policy: true,
       local_task_reconciliation: true,
       local_task_control_plane: true,

package/src/backend-executable.js

@@ -26,7 +26,7 @@ export async function resolveBackendExecutable(backend, options = {}) {
 
 export async function inspectBackendExecutable(
   backend,
-  { spawnImpl = spawn, candidates, timeoutMs = 5_000, signal, discoveryOptions = {}, minimumVersion } = {},
+  { spawnImpl = spawn, candidates, timeoutMs = 5_000, signal, discoveryOptions = {}, minimumVersion, executionEnvironment } = {},
 ) {
   const assertActive = () => { if (signal?.aborted) throw Object.assign(new Error('Backend inspection was cancelled.'), { code: 'cancelled' }); };
   assertActive();
@@ -41,7 +41,7 @@ export async function inspectBackendExecutable(
   // still fall back to automatic discovery, as before.
   if (explicitCodex && candidates.includes(explicitCodex)) {
     const pinned = await inspectBackendExecutable(backend, {
-      candidates: [explicitCodex], spawnImpl, timeoutMs, signal, minimumVersion,
+      candidates: [explicitCodex], spawnImpl, timeoutMs, signal, minimumVersion, executionEnvironment,
       discoveryOptions: { ...discoveryOptions, environment: {} },
     });
     if (pinned.compatible) return pinned;
@@ -51,11 +51,11 @@ export async function inspectBackendExecutable(
   // Comparing all Codex installs must not turn several slow wrappers into a
   // serial startup delay. Keep concurrency bounded and results in source order.
   const probes = backend === "codex"
-    ? await probeCandidates(candidates, { spawnImpl, timeoutMs, signal }, assertActive) : null;
+    ? await probeCandidates(candidates, { spawnImpl, timeoutMs, signal, executionEnvironment }, assertActive) : null;
   let selected = null;
   for (const [index, candidate] of candidates.entries()) {
     assertActive();
-    const probe = probes ? probes[index] : await probeExecutable(candidate, { spawnImpl, timeoutMs, signal });
+    const probe = probes ? probes[index] : await probeExecutable(candidate, { spawnImpl, timeoutMs, signal, executionEnvironment });
     assertActive();
     if (!probe.available) continue;
     const installedVersion = parseBackendVersion(probe.output);
@@ -111,6 +111,7 @@ export function backendCandidates(backend, {
     environment.SIMY_CODEX_BIN,
     "codex",
     ...codexPathCandidates(platform, environment),
+    ...(platform !== "win32" ? [path.posix.join(home, ".local", "bin", "codex")] : []),
     ...(platform === "darwin" ? ["/opt/homebrew/bin/codex", "/usr/local/bin/codex"] : []),
     ...(platform === "darwin" ? ["/Applications", path.posix.join(home, "Applications")].flatMap(directory =>
       ["ChatGPT.app", "Codex.app"].flatMap(app => {
@@ -228,13 +229,13 @@ function numericVersionParts(value) {
   return match.slice(1).map(Number);
 }
 
-function probeExecutable(command, { spawnImpl, timeoutMs, signal }) {
+function probeExecutable(command, { spawnImpl, timeoutMs, signal, executionEnvironment }) {
   return new Promise((resolve) => {
     let settled = false, terminating = false;
     let timeout, force, limit;
     let output = Buffer.alloc(0);
     let child;
-    try { child = spawnImpl(command, ["--version"], { stdio: ["ignore", "pipe", "pipe"] }); }
+    try { child = spawnImpl(command, ["--version"], { stdio: ["ignore", "pipe", "pipe"], ...(executionEnvironment ? { env: { ...process.env, ...executionEnvironment } } : {}) }); }
     catch { resolve({ available: false, output: "" }); return; }
     const capture = chunk => {
       // Version probes need a tiny prefix. Drain noisy executables without

package/src/bounded-local-task-subtask-pool.js

@@ -58,6 +58,7 @@ export function createBoundedLocalTaskSubtaskPool({
   prepareWorkspace = prepareLocalTaskWorkspace,
   leaseSeconds = DEFAULT_LEASE_SECONDS,
   heartbeatIntervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS,
+  now = Date.now,
   setIntervalImpl = setInterval,
   clearIntervalImpl = clearInterval,
   onError = () => {},
@@ -111,10 +112,12 @@ export function createBoundedLocalTaskSubtaskPool({
     let completionConfirmed = false;
     let completionState = null;
     let providerStarted = false;
+    let knownLeaseExpiry = Number.NaN;
     const startedAt = Date.now();
     try {
       normalized = normalizeDurableLocalTaskSubtaskClaim(claim, {
         parentAuthority: parent,
+        nowMs: now(),
         leaseSeconds,
       });
       if (normalized.disposition !== "execute") {
@@ -129,6 +132,12 @@ export function createBoundedLocalTaskSubtaskPool({
       }
       batchId ??= normalized.batch.batch_id;
 
+      knownLeaseExpiry = normalized.attempt.leaseExpiresAtMs;
+      const checkLease = async () => {
+        if (!controller.signal.aborted && !completionConfirmed && now() >= knownLeaseExpiry) await cancel("lease_lost");
+        return !controller.signal.aborted;
+      };
+
       const execution = boundedLocalTaskSubtaskExecution(normalized, parent);
       const runtime = await materializeSubtaskRuntime({
         normalized,
@@ -140,7 +149,7 @@ export function createBoundedLocalTaskSubtaskPool({
         downloadSource: sourceDownloader,
         signal: controller.signal,
       });
-      if (controller.signal.aborted) return;
+      if (!await checkLease()) return;
 
       const fence = durableLocalTaskSubtaskFence(normalized, parent);
       let boundaryConfirmed = false;
@@ -161,7 +170,7 @@ export function createBoundedLocalTaskSubtaskPool({
         }).catch(onError);
         return;
       }
-      if (boundaryConfirmed !== true || controller.signal.aborted) {
+      if (boundaryConfirmed !== true || !await checkLease()) {
         await api.abandon_local_task_subtask_attempt_v2({
           ...fence,
           p_reason_code: controller.signal.aborted
@@ -174,6 +183,8 @@ export function createBoundedLocalTaskSubtaskPool({
 
       const heartbeat = async () => {
         if (controller.signal.aborted || completionConfirmed) return;
+        const renewalStartedAt = now();
+        if (!await checkLease()) return;
         try {
           const response =
             await api.heartbeat_local_task_subtask_attempt_v2({
@@ -190,6 +201,7 @@ export function createBoundedLocalTaskSubtaskPool({
           ) {
             return;
           }
+          if (!await checkLease()) return;
           if (
             response?.ok !== true ||
             response.cancel_requested === true ||
@@ -198,6 +210,8 @@ export function createBoundedLocalTaskSubtaskPool({
                 normalized.parent.cancel_generation)
           ) {
             await cancel("server_cancelled");
+          } else {
+            knownLeaseExpiry = renewalStartedAt + leaseSeconds * 1_000;
           }
         } catch (error) {
           if (completionConfirmed && isKnownSubtaskFenceError(error)) return;
@@ -214,9 +228,11 @@ export function createBoundedLocalTaskSubtaskPool({
         }
       };
       heartbeatTimer = setIntervalImpl(() => {
-        if (heartbeatInFlight) return;
-        heartbeatInFlight = heartbeat().finally(() => {
-          heartbeatInFlight = null;
+        void checkLease().then((valid) => {
+          if (!valid || heartbeatInFlight || completionConfirmed) return;
+          heartbeatInFlight = heartbeat().finally(() => {
+            heartbeatInFlight = null;
+          });
         });
       }, heartbeatIntervalMs);
 
@@ -245,6 +261,13 @@ export function createBoundedLocalTaskSubtaskPool({
           ),
         );
       }
+      // Lease loss after the paid boundary cannot establish a cancelled result.
+      // Preserve a known result, but leave interrupted work for server resolution.
+      if (providerStarted && controller.signal.reason === "lease_lost" &&
+          rawResult?.status === "cancelled") {
+        rawResult = { ...rawResult, status: "unknown",
+          failure_code: "local_task_subtask_provider_result_unknown" };
+      }
       const result = normalizeDurableLocalTaskSubtaskResult(
         normalizeRunResult(rawResult, startedAt),
         { normalizedClaim: normalized },
@@ -305,12 +328,15 @@ export function createBoundedLocalTaskSubtaskPool({
       }
     } finally {
       if (heartbeatTimer) clearIntervalImpl(heartbeatTimer);
-      if (heartbeatInFlight) await heartbeatInFlight;
+      // Pending renewal has its own fenced completion handler; it must not
+      // hold a finished/cancelled slot open after its timer is cleared.
     }
   };
 
   const scheduler = async () => {
     if (!initialized) {
+      // Initialization only acknowledges the canonical plan. Backend keeps
+      // existing attempts/reservations intact; claim reconciles old generations.
       const initializedBatch =
         await api.initialize_local_task_subtask_batch_v2({
           p_turn_id: parent.turnId,

package/src/bounded-local-task-subtasks-contract.js

@@ -1043,7 +1043,7 @@ function uploadedAttachmentRefs(value, name) {
   return refs;
 }
 
-function normalizeParentUploadedRef(item, name) {
+export function normalizeParentUploadedRef(item, name = "uploaded source") {
   record(item, name);
   const allowed = new Set([
     "schema_version",

package/src/cli-contract.js

@@ -13,7 +13,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.7.15";
+export const CLI_VERSION = "0.7.17";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function narrativeImageCapabilityMetadata() {

package/src/codex-plugins/simy/.codex-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "simy",
   "version": "0.1.0",
-  "description": "SIMY quality and PR review. Delivery uses the explicitly requested CLI Agentic Loop.",
+  "description": "SIMY quality and PR review, with automatic checkpoint tracking through enabled provider hooks.",
   "author": {
     "name": "Specialist Doctors Inc.",
     "url": "https://github.com/SpecialistDoctors-Inc"
@@ -17,7 +17,7 @@
   "interface": {
     "displayName": "SIMY",
     "shortDescription": "Quality and PR review.",
-    "longDescription": "Run explicitly requested quality checks and PR reviews. Work directly in Codex by default. When the user explicitly requests SIMY Delivery Loop, use the CLI Agentic Loop; the local hook-based Delivery skill is retired.",
+    "longDescription": "Run explicitly requested quality checks and PR reviews. Enabled hooks automatically track eligible conversations from user prompts through checkpoints. Stops, permission waits and opt-outs are preserved. The local Delivery skill remains retired; independently managed work uses the CLI Agentic Loop.",
     "developerName": "Specialist Doctors Inc.",
     "category": "Developer Tools",
     "capabilities": [

package/src/codex-plugins/simy/hooks/README.md

@@ -18,9 +18,14 @@ scans ports or reads stored session tokens.
 
 ## Delivery Loop hooks
 
-`delivery-loop.mjs` is an independent opt-in workflow, shared by the Codex and
-Claude distributions. SessionStart supplies the exact session identity. It does
-not start a loop. After an explicit `simy delivery start`, Stop checks that
+`delivery-loop.mjs` is shared by the Codex and Claude distributions. The CLI
+prepares missing plugin sources automatically and maintains enabled plugin caches.
+SessionStart supplies identity without starting work. A nonempty UserPromptSubmit
+starts standard Delivery Loop by default for eligible connected conversations,
+including when SessionStart was missed. No per-project enable command is needed.
+`simy delivery auto off --provider codex|claude` saves a project override; updates
+preserve it. Existing loops, explicit stops, session opt-outs and revoked provider
+consent remain authoritative. No hook grants provider trust. Stop checks that
 session's checkpoint and returns bounded next-step instructions. Approval/input
 blocks, interruption, completion, failures and missing progress stop automatic continuation.
 Provider errors/exits are surfaced to SIMY's desktop; a dead provider is not