@entrorove/skill 0.1.73 → 0.1.78

package/service-prerequisite.mjs

@@ -0,0 +1,87 @@
+import { canonical } from './local-integrity.mjs';
+import { consumeRecovery } from './local-recovery-budget.mjs';
+
+const fields = ['schemaVersion', 'error', 'code', 'version', 'requiredSetDigest', 'confirmationUrl',
+  'grantsExecutionAuthority', 'recoverable', 'preAdmission', 'knownBeforeEffects'];
+const bound = 4096;
+export function servicePrerequisite(response, value) {
+  if (response?.status !== 403 || !value || typeof value !== 'object' || Array.isArray(value)
+    || Object.keys(value).sort().join('\0') !== [...fields].sort().join('\0')
+    || value.schemaVersion !== 'entrorove.account-agreement-required/1.0'
+    || value.error !== 'account-agreement-required' || value.code !== 'ENTROROVE_ACCOUNT_AGREEMENT_REQUIRED'
+    || !/^\d{4}-\d{2}-\d{2}\.[1-9][0-9]{0,5}$/.test(value.version ?? '')
+    || !/^[a-f0-9]{64}$/.test(value.requiredSetDigest ?? '') || value.confirmationUrl !== '/?legal=confirm'
+    || value.grantsExecutionAuthority !== false || value.recoverable !== true
+    || typeof value.preAdmission !== 'boolean' || value.preAdmission !== value.knownBeforeEffects
+    || Buffer.byteLength(JSON.stringify(value)) > bound) return null;
+  return Object.fromEntries(fields.map(field => [field, value[field]]));
+}
+export function prerequisiteError(response, value, binding = {}) {
+  const prerequisite = servicePrerequisite(response, value);
+  if (!prerequisite) return null;
+  return Object.assign(new Error('The account must explicitly confirm the current service agreement on Entrorove before retrying the original request'),
+    { code: prerequisite.code, servicePrerequisite: prerequisite, ...binding,
+      knownBeforeEffects: binding.outcomeUnknown === true ? false : prerequisite.knownBeforeEffects,
+      grantsExecutionAuthority: false, recoverable: true });
+}
+export function prerequisiteFields(error) {
+  const value = servicePrerequisite({ status: 403 }, error?.servicePrerequisite);
+  return value ? { servicePrerequisite: value, grantsExecutionAuthority: false, recoverable: true,
+    interaction: { kind: 'confirm-account-agreement', confirmationUrl: value.confirmationUrl,
+      version: value.version, requiredSetDigest: value.requiredSetDigest },
+    ...(error.knownBeforeTransmission ? { knownBeforeTransmission: true } : {}),
+    ...(error.knownBeforeEffects ? { knownBeforeEffects: true } : {}) } : {};
+}
+export function discoveryPrerequisite(error, requestId) {
+  if (!servicePrerequisite({ status: 403 }, error?.servicePrerequisite)) return error;
+  Object.assign(error, { sourceRequestId: error.requestId, requestId, knownBeforeTransmission: true });
+  delete error.outcomeUnknown; return error;
+}
+export async function retainPrerequisite(error, state, location, save, field = 'pending') {
+  const pending = state[field], value = servicePrerequisite({ status: 403 }, error?.servicePrerequisite);
+  const identity = pending?.requestId ?? pending?.uploadId;
+  if (!pending || !value || !(error.knownBeforeTransmission || error.knownBeforeEffects)
+    || (error.requestId ?? error.uploadId) !== identity) return false;
+  const { servicePrerequisite: _previous, ...original } = pending;
+  const receipt = { originalId: identity, original: structuredClone(original), response: value, httpStatus: 403,
+    ...(error.sourceRequestId ? { sourceRequestId: error.sourceRequestId } : {}),
+    ...(error.knownBeforeTransmission ? { originalNotSent: true } : {}) };
+  pending.servicePrerequisite = receipt;
+  state.servicePrerequisiteHistory = [...(state.servicePrerequisiteHistory ?? []), receipt];
+  await save(location, state); return true;
+}
+export async function retryKnownPrerequisite(state, location, save, field = 'pending') {
+  const pending = state[field], receipt = pending?.servicePrerequisite;
+  if (!receipt) return false;
+  const value = servicePrerequisite({ status: receipt.httpStatus }, receipt.response);
+  const { servicePrerequisite: _receipt, ...original } = pending;
+  if (!value || receipt.originalId !== (pending.requestId ?? pending.uploadId)
+    || canonical(receipt.original) !== canonical(original)
+    || !(receipt.originalNotSent === true || value.preAdmission === true && value.knownBeforeEffects === true)) {
+    throw new Error('Original service prerequisite receipt is invalid; preserve its journal without retransmission');
+  }
+  // Persist a new unresolved attempt before sending. If that attempt loses its
+  // response, later calls must use GET even though an earlier attempt was denied.
+  consumeRecovery(state, 'prerequisite');
+  delete pending.servicePrerequisite; await save(location, state); return true;
+}
+export async function fetchPrerequisiteError(response, binding = {}) {
+  if (response.status !== 403 || !response.headers.get('content-type')?.startsWith('application/json')) return null;
+  const reader = response.body?.getReader(); if (!reader) return null;
+  const chunks = []; let size = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read(); if (done) break;
+      size += value.byteLength; if (size > bound) return null; chunks.push(Buffer.from(value));
+    }
+    return prerequisiteError(response, JSON.parse(Buffer.concat(chunks).toString('utf8')), binding);
+  } catch { return null; } finally { await reader.cancel().catch(() => {}); }
+}
+export function streamPrerequisiteError(value, binding = {}) {
+  if (!['ENTROROVE_ACCOUNT_AGREEMENT_REQUIRED', 'account-agreement-required'].includes(value?.code)
+    || value.recoverable !== true || value.grantsExecutionAuthority !== false) return null;
+  const prerequisite = servicePrerequisite({ status: 403 }, value.prerequisite);
+  if (!prerequisite || prerequisite.preAdmission || prerequisite.knownBeforeEffects) return null;
+  // This is a running stream notification, not a proof about prior effects.
+  return prerequisiteError({ status: 403 }, prerequisite, { ...binding, outcomeUnknown: true });
+}

