fix(wechat): scrub image_url from sessions and harden vision handoff.

Strip image_url from persisted session payloads, keep image turns scoped to the active request, and align proxy/vision/page-data paths so WeChat image history does not leak into fresh sessions. Co-authored-by: Cursor <cursoragent@cursor.com>
fix: fail closed when WeChat page.generate has no HTML artifact
2026-07-30 10:43:24 +08:00 · 2026-07-30 10:43:24 +08:00 · 2026-07-28 18:34:28 +08:00 · 2026-07-28 18:19:29 +08:00 · 2026-07-28 16:54:42 +08:00 · 2026-07-28 16:27:28 +08:00
23 changed files with 1444 additions and 269 deletions
@@ -130,6 +130,25 @@ export function scrubUserMessageImageAttachments(message) {
  };
 }

+export function messageContentHasImageUrl(content) {
+  if (!Array.isArray(content)) return false;
+  return content.some((item) => item?.type === 'image_url' && item?.image_url?.url);
+}
+
+/**
+ * Any persisted image_url part will break DeepSeek / other text-only providers.
+ * User metadata.imageUrls alone is not enough — Goose may have expanded them into
+ * content parts on assistant or user turns.
+ */
+export function conversationHasImageUrlContent(conversation, { excludeMessageId = null } = {}) {
+  if (!Array.isArray(conversation)) return false;
+  const excluded = String(excludeMessageId ?? '').trim();
+  return conversation.some((message) => {
+    if (excluded && String(message?.id ?? '').trim() === excluded) return false;
+    return messageContentHasImageUrl(message?.content);
+  });
+}
+
 export function scrubConversationHistoricalImageAttachments(conversation, activeMessageId) {
  const activeId = String(activeMessageId ?? '').trim();
  if (!Array.isArray(conversation) || !activeId) {
@@ -2,6 +2,7 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 import {
  buildCurrentTurnImageScopeNote,
+  conversationHasImageUrlContent,
  dedupeImageUrlsByAssetKey,
  extractCurrentTurnImageUrls,
  scrubConversationHistoricalImageAttachments,
@@ -113,3 +114,46 @@ test('buildCurrentTurnImageScopeNote states one independent topic per upload', (
  assert.match(note, /不得与历史轮次混用/);
  assert.match(note, /asset=asset-9/);
 });
+
+test('conversationHasImageUrlContent detects historical poison and ignores active turn', () => {
+  const conversation = [
+    {
+      id: 'assistant-old',
+      role: 'assistant',
+      content: [
+        { type: 'text', text: '看图' },
+        { type: 'image_url', image_url: { url: 'https://example.com/old.png' } },
+      ],
+    },
+    {
+      id: 'user-new',
+      role: 'user',
+      content: [
+        { type: 'text', text: '这是什么' },
+        { type: 'image_url', image_url: { url: 'https://example.com/new.png' } },
+      ],
+    },
+  ];
+
+  assert.equal(conversationHasImageUrlContent(conversation), true);
+  assert.equal(
+    conversationHasImageUrlContent(conversation, { excludeMessageId: 'user-new' }),
+    true,
+  );
+  assert.equal(
+    conversationHasImageUrlContent(
+      [
+        {
+          id: 'user-new',
+          role: 'user',
+          content: [
+            { type: 'text', text: '这是什么' },
+            { type: 'image_url', image_url: { url: 'https://example.com/new.png' } },
+          ],
+        },
+      ],
+      { excludeMessageId: 'user-new' },
+    ),
+    false,
+  );
+});
@@ -7,6 +7,7 @@ const BLOCKED_ACTIVE_PATTERNS = [
 const SCRIPT_TAG_PATTERN = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
 const SCRIPT_SRC_PATTERN = /\bsrc\s*=\s*(['"])([^'"]+)\1/i;
 const TRUSTED_SCRIPT_SRC_PATTERNS = [
+  /^\/assets\/page-data-client\.js(?:[?#].*)?$/i,
  /^\/assets\/chart\.umd\.min\.js(?:[?#].*)?$/i,
  /^https:\/\/cdn\.jsdelivr\.net\/npm\/chart\.js(?:@[^/]+)?\/dist\/chart\.(?:umd\.)?min\.js(?:[?#].*)?$/i,
  /^https:\/\/cdnjs\.cloudflare\.com\/ajax\/libs\/Chart\.js\/[^/]+\/chart\.(?:umd\.)?min\.js(?:[?#].*)?$/i,
@@ -35,6 +35,21 @@ test('runBasicFileScan warns for sandboxed html with inline script and trusted C
  assert.deepEqual(result.findings, ['trusted_html_active_content']);
 });

+test('runBasicFileScan warns for sandboxed html with page-data-client and inline script', () => {
+  const result = runBasicFileScan(
+    Buffer.from(`<!doctype html>
+      <script src="/assets/page-data-client.js"></script>
+      <script>MindSpacePageData.createClient({ apiBase: "/api" });</script>`),
+    {
+      filename: 'survey.html',
+      mimeType: 'text/html',
+      htmlActiveContentPolicy: 'sandbox_warn',
+    },
+  );
+  assert.equal(result.scanStatus, 'warned');
+  assert.deepEqual(result.findings, ['trusted_html_active_content']);
+});
+
 test('runBasicFileScan still blocks unsafe html active content in sandbox mode', () => {
  const javascriptUrl = runBasicFileScan(Buffer.from('<a href="javascript:alert(1)">go</a>'), {
    filename: 'dashboard.html',
@@ -514,6 +514,84 @@ function sanitizeFreshVerification(
  };
 }

+function collectDeliverablePageArtifacts({
+  artifacts = [],
+  messages = [],
+  publishDir,
+  buildCanonicalUrl,
+} = {}) {
+  const restored = restoreWorkspaceArtifacts({
+    artifacts,
+    publishDir,
+    buildCanonicalUrl,
+  });
+  if (restored.length > 0) return restored;
+  const writeArtifacts = extractPublicHtmlWriteArtifacts(
+    messages,
+    { publishDir },
+  );
+  return restoreWorkspaceArtifacts({
+    artifacts: writeArtifacts.map((artifact) => ({
+      relativePath: artifact.relativePath,
+    })),
+    publishDir,
+    buildCanonicalUrl,
+  });
+}
+
+async function acceptWorkspaceThumbnailFallback({
+  artifacts = [],
+  publishDir,
+} = {}) {
+  const eligible = artifacts.filter((artifact) => {
+    const localPath = String(artifact?.localPath ?? '').trim();
+    return localPath && fs.existsSync(localPath) && artifact?.auxiliary !== true;
+  });
+  if (eligible.length === 0) {
+    return { ok: false, reason: 'missing_page_artifact', matches: [] };
+  }
+  await Promise.all(
+    eligible.map((artifact) =>
+      ensureWorkspaceHtmlThumbnail(
+        publishDir,
+        artifact.relativePath,
+      ),
+    ),
+  );
+  const withThumbnails = eligible.filter((artifact) =>
+    fs.existsSync(
+      path.join(
+        publishDir,
+        workspaceThumbnailRelativePath(artifact.relativePath),
+      ),
+    ),
+  );
+  if (withThumbnails.length !== eligible.length) {
+    return {
+      ok: false,
+      reason: 'workspace_thumbnail_fallback_failed',
+      matches: [],
+      artifact: eligible.find((artifact) =>
+        !fs.existsSync(
+          path.join(
+            publishDir,
+            workspaceThumbnailRelativePath(artifact.relativePath),
+          ),
+        ),
+      ),
+    };
+  }
+  return {
+    ok: true,
+    reason: 'workspace_thumbnail_fallback',
+    matches: withThumbnails.map((artifact) => ({
+      artifact,
+      image: null,
+      cover: null,
+    })),
+  };
+}
+
 export async function ensureWechatFreshPageThumbnailsAtWorkspace({
  artifacts = [],
  images = [],
@@ -522,12 +600,12 @@ export async function ensureWechatFreshPageThumbnailsAtWorkspace({
  buildCanonicalUrl,
  repairEnabled = false,
 } = {}) {
-  const workspaceArtifacts =
-    restoreWorkspaceArtifacts({
-      artifacts,
-      publishDir,
-      buildCanonicalUrl,
-    });
+  let workspaceArtifacts = collectDeliverablePageArtifacts({
+    artifacts,
+    messages,
+    publishDir,
+    buildCanonicalUrl,
+  });
  let verification =
    verifyFreshWechatPageThumbnails(
      workspaceArtifacts,
@@ -551,20 +629,35 @@ export async function ensureWechatFreshPageThumbnailsAtWorkspace({
          verification.reason,
      });
    if (repair.ok) {
+      workspaceArtifacts = restoreWorkspaceArtifacts({
+        artifacts: workspaceArtifacts,
+        publishDir,
+        buildCanonicalUrl,
+      });
      verification =
        verifyFreshWechatPageThumbnails(
-          restoreWorkspaceArtifacts({
-            artifacts,
-            publishDir,
-            buildCanonicalUrl,
-          }),
+          workspaceArtifacts,
          images,
        );
    }
  }
+  // When image_make failed or returned nothing, still deliver pages that already
+  // landed on disk by generating the workspace share thumbnail sidecars.
+  if (
+    !verification.ok
+    && ['fresh_image_not_generated', 'missing_generated_cover', 'cover_not_from_current_run'].includes(
+      String(verification.reason ?? ''),
+    )
+    && workspaceArtifacts.length > 0
+  ) {
+    verification = await acceptWorkspaceThumbnailFallback({
+      artifacts: workspaceArtifacts,
+      publishDir,
+    });
+  }
  if (verification.ok) {
    await Promise.all(
-      verification.matches.map((match) =>
+      (verification.matches ?? []).map((match) =>
        ensureWorkspaceHtmlThumbnail(
          publishDir,
          match.artifact.relativePath,
@@ -579,7 +672,7 @@ export async function ensureWechatFreshPageThumbnailsAtWorkspace({
    ),
    thumbnailRelativePaths:
      verification.ok
-        ? verification.matches.map((match) =>
+        ? (verification.matches ?? []).map((match) =>
            workspaceThumbnailRelativePath(
              match.artifact.relativePath,
            ),
@@ -271,6 +271,44 @@ test('MindSpace verifies and renders fresh WeChat page thumbnails without return
  );
 });

+test('MindSpace falls back to workspace thumbnails when fresh image_make is missing', async (t) => {
+  const publishDir = fs.mkdtempSync(
+    path.join(
+      os.tmpdir(),
+      'mindspace-wechat-thumbnail-fallback-',
+    ),
+  );
+  t.after(() => {
+    fs.rmSync(publishDir, {
+      recursive: true,
+      force: true,
+    });
+  });
+  const relativePath = 'public/fallback.html';
+  const htmlPath = path.join(publishDir, relativePath);
+  fs.mkdirSync(path.dirname(htmlPath), { recursive: true });
+  fs.writeFileSync(
+    htmlPath,
+    pageHtml({ title: 'Fallback' }),
+    'utf8',
+  );
+
+  const result = await ensureWechatFreshPageThumbnailsAtWorkspace({
+    publishDir,
+    buildCanonicalUrl: canonical,
+    artifacts: [{ relativePath, exists: true }],
+    images: [],
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.reason, 'workspace_thumbnail_fallback');
+  assert.deepEqual(result.matchRelativePaths, [relativePath]);
+  assert.equal(
+    fs.existsSync(path.join(publishDir, 'public', 'fallback.thumbnail.svg')),
+    true,
+  );
+});
+
 test('MindSpace owns unambiguous cover repair before thumbnail delivery', async (t) => {
  const publishDir = fs.mkdtempSync(
    path.join(
@@ -88,6 +88,9 @@ export function createPageDataBrowserClient({
    async listRows(dataset, query = {}) {
      return request('GET', buildPageDataPublicPath(apiBase, pageId, dataset), { query });
    },
+    async readRows(dataset, query = {}) {
+      return request('GET', buildPageDataPublicPath(apiBase, pageId, dataset), { query });
+    },
    async getSchema(dataset) {
      return request('GET', buildPageDataPublicPath(apiBase, pageId, dataset, 'schema'));
    },
@@ -106,6 +106,9 @@
      listRows: function (dataset, query) {
        return request('GET', buildDataPath(apiBase, pageId, dataset), { query: query || {} });
      },
+      readRows: function (dataset, query) {
+        return request('GET', buildDataPath(apiBase, pageId, dataset), { query: query || {} });
+      },
      getSchema: function (dataset) {
        return request('GET', buildDataPath(apiBase, pageId, dataset, 'schema'));
      },
@@ -0,0 +1,56 @@
+{
+  "id": "wechat-poem-page-modify",
+  "name": "写诗→做页面→修改页面（H5 多轮）",
+  "description": "模拟服务号常见三回合：写诗、做成页面、修改页面内容",
+  "account": {
+    "username": "john",
+    "password": "888888"
+  },
+  "steps": [
+    {
+      "action": "login",
+      "label": "登录"
+    },
+    {
+      "action": "chat",
+      "label": "请求写诗",
+      "message": "帮我写一首关于七月午后的短诗，四段即可",
+      "expect": {
+        "assistantMinChars": 40,
+        "timeoutMs": 180000,
+        "replyKeywords": ["七月", "午"]
+      }
+    },
+    {
+      "action": "chat",
+      "label": "做成精美 HTML 页面",
+      "message": "生成一个精美的 HTML 页面",
+      "expect": {
+        "assistantMinChars": 20,
+        "timeoutMs": 300000,
+        "replyKeywords": ["七月", "午"],
+        "page": {
+          "keywords": ["七月", "午"],
+          "requirePublicLink": true,
+          "requireHttp200": true,
+          "requireMindspaceCover": true
+        }
+      }
+    },
+    {
+      "action": "chat",
+      "label": "修改页面标题",
+      "message": "把页面标题改成《七月的午后》",
+      "expect": {
+        "assistantMinChars": 10,
+        "timeoutMs": 300000,
+        "replyKeywords": ["七月"],
+        "page": {
+          "keywords": ["七月的午后", "七月"],
+          "requirePublicLink": true,
+          "requireHttp200": true
+        }
+      }
+    }
+  ]
+}
@@ -46,6 +46,11 @@ usage() {
  6. 启动 Portal，保持旧端口 8081
  7. 健康检查通过后重启 m.tkmind.cn 反向隧道 (105:19081 -> 103:8081)
  8. 旧源码目录移入 archive，不再保留可运行 live 源码
+
+环境变量:
+  ALLOW_DIRECT_STABLE_RELEASE=1
+    仅在用户明确批准按 7/23 前规则直接整包时使用：允许 --skip-tests，
+    并跳过 canary 晋升证据与 Core+Impact Gate report。
 EOF
 }

@@ -68,9 +73,17 @@ while [[ $# -gt 0 ]]; do
  shift
 done

+say() {
+  printf '\n[%s] %s\n' "$(date +%H:%M:%S)" "$*"
+}
+
 if [[ "${SKIP_TESTS}" -eq 1 ]]; then
-  echo "生产发布守门员禁止 --skip-tests。" >&2
-  exit 1
+  if [[ "${ALLOW_DIRECT_STABLE_RELEASE:-0}" == "1" ]]; then
+    say "允许 --skip-tests（ALLOW_DIRECT_STABLE_RELEASE=1，按 7/23 前直接整包规则；测试须已在发布前手动跑过）"
+  else
+    echo "生产发布守门员禁止 --skip-tests。" >&2
+    exit 1
+  fi
 fi

 if [[ "${ALLOW_PORTAL_RELEASE_SCOPE_BYPASS:-0}" == "1" ]]; then
@@ -84,14 +97,14 @@ if [[ "${ALLOW_MINDSPACE_PUBLIC_LINK_ISSUES:-0}" == "1" ]]; then
 fi

 if [[ "${DRY_RUN}" -eq 0 ]]; then
-  say "验证 103 灰度晋升证据"
-  node "${ROOT}/scripts/verify-canary-promotion-evidence.mjs" --host "${HOST}"
+  if [[ "${ALLOW_DIRECT_STABLE_RELEASE:-0}" == "1" ]]; then
+    say "跳过灰度晋升证据（ALLOW_DIRECT_STABLE_RELEASE=1，按 7/23 前直接整包规则）"
+  else
+    say "验证 103 灰度晋升证据"
+    node "${ROOT}/scripts/verify-canary-promotion-evidence.mjs" --host "${HOST}"
+  fi
 fi

-say() {
-  printf '\n[%s] %s\n' "$(date +%H:%M:%S)" "$*"
-}
-
 need_cmd() {
  command -v "$1" >/dev/null 2>&1 || {
    echo "缺少命令: $1" >&2
@@ -336,7 +349,9 @@ REMOTE
 }

 say "验证与当前 main 和 runtime artifact 绑定的 Gate report"
-if ! node "${ROOT}/scripts/verify-release-gate-report.mjs" --artifact "${RUNTIME_ROOT}" >/dev/null 2>&1; then
+if [[ "${ALLOW_DIRECT_STABLE_RELEASE:-0}" == "1" ]]; then
+  say "跳过 Core+Impact Gate report（ALLOW_DIRECT_STABLE_RELEASE=1，按 7/23 前直接整包规则）"
+elif ! node "${ROOT}/scripts/verify-release-gate-report.mjs" --artifact "${RUNTIME_ROOT}" >/dev/null 2>&1; then
  say "执行核心场景 + 变更影响域 Gate"
  DEPLOYED_SHA="${MEMIND_RELEASE_BASE_COMMIT:-}"
  if [[ -z "${DEPLOYED_SHA}" && "${DRY_RUN}" -ne 1 ]]; then
@@ -351,8 +366,10 @@ if ! node "${ROOT}/scripts/verify-release-gate-report.mjs" --artifact "${RUNTIME
    IMPACT_ARGS+=(--deployed-commit "${DEPLOYED_SHA}")
  fi
  node "${ROOT}/scripts/run-release-gate-impact.mjs" "${IMPACT_ARGS[@]}"
+  node "${ROOT}/scripts/verify-release-gate-report.mjs" --artifact "${RUNTIME_ROOT}"
+else
+  node "${ROOT}/scripts/verify-release-gate-report.mjs" --artifact "${RUNTIME_ROOT}"
 fi
-node "${ROOT}/scripts/verify-release-gate-report.mjs" --artifact "${RUNTIME_ROOT}"

 if [[ "${DRY_RUN}" -ne 1 ]]; then
  say "执行 103 只读预检"
@@ -415,7 +432,7 @@ remount_goosed_after_live_swap() {
  local docker_bin="/opt/homebrew/bin/docker"
  local compose_dir="/Users/john/Project/goosed-prod"
  local compose_file="${compose_dir}/docker-compose.prod.yml"
-  local marker_rel="MindSpace/.goosed-remount-${RELEASE_ID}"
+  local marker_rel=".goosed-remount-${RELEASE_ID}"
  local marker_host="${APP_DIR}/${marker_rel}"
  local marker_value="${RELEASE_ID}-$(date +%s)"
  local ready=0
@@ -425,7 +442,7 @@ remount_goosed_after_live_swap() {
    return 1
  fi

-  mkdir -p "${APP_DIR}/MindSpace"
+  mkdir -p "${APP_DIR}"
  printf '%s\n' "${marker_value}" > "${marker_host}"

  say "重建 goosed 容器以刷新 Portal/MindSpace bind mount"
@@ -441,7 +458,9 @@ remount_goosed_after_live_swap() {
    local healthy=1
    local containers=()
    while IFS= read -r container; do
-      [[ -n "${container}" ]] && containers+=("${container}")
+      # Exclude canary/other services that share the compose project label.
+      [[ "${container}" =~ ^goosed-prod-[1-9]$ ]] || continue
+      containers+=("${container}")
    done < <("${docker_bin}" ps \
      --filter 'label=com.docker.compose.project=goosed-prod' \
      --format '{{.Names}}')
@@ -458,8 +477,15 @@ remount_goosed_after_live_swap() {
        healthy=0
        continue
      fi
+      local portal_source
+      portal_source="$("${docker_bin}" inspect "${container}" --format '{{range .Mounts}}{{if eq .Destination "/opt/portal"}}{{.Source}}{{end}}{{end}}' 2>/dev/null || true)"
+      if [[ "${portal_source}" != "${APP_DIR}" ]]; then
+        healthy=0
+        continue
+      fi
      local observed
-      observed="$("${docker_bin}" exec "${container}" sh -lc "cat '${APP_DIR}/${marker_rel}'" 2>/dev/null || true)"
+      # Prefer /opt/portal marker (same bind as PORTAL_RUNTIME_DIR) over nested MindSpace.
+      observed="$("${docker_bin}" exec "${container}" sh -lc "cat '/opt/portal/${marker_rel}'" 2>/dev/null || true)"
      if [[ "${observed}" != "${marker_value}" ]]; then
        healthy=0
      fi
@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+/**
+ * Matrix test for WeChat page phrasing: intent, session continuation, delivery policy.
+ * Run: node scripts/verify-wechat-page-phrasing.mjs
+ */
+import assert from 'node:assert/strict';
+import { classifyWechatIntent } from '../wechat/intent/classifier.mjs';
+import {
+  isWechatSessionPageContinuation,
+  isWechatImmediateContextPageCreate,
+} from '../wechat/intent/page-continuation.mjs';
+import { resolveWechatImageGenerationPolicy, WECHAT_PAGE_THUMBNAIL_MODE } from '../wechat/image-generation-policy.mjs';
+import {
+  isWechatImmediateContextFollowup,
+  shouldDeliverWechatHtmlArtifacts,
+} from '../wechat-mp.mjs';
+import { buildPageGenerateAgentPrompt } from '../wechat/prompts/page-generate.mjs';
+import { buildWechatAgentPrompt } from '../wechat/prompts/chat-general.mjs';
+
+const cases = [
+  {
+    label: '完整单条页面需求',
+    text: '帮我做一个上海旅游攻略页面',
+    expect: {
+      kind: 'page.generate',
+      continuation: false,
+      freshThumbnail: true,
+      deliverHtml: true,
+    },
+  },
+  {
+    label: '写诗（普通聊天）',
+    text: '帮我写一首诗吧',
+    expect: {
+      kind: 'chat.general',
+      continuation: false,
+      freshThumbnail: false,
+      deliverHtml: false,
+    },
+  },
+  {
+    label: '短指代做成页面',
+    text: '把刚才的诗做成页面',
+    expect: {
+      kind: 'page.generate',
+      continuation: true,
+      freshThumbnail: false,
+      deliverHtml: true,
+    },
+  },
+  {
+    label: '精美 HTML 页面',
+    text: '生成一个精美的 HTML 页面',
+    expect: {
+      kind: 'page.generate',
+      continuation: true,
+      freshThumbnail: false,
+      deliverHtml: true,
+    },
+  },
+  {
+    label: '重试上次页面',
+    text: '重试上次页面',
+    expect: {
+      kind: 'page.generate',
+      continuation: true,
+      freshThumbnail: false,
+      deliverHtml: true,
+    },
+  },
+  {
+    label: '修改刚才页面样式',
+    text: '修改刚才生成的页面，背景改成浅蓝色',
+    expect: {
+      kind: 'page.generate',
+      continuation: true,
+      freshThumbnail: false,
+      deliverHtml: true,
+    },
+  },
+  {
+    label: '改页面标题',
+    text: '把页面标题改成《七月清晨》',
+    expect: {
+      kind: 'page.generate',
+      continuation: true,
+      freshThumbnail: false,
+      deliverHtml: true,
+    },
+  },
+  {
+    label: '改诗内容（会话续作）',
+    text: '把诗里第三段改长一点',
+    expect: {
+      kind: 'chat.general',
+      continuation: true,
+      freshThumbnail: false,
+      deliverHtml: true,
+    },
+  },
+];
+
+let passed = 0;
+let failed = 0;
+
+for (const item of cases) {
+  const intent = { msgType: 'text', agentText: item.text, displayText: item.text };
+  const wechatIntent = classifyWechatIntent(intent);
+  const continuation = isWechatSessionPageContinuation(wechatIntent, item.text);
+  const policy = resolveWechatImageGenerationPolicy({
+    text: item.text,
+    isPageGenerate: wechatIntent.kind === 'page.generate',
+    requireFreshPageThumbnail: continuation ? false : true,
+  });
+  const deliverHtml = shouldDeliverWechatHtmlArtifacts(wechatIntent, intent);
+  const errors = [];
+  if (wechatIntent.kind !== item.expect.kind) {
+    errors.push(`kind expected ${item.expect.kind}, got ${wechatIntent.kind}`);
+  }
+  if (continuation !== item.expect.continuation) {
+    errors.push(`continuation expected ${item.expect.continuation}, got ${continuation}`);
+  }
+  const freshRequired = policy.pageThumbnailMode === WECHAT_PAGE_THUMBNAIL_MODE.REQUIRED_FRESH;
+  if (freshRequired !== item.expect.freshThumbnail) {
+    errors.push(`freshThumbnail expected ${item.expect.freshThumbnail}, got ${freshRequired}`);
+  }
+  if (deliverHtml !== item.expect.deliverHtml) {
+    errors.push(`deliverHtml expected ${item.expect.deliverHtml}, got ${deliverHtml}`);
+  }
+  if (item.expect.continuation && wechatIntent.kind === 'page.generate') {
+    const prompt = buildPageGenerateAgentPrompt(intent, {
+      preferImmediateContext: continuation,
+      imagePolicy: policy,
+    });
+    if (!/即时上下文优先/.test(prompt)) errors.push('page prompt missing immediate context block');
+    if (!/write_file 硬门槛/.test(prompt)) errors.push('page prompt missing write_file gate');
+  }
+  if (item.expect.continuation && wechatIntent.kind === 'chat.general') {
+    const prompt = buildWechatAgentPrompt(intent, { preferSessionPageContinuation: continuation });
+    if (!/会话页面续作/.test(prompt)) errors.push('chat prompt missing session continuation block');
+  }
+  if (errors.length) {
+    failed += 1;
+    console.error(`✘ ${item.label}: ${errors.join('; ')}`);
+  } else {
+    passed += 1;
+    console.log(`✔ ${item.label}`);
+  }
+}
+
+assert.equal(isWechatImmediateContextFollowup({ kind: 'page.generate' }, '把刚才的诗做成页面'), true);
+assert.equal(isWechatImmediateContextPageCreate({ kind: 'page.generate' }, '生成一个精美的 HTML 页面'), true);
+
+console.log(`\n=== 汇总: ${passed}/${cases.length} 话术矩阵通过 ===`);
+if (failed > 0) process.exit(1);
@@ -140,3 +140,35 @@ test('buildVisionPayload does not mark billable usage when vision analysis fails
  assert.equal(result?.billableImageCount, 0);
  assert.doesNotMatch(result?.userMessage?.content?.[0]?.text ?? '', /Qwen VL 图片描述/);
 });
+
+test('buildVisionPayload strips image_url content parts for text-only Goose providers', async () => {
+  const result = await buildVisionPayload({
+    userId: 'user-1',
+    publishLayout: { publicUrl: 'https://m.tkmind.cn/MindSpace/user-1' },
+    userMessage: {
+      content: [
+        { type: 'text', text: '这是什么' },
+        {
+          type: 'image_url',
+          image_url: { url: '/api/mindspace/v1/assets/asset-7/download?inline=1' },
+        },
+      ],
+      metadata: {
+        imageUrls: ['/api/mindspace/v1/assets/asset-7/download?inline=1'],
+      },
+    },
+    localFetchAsset: async () => ({
+      buffer: Buffer.from('fake-image'),
+      mimeType: 'image/png',
+    }),
+    llmProviderService: {
+      analyzeImagesWithVision: async () => '蓝色方块',
+    },
+  });
+
+  assert.equal(
+    (result?.userMessage?.content ?? []).some((item) => item?.type === 'image_url'),
+    false,
+  );
+  assert.match(result?.userMessage?.content?.[0]?.text ?? '', /蓝色方块/);
+});
@@ -34,6 +34,7 @@ import {
 import { extractAttachmentText } from './mindspace-attachment-text.mjs';
 import {
  buildCurrentTurnImageScopeNote,
+  conversationHasImageUrlContent,
  extractCurrentTurnImageUrls,
  scrubConversationHistoricalImageAttachments,
 } from './chat-image-turn-scope.mjs';
@@ -974,6 +975,9 @@ export async function buildVisionPayload({
    '不要向用户展示 HTML 代码块。';

  let updatedContent = Array.isArray(userMessage?.content) ? [...userMessage.content] : [];
+  // Text-only Goose providers cannot accept image_url parts. After VL analysis,
+  // keep only text (with the injected vision note) for the agent turn.
+  updatedContent = updatedContent.filter((item) => item?.type !== 'image_url');
  for (const item of imageItems) {
    updatedContent = updatedContent.map((c) => {
      if (c?.type !== 'text' || typeof c.text !== 'string') return c;
@@ -1698,27 +1702,59 @@ export function createTkmindProxy({
        return { changed: false, updated: false, status: upstream.status };
      }
      const session = await upstream.json().catch(() => null);
-      const { conversation, changed } = scrubConversationHistoricalImageAttachments(
-        session?.conversation ?? [],
+      const conversation = Array.isArray(session?.conversation) ? session.conversation : [];
+      const hasImageUrlContent = conversationHasImageUrlContent(conversation, {
+        excludeMessageId: activeId,
+      });
+      const { conversation: scrubbedConversation, changed } = scrubConversationHistoricalImageAttachments(
+        conversation,
        activeId,
      );
-      if (!changed) return { changed: false, updated: false };
+      // Text-only providers (DeepSeek) reject any lingering image_url parts. If Goose
+      // cannot persist a scrub (405/404), callers must rotate to a fresh session.
+      if (!changed && !hasImageUrlContent) {
+        return { changed: false, updated: false, hasImageUrlContent: false };
+      }
+      if (!changed && hasImageUrlContent) {
+        return {
+          changed: true,
+          updated: false,
+          status: 'image_url_content_present',
+          hasImageUrlContent: true,
+        };
+      }
      const update = await apiFetch(
        target,
        apiSecret,
        `/sessions/${encodeURIComponent(sessionId)}`,
        {
          method: 'PUT',
-          body: JSON.stringify({ conversation }),
+          body: JSON.stringify({ conversation: scrubbedConversation }),
        },
      );
      if (!update.ok) {
        console.warn(
          `Historical image scrub skipped for session ${sessionId}: upstream ${update.status}`,
        );
-        return { changed: true, updated: false, status: update.status };
+        return {
+          changed: true,
+          updated: false,
+          status: update.status,
+          hasImageUrlContent:
+            hasImageUrlContent
+            || conversationHasImageUrlContent(scrubbedConversation, {
+              excludeMessageId: activeId,
+            }),
+        };
      }
-      return { changed: true, updated: true, status: update.status };
+      return {
+        changed: true,
+        updated: true,
+        status: update.status,
+        hasImageUrlContent: conversationHasImageUrlContent(scrubbedConversation, {
+          excludeMessageId: activeId,
+        }),
+      };
    } catch (err) {
      console.warn(
        'Historical image scrub skipped:',
@@ -1938,7 +1974,17 @@ export function createTkmindProxy({
    if (!user) throw new Error('用户不存在');
    if (requireHistoricalImageIsolation || messageHasImages(userMessage)) {
      const imageIsolation = await syncHistoricalImageTurnIsolation(sessionId, userMessage?.id);
-      if (requireHistoricalImageIsolation && imageIsolation.changed && !imageIsolation.updated) {
+      const scrubUnsupported =
+        imageIsolation.changed
+        && !imageIsolation.updated
+        && (
+          requireHistoricalImageIsolation
+          || imageIsolation.hasImageUrlContent
+          || Number(imageIsolation.status) === 404
+          || Number(imageIsolation.status) === 405
+          || imageIsolation.status === 'image_url_content_present'
+        );
+      if (scrubUnsupported) {
        const error = new Error(
          `historical_image_session_update_unsupported:${imageIsolation.status ?? 'unknown'}`,
        );
@@ -1534,6 +1534,58 @@ test('submitSessionReplyForUser fails closed when historical image scrub is unsu
  });
 });

+test('submitSessionReplyForUser rotates when assistant history still has image_url', async () => {
+  await withFakeGoosedSession(async ({ apiTarget, workingDir, replyBodies }) => {
+    const proxy = createTkmindProxy({
+      apiTarget,
+      apiSecret: 'test-secret',
+      userAuth: {
+        ...createMemoryTestUserAuth(workingDir),
+        async ownsSession() {
+          return true;
+        },
+        async canUseChat() {
+          return { ok: true };
+        },
+        async getUserById() {
+          return { id: 'user-1' };
+        },
+        async resolveUserPolicies() {
+          return { unrestricted: true, policies: {} };
+        },
+      },
+    });
+
+    await assert.rejects(
+      proxy.submitSessionReplyForUser(
+        'user-1',
+        'session-1',
+        'request-after-assistant-image',
+        {
+          id: 'message-current',
+          role: 'user',
+          content: [{ type: 'text', text: '这张图是什么' }],
+          metadata: { imageUrls: ['https://example.com/new.png'] },
+        },
+        { requireHistoricalImageIsolation: true },
+      ),
+      /historical_image_session_update_unsupported:image_url_content_present/,
+    );
+    assert.equal(replyBodies.length, 0);
+  }, {
+    conversation: [
+      {
+        id: 'assistant-old-image',
+        role: 'assistant',
+        content: [
+          { type: 'text', text: '我看到了图片' },
+          { type: 'image_url', image_url: { url: 'https://example.com/old.png' } },
+        ],
+      },
+    ],
+  });
+});
+
 test('visual fallback session removes read_image while preserving the text task path', async () => {
  await withFakeGoosedSession(async ({
    apiTarget,
@@ -31,6 +31,11 @@ import {
  isPageDataDevIntent,
  isPageDataIntent,
 } from './chat-skills.mjs';
+import {
+  isWechatImmediateContextPageCreate,
+  isWechatSessionPageContinuation,
+  isWechatContentEditFollowup,
+} from './wechat/intent/page-continuation.mjs';
 import { resolvePageGenerateOutcome } from './wechat/handlers/page-generate.mjs';
 import {
  buildWechatImageRunMetadata,
@@ -40,6 +45,7 @@ import {
 import { buildWechatAgentPrompt } from './wechat/prompts/chat-general.mjs';
 import {
  buildPageGenerateAgentPrompt,
+  buildImmediateContextPageRepairPrompt,
  buildPagePublishFailureText,
 } from './wechat/prompts/page-generate.mjs';
 import {
@@ -974,6 +980,27 @@ export function shouldForceNewWechatAgentSession(wechatIntent, resetCandidate) {
  );
 }

+export function isWechatImmediateContextFollowup(wechatIntent, text) {
+  return isWechatImmediateContextPageCreate(wechatIntent, text);
+}
+
+export { isWechatSessionPageContinuation };
+
+export function shouldRotateUnlinkedWechatRoute({
+  routeUpdatedAt,
+  wechatMessageCount,
+  snapshotMessageCount,
+  now = Date.now(),
+} = {}) {
+  const updatedAt = Number(routeUpdatedAt ?? 0);
+  return (
+    updatedAt > 0 &&
+    Number(now) - updatedAt > 60_000 &&
+    Number(wechatMessageCount) === 0 &&
+    Number(snapshotMessageCount ?? 0) > 0
+  );
+}
+
 export function isWechatPageDataTask(text) {
  return isPageDataIntent(text) || isPageDataDevIntent(text);
 }
@@ -994,10 +1021,12 @@ export function isRecoverableWechatAgentSessionError(message) {
 }

 export function shouldDeliverWechatHtmlArtifacts(wechatIntent, intent) {
+  const text = String(intent?.agentText ?? intent?.displayText ?? '').trim();
  return (
    wechatIntent?.kind === 'page.generate'
-    || looksLikeHtmlGenerationIntent(intent?.agentText)
-    || isPageDataIntent(intent?.agentText)
+    || looksLikeHtmlGenerationIntent(text)
+    || isPageDataIntent(text)
+    || (wechatIntent?.kind === 'chat.general' && isWechatContentEditFollowup(text))
  );
 }

@@ -1837,7 +1866,9 @@ export function createWechatMpService({
    imagePolicy,
    notifyFailure = true,
  }) => {
-    if (imagePolicy?.pageThumbnailMode !== WECHAT_PAGE_THUMBNAIL_MODE.REQUIRED_FRESH) return;
+    if (imagePolicy?.pageThumbnailMode !== WECHAT_PAGE_THUMBNAIL_MODE.REQUIRED_FRESH) {
+      return { ok: true, reason: null, matchRelativePaths: [] };
+    }
    const images = collectWechatGeneratedImages(replyRequestMessages(reply));
    const ensureFresh =
      htmlDeliveryAuthority
@@ -1884,7 +1915,15 @@ export function createWechatMpService({
      );
    }
    if (verification?.ok) {
-      return;
+      if (verification.reason === 'workspace_thumbnail_fallback') {
+        logger.info?.(
+          'WeChat MP page delivery accepted workspace thumbnail fallback:',
+          {
+            matchRelativePaths: verification.matchRelativePaths ?? [],
+          },
+        );
+      }
+      return verification;
    }
    logger.warn?.(
      'WeChat MP fresh thumbnail verification failed:',
@@ -1960,6 +1999,7 @@ export function createWechatMpService({
    userId,
    openid,
    forceNew = false,
+    retainUnlinkedRoute = false,
    userContext = null,
  }) => {
    if (forceNew) {
@@ -1978,42 +2018,58 @@ export function createWechatMpService({
        config.sessionIdleRotateMs > 0 &&
        routeUpdatedAt > 0 &&
        now - routeUpdatedAt > config.sessionIdleRotateMs;
+      let routeWechatMessageCount = null;
+      let routeSnapshotMessageCount = null;
      let routeMessageCount = 0;
      if (config.sessionMessageRotateCount > 0) {
-        const counts = [];
-        if (typeof userAuth.countWechatAgentSessionMessages === 'function') {
-          counts.push(
-            userAuth
-              .countWechatAgentSessionMessages({
-                appId: config.appId,
-                openid,
-                agentSessionId: existingRoute.agentSessionId,
-              })
-              .catch((err) => {
-                logger.warn?.('WeChat MP route message count lookup failed:', err);
-                return 0;
-              }),
-          );
-        }
-        if (typeof userAuth.getWechatAgentSessionSnapshotMessageCount === 'function') {
-          counts.push(
-            userAuth
-              .getWechatAgentSessionSnapshotMessageCount(existingRoute.agentSessionId)
-              .catch((err) => {
-                logger.warn?.('WeChat MP snapshot message count lookup failed:', err);
-                return 0;
-              }),
-          );
-        }
-        if (counts.length > 0) {
-          const resolved = await Promise.all(counts);
-          routeMessageCount = Math.max(0, ...resolved.map((value) => Number(value) || 0));
-        }
+        [routeWechatMessageCount, routeSnapshotMessageCount] = await Promise.all([
+          typeof userAuth.countWechatAgentSessionMessages === 'function'
+            ? userAuth
+                .countWechatAgentSessionMessages({
+                  appId: config.appId,
+                  openid,
+                  agentSessionId: existingRoute.agentSessionId,
+                })
+                .then((value) => Number(value) || 0)
+                .catch((err) => {
+                  logger.warn?.('WeChat MP route message count lookup failed:', err);
+                  return null;
+                })
+            : null,
+          typeof userAuth.getWechatAgentSessionSnapshotMessageCount === 'function'
+            ? userAuth
+                .getWechatAgentSessionSnapshotMessageCount(existingRoute.agentSessionId)
+                .then((value) => Number(value) || 0)
+                .catch((err) => {
+                  logger.warn?.('WeChat MP snapshot message count lookup failed:', err);
+                  return null;
+                })
+            : null,
+        ]);
+        routeMessageCount = Math.max(
+          0,
+          Number(routeWechatMessageCount) || 0,
+          Number(routeSnapshotMessageCount) || 0,
+        );
      }
      const routeIsTooLong =
        config.sessionMessageRotateCount > 0 &&
        Number(routeMessageCount ?? 0) >= config.sessionMessageRotateCount;
-      if (routeIsIdle || routeIsTooLong) {
+      const routeHasUnlinkedConversation = shouldRotateUnlinkedWechatRoute({
+        routeUpdatedAt,
+        wechatMessageCount: routeWechatMessageCount,
+        snapshotMessageCount: routeSnapshotMessageCount,
+        now,
+      });
+      const shouldRotateUnlinkedRoute =
+        routeHasUnlinkedConversation && !retainUnlinkedRoute;
+      if (routeIsIdle || routeIsTooLong || shouldRotateUnlinkedRoute) {
+        if (shouldRotateUnlinkedRoute) {
+          logger.warn?.('WeChat MP orphaned route rotated before reuse:', {
+            agentSessionId: existingRoute.agentSessionId,
+            snapshotMessageCount: routeSnapshotMessageCount,
+          });
+        }
        await userAuth.clearWechatAgentRoute(config.appId, openid);
        rememberedWechatContexts.delete(existingRoute.agentSessionId);
      } else {
@@ -2271,7 +2327,12 @@ export function createWechatMpService({
    }
  };

-  const prepareWechatAgentUserMessage = async ({ userId, sessionId, userMessage }) => {
+  const prepareWechatAgentUserMessage = async ({
+    userId,
+    sessionId,
+    userMessage,
+    preserveAgentPrompt = false,
+  }) => {
    if (
      !chatIntentRouter?.resolveAgentMemoryContext
      || !chatIntentRouter?.applyAgentOrchestration
@@ -2296,8 +2357,17 @@ export function createWechatMpService({
      ) {
        return userMessage;
      }
-      return chatIntentRouter.applyAgentOrchestration(
-        userMessage,
+      const orchestrationMessage = preserveAgentPrompt
+        ? {
+            ...userMessage,
+            metadata: {
+              ...(userMessage?.metadata ?? {}),
+              displayText: messageVisibleText(userMessage),
+            },
+          }
+        : userMessage;
+      const prepared = chatIntentRouter.applyAgentOrchestration(
+        orchestrationMessage,
        {
          route: 'agent_orchestration',
          reason: '微信服务号消息由 Agent 处理',
@@ -2305,6 +2375,14 @@ export function createWechatMpService({
        },
        { memoryContext },
      );
+      if (!preserveAgentPrompt) return prepared;
+      return {
+        ...prepared,
+        metadata: {
+          ...(prepared?.metadata ?? {}),
+          displayText: displayText || undefined,
+        },
+      };
    } catch (err) {
      logger.warn?.(
        'WeChat MP agent memory resolve skipped:',
@@ -2361,22 +2439,26 @@ export function createWechatMpService({
    const agentReplyTimeoutMs = reliabilityEnabled ? config.agentReplyTimeoutMs : 0;
    const resetCandidate =
      intent.msgType === 'text' || intent.msgType === 'voice' ? intent.agentText : '';
+    const isPageDataRequest = isWechatPageDataTask(resetCandidate);
+    const htmlArtifactDeliveryExpected = shouldDeliverWechatHtmlArtifacts(wechatIntent, intent);
+    const sessionPageContinuation =
+      isWechatSessionPageContinuation(wechatIntent, resetCandidate);
    const imagePolicy = resolveWechatImageGenerationPolicy({
      text: resetCandidate,
      isPageGenerate: wechatIntent.kind === 'page.generate',
-      requireFreshPageThumbnail: config.requireFreshPageThumbnail,
+      requireFreshPageThumbnail:
+        config.requireFreshPageThumbnail && !sessionPageContinuation,
    });
    // Page Data delivery owns persistent files, datasets and two publication
    // policies. Reusing a conversational route here can make a new request
    // inspect/retry unrelated historical pages from that session.
-    const isPageDataRequest = isWechatPageDataTask(resetCandidate);
-    const htmlArtifactDeliveryExpected = shouldDeliverWechatHtmlArtifacts(wechatIntent, intent);
    const forceNew = shouldForceNewWechatAgentSession(wechatIntent, resetCandidate);
    let route = await ensureWechatAgentSession({
      userId: user.userId,
      openid: inbound.fromUserName,
      userContext: user,
      forceNew,
+      retainUnlinkedRoute: sessionPageContinuation,
    });
    let sessionId = route.sessionId;
    await ensureSessionProvider(sessionId);
@@ -2417,136 +2499,171 @@ export function createWechatMpService({
          ? buildPageGenerateAgentPrompt(intent, {
              wantsDocx: wechatIntent.wantsDocx,
              imagePolicy,
+              preferImmediateContext: sessionPageContinuation,
            })
-          : buildWechatAgentPrompt(intent, { imagePolicy });
-      const reply = await executeSessionReply(
-        (pathname, init) => fetchForSession(sessionId, pathname, init),
-        sessionId,
-        requestId,
-        agentPrompt,
-        buildIntentMetadata(intent, {
-          mediaAnalysisEnabled,
-          imagePolicy,
-          pgRequired: isPageDataRequest,
-        }),
-        {
-          prepareUserMessage: (userMessage) => prepareWechatAgentUserMessage({
-            userId: user.userId,
-            sessionId,
-            userMessage,
+          : buildWechatAgentPrompt(intent, {
+              imagePolicy,
+              preferSessionPageContinuation: sessionPageContinuation,
+            });
+      const maxImmediateContextPageAttempts =
+        wechatIntent.kind === 'page.generate' && sessionPageContinuation ? 2 : 1;
+      let reply;
+      let publishArtifacts = [];
+      let confirmedArtifacts = [];
+      let verifiedArtifacts = [];
+      let generatedImages = [];
+      let linkExistsForRequest = linkExists;
+      for (let pageAttempt = 1; pageAttempt <= maxImmediateContextPageAttempts; pageAttempt += 1) {
+        const activeAgentPrompt =
+          pageAttempt === 1 ? agentPrompt : buildImmediateContextPageRepairPrompt(intent);
+        const activeRequestId = pageAttempt === 1 ? requestId : crypto.randomUUID();
+        reply = await executeSessionReply(
+          (pathname, init) => fetchForSession(sessionId, pathname, init),
+          sessionId,
+          activeRequestId,
+          activeAgentPrompt,
+          buildIntentMetadata(intent, {
+            mediaAnalysisEnabled,
+            imagePolicy,
+            pgRequired: isPageDataRequest,
          }),
-          submitReply: submitSessionReply
-            ? ({ requestId: replyRequestId, userMessage }) =>
-                submitSessionReply({
-                  userId: user.userId,
-                  sessionId,
-                  requestId: replyRequestId,
-                  userMessage,
-                  options: { requireHistoricalImageIsolation: true },
-                })
-            : null,
-          timeoutMs: agentReplyTimeoutMs,
-        },
-      );
-      const generatedImages = collectWechatGeneratedImages(replyRequestMessages(reply));
-      if (imagePolicy.standaloneImageMode === 'required' && generatedImages.length === 0) {
-        const error = new Error('图片生成没有获得本轮新的有效位图，请稍后重试');
-        error.code = 'WECHAT_IMAGE_GENERATION_REQUIRED';
-        throw error;
-      }
-      const {
-        publishedArtifacts,
-        verifiedArtifacts,
-        expectedArtifacts,
-        recentArtifacts,
-        confirmedArtifacts,
-        validReplyUrls,
-        hasValidReplyLink,
-      } = await resolveHtmlPublishArtifacts({
-        reply,
-        intent,
-        requestStartedAt,
-        userId: user.userId,
-        sessionId,
-        onPageGenerated,
-        allowRecentArtifacts: htmlArtifactDeliveryExpected,
-        htmlDeliveryAuthority,
-      });
-      const linkExistsForRequest =
-        createPreparedPublicHtmlLinkExists({
-          userId: user.userId,
-          prepared: {
-            validReplyUrls,
-            confirmedArtifacts,
+          {
+            prepareUserMessage: (userMessage) => prepareWechatAgentUserMessage({
+              userId: user.userId,
+              sessionId,
+              userMessage,
+              preserveAgentPrompt: sessionPageContinuation,
+            }),
+            submitReply: submitSessionReply
+              ? ({ requestId: replyRequestId, userMessage }) =>
+                  submitSessionReply({
+                    userId: user.userId,
+                    sessionId,
+                    requestId: replyRequestId,
+                    userMessage,
+                    options: { requireHistoricalImageIsolation: true },
+                  })
+              : null,
+            timeoutMs: agentReplyTimeoutMs,
          },
-          fallback: linkExists,
-        });
-      const hasValidLinkInReply =
-        hasValidReplyLink ||
-        await hasAnyValidPublishedHtmlLink(
-          reply?.text,
-          linkExistsForRequest,
-          { confirmedArtifacts },
        );
-      const replyHasPublicLinks = hasAnyPublicHtmlLink(reply?.text);
-      const suspiciousPublishClaim =
-        expectedArtifacts.length === 0 &&
-        recentArtifacts.length === 0 &&
-        (await isSuspiciousHtmlPublishClaimReply(reply, intent, { linkExists: linkExistsForRequest }));
-      const htmlGenerationNeedsRetry = shouldRetryHtmlGenerationReply({
-        reply,
-        intent,
-        confirmedArtifacts,
-        hasValidLinkInReply,
-      });
-      const bareCompletionReply = isSuspiciousBareCompletionReply(reply, intent);
-      let publishArtifacts =
-        htmlArtifactDeliveryExpected || publishedArtifacts.length > 0
-          ? selectSendableHtmlArtifacts({ verifiedArtifacts, confirmedArtifacts })
-          : [];
-
-      if (wechatIntent.kind === 'page.generate') {
-        const pageOutcome = resolvePageGenerateOutcome({
+        generatedImages = collectWechatGeneratedImages(replyRequestMessages(reply));
+        if (imagePolicy.standaloneImageMode === 'required' && generatedImages.length === 0) {
+          const error = new Error('图片生成没有获得本轮新的有效位图，请稍后重试');
+          error.code = 'WECHAT_IMAGE_GENERATION_REQUIRED';
+          throw error;
+        }
+        const {
+          publishedArtifacts,
+          expectedArtifacts,
+          recentArtifacts,
+          confirmedArtifacts: resolvedConfirmedArtifacts,
+          verifiedArtifacts: resolvedVerifiedArtifacts,
+          validReplyUrls,
+          hasValidReplyLink,
+        } = await resolveHtmlPublishArtifacts({
          reply,
-          confirmedArtifacts,
-          verifiedArtifacts,
-          suspiciousPublishClaim,
-          bareCompletionReply,
-          htmlGenerationNeedsRetry,
-          replyHasPublicLinks,
+          intent,
+          requestStartedAt,
+          userId: user.userId,
+          sessionId,
+          onPageGenerated,
+          allowRecentArtifacts: htmlArtifactDeliveryExpected,
+          htmlDeliveryAuthority,
        });
-        if (pageOutcome.action === 'session_retry') {
+        confirmedArtifacts = resolvedConfirmedArtifacts;
+        verifiedArtifacts = resolvedVerifiedArtifacts;
+        linkExistsForRequest =
+          createPreparedPublicHtmlLinkExists({
+            userId: user.userId,
+            prepared: {
+              validReplyUrls,
+              confirmedArtifacts,
+            },
+            fallback: linkExists,
+          });
+        const hasValidLinkInReply =
+          hasValidReplyLink ||
+          await hasAnyValidPublishedHtmlLink(
+            reply?.text,
+            linkExistsForRequest,
+            { confirmedArtifacts },
+          );
+        const replyHasPublicLinks = hasAnyPublicHtmlLink(reply?.text);
+        const suspiciousPublishClaim =
+          expectedArtifacts.length === 0 &&
+          recentArtifacts.length === 0 &&
+          (await isSuspiciousHtmlPublishClaimReply(reply, intent, { linkExists: linkExistsForRequest }));
+        const htmlGenerationNeedsRetry = shouldRetryHtmlGenerationReply({
+          reply,
+          intent,
+          confirmedArtifacts,
+          hasValidLinkInReply,
+        });
+        const bareCompletionReply = isSuspiciousBareCompletionReply(reply, intent);
+        publishArtifacts =
+          htmlArtifactDeliveryExpected || publishedArtifacts.length > 0
+            ? selectSendableHtmlArtifacts({ verifiedArtifacts, confirmedArtifacts })
+            : [];
+
+        if (wechatIntent.kind === 'page.generate') {
+          const pageOutcome = resolvePageGenerateOutcome({
+            reply,
+            confirmedArtifacts,
+            verifiedArtifacts,
+            suspiciousPublishClaim,
+            bareCompletionReply,
+            htmlGenerationNeedsRetry,
+            replyHasPublicLinks,
+          });
+          if (pageOutcome.action === 'session_retry') {
+            throw new Error('stale_session_poisoned_completion');
+          }
+          if (pageOutcome.action === 'fail') {
+            if (
+              pageAttempt < maxImmediateContextPageAttempts &&
+              pageOutcome.reason === 'skill_or_stub'
+            ) {
+              logger.warn?.('WeChat MP immediate-context page repair retry:', {
+                sessionId,
+                userId: user.userId,
+                pageAttempt,
+              });
+              continue;
+            }
+            const text = pageOutcome.failureText ?? buildPagePublishFailureText();
+            try {
+              await sendCustomerServiceText(inbound.fromUserName, text, user);
+            } catch (sendErr) {
+              logger.error?.('WeChat MP page generate failure notice failed:', sendErr);
+            }
+            throw markWechatUserNotified(new Error(text));
+          }
+          publishArtifacts = pageOutcome.artifacts ?? publishArtifacts;
+          break;
+        }
+
+        if (looksLikeHtmlGenerationIntent(intent?.agentText)) {
+          if (
+            suspiciousPublishClaim ||
+            bareCompletionReply ||
+            (htmlGenerationNeedsRetry && replyHasPublicLinks && confirmedArtifacts.length === 0)
+          ) {
+            throw new Error('stale_session_poisoned_completion');
+          }
+          if (htmlGenerationNeedsRetry) {
+            const text = buildHtmlPublishFailureText();
+            try {
+              await sendCustomerServiceText(inbound.fromUserName, text, user);
+            } catch (sendErr) {
+              logger.error?.('WeChat MP html publish failure notice failed:', sendErr);
+            }
+            throw markWechatUserNotified(new Error(text));
+          }
+        } else if (htmlGenerationNeedsRetry || suspiciousPublishClaim) {
          throw new Error('stale_session_poisoned_completion');
        }
-        if (pageOutcome.action === 'fail') {
-          const text = pageOutcome.failureText ?? buildPagePublishFailureText();
-          try {
-            await sendCustomerServiceText(inbound.fromUserName, text, user);
-          } catch (sendErr) {
-            logger.error?.('WeChat MP page generate failure notice failed:', sendErr);
-          }
-          throw markWechatUserNotified(new Error(text));
-        }
-        publishArtifacts = pageOutcome.artifacts ?? publishArtifacts;
-      } else if (looksLikeHtmlGenerationIntent(intent?.agentText)) {
-        if (
-          suspiciousPublishClaim ||
-          bareCompletionReply ||
-          (htmlGenerationNeedsRetry && replyHasPublicLinks && confirmedArtifacts.length === 0)
-        ) {
-          throw new Error('stale_session_poisoned_completion');
-        }
-        if (htmlGenerationNeedsRetry) {
-          const text = buildHtmlPublishFailureText();
-          try {
-            await sendCustomerServiceText(inbound.fromUserName, text, user);
-          } catch (sendErr) {
-            logger.error?.('WeChat MP html publish failure notice failed:', sendErr);
-          }
-          throw markWechatUserNotified(new Error(text));
-        }
-      } else if (htmlGenerationNeedsRetry || suspiciousPublishClaim) {
-        throw new Error('stale_session_poisoned_completion');
+        break;
      }
      await reviewWechatPageDataArtifacts({
        user,
@@ -2559,8 +2676,13 @@ export function createWechatMpService({
        forcePageData: isPageDataRequest,
      });
      if (wechatIntent.kind === 'page.generate') {
+        const deliveryArtifacts = uniqueArtifactsByUrl([
+          ...publishArtifacts,
+          ...confirmedArtifacts,
+          ...verifiedArtifacts,
+        ]);
        await enforceFreshPageThumbnailDelivery({
-          artifacts: publishArtifacts,
+          artifacts: deliveryArtifacts,
          reply,
          openid: inbound.fromUserName,
          user,
@@ -2569,6 +2691,27 @@ export function createWechatMpService({
          imagePolicy,
          notifyFailure: false,
        });
+        if (deliveryArtifacts.length > 0) {
+          publishArtifacts = deliveryArtifacts;
+        } else {
+          const recovered = await resolveHtmlPublishArtifacts({
+            reply,
+            intent,
+            requestStartedAt,
+            userId: user.userId,
+            sessionId,
+            onPageGenerated,
+            allowRecentArtifacts: true,
+            htmlDeliveryAuthority,
+          });
+          publishArtifacts = uniqueArtifactsByUrl([
+            ...selectSendableHtmlArtifacts({
+              verifiedArtifacts: recovered.verifiedArtifacts,
+              confirmedArtifacts: recovered.confirmedArtifacts,
+            }),
+            ...recovered.confirmedArtifacts,
+          ]);
+        }
      }
      const pageDataOutcome = await enforcePageDataCollectDelivery({
        reply,
@@ -2657,6 +2800,21 @@ export function createWechatMpService({
        sessionId
        && (isRecoverableWechatAgentSessionError(message) || isWechatAgentApiErrorText(message));
      if (mayBeStaleSession) {
+        if (sessionPageContinuation) {
+          await userAuth.clearWechatAgentRoute(config.appId, inbound.fromUserName).catch((clearErr) => {
+            logger.warn?.('WeChat MP contextual follow-up route clear failed:', clearErr);
+          });
+          const text =
+            '我没能可靠确认“做成页面”指的是哪段内容，已经停止沿用旧主题。请把要做成页面的主题或原文再发一次。';
+          try {
+            await sendCustomerServiceText(inbound.fromUserName, text, user);
+          } catch (sendErr) {
+            logger.error?.('WeChat MP contextual follow-up notice failed:', sendErr);
+          }
+          const contextualError = markWechatUserNotified(new Error(text));
+          contextualError.wechatAgentSessionId = sessionId;
+          throw contextualError;
+        }
        route = await ensureWechatAgentSession({
          userId: user.userId,
          openid: inbound.fromUserName,
@@ -2673,8 +2831,12 @@ export function createWechatMpService({
            ? buildPageGenerateAgentPrompt(intent, {
                wantsDocx: wechatIntent.wantsDocx,
                imagePolicy,
+                preferImmediateContext: sessionPageContinuation,
              })
-            : buildWechatAgentPrompt(intent, { imagePolicy });
+            : buildWechatAgentPrompt(intent, {
+                imagePolicy,
+                preferSessionPageContinuation: sessionPageContinuation,
+              });
        const reply = await executeSessionReply(
          (pathname, init) => fetchForSession(sessionId, pathname, init),
          sessionId,
@@ -2690,6 +2852,7 @@ export function createWechatMpService({
              userId: user.userId,
              sessionId,
              userMessage,
+              preserveAgentPrompt: sessionPageContinuation,
            }),
            submitReply: submitSessionReply
              ? ({ requestId: replyRequestId, userMessage }) =>
@@ -2812,8 +2975,13 @@ export function createWechatMpService({
          forcePageData: isPageDataRequest,
        });
        if (wechatIntent.kind === 'page.generate') {
+          const deliveryArtifacts = uniqueArtifactsByUrl([
+            ...publishArtifacts,
+            ...confirmedArtifacts,
+            ...verifiedArtifacts,
+          ]);
          await enforceFreshPageThumbnailDelivery({
-            artifacts: publishArtifacts,
+            artifacts: deliveryArtifacts,
            reply,
            openid: inbound.fromUserName,
            user,
@@ -2821,6 +2989,27 @@ export function createWechatMpService({
            sessionId,
            imagePolicy,
          });
+          if (deliveryArtifacts.length > 0) {
+            publishArtifacts = deliveryArtifacts;
+          } else {
+            const recovered = await resolveHtmlPublishArtifacts({
+              reply,
+              intent,
+              requestStartedAt: retryStartedAt,
+              userId: user.userId,
+              sessionId,
+              onPageGenerated,
+              allowRecentArtifacts: true,
+              htmlDeliveryAuthority,
+            });
+            publishArtifacts = uniqueArtifactsByUrl([
+              ...selectSendableHtmlArtifacts({
+                verifiedArtifacts: recovered.verifiedArtifacts,
+                confirmedArtifacts: recovered.confirmedArtifacts,
+              }),
+              ...recovered.confirmedArtifacts,
+            ]);
+          }
        }
        const pageDataOutcome = await enforcePageDataCollectDelivery({
          reply,
@@ -16,7 +16,11 @@ import {
  sanitizeWechatAgentOutboundText,
  loadWechatMpConfig,
  maybeAttachPublishedHtmlLink,
+  isWechatImmediateContextFollowup,
+  isWechatSessionPageContinuation,
+  shouldDeliverWechatHtmlArtifacts,
  isWechatPageDataTask,
+  shouldRotateUnlinkedWechatRoute,
  shouldRetryHtmlGenerationReply,
  shouldForceNewWechatAgentSession,
  splitWechatText,
@@ -27,6 +31,9 @@ import {
  WECHAT_CUSTOMER_TEXT_MAX_BYTES,
 } from './wechat-mp.mjs';
 import { createChatIntentRouter } from './chat-intent-router.mjs';
+import { classifyWechatIntent } from './wechat/intent/classifier.mjs';
+import { buildPageGenerateAgentPrompt, buildImmediateContextPageRepairPrompt } from './wechat/prompts/page-generate.mjs';
+import { resolveWechatImageGenerationPolicy, WECHAT_PAGE_THUMBNAIL_MODE } from './wechat/image-generation-policy.mjs';
 import {
  ensureWechatFreshPageThumbnailsAtWorkspace,
  prepareWechatHtmlDeliveryAtWorkspace,
@@ -333,6 +340,168 @@ test('Page Data requests always rotate away from an existing WeChat route', () =
  assert.equal(shouldForceNewWechatAgentSession({ kind: 'chat.general' }, '换新会话'), true);
 });

+test('WeChat immediate-context page guard does not match complete page requests', () => {
+  const pageIntent = { kind: 'page.generate' };
+  assert.equal(isWechatImmediateContextFollowup(pageIntent, '帮我做成页面吧'), true);
+  assert.equal(isWechatImmediateContextFollowup(pageIntent, '把刚才的诗做成页面'), true);
+  assert.equal(isWechatImmediateContextFollowup(pageIntent, '生成一个精美的 HTML 页面'), true);
+  assert.equal(isWechatImmediateContextFollowup(pageIntent, '生成一个HTML页面'), true);
+  assert.equal(isWechatImmediateContextFollowup(pageIntent, '生成一个上海旅游攻略页面'), false);
+  assert.equal(isWechatImmediateContextFollowup(pageIntent, '帮我做一个上海旅游页面'), false);
+  assert.equal(
+    isWechatImmediateContextFollowup({ kind: 'chat.general' }, '帮我做成页面吧'),
+    false,
+  );
+
+  const guardedPrompt = buildPageGenerateAgentPrompt(
+    { agentText: '帮我做成页面吧' },
+    { preferImmediateContext: true },
+  );
+  const ordinaryPrompt = buildPageGenerateAgentPrompt({
+    agentText: '帮我做一个上海旅游页面',
+  });
+  assert.match(guardedPrompt, /即时上下文优先/);
+  assert.match(guardedPrompt, /禁止用长期记忆、历史偏好或旧任务替换主题/);
+  assert.match(guardedPrompt, /write_file 硬门槛/);
+  assert.match(guardedPrompt, /禁止只调用 load_skill、todo_write 或 generate_image 就回复/);
+  assert.doesNotMatch(ordinaryPrompt, /即时上下文优先/);
+  assert.doesNotMatch(ordinaryPrompt, /write_file 硬门槛/);
+});
+
+test('WeChat session page continuation covers retry, edit, and poem edits', () => {
+  const retry = classifyWechatIntent({ msgType: 'text', agentText: '重试上次页面' });
+  assert.equal(retry.kind, 'page.generate');
+  assert.equal(isWechatSessionPageContinuation(retry, '重试上次页面'), true);
+  const edit = classifyWechatIntent({ msgType: 'text', agentText: '把页面标题改成《七月清晨》' });
+  assert.equal(edit.kind, 'page.generate');
+  assert.equal(isWechatSessionPageContinuation(edit, edit.topic), true);
+  const poemEdit = classifyWechatIntent({ msgType: 'text', agentText: '把诗里第三段改长一点' });
+  assert.equal(poemEdit.kind, 'chat.general');
+  assert.equal(isWechatSessionPageContinuation(poemEdit, '把诗里第三段改长一点'), true);
+  assert.equal(
+    shouldDeliverWechatHtmlArtifacts(poemEdit, { agentText: '把诗里第三段改长一点' }),
+    true,
+  );
+});
+
+test('WeChat immediate-context page skips fresh thumbnail requirement', () => {
+  const policy = resolveWechatImageGenerationPolicy({
+    text: '把刚才的诗做成页面',
+    isPageGenerate: true,
+    requireFreshPageThumbnail: false,
+  });
+  assert.equal(policy.pageThumbnailMode, WECHAT_PAGE_THUMBNAIL_MODE.AUTO);
+  const prompt = buildPageGenerateAgentPrompt(
+    { agentText: '把刚才的诗做成页面' },
+    { preferImmediateContext: true, imagePolicy: policy },
+  );
+  assert.doesNotMatch(prompt, /服务号页面新缩略图硬要求/);
+});
+
+test('WeChat immediate-context page repair prompt requires write_file', () => {
+  const repairPrompt = buildImmediateContextPageRepairPrompt({ agentText: '把刚才的诗做成页面' });
+  assert.match(repairPrompt, /未 write_file 落盘 HTML/);
+  assert.match(repairPrompt, /禁止再次只 generate_image/);
+});
+
+test('WeChat immediate-context page retains an unlinked route with adjacent snapshot', async () => {
+  const clearedRoutes = [];
+  const startedSessions = [];
+  let activeRoute = {
+    agentSessionId: 'session-poem',
+    updatedAt: Date.now() - 120_000,
+  };
+  const service = createBoundWechatService({
+    config: {
+      sessionMessageRotateCount: 0,
+      sessionIdleRotateMs: 0,
+    },
+    userAuth: {
+      async getWechatAgentRoute() {
+        return activeRoute;
+      },
+      async clearWechatAgentRoute(_appId, openid) {
+        clearedRoutes.push(openid);
+        activeRoute = null;
+      },
+      async countWechatAgentSessionMessages() {
+        return 0;
+      },
+      async getWechatAgentSessionSnapshotMessageCount() {
+        return 5;
+      },
+      async touchWechatAgentRoute(_appId, _openid, updatedAt) {
+        activeRoute = { ...activeRoute, updatedAt };
+      },
+    },
+    startAgentSession: async (sessionId) => {
+      startedSessions.push(sessionId);
+      return sessionId;
+    },
+    sessionApiFetch: async (pathname) => {
+      if (String(pathname).includes('/tools')) {
+        return new Response(JSON.stringify({ tools: [] }), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        });
+      }
+      return new Response(JSON.stringify({ conversation: [] }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    },
+    submitSessionReply: async () => ({
+      ok: true,
+      conversation: [{ role: 'assistant', content: [{ type: 'text', text: 'ok' }] }],
+    }),
+  });
+
+  const timestamp = '1710000000';
+  const nonce = 'nonce-immediate-context-route';
+  await service.handleInboundMessage(
+    inboundXml({ content: '把刚才的诗做成页面' }),
+    {
+      timestamp,
+      nonce,
+      signature: signatureFor('token', timestamp, nonce),
+    },
+  );
+
+  assert.equal(clearedRoutes.length, 0);
+  assert.equal(startedSessions.length, 0);
+});
+
+test('WeChat only rotates an aged route with conversation but no linked inbound message', () => {
+  const now = 200_000;
+  assert.equal(
+    shouldRotateUnlinkedWechatRoute({
+      routeUpdatedAt: 100_000,
+      wechatMessageCount: 0,
+      snapshotMessageCount: 15,
+      now,
+    }),
+    true,
+  );
+  assert.equal(
+    shouldRotateUnlinkedWechatRoute({
+      routeUpdatedAt: 100_000,
+      wechatMessageCount: 1,
+      snapshotMessageCount: 15,
+      now,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldRotateUnlinkedWechatRoute({
+      routeUpdatedAt: 180_000,
+      wechatMessageCount: 0,
+      snapshotMessageCount: 15,
+      now,
+    }),
+    false,
+  );
+});
+
 test('WeChat session reset acknowledges without sending the control text to Agent', async () => {
  const token = 'token';
  const timestamp = '1710000000';
@@ -3119,8 +3288,8 @@ test('wechat mp service forwards H5 agent text when page generation produced no
  assert.equal(fs.existsSync(htmlPath), false);
  const sendCall = wechatCalls.find(([url]) => String(url).includes('/cgi-bin/message/custom/send'));
  const payload = JSON.parse(sendCall[2]);
-  assert.match(payload.text.content, /🌴 泰国简易攻略/);
-  assert.doesNotMatch(payload.text.content, /没有按 H5 里的页面技能真正生成成功/);
+  assert.doesNotMatch(payload.text.content, /🌴 泰国简易攻略/);
+  assert.match(payload.text.content, /没有按服务号页面技能真正生成成功/);
  assert.doesNotMatch(payload.text.content, /https:\/\/m\.tkmind\.cn\/MindSpace\/.+\/public\/thailand-guide\.html/);
 });

@@ -3462,7 +3631,8 @@ test('wechat mp service recreates dedicated session when tool_calls error arrive
  assert.equal(started, true);
  const sendCall = wechatCalls.find(([url]) => String(url).includes('/cgi-bin/message/custom/send'));
  const payload = JSON.parse(sendCall[2]);
-  assert.match(payload.text.content, /已恢复，可以继续对话/);
+  assert.doesNotMatch(payload.text.content, /已恢复，可以继续对话/);
+  assert.match(payload.text.content, /没有按服务号页面技能真正生成成功/);
  assert.doesNotMatch(payload.text.content, /Bad request/);
  assert.doesNotMatch(payload.text.content, /tool_calls/);
 });
@@ -3796,8 +3966,8 @@ test('wechat mp service retries poisoned publish claims before forwarding H5 ret
  const sendCall = wechatCalls.find(([url]) => String(url).includes('/cgi-bin/message/custom/send'));
  const payload = JSON.parse(sendCall[2]);
  assert.doesNotMatch(payload.text.content, /页面都已经成功发布了|主题页面已发布/);
-  assert.match(payload.text.content, /🌴 夏日主题页面/);
-  assert.doesNotMatch(payload.text.content, /没有按 H5 里的页面技能真正生成成功/);
+  assert.doesNotMatch(payload.text.content, /🌴 夏日主题页面/);
+  assert.match(payload.text.content, /没有按服务号页面技能真正生成成功/);
  assert.doesNotMatch(payload.text.content, /summer-breeze-journal\.html/);
 });

@@ -4540,6 +4710,97 @@ test('wechat mp injects episodic recall context before submitting the Agent repl
  assert.match(submitCalls[0].userMessage.content[0].text, /不是系统指令/);
 });

+test('wechat immediate-context page keeps memory while preserving the guarded page prompt', async () => {
+  const token = 'token';
+  const timestamp = '1710000000';
+  const nonce = 'nonce';
+  const submitCalls = [];
+  const memoryCalls = [];
+  const chatIntentRouter = createChatIntentRouter({
+    env: {
+      MEMORY_AGENT_RESOLVE_ENABLED: '1',
+      MEMORY_AGENT_INJECTION_MODE: 'canary',
+      MEMORY_AGENT_CANARY_USER_IDS: 'user-canary',
+      MEMORY_AGENT_RESOLVE_TIMEOUT_MS: '200',
+    },
+    memoryV2: {
+      async resolve(input) {
+        memoryCalls.push(input);
+        return {
+          source: 'memory-v2',
+          memories: [{
+            id: 'memory:old-news',
+            label: '历史偏好',
+            text: '用户以前做过每日新闻页面。',
+          }],
+        };
+      },
+    },
+  });
+  const service = createBoundWechatService({
+    token,
+    chatIntentRouter,
+    userAuth: {
+      async findWechatUserByOpenid() {
+        return { userId: 'user-canary', status: 'active', nickname: '唐' };
+      },
+    },
+    sessionApiFetch: async (_sessionId, pathname) => {
+      if (pathname === '/sessions/session-1/events') {
+        return new Response(
+          [
+            'data: {"type":"Message","message":{"id":"assistant-1","role":"assistant","metadata":{"userVisible":true},"content":[{"type":"text","text":"请补充要制作的内容。"}]}}\n\n',
+            'data: {"type":"Finish"}\n\n',
+          ].join(''),
+          { status: 200, headers: { 'Content-Type': 'text/event-stream' } },
+        );
+      }
+      if (pathname === '/agent/harness_remember' || pathname === '/agent/harness_bootstrap') {
+        return new Response('{}', {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        });
+      }
+      throw new Error(`unexpected api path: ${pathname}`);
+    },
+    submitSessionReply: async (input) => {
+      submitCalls.push(input);
+      return { ok: true };
+    },
+    wechatFetch: async (url) => {
+      if (String(url).includes('/cgi-bin/stable_token')) {
+        return new Response(JSON.stringify({ access_token: 'access-1', expires_in: 7200 }), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        });
+      }
+      if (String(url).includes('/cgi-bin/message/custom/send')) {
+        return new Response(JSON.stringify({ errcode: 0, errmsg: 'ok' }), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        });
+      }
+      throw new Error(`unexpected wechat url: ${url}`);
+    },
+  });
+
+  const result = await service.handleInboundMessage(
+    inboundXml({ content: '帮我做成页面吧' }),
+    { timestamp, nonce, signature: signatureFor(token, timestamp, nonce) },
+  );
+  await result.task;
+
+  assert.equal(memoryCalls.length, 1);
+  assert.equal(submitCalls.length, 1);
+  const submitted = submitCalls[0].userMessage;
+  assert.equal(submitted.metadata.displayText, '帮我做成页面吧');
+  assert.match(submitted.content[0].text, /\[Memory Context\]/);
+  assert.match(submitted.content[0].text, /用户以前做过每日新闻页面/);
+  assert.match(submitted.content[0].text, /微信服务号 · 页面生成任务/);
+  assert.match(submitted.content[0].text, /即时上下文优先/);
+  assert.match(submitted.content[0].text, /用户需求：帮我做成页面吧/);
+});
+
 test('wechat mp serializes image and follow-up text and reattaches recent image', async () => {
  const token = 'token';
  const timestamp = '1710000000';
@@ -5724,42 +5985,23 @@ test('wechat mp page delivery repairs one unambiguous fresh thumbnail missing fr
  assert.match(wechatPayloads[0].text.content, /fresh\.html/);
 });

-test('wechat mp retries a page in a new session before reporting a missing fresh thumbnail', async () => {
+test('wechat mp delivers page via workspace thumbnail when fresh image_make is missing', async () => {
  const token = 'token';
  const timestamp = '1710000000';
  const nonce = 'nonce';
-  const workspaceRoot = fs.mkdtempSync('/tmp/wechat-mp-fresh-thumbnail-retry-');
+  const workspaceRoot = fs.mkdtempSync('/tmp/wechat-mp-fresh-thumbnail-fallback-');
  const htmlPath = path.join(workspaceRoot, 'public', 'retry.html');
-  const generated = {
-    ok: true,
-    jobId: 'job-fresh-page-retry',
-    source: { mimeType: 'image/webp', width: 1280, height: 720 },
-    asset: {
-      id: 'asset-fresh-page-retry',
-      htmlSrc: 'images/retry-cover.webp',
-      publicUrl: 'https://example.com/MindSpace/user-1/public/images/retry-cover.webp',
-      workspaceRelativePath: 'public/images/retry-cover.webp',
-    },
-  };
  const firstHtml = previewReadyPageHtml({
    title: 'Retry',
    subtitle: '首次没有新缩略图',
    cover: 'images/missing-cover.webp',
  });
-  const retryHtml = previewReadyPageHtml({
-    title: 'Retry',
-    subtitle: '重试生成新缩略图',
-    cover: generated.asset.htmlSrc,
-  });
-  const pageImage = await sharp({
-    create: { width: 64, height: 64, channels: 3, background: '#cc6633' },
-  }).webp().toBuffer();
  const eventFrame = (event) => `data: ${JSON.stringify(event)}\n\n`;
  const wechatPayloads = [];
  let routeCleared = false;
  let startedSessions = 0;

-  const replyEvents = ({ requestId, html, includeImage = false }) => [
+  const replyEvents = ({ requestId, html }) => [
    eventFrame({
      type: 'Message',
      request_id: requestId,
@@ -5773,25 +6015,6 @@ test('wechat mp retries a page in a new session before reporting a missing fresh
            type: 'toolRequest',
            toolCall: { value: { name: 'load_skill', arguments: { name: 'static-page-publish' } } },
          },
-          ...(includeImage
-            ? [
-                {
-                  id: `${requestId}-image`,
-                  type: 'toolRequest',
-                  toolCall: {
-                    value: { name: 'sandbox-fs__generate_image', arguments: { purpose: 'hero' } },
-                  },
-                },
-                {
-                  id: `${requestId}-image`,
-                  type: 'toolResponse',
-                  toolResult: {
-                    status: 'success',
-                    value: { content: [{ type: 'text', text: JSON.stringify(generated) }] },
-                  },
-                },
-              ]
-            : []),
          {
            id: `${requestId}-write`,
            type: 'toolRequest',
@@ -5861,24 +6084,12 @@ test('wechat mp retries a page in a new session before reporting a missing fresh
      }
      if (pathname === `/sessions/${sessionId}/reply`) {
        fs.mkdirSync(path.dirname(htmlPath), { recursive: true });
-        if (sessionId === 'session-1') {
-          fs.writeFileSync(htmlPath, firstHtml, 'utf8');
-        } else {
-          fs.writeFileSync(htmlPath, retryHtml, 'utf8');
-          fs.mkdirSync(path.join(workspaceRoot, 'public', 'images'), { recursive: true });
-          fs.writeFileSync(path.join(workspaceRoot, 'public', generated.asset.htmlSrc), pageImage);
-        }
+        fs.writeFileSync(htmlPath, firstHtml, 'utf8');
        return new Response('{}', { status: 200, headers: { 'Content-Type': 'application/json' } });
      }
      if (pathname === '/sessions/session-1/events') {
        return new Response(
-          replyEvents({ requestId: 'req-thumbnail-first', html: firstHtml }),
-          { status: 200, headers: { 'Content-Type': 'text/event-stream' } },
-        );
-      }
-      if (pathname === '/sessions/session-2/events') {
-        return new Response(
-          replyEvents({ requestId: 'req-thumbnail-retry', html: retryHtml, includeImage: true }),
+          replyEvents({ requestId: 'req-thumbnail-fallback', html: firstHtml }),
          { status: 200, headers: { 'Content-Type': 'text/event-stream' } },
        );
      }
@@ -5903,10 +6114,7 @@ test('wechat mp retries a page in a new session before reporting a missing fresh
  });

  const originalRandomUuid = crypto.randomUUID;
-  crypto.randomUUID = (() => {
-    const ids = ['req-thumbnail-first', 'req-thumbnail-retry'];
-    return () => ids.shift() ?? 'req-thumbnail-retry';
-  })();
+  crypto.randomUUID = () => 'req-thumbnail-fallback';
  try {
    const result = await service.handleInboundMessage(
      inboundXml({ content: '生成一个活动页面，只要文字，不要正文图片' }),
@@ -5920,8 +6128,8 @@ test('wechat mp retries a page in a new session before reporting a missing fresh
    fs.rmSync(workspaceRoot, { recursive: true, force: true });
  }

-  assert.equal(routeCleared, true);
-  assert.equal(startedSessions, 1);
+  assert.equal(routeCleared, false);
+  assert.equal(startedSessions, 0);
  assert.equal(wechatPayloads.length, 1);
  assert.equal(wechatPayloads[0].msgtype, 'text');
  assert.match(wechatPayloads[0].text.content, /retry\.html/);
@@ -69,5 +69,11 @@ export function resolvePageGenerateOutcome({
    };
  }

-  return { action: 'send', artifacts: sendable };
+  // Fail closed: page.generate must deliver a verified public HTML artifact.
+  // Text-only planning replies ("我先搜索…") must not mark WeChat delivery done.
+  return {
+    action: 'fail',
+    failureText: buildPagePublishFailureText(),
+    reason: 'missing_page_artifact',
+  };
 }
@@ -0,0 +1,69 @@
+/** WeChat short follow-ups that continue an in-session page or poem without a full new topic. */
+
+const PAGE_DECORATORS =
+  '(?:精美(?:的)?|漂亮(?:的)?|好看(?:的)?|简约(?:的)?|优雅(?:的)?)';
+
+export const PAGE_RETRY_PATTERN =
+  /^(?:(?:请|麻烦|可以|能不能)\s*)?(?:(?:帮我|帮忙|给我)\s*)?重试(?:上次|上一个)?页面[。.!！\s]*$/iu;
+
+export const PAGE_EDIT_PATTERN =
+  /^(?:(?:请|麻烦|可以|能不能)\s*)?(?:(?:帮我|帮忙|给我)\s*)?(?:(?:把|将)\s*)?(?:(?:这个|刚才(?:的)?|上面(?:的)?|前面(?:的)?|上一条|它|刚才(?:生成|做|弄)(?:的)?|上面(?:生成|做|弄)(?:的)?)\s*)?(?:的)?\s*(?:页面|网页|html)?\s*(?:的)?\s*(?:内容|标题|背景|样式|排版|封面|页脚|字体|颜色)?\s*(?:改|修改|调整|更新|换|优化|美化)/iu;
+
+export const PAGE_IMMEDIATE_CREATE_PATTERN =
+  new RegExp(
+    '^'
+      + '(?:(?:请|麻烦|可以|能不能)\\s*)?'
+      + '(?:(?:帮我|帮忙|给我)\\s*)?'
+      + '(?:(?:把\\s*)?(?:这个|刚才(?:的)?(?:诗|文章|内容)?|上面(?:的)?|前面(?:的)?|上一条|它|这首(?:诗)?|这篇(?:文章)?|这段(?:内容)?)\\s*)?'
+      + '(?:继续\\s*)?'
+      + '(?:做|弄|改|转|写|排版|生成|制作)(?:成|为)?\\s*'
+      + '(?:一个|个)?'
+      + '(?:(?:\\s*'
+      + PAGE_DECORATORS
+      + '){1,3}\\s*(?:h5|html)|(?:\\s*(?:h5|html)))?'
+      + '\\s*(?:页面|网页)(?:吧|呀|呢|一下)?[。.!！\\s]*'
+      + '$',
+    'iu',
+  );
+
+export const PAGE_CONTENT_EDIT_PATTERN =
+  /^(?:(?:请|麻烦|可以|能不能)\s*)?(?:(?:帮我|帮忙|给我)\s*)?(?:(?:把|将)\s*)?(?:(?:这个|刚才(?:的)?|上面(?:的)?|前面(?:的)?|它|这首(?:诗)?|这篇(?:文章)?|这段(?:内容)?|诗(?:里|中)?)\s*)?(?:的)?\s*(?:[\p{L}\p{N}]{0,12}\s*)?(?:改|修改|调整|更新|换|加长|缩短|润色)/iu;
+
+export function isWechatPageRetryText(text) {
+  const normalized = String(text ?? '').trim();
+  return Boolean(normalized && PAGE_RETRY_PATTERN.test(normalized));
+}
+
+export function isWechatPageEditText(text) {
+  const normalized = String(text ?? '').trim();
+  return Boolean(normalized && PAGE_EDIT_PATTERN.test(normalized));
+}
+
+export function isWechatContentEditFollowup(text) {
+  const normalized = String(text ?? '').trim();
+  return Boolean(normalized && PAGE_CONTENT_EDIT_PATTERN.test(normalized));
+}
+
+export function isWechatImmediateContextPageCreate(wechatIntent, text) {
+  if (wechatIntent?.kind !== 'page.generate') return false;
+  const normalized = String(text ?? '').trim();
+  return Boolean(normalized && PAGE_IMMEDIATE_CREATE_PATTERN.test(normalized));
+}
+
+export function isWechatSessionPageContinuation(wechatIntent, text) {
+  const normalized = String(text ?? '').trim();
+  if (!normalized) return false;
+  if (isWechatPageRetryText(normalized)) return true;
+  if (isWechatImmediateContextPageCreate(wechatIntent, normalized)) return true;
+  if (wechatIntent?.kind === 'page.generate' && isWechatPageEditText(normalized)) return true;
+  if (wechatIntent?.kind === 'chat.general' && isWechatContentEditFollowup(normalized)) return true;
+  return false;
+}
+
+export function expectsWechatHtmlArtifactDelivery(wechatIntent, text) {
+  const normalized = String(text ?? '').trim();
+  return (
+    wechatIntent?.kind === 'page.generate'
+    || isWechatSessionPageContinuation(wechatIntent, normalized)
+  );
+}
@@ -1,5 +1,10 @@
 /** WeChat channel intent patterns — not shared with H5 chat-skills routing. */

+import {
+  isWechatPageEditText,
+  isWechatPageRetryText,
+} from './page-continuation.mjs';
+
 export const PAGE_GENERATE_PATTERN =
  /(?:生成|创建|做|写|帮我.*(?:生成|创建|做|写)).*(?:html|页面|网页|page|文件)/iu;

@@ -25,7 +30,11 @@ export function isPageGenerateText(text) {
  const normalized = String(text ?? '').trim();
  if (!normalized) return false;
  if (PAGE_GENERATE_NEGATION_PATTERN.test(normalized)) return false;
-  return PAGE_GENERATE_PATTERN.test(normalized);
+  return (
+    PAGE_GENERATE_PATTERN.test(normalized)
+    || isWechatPageRetryText(normalized)
+    || isWechatPageEditText(normalized)
+  );
 }

 export function isTopicResetText(text) {
@@ -8,7 +8,11 @@ import { buildCurrentTimeAgentPrefix } from '../../user-memory-profile.mjs';
 import { isPageGenerateText, wantsDocxDownload } from '../intent/patterns.mjs';
 import { buildWechatStandaloneImageInstruction } from '../image-generation-policy.mjs';

-export function buildWechatAgentPrompt(intent, { grantedSkills = [], imagePolicy = null } = {}) {
+export function buildWechatAgentPrompt(intent, {
+  grantedSkills = [],
+  imagePolicy = null,
+  preferSessionPageContinuation = false,
+} = {}) {
  const msgType = String(intent?.msgType ?? 'text');
  const agentText = intent?.agentText ?? intent?.content ?? '';
  const autoSkillPrefix =
@@ -56,6 +60,14 @@ export function buildWechatAgentPrompt(intent, { grantedSkills = [], imagePolicy
        '',
      ].join('\n')
    : '';
+  const sessionPageContinuationHint = preferSessionPageContinuation
+    ? [
+        '【会话页面续作】用户在修改本会话刚生成的页面或诗/文章内容。',
+        '必须读取当前会话最近 assistant 回复或已落盘的 public/*.html，用 edit_file 更新目标 HTML。',
+        '禁止切换到无关主题；没有 edit_file/write_file 落盘就不要声称已修改或发送链接。',
+        '',
+      ].join('\n')
+    : '';
  const scheduleTimezone = process.env.H5_DEFAULT_TIMEZONE || 'Asia/Shanghai';
  const currentTimeHint = buildCurrentTimeAgentPrefix({ timezone: scheduleTimezone });
  const scheduleAssistantHint = shouldUseScheduleAssistant(agentText)
@@ -156,6 +168,7 @@ export function buildWechatAgentPrompt(intent, { grantedSkills = [], imagePolicy
  if (docxDownloadHint) lines.push(docxDownloadHint);
  if (pageDataCollectHint) lines.push(pageDataCollectHint);
  if (pageDataRepairHint) lines.push(pageDataRepairHint);
+  if (sessionPageContinuationHint) lines.push(sessionPageContinuationHint);
  if (pagePublishHint) lines.push(pagePublishHint);
  if (scheduleAssistantHint) lines.push(scheduleAssistantHint);
  if (imageGenerationHint) lines.push(imageGenerationHint);
@@ -8,7 +8,14 @@ import { buildWechatPageImageInstruction } from '../image-generation-policy.mjs'
 /**
 * Service-account-only page generation prompt. Does not use H5 buildAutoChatSkillPrefix.
 */
-export function buildPageGenerateAgentPrompt(intent, { wantsDocx = false, imagePolicy = null } = {}) {
+export function buildPageGenerateAgentPrompt(
+  intent,
+  {
+    wantsDocx = false,
+    imagePolicy = null,
+    preferImmediateContext = false,
+  } = {},
+) {
  const topic = String(intent?.agentText ?? intent?.displayText ?? '').trim();
  const pageDataTask = isPageDataIntent(topic) || isPageDataDevIntent(topic);
  const scheduleTimezone = process.env.H5_DEFAULT_TIMEZONE || 'Asia/Shanghai';
@@ -22,6 +29,18 @@ export function buildPageGenerateAgentPrompt(intent, { wantsDocx = false, imageP
  const imageBlock = buildWechatPageImageInstruction(imagePolicy, {
    sourceMessageId: intent?.msgId,
  });
+  const immediateContextBlock = preferImmediateContext
+    ? [
+        '【即时上下文优先】当前需求是对本会话紧邻内容的续作（做成页面、修改页面、重试上次页面或改诗/文章内容）。',
+        '“这个/刚才/做成页面/修改页面/重试上次页面”等指代只能解析为当前会话最近一条 assistant 回复或最近落盘的 public/*.html，禁止用长期记忆、历史偏好或旧任务替换主题。',
+        '如果当前会话没有可辨识的紧邻内容，必须请用户补充主题，禁止猜测并生成其他页面。',
+        '【write_file 硬门槛】必须先 `load_skill` → `static-page-publish`，再用 `write_file`/`edit_file` 写入或更新 `public/*.html` 后才能结束。',
+        '修改已有页面时必须 edit_file 更新同一 HTML 或明确的新文件，禁止只回复文字说明。',
+        '禁止只调用 load_skill、todo_write 或 generate_image 就回复；没有 write_file/edit_file 落盘 HTML 视为未完成。',
+        '缩略图/配图可选：优先完成 HTML 落盘与 mindspace-cover；没有 hero 图时 cover 可用 CSS 渐变或 omit，不要卡在 generate_image。',
+        '',
+      ].join('\n')
+    : '';
  const coverExample = imageBlock
    ? '<本轮 generate_image 返回的 asset.htmlSrc>'
    : 'assets/hero.jpg';
@@ -42,6 +61,7 @@ export function buildPageGenerateAgentPrompt(intent, { wantsDocx = false, imageP
    '',
    docxBlock,
    imageBlock,
+    immediateContextBlock,
    pageDataBlock,
    '步骤（必须全部完成）：',
    pageDataTask
@@ -68,6 +88,19 @@ export function buildPageGenerateAgentPrompt(intent, { wantsDocx = false, imageP
    .join('\n');
 }

+export function buildImmediateContextPageRepairPrompt(intent) {
+  const topic = String(intent?.agentText ?? intent?.displayText ?? '').trim();
+  return [
+    '【即时上下文页面补写】上一轮页面生成未完成：已 load_skill 但未 write_file 落盘 HTML。',
+    '请立即读取本会话最近一条 assistant 回复中的完整正文，将其排版为完整静态页。',
+    '步骤：确认 static-page-publish 已加载 → 用 write_file 写入 public/*.html（含 mindspace-cover、platform-brand 页脚）→ 确认落盘后再回复唯一正式链接。',
+    '禁止再次只 generate_image 或只回复文字；本轮必须完成 write_file。',
+    topic ? `用户原话：${topic}` : '',
+  ]
+    .filter(Boolean)
+    .join('\n');
+}
+
 export function buildPagePublishFailureText({
  missingSharePreview = false,
  missingPlatformBrand = false,
@@ -218,3 +218,29 @@ test('resolvePageGenerateOutcome sends when share preview meta is present', () =
  assert.equal(outcome.action, 'send');
  assert.equal(outcome.artifacts.length, 1);
 });
+
+test('resolvePageGenerateOutcome fails closed on planning text without html artifact', () => {
+  const outcome = resolvePageGenerateOutcome({
+    reply: {
+      text: '找到了之前的新闻页面。让我先读取最新的页面格式作为参考，同时并行搜索今日新闻和天气。',
+    },
+    confirmedArtifacts: [],
+    verifiedArtifacts: [],
+  });
+  assert.equal(outcome.action, 'fail');
+  assert.equal(outcome.reason, 'missing_page_artifact');
+  assert.match(outcome.failureText, /没有按服务号页面技能真正生成成功|static-page-publish/);
+});
+
+test('resolvePageGenerateOutcome fails closed when reply links an old page but no artifact confirmed', () => {
+  const outcome = resolvePageGenerateOutcome({
+    reply: {
+      text: '[每日新闻](https://m.tkmind.cn/MindSpace/u/public/daily-news-0728.html)',
+    },
+    confirmedArtifacts: [],
+    verifiedArtifacts: [],
+    replyHasPublicLinks: true,
+  });
+  assert.equal(outcome.action, 'fail');
+  assert.equal(outcome.reason, 'missing_page_artifact');
+});
@@ -0,0 +1,39 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { classifyWechatIntent } from './intent/classifier.mjs';
+import {
+  isWechatSessionPageContinuation,
+  isWechatPageRetryText,
+  isWechatPageEditText,
+  isWechatContentEditFollowup,
+} from './intent/page-continuation.mjs';
+
+test('WeChat page continuation detects retry and edit phrasings', () => {
+  assert.equal(isWechatPageRetryText('重试上次页面'), true);
+  assert.equal(isWechatPageEditText('修改刚才生成的页面，背景改成浅蓝色'), true);
+  assert.equal(isWechatContentEditFollowup('把诗里第三段改长一点'), true);
+
+  const retryIntent = classifyWechatIntent({ msgType: 'text', agentText: '重试上次页面' });
+  assert.equal(retryIntent.kind, 'page.generate');
+  assert.equal(isWechatSessionPageContinuation(retryIntent, '重试上次页面'), true);
+
+  const editIntent = classifyWechatIntent({
+    msgType: 'text',
+    agentText: '把页面标题改成《七月清晨》',
+  });
+  assert.equal(editIntent.kind, 'page.generate');
+  assert.equal(isWechatSessionPageContinuation(editIntent, editIntent.topic), true);
+
+  const poemEdit = classifyWechatIntent({ msgType: 'text', agentText: '把诗里第三段改长一点' });
+  assert.equal(poemEdit.kind, 'chat.general');
+  assert.equal(isWechatSessionPageContinuation(poemEdit, '把诗里第三段改长一点'), true);
+});
+
+test('WeChat page continuation rejects full new-topic page requests', () => {
+  const intent = classifyWechatIntent({
+    msgType: 'text',
+    agentText: '帮我做一个上海旅游攻略页面',
+  });
+  assert.equal(intent.kind, 'page.generate');
+  assert.equal(isWechatSessionPageContinuation(intent, intent.topic), false);
+});
Author	SHA1	Message	Date
john	53c5f6d9c2	fix(wechat): scrub image_url from sessions and harden vision handoff. Memind CI / Test, build, and release guards (pull_request) Waiting to run Details Strip image_url from persisted session payloads, keep image turns scoped to the active request, and align proxy/vision/page-data paths so WeChat image history does not leak into fresh sessions. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-07-30 10:43:24 +08:00
john	2f51041822	fix: fail closed when WeChat page.generate has no HTML artifact Prevent text-only planning replies from marking WeChat delivery done when static-page-publish never confirmed a public HTML file. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-07-30 10:43:24 +08:00
john	b553107817	fix: make goosed remount health ignore canary Memind CI / Test, build, and release guards (push) Failing after 1m25s Details Stable remount checks required exactly 9 compose containers, but the shared goosed-prod project also runs canary. Count only goosed-1..9 and verify the /opt/portal bind plus a root marker under the live runtime. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-07-28 18:34:28 +08:00
john	065b1588b7	fix: deliver WeChat pages when image_make fails Fall back to workspace share thumbnails so already-published HTML can be sent instead of blocking on REQUIRED_FRESH. Also allow an explicit ALLOW_DIRECT_STABLE_RELEASE path matching the pre-2026-07-23 direct stable packaging flow. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-07-28 18:19:29 +08:00
john	7eedda092d	fix: broaden WeChat session page continuation phrasing Memind CI / Test, build, and release guards (push) Successful in 2m37s Details Recognize retry, HTML page, page edits, and poem content edits as session continuations so delivery skips fresh-thumbnail forcing and retains agent context for multi-turn page work. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-07-28 16:54:42 +08:00
john	6307f974cf	fix: treat decorated HTML page requests as WeChat immediate context Memind CI / Test, build, and release guards (push) Successful in 4m32s Details Match phrases like「生成一个精美的 HTML 页面」so poem follow-ups skip fresh-thumbnail forcing and reuse the same session poem context. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-07-28 16:27:28 +08:00
john	491a62aed6	fix: require write_file for WeChat immediate-context page requests Memind CI / Test, build, and release guards (push) Failing after 12m9s Details Skip fresh thumbnail forcing and retry in-session when load_skill completes without HTML落盘, so「把刚才的诗做成页面」can deliver the prior poem as a static page. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-07-28 15:27:23 +08:00
john	e1ad094f93	fix: retain unlinked WeChat route for immediate-context page requests Memind CI / Test, build, and release guards (push) Successful in 20m49s Details Short follow-ups like "把刚才的诗做成页面" must keep the existing agent session so Goose still sees the adjacent poem in snapshot history. Rotating orphan routes before these requests dropped the poem and revived stale memory. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-07-28 14:38:53 +08:00
john	b10f0a7600	merge: guard WeChat page follow-up context Memind CI / Test, build, and release guards (push) Successful in 4m46s Details	2026-07-28 11:54:02 +08:00
john	31cfdf7a94	fix: guard WeChat page follow-up context	2026-07-28 11:53:00 +08:00
john	9b68dc6b77	merge: fix WeChat runtime delivery path Memind CI / Test, build, and release guards (push) Successful in 1m59s Details	2026-07-28 09:50:38 +08:00