@alipay/alipay-aipay 1.7.8 → 1.8.0

package/skill-pre/references/normal/scripts/telemetry.mjs

@@ -24,6 +24,8 @@ const syncLogCode = '1005';
 const syncLogMsg = 'alipay_aipay_skill_event';
 const syncLogYuyanID = '180020010001290755';
 const uploadTimeoutMs = 3000;
+const conversationUploadTimeoutMs = 10000;
+const uploadWorkerLifetimeMs = 60000;
 const permissionedForegroundFlushLimit = 5;
 const localWriteMaxAttempts = 2;
 const runStateLockWaitMs = 5000;
@@ -405,11 +407,12 @@ function writePrivateJson(file, value) {
   return false;
 }
 
-function acquireRunStateLock(env = process.env, lockPath = runStateLockPath(env)) {
+function acquireRunStateLock(env = process.env, lockPath = runStateLockPath(env), waitMs = runStateLockWaitMs) {
   const startedAt = Date.now();
+  let recoveredStaleLock = false;
   try {
     ensurePrivateDir(path.dirname(lockPath));
-    while (Date.now() - startedAt < runStateLockWaitMs) {
+    while (true) {
       try {
         const descriptor = fs.openSync(lockPath, 'wx', 0o600);
         fs.closeSync(descriptor);
@@ -418,8 +421,13 @@ function acquireRunStateLock(env = process.env, lockPath = runStateLockPath(env)
         if (error?.code !== 'EEXIST') return '';
         try {
           const lockStat = fs.statSync(lockPath);
-          if (Date.now() - lockStat.mtimeMs >= runStateLockStaleMs) fs.unlinkSync(lockPath);
+          if (!recoveredStaleLock && Date.now() - lockStat.mtimeMs >= runStateLockStaleMs) {
+            fs.unlinkSync(lockPath);
+            recoveredStaleLock = true;
+            continue;
+          }
         } catch {}
+        if (Date.now() - startedAt >= waitMs) return '';
         sleepSync(10);
       }
     }
@@ -427,8 +435,8 @@ function acquireRunStateLock(env = process.env, lockPath = runStateLockPath(env)
   return '';
 }
 
-function withRunStateLock(env = process.env, operation, requestedLockPath = runStateLockPath(env)) {
-  const lockPath = acquireRunStateLock(env, requestedLockPath);
+function withRunStateLock(env = process.env, operation, requestedLockPath = runStateLockPath(env), waitMs = runStateLockWaitMs) {
+  const lockPath = acquireRunStateLock(env, requestedLockPath, waitMs);
   if (!lockPath) return { acquired: false, value: null };
   try {
     return { acquired: true, value: operation() };
@@ -893,7 +901,7 @@ export function setConversationConsent({ sessionId = '', decision, inputId, conv
         }
       }
       return next;
-    }, conversationSessionFile(ownerHash, 'index.lock', env));
+    }, conversationSessionFile(ownerHash, 'index.lock', env), 0);
     return transaction.acquired ? transaction.value : null;
   } catch { return null; }
 }
@@ -920,6 +928,39 @@ function readConversationState(conversationId, env, { checkOwner = true } = {})
   } catch { return null; }
 }
 
+// Called only while holding the conversation's session lock. A private pending
+// marker survives a crash between enqueue and the final sequence/dedup commit.
+function reconcileConversationMessage(state, env) {
+  if (!state || !Object.prototype.hasOwnProperty.call(state, 'pending_message')) return state;
+  const pending = state.pending_message;
+  if (!pending || pending.sequence !== state.sequence + 1
+    || !Number.isSafeInteger(pending.sequence)
+    || !/^[a-f0-9]{32}$/.test(pending.message_hash || '')
+    || state.message_hashes.includes(pending.message_hash)
+    || !Number.isSafeInteger(pending.timestamp) || pending.timestamp <= 0) return null;
+  const basename = outboxFilename({ kind: 'conversation_message',
+    conversation_id: state.conversation_id, sequence: pending.sequence, timestamp: pending.timestamp });
+  let queued;
+  try {
+    const names = fs.readdirSync(outboxDir(env));
+    const name = names.find(name => name === basename || name.startsWith(`${basename}.sending.`));
+    if (name) {
+      queued = readOutboxRecord(path.join(outboxDir(env), name));
+      if (!queued || queued.event.conversation_id !== state.conversation_id
+        || queued.event.sequence !== pending.sequence || queued.event.timestamp !== pending.timestamp) return null;
+    }
+  } catch (error) {
+    // Missing queue means the process stopped before enqueue, or cleanup succeeded.
+    if (error?.code !== 'ENOENT') return null;
+  }
+  const { pending_message: _pending, ...next } = state;
+  if (queued) {
+    next.sequence = pending.sequence;
+    next.message_hashes = [...state.message_hashes, pending.message_hash];
+  }
+  return writePrivateJson(conversationStatePath(state.conversation_id, env), next) ? next : null;
+}
+
 export function startConversation({ sessionId = '' } = {}, env = process.env, nowMs = Date.now()) {
   if (!telemetryEnabled(env) || !conversationCode(env)) return null;
   try {
@@ -944,7 +985,7 @@ export function startConversation({ sessionId = '' } = {}, env = process.env, no
       if (!writePrivateJson(conversationStatePath(conversationId, env), state)
         || !writePrivateJson(indexPath, { conversation_id: conversationId })) return null;
       return { ...state, created: true };
-    }, `${indexPath}.lock`);
+    }, `${indexPath}.lock`, 0);
     return transaction.acquired ? transaction.value : null;
   } catch { return null; }
 }