package/task-entry-client.mjs

@@ -1,6 +1,7 @@
 import { requestTransport, parseTransportResponse, trustedOrigin } from './remote-transport.mjs';
 import { runCloudTask } from './cloud-task-client.mjs';
 import { displayIdeEvent, ideClientHeaders, ideTaskIdentity } from './ide-presentation.mjs';
+import { prerequisiteError } from './service-prerequisite.mjs';
 
 /** New IDE tasks use the authenticated account preference; resumes keep their original route. */
 export async function routeTaskEntry(data, token, dependencies) {
@@ -20,6 +21,8 @@ export async function routeTaskEntry(data, token, dependencies) {
     headers: { authorization: `Bearer ${token}`,...ideClientHeaders() },timeoutMs: 15000,
   });
   const preference = parseTransportResponse(response, 'cloud-sandbox preference');
+  const prerequisite = prerequisiteError(response, preference, { knownBeforeTransmission: true });
+  if (prerequisite) throw prerequisite;
   if (!response.ok || typeof preference?.enabled !== 'boolean') {
     throw new Error(`Cloud sandbox preference unavailable: HTTP ${response.status}. Task entry stopped.`);
   }

package/workflow-observation-client.mjs

@@ -1,3 +1,4 @@
+import { prerequisiteFields } from './service-prerequisite.mjs';
 import { bootstrapCloudMutationAuthority } from './cloud-mutation-authority.mjs';
 import { observationInput } from './workflow-observation-wire.mjs';
 