@@ -966,7 +1007,7 @@ export function endConversation(conversationId, env = process.env) {
       if (!state || state.lifecycle === 'CLOSED') return state;
       const closed = { ...state, lifecycle: 'CLOSED' };
       return writePrivateJson(file, closed) ? closed : null;
-    }, conversationSessionFile(existing.session_hash, 'index.lock', env));
+    }, conversationSessionFile(existing.session_hash, 'index.lock', env), 0);
     return transaction.acquired ? transaction.value : null;
   } catch { return null; }
 }
@@ -992,7 +1033,7 @@ export async function recordConversationMessage(message, context = {}, env = pro
     const existing = readConversationState(conversationId, env);
     if (!existing) return null;
     const transaction = withRunStateLock(env, () => {
-      const state = readConversationState(conversationId, env);
+      const state = reconcileConversationMessage(readConversationState(conversationId, env), env);
       if (!state || state.lifecycle !== 'ACTIVE' || !hasConversationConsent(state, env)) return null;
       const hash = userInputHash(`${message.role}:${messageId}`, conversationId);
       const existingIndex = state.message_hashes.indexOf(hash);
@@ -1003,13 +1044,28 @@ export async function recordConversationMessage(message, context = {}, env = pro
       const event = normalizeConversationEvent({ ...conversationEventBase(state, productType, env, nowMs),
         sequence, role: message.role, content: sanitized.content, truncated: sanitized.truncated,
         has_attachments: message.has_attachments ?? false, redaction_version: 1 });
+      if (!event) return null;
+      // Reserve only recovery metadata, not a committed sequence or message body.
+      if (!writePrivateJson(file, { ...state, pending_message: {
+        sequence, message_hash: hash, timestamp: event.timestamp
+      } })) return null;
+      const queuedFile = writeOutboxRecord(event, env);
+      if (!queuedFile) {
+        writePrivateJson(file, state);
+        return null;
+      }
       const next = { ...state, sequence, message_hashes: [...state.message_hashes, hash] };
-      return event && writePrivateJson(file, next) ? event : null;
-    }, conversationSessionFile(existing.session_hash, 'index.lock', env));
+      if (!writePrivateJson(file, next)) {
+        try { fs.unlinkSync(queuedFile); } catch {}
+        return null;
+      }
+      return event;
+    }, conversationSessionFile(existing.session_hash, 'index.lock', env), 0);
     if (!transaction.acquired || !transaction.value) return null;
-    if (transaction.value.duplicate) return transaction.value;
+    // Recovered duplicate retries may also need to wake their queued upload.
+    // Already queued under the session lock; do not enqueue twice or wait for HTTP.
     // Never echo dialogue content in stderr markers, including in capture-only mode.
-    await deliverPersistedStageEvent(transaction.value, env, null);
+    if (telemetryUploadEnabled(env)) spawnOutboxFlush(env, { recordStageFailure: false });
     return transaction.value;
   } catch { return null; }
 }
@@ -1452,30 +1508,43 @@ export function isSuccessfulHttpStatus(statusCode) {
 }
 
 export function sendSyncLogReportDetailed(report, {
-  timeoutMs = report?.item?.msg === 'alipay_aipay_skill_conversation' ? 0 : uploadTimeoutMs
+  timeoutMs = report?.item?.msg === 'alipay_aipay_skill_conversation' ? conversationUploadTimeoutMs : uploadTimeoutMs,
+  request = https.request
 } = {}) {
   return new Promise((resolve) => {
     let settled = false;
+    let timer;
+    let req;
+    const limit = report?.item?.msg === 'alipay_aipay_skill_conversation' ? conversationUploadTimeoutMs : uploadTimeoutMs;
+    const budget = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.min(timeoutMs, limit) : limit;
     const finish = (result) => {
       if (settled) return;
       settled = true;
+      clearTimeout(timer);
       resolve(result);
     };
+    const timeout = () => {
+      finish({ ok: false, error_code: 'ETIMEDOUT', error_message: 'request timeout' });
+      req?.destroy();
+    };
     try {
       if (!report?.item || !report?.options) {
         finish({ ok: false, error_code: 'INVALID_REPORT', error_message: 'invalid report' });
         return;
       }
       const body = syncLogRequestBody(report);
-      const req = https.request(`${syncLogServerURL}?biztype=${syncLogBizType}`, {
+      // A wall-clock deadline also covers DNS/TLS stalls and trickling responses.
+      timer = setTimeout(timeout, budget);
+      req = request(`${syncLogServerURL}?biztype=${syncLogBizType}`, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/x-www-form-urlencoded',
           'Content-Length': Buffer.byteLength(body)
         },
-        timeout: timeoutMs
+        timeout: budget
       }, (resp) => {
         resp.resume();
+        resp.on('error', error => finish(failedResult(error)));
         resp.on('end', () => {
           const statusCode = Number(resp.statusCode || 0);
           const ok = isSuccessfulHttpStatus(statusCode);
@@ -1489,10 +1558,7 @@ export function sendSyncLogReportDetailed(report, {
           });
         });
       });
-      req.on('timeout', () => {
-        finish({ ok: false, error_code: 'ETIMEDOUT', error_message: 'request timeout' });
-        req.destroy();
-      });
+      req.on('timeout', timeout);
       req.on('error', (error) => finish(failedResult(error)));
       req.end(body);
     } catch (error) {
@@ -1729,6 +1795,7 @@ export async function flushOutbox(env = process.env, {
   targetFile = '',
   timeoutMs = uploadTimeoutMs,
   sender = sendSyncLogReportDetailed,
+  onSent = null,
   prioritizeTerminal = false,
   includeConversations = true
 } = {}) {
@@ -1745,8 +1812,22 @@ export async function flushOutbox(env = process.env, {
     }
   }
   for (const file of files) {
-    const claimedFile = claimOutboxFile(file);
-    if (!claimedFile) continue;
+    const pending = file.endsWith('.conversation') ? readOutboxRecord(file) : null;
+    const owner = pending && readConversationState(pending.event.conversation_id, env, { checkOwner: false });
+    // Claim only after the recorder has committed state or removed its failed
+    // enqueue. Release this local lock before doing any network work.
+    const claim = owner ? withRunStateLock(env, () => {
+      const state = reconcileConversationMessage(
+        readConversationState(owner.conversation_id, env, { checkOwner: false }), env);
+      return state ? claimOutboxFile(file) : '';
+    }, conversationSessionFile(owner.session_hash, 'index.lock', env)) : null;
+    const claimedFile = owner ? (claim.acquired ? claim.value : '') : claimOutboxFile(file);
+    if (!claimedFile) {
+      // A local recovery/claim failure is retained work, not an empty batch.
+      // Let the worker stop instead of spinning on an uncommittable record.
+      if (fs.existsSync(file)) result.retained += 1;
+      continue;
+    }
     const record = readOutboxRecord(claimedFile);
     if (!record) {
       result.invalid += 1;
@@ -1756,7 +1837,7 @@ export async function flushOutbox(env = process.env, {
       continue;
     }
     if (isConversationEvent(record.event)) {
-      // Finish stage accounting before a conversation request can wait indefinitely.
+      // Finish stage accounting before handing off to conversation delivery.
       recordStageSuccess();
       // Legacy preview queues were captured before explicit consent existed.
       // Never retroactively authorize those messages with a later confirmation.
@@ -1766,6 +1847,13 @@ export async function flushOutbox(env = process.env, {
         result.invalid += 1;
         continue;
       }
+      // A recorder queues before committing its sequence. An already-running
+      // worker must leave that record pending until the state write succeeds.
+      if (record.event.sequence > state.sequence) {
+        releaseOutboxClaim(claimedFile);
+        result.retained += 1;
+        continue;
+      }
     }
     const report = buildSyncLogReport(
       record.event,
@@ -1785,7 +1873,7 @@ export async function flushOutbox(env = process.env, {
     let sendResult = { ok: false, error_code: 'SENDER_FAILED', error_message: 'sender failed' };
     try {
       const rawSendResult = await sender(report, {
-        timeoutMs: isConversationEvent(record.event) ? 0 : timeoutMs
+        timeoutMs: isConversationEvent(record.event) ? conversationUploadTimeoutMs : timeoutMs
       });
       sendResult = typeof rawSendResult === 'boolean' ? { ok: rawSendResult } : rawSendResult;
     } catch (error) {
@@ -1793,6 +1881,7 @@ export async function flushOutbox(env = process.env, {
     }
     if (sendResult?.ok) {
       result.sent += 1;
+      if (typeof onSent === 'function') onSent();
       if (!conversation) stages.sent += 1;
       try {
         fs.unlinkSync(claimedFile);
@@ -1826,7 +1915,7 @@ function outboxFilesForFlush(env = process.env, {
 } = {}) {
   const files = outboxFiles(env, { targetFile, limit: 0 })
     .filter((file) => includeConversations || !file.endsWith('.conversation'))
-    // Drain bounded stage uploads before potentially unbounded conversation requests.
+    // Drain stage uploads before the separately bounded conversation requests.
     .sort((a, b) => Number(a.endsWith('.conversation')) - Number(b.endsWith('.conversation')));
   if (!prioritizeTerminal || targetFile) return limit > 0 ? files.slice(0, limit) : files;
   const terminalFiles = [];
@@ -1840,11 +1929,139 @@ function outboxFilesForFlush(env = process.env, {
   return limit > 0 ? ordered.slice(0, limit) : ordered;
 }
 
+function uploadWorkerLeasePath(env) {
+  return path.join(outboxDir(env), '.upload-worker.json');
+}
+
+function readUploadWorkerLease(env) {
+  try {
+    const file = uploadWorkerLeasePath(env);
+    const lease = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!Number.isSafeInteger(lease.pid) || lease.pid <= 0 || !validConversationId(lease.token)) return null;
+    // Older workers did not store a deadline. Bound their records by their
+    // original file age instead of trusting a reused PID indefinitely.
+    if (lease.started_at === undefined && lease.expires_at === undefined) {
+      const startedAt = Math.floor(fs.statSync(file).mtimeMs);
+      return { ...lease, started_at: startedAt,
+        expires_at: startedAt + uploadWorkerLifetimeMs + 2 * runStateLockWaitMs };
+    }
+    return lease;
+  } catch { return null; }
+}
+
+function uploadWorkerProcessAlive(lease) {
+  if (!lease) return false;
+  try { process.kill(lease.pid, 0); return true; }
+  catch (error) { return error.code !== 'ESRCH'; }
+}
+
+function uploadWorkerAlive(lease) {
+  if (!lease) return false;
+  const now = Date.now();
+  const maxAge = uploadWorkerLifetimeMs + 2 * runStateLockWaitMs;
+  if (!Number.isSafeInteger(lease.started_at) || !Number.isSafeInteger(lease.expires_at)
+    || lease.started_at <= 0 || lease.started_at > now || lease.expires_at <= now
+    || lease.expires_at <= lease.started_at || lease.expires_at - lease.started_at > maxAge) return false;
+  return uploadWorkerProcessAlive(lease);
+}
+
+function releaseWorkerClaims(env, pid = process.pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return;
+  try {
+    for (const name of fs.readdirSync(outboxDir(env))) {
+      if (isOutboxClaimName(name) && name.endsWith(`.sending.${pid}`)) {
+        releaseOutboxClaim(path.join(outboxDir(env), name));
+      }
+    }
+  } catch {}
+}
+
+async function runOutboxWorker(env) {
+  // Startup and exit share this short metadata lock; no network work holds it.
+  // Checking and replacing an expired/dead owner's lease are one operation.
+  const testLifetime = Number(env.ALIPAY_AIPAY_TEST_WORKER_LIFETIME_MS);
+  const lifetime = env.ALIPAY_AIPAY_TEST_MODE === '1' && Number.isFinite(testLifetime) && testLifetime > 0
+    ? Math.min(testLifetime, uploadWorkerLifetimeMs) : uploadWorkerLifetimeMs;
+  const transaction = withRunStateLock(env, () => {
+    const previous = readUploadWorkerLease(env);
+    if (uploadWorkerAlive(previous)) return null;
+    // A still-live reused PID may own a different foreground upload. Leave its
+    // claims to the existing TTL recovery instead of reclaiming active work.
+    if (previous && !uploadWorkerProcessAlive(previous)) releaseWorkerClaims(env, previous.pid);
+    const startedAt = Date.now();
+    const lease = { pid: process.pid, token: crypto.randomUUID(), started_at: startedAt,
+      expires_at: startedAt + lifetime + 2 * runStateLockWaitMs };
+    return writePrivateJson(uploadWorkerLeasePath(env), lease) ? lease : null;
+  }, `${uploadWorkerLeasePath(env)}.guard`);
+  const lease = transaction.acquired && transaction.value;
+  if (!lease) return;
+  let released = false;
+  let sent = 0;
+  let drained = false;
+  const cleanup = (keepIfPending = false) => {
+    if (released) return false;
+    const transaction = withRunStateLock(env, () => {
+      if (readUploadWorkerLease(env)?.token !== lease.token) { released = true; return false; }
+      // Foreground producers never wait for this guard. Check again after
+      // releasing it, so messages queued in the empty-check / exit window drain.
+      if (keepIfPending && outboxFilesForFlush(env, { limit: 1 }).length > 0) return true;
+      releaseWorkerClaims(env);
+      fs.unlinkSync(uploadWorkerLeasePath(env));
+      released = true;
+      return false;
+    }, `${uploadWorkerLeasePath(env)}.guard`);
+    return transaction.acquired && transaction.value;
+  };
+  // Production lifetime is fixed. Only the explicit test mode can shorten it.
+  const watchdog = setTimeout(() => {
+    cleanup();
+    // Continue a healthy backlog in a new bounded worker. A stalled first
+    // request never creates an endless chain of replacement processes.
+    if (released && sent > 0 && hasPendingOutboxRecords(env)) spawnOutboxFlush({ ...env,
+      ALIPAY_AIPAY_TELEMETRY_FLUSH_TARGET_FILE: '', ALIPAY_AIPAY_TELEMETRY_FLUSH_DELAY_MS: '0' });
+    process.exit(0);
+  }, lifetime);
+  try {
+    const delay = parseNonNegativeInteger(env.ALIPAY_AIPAY_TELEMETRY_FLUSH_DELAY_MS);
+    if (delay) await new Promise(resolve => setTimeout(resolve, Math.min(delay, 30000)));
+    const timeout = Number(env.ALIPAY_AIPAY_TELEMETRY_UPLOAD_TIMEOUT_MS || uploadTimeoutMs);
+    let targetFile = env.ALIPAY_AIPAY_TELEMETRY_FLUSH_TARGET_FILE || '';
+    while (!released) {
+      const result = await flushOutbox(env, {
+        targetFile,
+        timeoutMs: Number.isFinite(timeout) ? timeout : uploadTimeoutMs,
+        onSent: () => { sent += 1; }
+      });
+      targetFile = '';
+      // Do not busy-retry network or local failures. Keep their records queued.
+      if (result.retained > 0) break;
+      if (!cleanup(true)) { drained = true; break; }
+    }
+  } finally {
+    clearTimeout(watchdog);
+    cleanup();
+    if (drained && released && outboxFilesForFlush(env, { limit: 1 }).length > 0) {
+      spawnOutboxFlush({ ...env,
+        ALIPAY_AIPAY_TELEMETRY_FLUSH_TARGET_FILE: '', ALIPAY_AIPAY_TELEMETRY_FLUSH_DELAY_MS: '0' });
+    }
+  }
+}
+
 function spawnOutboxFlush(env = process.env, {
   delayMs = 0,
   recordStageFailure = hasPendingOutboxRecords(env, { includeConversations: false })
 } = {}) {
   if (!telemetryUploadEnabled(env)) return false;
+  // Best effort: a busy uploader must not delay capture or business delivery.
+  // Its post-release queue check handles an overlapping successful exit.
+  const transaction = withRunStateLock(env, () => {
+    if (uploadWorkerAlive(readUploadWorkerLease(env))) return true;
+    return launchOutboxFlush(env, { delayMs, recordStageFailure });
+  }, `${uploadWorkerLeasePath(env)}.guard`, 0);
+  return transaction.acquired && transaction.value;
+}
+
+function launchOutboxFlush(env, { delayMs, recordStageFailure }) {
   try {
     const childEnv = {
       ...env,
@@ -2066,13 +2283,7 @@ export async function runTelemetryCli(argv = process.argv) {
     if (command === 'flush-outbox-worker') {
       assertCliArgs(args, new Set(), 0);
       if (!telemetryUploadEnabled(process.env)) return 0;
-      const timeout = Number(process.env.ALIPAY_AIPAY_TELEMETRY_UPLOAD_TIMEOUT_MS || uploadTimeoutMs);
-      const delay = parseNonNegativeInteger(process.env.ALIPAY_AIPAY_TELEMETRY_FLUSH_DELAY_MS);
-      if (delay && delay > 0) sleepSync(Math.min(delay, 30000));
-      await flushOutbox(process.env, {
-        targetFile: process.env.ALIPAY_AIPAY_TELEMETRY_FLUSH_TARGET_FILE || '',
-        timeoutMs: Number.isFinite(timeout) ? timeout : uploadTimeoutMs
-      });
+      await runOutboxWorker(process.env);
       return 0;
     }
     if (!telemetryEnabled(process.env)) return 0;

package/skill-pre/references/normal/scripts/windows/git-discovery.mjs

@@ -1,14 +1,18 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import {run, fail} from './host.mjs';
-const managedGitVersion=JSON.parse(fs.readFileSync(new URL('./policy.json',import.meta.url),'utf8')).git.version;
+function managedGitVersion() {
+  try { return JSON.parse(fs.readFileSync(new URL('./policy.json',import.meta.url),'utf8')).git.version; }
+  catch { return ''; }
+}
 
 export function gitCandidates(env = process.env) {
   if (env.ALIPAY_GIT_BASH) return [env.ALIPAY_GIT_BASH];
+  const managedVersion = env.LOCALAPPDATA ? managedGitVersion() : '';
   const candidates = [
     path.win32.join(env.ProgramFiles || 'C:/Program Files', 'Git/bin/bash.exe'),
     ...(env.LOCALAPPDATA ? [path.win32.join(env.LOCALAPPDATA, 'Programs/Git/bin/bash.exe'),
-      path.win32.join(env.LOCALAPPDATA, `Programs/Git-Aipay-${managedGitVersion}/bin/bash.exe`)] : [])
+      ...(managedVersion ? [path.win32.join(env.LOCALAPPDATA, `Programs/Git-Aipay-${managedVersion}/bin/bash.exe`)] : [])] : [])
   ];
   const search = Object.entries(env).find(([key]) => key.toLowerCase() === 'path')?.[1] || '';
   for (const directory of search.split(';').filter(p => path.win32.isAbsolute(p))) {

package/skill-pre/references/normal/scripts/windows/git-install.mjs

@@ -1,14 +1,13 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import {policy,run,fail} from './preflight.mjs';
+import {loadPolicy,run,fail} from './preflight.mjs';
 import {findGitBash} from './git-discovery.mjs';
 import {powershell,psEnv} from './host.mjs';
 
 export function installGitOfficial({env=process.env,execute=run,exists=fs.existsSync,
   read=fs.readFileSync,remove=fs.rmSync,discover=findGitBash,root,
-  signatureCommand=powershell,beforeAttempt=()=>{}}={}) {
-  const asset=policy.git;
+  signatureCommand=powershell,beforeAttempt=()=>{},asset=loadPolicy('Git Bash').git}={}) {
   if(!root || !env.LOCALAPPDATA || !path.win32.isAbsolute(env.LOCALAPPDATA) ||
       !/^https:\/\/github\.com\/git-for-windows\/git\/releases\/download\/v[0-9.]+\.windows\.[0-9]+\/Git-[0-9.]+-64-bit\.exe$/u.test(asset.url) ||
       !/^[a-f0-9]{64}$/u.test(asset.sha256)) fail('GIT_ASSET_INVALID','Git Bash');

package/skill-pre/references/normal/scripts/windows/preflight.mjs

@@ -5,7 +5,18 @@ import crypto from 'node:crypto';
 import {fileURLToPath} from 'node:url';
 
 export const directory = path.dirname(fileURLToPath(import.meta.url));
-export const policy = JSON.parse(fs.readFileSync(path.join(directory,'policy.json'),'utf8'));
+export function loadPolicy(dependency, read = fs.readFileSync) {
+  try {
+    const policy = JSON.parse(read(path.join(directory,'policy.json'),'utf8'));
+    const asset = dependency === 'Git Bash' ? policy?.git : policy?.jq;
+    if (!asset || typeof asset !== 'object' || typeof asset.url !== 'string' ||
+      typeof asset.sha256 !== 'string' || (dependency === 'Git Bash' && typeof asset.version !== 'string')) {
+      throw new Error('incomplete policy');
+    }
+    return policy;
+  }
+  catch { fail('POLICY_UNAVAILABLE',dependency); }
+}
 const slash = p => p.replaceAll('\\','/');
 let invocationContext;
 import {fail, run, checkWritable} from './host.mjs';
@@ -69,7 +80,7 @@ export function locateJq() {
 }
 export function locate() {
   if(process.platform!=='win32') fail('WINDOWS_ADAPTER_REQUIRES_WINDOWS');
-  if(Number(process.versions.node.split('.')[0])<policy.nodeMinimumMajor) fail('DEPENDENCY_VERSION','Node');
+  if(Number(process.versions.node.split('.')[0])<18) fail('DEPENDENCY_VERSION','Node');
   requireWindowsX64Node();
   const foundGit=findGitBash();
   if(!foundGit) fail('DEPENDENCY_MISSING','Git Bash');

package/skill-pre/references/normal/scripts/windows/prepare.mjs

@@ -7,7 +7,7 @@ import {findGitBash} from './git-discovery.mjs';
 import {findWinget} from './winget.mjs';
 import {installGitOfficial} from './git-install.mjs';
 import {powershell} from './host.mjs';
-import {policy,run,stateRoot,readState,saveState,withLock,ensureReady,locateJq,fail,report} from './preflight.mjs';
+import {loadPolicy,run,stateRoot,readState,saveState,withLock,ensureReady,locateJq,fail,report} from './preflight.mjs';
 
 export function claimPreparation(state,stage,{source='official',repair=false,authorized=false}={}) {
   if(!authorized) fail('PREPARATION_AUTHORIZATION_REQUIRED');
@@ -65,7 +65,7 @@ export function prepareDependencies(state,{authorized=false,repair=false,save=()
   gitReady=()=>findGitBash(),jqReady=()=>locateJq(),
   cliReady=()=>{const cli=path.join(os.homedir(),'.local/bin/alipay-cli.exe');return fs.existsSync(cli)&&run(cli,['version']).status===0;},
   installWinget=installGitWithWinget,installOfficial=installGitOfficial,
-  prepareJq=(beforeAttempt)=>{requireAssetDownloader();beforeAttempt();installAsset('jq',policy.jq);},
+  prepareJq=(beforeAttempt)=>{const asset=loadPolicy('jq').jq;requireAssetDownloader();beforeAttempt();installAsset('jq',asset);},
   prepareCli=(beforeAttempt)=>{powershell();beforeAttempt();if(refreshWindowsCli()!=='READY')fail('CLI_INSTALL_FAILED','alipay-cli');}
 }={}) {
   if(!authorized) fail('PREPARATION_AUTHORIZATION_REQUIRED');

package/skill-pre/references/normal/scripts/windows/routing.mjs

@@ -6,12 +6,15 @@ const prefix = 'ALIPAY_AIPAY_INTERNAL:';
 
 // Optional tool failures do not prevent independent project code development.
 function codeOnlyFailure(error) {
+  if (error.reason === 'SHELL_TRANSPORT_FAILED' && error.dependency !== 'Node') return true;
+  if (error.reason === 'NOT_GIT_BASH' && error.dependency === 'ALIPAY_GIT_BASH') return true;
+  if (error.dependency === 'Node') return false;
   const tools = ['Git Bash', 'git', 'jq', 'alipay-cli', 'cli', 'curl', 'PowerShell'];
   if (!tools.includes(error.dependency)) return false;
   return ['DEPENDENCY_MISSING', 'DEPENDENCY_VERSION', 'EXECUTION_FAILED',
     'WINGET_UNAVAILABLE', 'GIT_INSTALL_FAILED', 'GIT_VERIFY_FAILED', 'CLI_INSTALL_FAILED',
     'DOWNLOAD_FAILED', 'INTEGRITY_FAILED', 'SIGNATURE_FAILED', 'RETRY_BUDGET_EXHAUSTED',
-    'USER_SCOPE_REQUIRED'].includes(error.reason);
+    'USER_SCOPE_REQUIRED', 'POLICY_UNAVAILABLE'].includes(error.reason);
 }
 
 // This is a routing result, never proof of a successful payment or onboarding.

package/skill-pre/references/normal/windows-environment.md

@@ -34,11 +34,11 @@ stdout 为空、原始安装器输出不对客，只映射根协议的唯一刷
 
 CLI 刷新策略与非 Windows 保持同一会话预算，不锁定 0.1.7 或其哈希；Windows 交由正式 PowerShell 安装器选择版本。jq 优先复用能通过版本和实际 filter 检查的既有原生工具；缺失或不可用时安装固定 1.7.1，官方 HTTPS 资产和 SHA-256 位于 `scripts/windows/policy.json`。Node 优先复用当前可运行的 Windows x64 Node >=18；缺失时由根启动器的 PowerShell 引导准备官方 LTS 用户级 ZIP，SHA-256 验证后返回绝对可执行路径，首次一次、明确修复最多一次。Git Bash 从常见目录和本机 PATH 的 Git 安装布局定位，也可由 `ALIPAY_GIT_BASH` 指定绝对路径；必须验证 Git for Windows 版本、cygpath 和 Bash 的 MINGW/MSYS 平台，不使用 System32/WSL Bash，显式指定错误时停止而不偷偷换工具。
 
-初次缺 Git Bash、jq 或本机 CLI 无法启动且当前任务授权准备时，按 Git Bash → jq → 必要的 CLI 修复 → 完整复检执行。CLI 已可用时不重复安装。Git 优先复用已有可运行的 Git for Windows；缺失时优先调用用户级 winget，无法运行或未通过复检时使用 `scripts/windows/policy.json` 固定的 Git for Windows 官方 x64 安装包（当前 2.56.0.2）。官方包下载后先校验固定 SHA-256，再由系统 PowerShell 验证 Authenticode 有效，之后安装到 `%LOCALAPPDATA%/Programs/Git-Aipay-<version>`，并实测 git、bash、cygpath。下载或校验失败不运行安装包。两种来源均不可用时保持 BLOCKED，展示原因及官方手工安装路径，不静默跳站点。
+初次缺 Git Bash、jq 或本机 CLI 无法启动且当前任务授权准备时，按 Git Bash → jq → 必要的 CLI 修复 → 完整复检执行。CLI 已可用时不重复安装。Git 优先复用已有可运行的 Git for Windows；缺失时优先调用用户级 winget，无法运行或未通过复检时使用 `scripts/windows/policy.json` 固定的 Git for Windows 官方 x64 安装包（当前 2.56.0.2）。官方包下载后先校验固定 SHA-256，再由系统 PowerShell 验证 Authenticode 有效，之后安装到 `%LOCALAPPDATA%/Programs/Git-Aipay-<version>`，并实测 git、bash、cygpath。下载或校验失败不运行安装包。两种来源均不可用时按根意图返回 CODE_ONLY 或 BLOCKED，展示原因及官方手工安装路径，不静默跳站点。
 
-jq 使用固定 1.7.1 官方资产和 SHA-256，已有健康版本直接复用；CLI 仍使用正式 PowerShell 安装器选择当前版本。每个依赖和 Git 的两种安装来源分别记录实际开始的安装尝试，确认来源前的只读探测不消耗预算；Git 的 winget 失败可在同次准备中尝试官方固定包。初次每个来源最多一次，用户明确修复后每个来源最多再一次；失败阶段可续跑，已健康的阶段不重装。状态记录不含业务材料；复检始终只读且不消耗安装预算。网络、实际权限、签名或完整性失败保持 BLOCKED，不轮换未经验证的镜像、使用 WSL、提权或修改执行策略。
+jq 使用固定 1.7.1 官方资产和 SHA-256，已有健康版本直接复用；CLI 仍使用正式 PowerShell 安装器选择当前版本。每个依赖和 Git 的两种安装来源分别记录实际开始的安装尝试，确认来源前的只读探测不消耗预算；Git 的 winget 失败可在同次准备中尝试官方固定包。初次每个来源最多一次，用户明确修复后每个来源最多再一次；失败阶段可续跑，已健康的阶段不重装。状态记录不含业务材料；复检始终只读且不消耗安装预算。可选工具的网络、签名或完整性失败按第 21 行分流；实际存储故障仍为 BLOCKED。不轮换未经验证的镜像、使用 WSL、提权或修改执行策略。
 
-环境诊断和次数保存在 `%LOCALAPPDATA%/alipay-aipay-pre/windows/environment.json`；旧版全局次数无法归属具体安装阶段，迁移时保留阻断原因并从新版本的有限分阶段预算重新计数。锁短时占用或状态损坏时，完整工具检查通过仍可 READY；自动安装保持阻断，不删除锁或状态绕过预算。用户修好依赖后，只读复检可再次执行，无论此前安装预算是否用尽：
+环境诊断和次数保存在 `%LOCALAPPDATA%/alipay-aipay-pre/windows/environment.json`；旧版全局次数无法归属具体安装阶段，迁移时保留阻断原因并从新版本的有限分阶段预算重新计数。锁短时占用或状态损坏时，完整工具检查通过仍可 READY；自动安装保持阻断，不删除锁或状态绕过预算。CODE_ONLY 的恢复使用第 23 行 `windows-entry`；以下仅适用于 BLOCKED。用户修好依赖后，只读复检可再次执行，无论此前安装预算是否用尽：
 
 ```text
 node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" env retry --repair-confirmed true --root-intent "<ROOT_INTENT>" --agent-platform "<AGENT_PLATFORM>" --session-id "<SESSION_ID>" --windows-route BLOCKED
@@ -52,7 +52,7 @@ node "<SKILL_DIR>/references/normal/scripts/runtime.mjs" env prepare --authorize
 
 如果之前只是缺少授权或没有找到安装来源，尚未实际尝试该阶段，则使用同一命令但省略 `--repair-confirmed true`，继续首次准备；不能把新授权当成已消耗预算后的额外重试许可。
 
-仅退出 0、唯一 `CLI_ENV:READY` 和唯一根意图匹配的 `WINDOWS_ROUTE=READY` 可更新分流。其他结果保持 BLOCKED，说明具体失败原因；不重建会话、重复计数或重放业务操作。用户明确选择站点或平台执行映射不支持时，可走原 LEGACY 分支；可恢复的依赖失败不能自动转站点。
+仅退出 0、唯一 `CLI_ENV:READY` 和唯一根意图匹配的 `WINDOWS_ROUTE=READY` 可恢复沙箱及开通能力。BLOCKED 恢复命令的其他结果保持 BLOCKED，说明具体失败原因；不重建会话、重复计数或重放业务操作。CODE_ONLY 按第 23 行重新取得入口分流。用户明确选择站点或平台执行映射不支持时，可走原 LEGACY 分支；可恢复的依赖失败不能自动转站点。
 
 ## 路径、权限与进程