@@ -31,6 +32,7 @@ function blocked(error, input) {
     && Number.isSafeInteger(cause.rejection.generation) && cause.rejection.generation > 0
     && ['member-observation-admit', 'member-observation-report'].includes(cause.rejection.operation);
   return { schemaVersion: 'entrorove.local-observation-connection/1.0', status: 'blocked',
+    ...prerequisiteFields(cause),
     ...(safeId(input?.flowId) ? { flowId: input.flowId } : {}), independentValidation: 'pending', code,
     message: messages[code] ?? 'Local observation could not continue; its original command and result remain preserved',
     ...(recoverable ? { prerequisite: { status: 'blocked', code, recoverable: true, ...(reason ? { reason } : {}),

package/workflow-observation-remote.mjs

@@ -6,6 +6,7 @@ import { acknowledgeAutomaticFeedback, queryAutomaticFeedback, verifyAutomaticFe
 import { saveObservationState } from './workflow-observation-state.mjs';
 import { observationFail } from './workflow-observation-wire.mjs';
 import { readInvocations } from './local-invocations.mjs';
+import { prerequisiteError, retainPrerequisite, retryKnownPrerequisite } from './service-prerequisite.mjs';
 
 const unknown = requestId => Object.assign(new Error('Original local observation request outcome is unknown; recover its GET without repeating execution'),
   { code: 'ENTROROVE_LOCAL_OBSERVATION_UNKNOWN', outcomeUnknown: true, requestId });
@@ -25,12 +26,15 @@ async function recover(pending, dependencies) {
     response = await requestTransport(origin, `/api/skill/status/${pending.requestId}`, { headers: {
       authorization: `Bearer ${token}`, ...ideClientHeaders() } });
     result = parseTransportResponse(response, 'original local observation status');
+    const prerequisite = prerequisiteError(response, result, { requestId: pending.requestId });
+    if (prerequisite) throw Object.assign(unknown(pending.requestId), { servicePrerequisite: prerequisite.servicePrerequisite });
     if (result?.output?.requestId !== pending.requestId || !response.ok && response.status >= 500
       || ['pending', 'running'].includes(result.output.status)) throw unknown(pending.requestId);
     result.feedback ??= await queryAutomaticFeedback(pending.requestId, dependencies);
     verifyAutomaticFeedback(result.feedback, pending.requestId, pending.requestId);
     result.feedback = await acknowledgeAutomaticFeedback(result.feedback, origin, token, ideClientHeaders());
-  } catch { throw unknown(pending.requestId); }
+  } catch (error) { throw Object.assign(unknown(pending.requestId),
+    error?.servicePrerequisite ? { servicePrerequisite: error.servicePrerequisite } : {}); }
   return { response, result };
 }
 function prerequisite(output) {
@@ -66,21 +70,25 @@ function terminalRejection(result, pending) {
 export async function observationRemote(stage, operation, input, state, location, dependencies) {
   const requestId = buildInvocation(operation, input).requestId;
   let response, result;
-  if (state.pending) {
+  const existing = Boolean(state.pending);
+  if (existing) {
     if (state.pending.stage !== stage || state.pending.operation !== operation || state.pending.requestId !== requestId
       || canonical(state.pending.input) !== canonical(input)) observationFail('Original observation request must finish before another operation');
+  }
+  if (existing && !await retryKnownPrerequisite(state, location, saveObservationState)) {
     ({ response, result } = await recover(state.pending, dependencies));
   } else {
-    state.pending = { stage, operation, input, requestId };
+    if (!existing) state.pending = { stage, operation, input, requestId };
     try { await saveObservationState(location, state); } catch { throw notSent(requestId); }
     try { ({ response, result } = await invokeRemoteResult({ operation, input }, dependencies)); }
-    catch {
+    catch (error) {
+      if (await retainPrerequisite(error, state, location, saveObservationState)) throw error;
       if (await knownNotSent(state.pending, dependencies.home)) {
         delete state.pending;
         try { await saveObservationState(location, state); } catch { throw notSent(requestId); }
         throw notSent(requestId);
       }
-      throw unknown(requestId);
+      throw Object.assign(unknown(requestId), error?.servicePrerequisite ? { servicePrerequisite: error.servicePrerequisite } : {});
     }
   }
   const statuses = ['reported', 'succeeded', ...(operation === 'member-observation-report' ? ['local-accepted'] : [])];