feat(ops): add imgproxy native runtime tooling and record 103 deployment

Bundle vendored imgproxy with Mach-O dylibs for 103 launchd, fix install to exec the binary directly with launchctl enable, and document the live native release in the runtime topology.

Co-authored-by: Cursor <cursoragent@cursor.com>

.env.example

@@ -6,6 +6,12 @@
 #
 # 后端代理（server.mjs / vite dev proxy 共用）
 TKMIND_API_TARGET=https://127.0.0.1:18006
+# Native dual pool (local simulation): bash scripts/install-local-goosed-pool.sh
+# TKMIND_API_TARGET_1=https://127.0.0.1:18007
+# TKMIND_API_TARGETS=https://127.0.0.1:18006,https://127.0.0.1:18007
+# GOOSED_NATIVE_POOL_PORTS=18006,18007
+# GOOSED_RUNTIME=native   # runtime-worker-metrics.mjs; auto detects when no docker pool
+# Soak: node scripts/soak-local-goosed-pool.mjs --minutes 30 --interval 60
 TKMIND_SERVER__SECRET_KEY=local-dev-secret
 H5_PORT=8081
 # Vite UI 预览用 5173；Agent 交付的 MindSpace 公开页 + Page Data API 走 Portal（8081）。
@@ -65,6 +71,22 @@ H5_PUBLIC_BASE_URL=http://127.0.0.1:5173
 # MEMIND_AGENT_RUN_WORKER_ID=<optional-instance-id>
 # MEMIND_AGENT_RUN_WORKER_EXPECT_RUNNING=0
 
+# 本机 Aider / OpenHands（Colima 迁出后走 native CLI，见 memind-local-aider / memind-local-openhands）
+# AIDER_BIN=/Users/john/.local/bin/aider
+# GOOSE_AIDER_BIN=/Users/john/.openhands/bin/studio-aider
+# OPENHANDS_BIN=/Users/john/.local/bin/openhands
+# GOOSE_AIDER_BIN=/Users/john/Project/Memind/scripts/aider-goose-wrapper.sh
+# GOOSE_OPENHANDS_BIN=/Users/john/Project/Memind/scripts/openhands-goose-wrapper.sh
+# GOOSE_OPENHANDS_RUNNER=host
+# 本地开发：普通用户 role=user 默认开启 aider/openhands；生产保持 0
+# MEMIND_ROLE_CODE_TOOLS_DEFAULT=0
+# MEMIND_TOOL_GATEWAY_ENABLED=0
+# MEMIND_TOOL_GATEWAY_DRY_RUN=0
+# MEMIND_TOOL_GATEWAY_DEFAULT_EXECUTOR=aider
+# Orchestrator worker（memind-local-orchestrator/.env 同步）OpenHands 进程执行器：
+# MEMIND_EXECUTOR_OPENHANDS_COMMAND=/Users/john/Project/Memind/scripts/openhands-goose-wrapper.sh
+# MEMIND_EXECUTOR_WORKSPACE_ROOT=/Users/john/Project/Memind
+
 # LangGraph Orchestrator Shadow（默认完全不接入 Agent Run 请求路径）。
 # 仅在独立 Orchestrator 已健康、service token 已配置后，先显式打开观察 wiring，
 # 再通过 memindadm 选择 shadow。关闭 wiring 时不查询编排配置、不排队、不传用户数据。
@@ -331,6 +353,10 @@ VITE_TKMIND_WORKING_DIR=/Users/john/PycharmProjects/tkmind
 # MindSearch / standalone Deep Search
 # ---------------------------------------------------------------------------
 # Production SearXNG on 103 is bound to the host at 127.0.0.1:20080.
+# Outbound proxy for DuckDuckGo/Yandex lives in searxng-runtime shared config:
+#   /Users/john/Project/searxng-runtime/shared/.env
+#   SEARXNG_OUTGOING_PROXY=http://127.0.0.1:1082  (Shadowrocket MacPacket)
+# Template source: /Users/john/Project/searxng-prod/settings.yml.template
 # Goosed MCP endpoints are automatically rewritten to host.docker.internal.
 # TKMIND_SEARCH_SEARXNG_URL=http://127.0.0.1:20080/search
 # TKMIND_SEARCH_MCP_HOST_GATEWAY=host.docker.internal

chat-image-turn-scope.mjs

@@ -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) {

chat-image-turn-scope.test.mjs

@@ -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,
+  );
+});

chat-skills.test.mjs

@@ -164,7 +164,7 @@ test('buildAutoChatSkillPrefix routes an uploaded xlsx only when Excel Analyst i
 
 test('manifest enhanced search route is opt-in and uses the MindSearch skill prompt', () => {
   const routes = [{ skillName: 'search-enhanced', promptKey: 'search-enhanced', keywords: ['最新资料'], priority: 30 }];
-  assert.match(buildAutoChatSkillPrefix('请搜索最新资料：Goose MCP', ['search-enhanced'], { skillRouterV2: true, manifestRoutes: routes }), /tkmind-search/);
+  assert.match(buildAutoChatSkillPrefix('请搜索最新资料：Goose MCP', ['search-enhanced'], { skillRouterV2: true, manifestRoutes: routes }), /tkmind_search/);
   assert.equal(buildAutoChatSkillPrefix('请搜索最新资料：Goose MCP', [], { skillRouterV2: true, manifestRoutes: routes }), '');
 });
 

conversation-display.mjs

@@ -32,8 +32,17 @@ export function stripMindSpaceContextPrefix(text) {
   return next;
 }
 
-const ASSISTANT_DELIVERABLE_RE =
-  /\[[^\]]+\]\(https?:\/\/[^)]+\)|https?:\/\/(?:m\.)?[^/\s]*tkmind\.(?:cn|ai)\/MindSpace\//i;
+/** MindSpace 交付链接：生产域名与本地 dev（127.0.0.1 / localhost）都必须可点击，不可被架构脱敏替换。 */
+export const MINDSPACE_DELIVERABLE_ORIGIN_RE =
+  '(?:127\\.0\\.0\\.1|localhost):\\d+|(?:m\\.)?[^/\\s]*tkmind\\.(?:cn|ai)';
+
+const ASSISTANT_DELIVERABLE_RE = new RegExp(
+  [
+    '\\[[^\\]]+\\]\\(https?:\\/\\/[^)]+\\)',
+    `https?:\\/\\/${MINDSPACE_DELIVERABLE_ORIGIN_RE}\\/MindSpace\\/`,
+  ].join('|'),
+  'i',
+);
 
 const INTERNAL_ASSISTANT_MARKERS = [
   /data-mindspace-page-tag/i,

conversation-display.test.mjs

@@ -89,3 +89,13 @@ test('deriveAssistantFacingText keeps user-facing replies with public links', ()
     '页面已生成：[AI 机器人研究报告 2026](https://m.tkmind.cn/MindSpace/john/public/ai-robot-report.html)';
   assert.equal(deriveAssistantFacingText(external), external);
 });
+
+test('deriveAssistantFacingText keeps local MindSpace deliverable links clickable', () => {
+  const localMarkdown =
+    '日记本就绪：[打开日记本](http://127.0.0.1:8081/MindSpace/32035858-9a20-425b-89da-c118ef0779aa/public/diary.html)';
+  assert.equal(deriveAssistantFacingText(localMarkdown), localMarkdown);
+
+  const localBare =
+    '本地预览：http://127.0.0.1:5173/MindSpace/john/public/survey.html';
+  assert.equal(deriveAssistantFacingText(localBare), localBare);
+});

docs/103-runtime-topology.md

@@ -1,6 +1,6 @@
 # Local and 103 runtime topology
 
-> Last confirmed: 2026-07-26 20:18 CST.
+> Last confirmed: 2026-07-30 20:20 CST (goosed native migration).
 >
 > This is the current topology source of truth for local Memind and 103 production. Prefer this document over older migration notes. Older architecture documents may contain historical paths from before the MindSpace split.
 
@@ -75,48 +75,62 @@ or whose `gitSha` does not match the runtime artifact manifest.
 
 ## goosed
 
-103 goosed runs in Colima/Docker, not as native launchd processes.
+103 goosed runs as **native launchd** processes (2026-07-30 migrated). Docker/Colima pool is stopped; `goosed-prod-1` is kept as emergency standby.
+
+> 迁移记录与回滚：[goosed-native-103-migration-plan.md](./goosed-native-103-migration-plan.md)（**已执行 2026-07-30**）。脚本：`scripts/goosed-native-103-migrate.sh`。
 
 | Item | Value |
 |------|-------|
-| Docker context | `colima` |
-| Compose directory | `/Users/john/Project/goosed-prod` |
-| Compose env | `/Users/john/Project/goosed-prod/.env` |
-| Image pattern | `tkmind/goosed:prod-${GOOSED_TAG}` |
-| Session store | PostgreSQL `memind_sessions` through `GOOSE_SESSION_DB_URL` |
-| Session PostgreSQL | **Host** `postgresql@17` on `127.0.0.1:5432` (`/opt/homebrew/var/postgresql@17`) |
+| Runtime type | Native launchd (`GOOSED_RUNTIME=native`) |
+| Root | `/Users/john/Project/tkmind_go-native` |
+| Binary | `tkmind_go-native/goosed` → `releases/goosed-*` |
+| Launchd labels | `cn.tkmind.goosed-native-18006` … `18014` |
+| Run script | `run-goosed-native.sh <port>` + `.env.<port>` |
+| Session store | PostgreSQL `memind_sessions` via `GOOSE_SESSION_DB_URL` → `127.0.0.1:5432` |
+| FD monitor | `cn.tkmind.goosed-monitor` → `scripts/monitor-goosed-fds.mjs` |
+| Docker standby | `goosed-prod-1` stopped, `restart=no`（紧急回滚 18006） |
+| DeepSeek no-think | `cn.tkmind.memind-deepseek-no-think` → `:18036`（native 必需，`MEMIND_DEEPSEEK_PROXY_ENTRYPOINT=1`） |
 
-**Critical:** Colima goosed reaches the session DB via `host.docker.internal:5432`. If host PostgreSQL is stopped, H5 `/agent/start` hangs ~60s then fails with `pool timed out`, and the UI stays on「正在创建新对话…」. Recovery:
+**Critical:** Native goosed uses host PostgreSQL on `127.0.0.1:5432`. If PostgreSQL stops, H5 `/agent/start` hangs ~60s. Recovery:
 
 ```bash
-ssh john@58.38.22.103 'bash /Users/john/Project/goosed-prod/scripts/ensure-goose-session-postgres.sh'
+ssh john@58.38.22.103 'bash /Users/john/Project/Memind/scripts/ensure-goose-session-postgres.sh'
 ssh john@58.38.22.103 '/opt/homebrew/opt/postgresql@17/bin/pg_isready -h 127.0.0.1 -p 5432'
 ```
 
-`cn.tkmind.goosed-monitor`（103）运行 `goosed-prod/scripts/monitor-goosed-containers.mjs`，本地 native goosed 监控用 `scripts/monitor-goosed-fds.mjs`；两者都会在巡检时调用 `ensure-goose-session-postgres.sh`。
+Port layout (native listens directly on host port):
 
-Container layout (host port → container `18006`):
-
-| Container | Host port | Container port |
-|-----------|-----------|----------------|
-| `goosed-prod-1` | `18006` | `18006` |
-| `goosed-prod-2` | `18007` | `18006` |
-| `goosed-prod-3` | `18008` | `18006` |
-| `goosed-prod-4` | `18009` | `18006` |
-| `goosed-prod-5` | `18010` | `18006` |
-| `goosed-prod-6` | `18011` | `18006` |
-| `goosed-prod-7` | `18012` | `18006` |
-| `goosed-prod-8` | `18013` | `18006` |
-| `goosed-prod-9` | `18014` | `18006` |
+| Port | Launchd label |
+|------|---------------|
+| `18006` | `cn.tkmind.goosed-native-18006` |
+| `18007` | `cn.tkmind.goosed-native-18007` |
+| … | … |
+| `18014` | `cn.tkmind.goosed-native-18014` |
 
 All nine host ports must return `ok` from `/status`, and must appear in Portal `.env` `TKMIND_API_TARGETS`.
 
+### Legacy Docker pool (standby only)
+
+| Item | Value |
+|------|-------|
+| Compose directory | `/Users/john/Project/goosed-prod` |
+| Image pattern | `tkmind/goosed:prod-${GOOSED_TAG}` |
+| Containers | `goosed-prod-1..9` — **stopped**, `docker update --restart=no` |
+
+Do **not** leave `cn.tkmind.goosed-monitor` on `monitor-goosed-containers.mjs` with `GOOSED_RESTART_UNHEALTHY=1`; it will restart Docker and fight native ports.
+
+```bash
+# Emergency: single Docker instance on 18006 only
+launchctl bootout gui/$(id -u)/cn.tkmind.goosed-native-18006
+docker update --restart=unless-stopped goosed-prod-1 && docker start goosed-prod-1
+```
+
 ## PostgreSQL rule
 
-Both local native goosed and 103 Colima goosed persist sessions in PostgreSQL:
+Both local native goosed and 103 native goosed persist sessions in PostgreSQL:
 
 - local native goosed: PostgreSQL database `goose_sessions_dev`
-- 103 Colima goosed: PostgreSQL database `memind_sessions`
+- 103 native goosed: PostgreSQL database `memind_sessions`
 
 Do not assume a local SQLite session store when debugging current Memind/goosed behavior.
 
@@ -152,3 +166,80 @@ ssh john@58.38.22.103 'curl -fsS http://127.0.0.1:8082/health'
 ssh john@58.38.22.103 'for p in $(seq 18006 18014); do curl -kfsS https://127.0.0.1:$p/status; echo; done'
 ssh john@58.38.22.103 'grep ^TKMIND_API_TARGETS= /Users/john/Project/Memind/.env'
 ```
+
+## imgproxy
+
+103 imgproxy runs as a **native vendor runtime** (no brew on 103; Docker `memind-imgproxy` retired).
+
+| Item | Value |
+|------|-------|
+| Runtime base | `/Users/john/Project/imgproxy-runtime` |
+| Current release (2026-07-31) | `20260731-052342-imgproxy-native` (**native launchd**, imgproxy 4.0.7) |
+| Legacy Docker release | `20260715-3819ccd5` (retired) |
+| Vendor binary | `releases/<id>/vendor/imgproxy-runtime/bin/imgproxy` (+ bundled dylibs) |
+| LaunchAgent | `cn.tkmind.imgproxy` → direct binary exec → `127.0.0.1:20082` |
+| Compat proxy | `cn.tkmind.imgproxy-compat` → `10.10.0.2:20081` |
+| Public entry | `https://img.tkmind.cn` |
+| Signing config | Portal `.env` → `IMGPROXY_SIGNING_KEY` / `IMGPROXY_SIGNING_SALT` |
+| Storage root | `MINDSPACE_STORAGE_ROOT=/Users/john/MindSpace/data/mindspace` |
+
+Build locally, release to 103:
+
+```bash
+npm run build:imgproxy-runtime-native
+bash scripts/release-imgproxy-native-prod.sh --dry-run   # from release/* on synced main
+bash scripts/release-imgproxy-native-prod.sh --yes
+```
+
+Install on 103 reads Portal `.env` for signing keys and storage root; launchd plist **must exec the vendored binary directly** (not `/bin/bash` wrapper). If bootstrap fails with `error 5`, run `launchctl enable gui/$(id -u)/cn.tkmind.imgproxy` before re-bootstrap.
+
+Verify:
+
+```bash
+ssh john@58.38.22.103 'curl -fsS http://127.0.0.1:20082/health'
+ssh john@58.38.22.103 'curl -fsS http://10.10.0.2:20081/health'
+curl -fsS https://img.tkmind.cn/health
+```
+
+Legacy Docker release remains in `scripts/release-imgproxy-runtime-prod.sh` for rollback only.
+
+Do **not** point launchd at `/Users/john/Project/Memind/vendor/...` without a Portal runtime that actually ships that path; imgproxy is an independent runtime under `imgproxy-runtime/`.
+
+## image_make
+
+`image_make` is an independent service. Portal runtime does **not** bundle it.
+
+| Item | Value |
+|------|-------|
+| Local source | `/Users/john/Project/image_make` |
+| 103 runtime base | `/Users/john/Project/image_make` |
+| Current release (2026-07-30) | `20260730-220317-native-ceaff399a073` (**native launchd**) |
+| Legacy Docker release | `20260720-standalone-rc1` (retired) |
+| Listen | `127.0.0.1:18083` |
+| LaunchAgent | `cn.tkmind.image-make` |
+| Persistent env | `shared/.env` |
+| Persistent data | `shared/data/artifacts` |
+| Build (local) | `bash scripts/build-image-make-runtime-native.sh` |
+| Release (103) | `bash scripts/release-image-make-runtime-prod.sh --yes` |
+| Source fingerprint | `release-metadata.env` → `IMAGE_MAKE_SOURCE_TREE_SHA256` |
+
+103 runs **darwin/arm64 native** (uv venv in release tar). Docker/Colima is no longer required for image_make.
+
+**ComfyUI is a separate runtime** (not bundled into image_make tar):
+
+| Item | Value |
+|------|-------|
+| Local build tree | `/Users/john/Project/image_make/.runtime/ComfyUI` + `comfyui-venv` |
+| 103 runtime base | `/Users/john/Project/comfyui-runtime` |
+| Current release (2026-07-30) | `20260730-222051-native-e87e7a81bb76` (**native launchd**) |
+| Publish entry | `bash scripts/release-comfyui-runtime-prod.sh --yes` (from local Mac) |
+| LaunchAgent | `cn.tkmind.comfyui` → `127.0.0.1:8188` |
+| Fingerprint | `config/comfyui/runtime.lock` + SD1.5 SHA256 |
+
+103 must **not** run `install_comfyui_runtime.sh` or download models directly; the local machine stages
+`/Users/john/Project/comfyui-runtime/releases/<id>/` with production paths, tars it, and scp installs it.
+
+Enable `comfyui` in Portal `h5_image_make_admin_config` only after ComfyUI is running.
+Current production: default `aliyun_bailian`, `comfyui` enabled as failover backup.
+
+Memind integration: HTTP client only (`image-make-client.mjs`); config via `IMAGE_MAKE_BASE_URL` + token. Docs: [image-make-integration.md](./image-make-integration.md).

docs/goosed-native-103-migration-plan.md

@@ -0,0 +1,365 @@
+# 103 生产 goosed 迁移计划：Docker/Colima → Native 多实例
+
+> **状态：** 已执行（2026-07-30 维护窗）  
+> **适用范围：** 103（`58.38.22.103` / Mac Studio）生产环境  
+> **目标运行时：** 去掉 goosed 对 Docker/Colima 的依赖，改为 native launchd 多实例（`18006`–`18014`）  
+> **前提：** 允许维护窗口停机；**不要求**进行中 SSE/工具任务不断线  
+> **关联拓扑：** [103-runtime-topology.md](./103-runtime-topology.md)  
+> **发布闸门：** [production-release-guardian.md](./production-release-guardian.md)、[发包必看.md](./发包必看.md)
+
+---
+
+## 1. 目标与边界
+
+### 1.1 要达成什么
+
+| 目标 | 说明 |
+|------|------|
+| 去掉 goosed Docker/Colima 池 | `goosed-prod-1..9` + canary 容器退役 |
+| 改为 native launchd 池 | 参考 103 已有 `tkmind_go-native` / 本机 `install-local-goosed-pool.sh` 模式，扩到 9 实例 |
+| 用户数据零丢失 | RDS、PostgreSQL、MindSpace 磁盘原样保留 |
+| 功能等价恢复 | 登录、聊天、续聊、页面生成、微信、Plaza/adm 等与迁移前一致 |
+| 消除 bind mount inode 漂移 | Portal 发版后不再依赖 `docker compose force-recreate` remount |
+
+### 1.2 「无缝」的定义（本计划）
+
+| 维度 | 本计划承诺 | 不承诺 |
+|------|------------|--------|
+| 账号、余额、MindSpace 页面、历史落库 | 零丢失 | — |
+| 系统功能 | 维护窗结束后等价恢复 | — |
+| 进行中的 SSE / 工具执行 | — | 不断线；用户需刷新或重开对话 |
+| 零停机 | — | 必须安排维护窗口 |
+
+架构约束（[memind-2-streaming-agent-runtime-plan.md](./architecture/memind-2-streaming-agent-runtime-plan.md)）：
+
+- 已存在 session **保持 worker affinity，不做中途迁移**
+- **不做无损中途迁移**，除非 goosed 支持完整 session restore
+
+### 1.3 不在本次范围
+
+- 103 迁到新物理机
+- 实例数从 9 缩到 2（首次迁移禁止同时缩容）
+- 修改 RDS / 用户 schema
+- 合并尚未走完发布闸门的 Portal 大功能（除非维护窗内单独批准发版）
+
+---
+
+## 2. 生产数据与依赖地图
+
+```text
+105 nginx (m.tkmind.cn)
+        │
+        ▼
+103 Portal :8081                    cn.tkmind.memind-portal
+        │
+        ├── 阿里云 RDS MySQL `goose`   用户、计费、h5_user_sessions.goosed_target、agent_run…
+        ├── MindSpace Service :8082   /Users/john/MindSpace（不动）
+        ├── memind_adm :8085          （不动）
+        ├── Plaza :3001               （不动）
+        │
+        ├── goosed 18006–18014        【本次替换】Docker → native
+        │       └── PG5432 memind_sessions（共享，不迁移数据）
+        │
+        ├── PG5433 mindspace_userdata_prod
+        ├── Redis :6379               运行时路由/指标（可清空重建）
+        └── 磁盘（Portal persist）
+              .env
+              /Users/john/MindSpace/data/mindspace
+              /Users/john/Project/Memind/users
+              /Users/john/Project/Memind/data
+              public/plaza-covers, logs, .tailscale
+```
+
+### 2.1 持久化清单（必须备份）
+
+与 `scripts/release-portal-runtime-prod.sh` manifest 一致：
+
+```text
+.env, MindSpace, data, users, .tailscale, public/plaza-covers, logs
+```
+
+**额外必须备份（不在 persist tar 内）：**
+
+| 资产 | 备份方式 |
+|------|----------|
+| 阿里云 RDS `goose` | 控制台快照 + 可选逻辑导出 |
+| PostgreSQL `memind_sessions` | `pg_dump` |
+| PostgreSQL `mindspace_userdata_prod` | `pg_dump` |
+| `goosed-prod` compose + `.env` + 镜像 tag | 目录 tar + `GOOSED_TAG` 记录 |
+| `tkmind_go-native`（若已存在） | 目录拷贝 |
+| Portal `.release-manifest.txt` | 记录 `release_id` / `git_head` |
+| 105 nginx `m.tkmind.cn` 等配置 | 发布脚本同款备份 |
+
+### 2.2 Session 与流量（迁移后行为不变）
+
+- **新对话：** Portal `pickTarget()` 在 `TKMIND_API_TARGETS` 上轮询 / Redis 负载评分
+- **老对话：** MySQL `h5_user_sessions.goosed_target` + Redis `session:{id}:target` 粘住原 `https://127.0.0.1:1800N`
+- **goosed 会话体：** PG `memind_sessions` 多实例共享；native 直连 `127.0.0.1:5432`（替代 Docker `host.docker.internal`）
+
+**首次迁移硬规则：native 仍监听 `18006`–`18014` 全端口**，与现网 `goosed_target` URL 兼容。
+
+---
+
+## 3. 迁移前准入条件（Gate）
+
+以下 **全部满足** 才允许申请 103 维护窗：
+
+### 3.1 本机验证（不动 103）
+
+| # | 项 | 命令 / 标准 |
+|---|-----|-------------|
+| 1 | native 双实例 soak | `node scripts/soak-local-goosed-pool.mjs --minutes 30 --interval 60` 通过 |
+| 2 | 池健康检查 | `node scripts/check-local-goosed-pool.mjs` |
+| 3 | Portal 多 target | `.env` 中 `TKMIND_API_TARGETS=18006,18007` + 续聊 / 新建 session 冒烟 |
+| 4 | native 指标 | `GOOSED_RUNTIME=native node scripts/runtime-worker-metrics.mjs status --dry-run` |
+| 5 | 安装脚本 | `bash scripts/install-local-goosed-pool.sh` 可重复执行 |
+| 6 | 发布脚本 native 分支 | `GOOSED_RUNTIME=native` 时 `release-portal-runtime-prod.sh` 不依赖 Docker remount（合并 main 后） |
+| 7 | 回滚演练 | 本机或 103 只读：Docker compose 停/起 + `/status` 全绿 |
+
+### 3.2 仓库与发布
+
+| # | 项 |
+|---|-----|
+| 1 | 相关脚本 / 文档已合并 `main`，CI 通过 |
+| 2 | `bash scripts/check-release-ready.sh` 通过 |
+| 3 | 生产发布守门员 Core + Impact Gate report 已准备（与维护窗发版 commit 绑定） |
+| 4 | 用户 **明确批准** 103 维护窗与迁移执行（口头「继续」不构成批准） |
+
+### 3.3 103 只读基线（迁移前 24h 内采集）
+
+```bash
+# 只读，禁止改 103
+ssh john@58.38.22.103 'cat /Users/john/Project/Memind/.release-manifest.txt'
+ssh john@58.38.22.103 'grep ^TKMIND_API_TARGETS= /Users/john/Project/Memind/.env'
+ssh john@58.38.22.103 'grep ^GOOSED_TAG= /Users/john/Project/goosed-prod/.env'
+ssh john@58.38.22.103 'for p in $(seq 18006 18014); do curl -kfsS --connect-timeout 2 https://127.0.0.1:$p/status; echo; done'
+ssh john@58.38.22.103 'curl -fsS http://127.0.0.1:8082/mindspace/v1/contract | head -c 400'
+```
+
+保存到本机 `test/_103_baselines/pre-native-migration-YYYYMMDD/`。
+
+---
+
+## 4. 维护窗口执行计划
+
+**建议窗口：** ≥ 30 分钟（9 实例安装 + provider 同步 + 回归）  
+**建议时段：** 低峰 + 可联系 105 改 nginx 的人员在场
+
+### Phase 0 — 备份（T0 前，可先执行）
+
+- [ ] RDS 快照
+- [ ] `pg_dump memind_sessions`、`mindspace_userdata_prod`
+- [ ] 103 上执行 persist 备份（或等价 `memind-persisted-*-before.tar.gz`）
+- [ ] 全目录 / compose / 105 nginx 备份
+- [ ] 记录：`release_id`、`GOOSED_TAG`、九个 Docker 容器 ID、`TKMIND_API_TARGETS`
+
+### Phase 1 — 切流量（停机开始）
+
+- [ ] 105：维护页或 upstream 指向维护（禁止新用户进入）
+- [ ] 103：可选公告 / 微信模板（「系统维护约 N 分钟」）
+- [ ] **Soft drain（推荐，最多等 10 分钟）：**
+
+```bash
+# 103 上，对每个 worker 设 drain，等待 active_streams 归零
+# 见 memind-2-streaming-agent-runtime-plan.md P5 drain 说明
+docker exec memind-runtime-redis redis-cli SET memind:runtime:worker:goosed-N:drain 1
+curl -sk https://m.tkmind.cn/api/runtime/status   # 观察 activeStreams
+```
+
+- [ ] 超时后 **硬停**：`cn.tkmind.memind-portal`（或仅阻止新 session，视 drain 结果）
+
+### Phase 2 — 替换 goosed 运行时
+
+- [ ] 停止 Docker goosed 池：
+
+```bash
+cd /Users/john/Project/goosed-prod
+docker compose -f docker-compose.prod.yml down
+docker rm -f goosed-prod-canary 2>/dev/null || true
+```
+
+- [ ] 部署 native 9 实例（目录模式参考 `tkmind_go-native`，端口 `18006`–`18014`）：
+  - 同一 `GOOSE_SESSION_DB_URL` → `memind_sessions`
+  - `GOOSE_TLS=true`
+  - `GOOSED_MCP_CONTAINERIZED=0`
+  - `GOOSED_MCP_*` 使用宿主机路径（与 Portal `.env` 一致）
+  - `MINDSPACE_STORAGE_ROOT=/Users/john/MindSpace/data/mindspace`
+  - `PORTAL_RUNTIME_DIR=/Users/john/Project/Memind`
+
+- [ ] 更新 Portal `.env`（若需要）：
+  - `TKMIND_API_TARGETS=https://127.0.0.1:18006,...,https://127.0.0.1:18014`（**含 18006**）
+  - `GOOSED_RUNTIME=native`
+  - DeepSeek no-think：`127.0.0.1:18036`（去掉 `host.docker.internal` 依赖）
+
+- [ ] **MindSpace :8082、RDS、磁盘：不移动、不删**
+
+- [ ] Provider 同步到 **全部 9 个 target**
+
+- [ ] 验收九个 `/status`：
+
+```bash
+for p in $(seq 18006 18014); do
+  echo -n "$p: "
+  curl -kfsS --connect-timeout 3 "https://127.0.0.1:$p/status" || echo FAIL
+done
+```
+
+### Phase 3 — Portal 与附属服务
+
+**若维护窗内无 Portal 代码变更：**
+
+- [ ] 重启 `cn.tkmind.memind-portal`（读新 `.env`）
+- [ ] **跳过** Docker remount 步骤
+
+**若维护窗内包含 Portal runtime 发版：**
+
+- [ ] 按 [发包必看.md](./发包必看.md) 走 canary 或晋升流程
+- [ ] 发版脚本使用 `GOOSED_RUNTIME=native` 检查链
+- [ ] MindSpace contract `gitSha` 与 manifest 对齐
+
+**始终确认仍在运行：**
+
+- [ ] `cn.tkmind.mindspace-service` :8082
+- [ ] memind_adm :8085、Plaza :3001、imgproxy、SearXNG、agent-run-worker、DeepSeek no-think :18036
+
+### Phase 4 — 功能回归（103 localhost + 105 外网）
+
+| 优先级 | 场景 | 验证方式 |
+|--------|------|----------|
+| P0 | Portal `/api/status` | `curl http://127.0.0.1:8081/api/status` |
+| P0 | 登录 / 鉴权 | `/auth/login`、`/auth/status` |
+| P0 | 新建对话 | H5 开聊，检查 `h5_user_sessions.goosed_target` 分布 |
+| P0 | **旧对话续聊** | 维护前存在的 session，迁移后 `/reply` 成功 |
+| P0 | 页面列表 / 公开页 | MindSpace remote + 已有 HTML 可访问 |
+| P1 | page.generate / edit_file | workspace 落盘 + `public/*.html` |
+| P1 | 微信真实回调 | 非仅 health |
+| P1 | MindSearch / 图片 imgproxy | 生产 URL |
+| P1 | agent-run worker | 队列消费 |
+| P2 | Plaza、adm 后台 | 各端口 health |
+
+生产 Gate：维护窗发版 commit 须绑定 **Core + Impact Gate report**（见 production-release-guardian）。
+
+### Phase 5 — 恢复流量
+
+- [ ] 105 nginx 恢复 `58.38.22.103:8081`（或既定 upstream）
+- [ ] 外网抽样：`https://m.tkmind.cn/api/status`
+- [ ] 维护结束公告
+
+### Phase 6 — 迁移后观察（24–72h）
+
+- [ ] `GOOSED_RUNTIME=native node scripts/runtime-worker-metrics.mjs sample`
+- [ ] native FD 监控（`monitor-goosed-fds.mjs`，覆盖 `18006`–`18014`）
+- [ ] Redis worker 指标、SLO report 无异常尖刺
+- [ ] 用户续聊 / 页面生成无集中投诉
+
+---
+
+## 5. 回滚计划
+
+**触发条件：** P0 回归失败、九个 target 无法全绿、旧 session 批量无法续聊、FD 泄漏导致整机不稳定
+
+**目标时间：** 维护窗内 < 15 分钟完成回滚
+
+| 步骤 | 操作 |
+|------|------|
+| 1 | 105 维护页保持 |
+| 2 | 停 native launchd 池（`18006`–`18014`） |
+| 3 | `cd goosed-prod && docker compose -f docker-compose.prod.yml up -d`（**原 GOOSED_TAG**） |
+| 4 | `.env` 恢复备份：`TKMIND_API_TARGETS`、Docker MCP 路径、`GOOSED_RUNTIME=docker` |
+| 5 | 若 Portal 已发新版：回滚至备份 `release_id` runtime |
+| 6 | 九容器 healthy + provider 同步 + `/status` 全绿 |
+| 7 | 105 恢复流量 |
+
+**回滚不需要：** 恢复 RDS / PG（迁移中若未改库）。
+
+---
+
+## 6. 配置对照表（Docker → Native）
+
+| 配置项 | Docker 生产（现） | Native 生产（目标） |
+|--------|-------------------|---------------------|
+| goosed 进程 | `goosed-prod-1..9` 容器 | `com.tkmind.goosed-native-1800N` launchd |
+| Session PG | `host.docker.internal:5432` | `127.0.0.1:5432` |
+| MCP | 容器内 `/usr/local/bin/node` 等 | 宿主机 `GOOSED_MCP_*` |
+| `GOOSED_MCP_CONTAINERIZED` | 隐式容器 | `0` 或不设 |
+| Portal remount | 发版后 `compose force-recreate` | **不需要** |
+| 监控 | `monitor-goosed-containers.mjs` | `monitor-goosed-fds.mjs`（扩展全端口） |
+| 指标 | `runtime-worker-metrics` docker | `GOOSED_RUNTIME=native` |
+| Canary goosed | `goosed-prod-canary:18015` | native `18015`（Phase 2 后单独迁移） |
+
+---
+
+## 7. 风险与缓解
+
+| 风险 | 严重度 | 缓解 |
+|------|--------|------|
+| 进行中对话全部中断 | 高 | 维护公告；soft drain；恢复后提示刷新 |
+| 旧 session PG restore 失败 | 高 | 迁移前用 PG 副本在 staging 验续聊 |
+| provider 未覆盖全 target | 高 | 自动化检查 + 发版脚本 gate |
+| MCP 路径 / sandbox 失败 | 高 | `page.generate` smoke + sandbox-fs |
+| `goosed_target` 指向已下线端口 | 中 | 首次迁移保持 9 端口不变 |
+| native FD 泄漏 ×9 | 中 | 72h 监控 + kickstart 阈值 |
+| MindSpace / Portal 版本漂移 | 中 | contract gitSha 对账 |
+| 105 切流后 CDN/缓存 | 低 | 外网真实 URL 验证 |
+
+---
+
+## 8. 时间线模板
+
+| 时点 | 动作 | 环境 |
+|------|------|------|
+| T-14d | 本机 native 双实例 → 脚本 native 化完成 | 本机 |
+| T-7d | 本机 native 9 实例 soak（若与生产同构） | 本机 |
+| T-3d | 103 只读基线 + 备份演练 + Docker 回滚演练 | 103 只读/演练 |
+| T-1d | 维护公告定稿；105 维护页脚本就绪 | 105 |
+| T0 | Phase 0–5 执行 | 103 + 105 |
+| T+24h | FD / 续聊 / 微信观察 | 103 |
+| T+7d | 评审：是否退役 Colima、删 Docker 镜像、更新 topology 文档 | 文档 |
+| T+30d | 可选：评估实例缩容（**单独变更**，不在本计划内） | — |
+
+---
+
+## 9. 迁移后文档更新
+
+迁移成功并稳定 7 天后：
+
+- [ ] 更新 [103-runtime-topology.md](./103-runtime-topology.md)（goosed 段改为 native 9 实例）
+- [ ] 更新 [发包必看.md](./发包必看.md) §5 goosed 镜像 → native 二进制发布
+- [ ] 在 [docs/branch-disposition.md](./branch-disposition.md) 登记相关功能分支（若适用）
+- [ ] 归档 Docker compose 回滚包位置与 `GOOSED_TAG`
+
+---
+
+## 10. 本仓库工具索引
+
+| 用途 | 路径 |
+|------|------|
+| 本机安装 native 池 | `bash scripts/install-local-goosed-pool.sh` |
+| 池健康检查 | `node scripts/check-local-goosed-pool.mjs` |
+| 长跑 soak | `node scripts/soak-local-goosed-pool.mjs` |
+| native worker 指标 | `GOOSED_RUNTIME=native node scripts/runtime-worker-metrics.mjs` |
+| FD 监控 | `scripts/monitor-goosed-fds.mjs` + `scripts/install-goosed-monitor.sh` |
+| Portal 生产发布 | `scripts/release-portal-runtime-prod.sh` |
+| 发布就绪 | `bash scripts/check-release-ready.sh` |
+
+---
+
+## 11. 批准记录（执行时填写）
+
+| 字段 | 值 |
+|------|-----|
+| 维护窗口 | YYYY-MM-DD HH:MM – HH:MM (UTC+8) |
+| 执行人 | |
+| Portal `git_head` | |
+| Native goosed 二进制 / release | |
+| 回滚 `GOOSED_TAG` | |
+| RDS 快照 ID | |
+| persist_backup 路径 | |
+| Gate report ID | |
+| 结果 | 成功 / 回滚 |
+| 备注 | |
+
+---
+
+**版本：** 2026-07-30 v1  
+**下次评审：** 本机 Phase 3（发布脚本 native 分支）合并 main 后

docs/openhands-install.md

@@ -1,5 +1,10 @@
 # OpenHands 安装说明
 
+> **本机 Colima 已迁出（2026-07-29）**。日常开发请优先使用
+> [`/Users/john/Project/memind-local-openhands`](../memind-local-openhands/README.md)
+> 与 [`memind-local-infra/MIGRATION.md`](/Users/john/Project/memind-local-infra/MIGRATION.md)。
+> 下文 Colima compose 章节仅作历史参考。
+
 > 目标：先把 OpenHands 独立安装并跑起来，确认可用后，再接入 Goose / 路由策略。
 >
 > 原则：安装阶段不改动现有 Goose 服务，不影响当前生产/测试链路。

docs/regression-guards/page-data-delivery-contract.md

@@ -7,6 +7,16 @@ Page Data 页面只有在下面所有条件满足后才可向用户交付链接
 3. page record、online publication 与 policy 使用同一个真实 page UUID。
 4. 公开页完成一次受权限约束的 insert smoke；后台页完成 password auth 后的 read smoke。
 
+## 页面空间配额（grace write）
+
+MindSpace **页面 HTML**（`public/*.html`、`draft/*.html`）配额策略：
+
+- **尚未超配额**但剩余空间不足：允许当次页面写完并完成 bind（grace write）。
+- **已经超配额**（`used_bytes + reserved_bytes >= quota_bytes`）：下一次 `write_file` / `edit_file` / bind / 发布必须直接失败，提示用户先清理空间。
+- grace **不覆盖**图片/附件等非页面 HTML 资产。
+
+Agent 不得在空间已满时交付 Page Data 链接；不得只写 slug policy 文件而不完成 `private_data_bind_workspace_page`。
+
 `private_data_bind_workspace_page` 是硬门：它在创建 page / publication / policy 前，必须从 SQLite registry 派生权限。Agent 传入的策略不能凭空创建 dataset 或字段权限。
 
 运行时路径必须按语义区分：

mindspace-local-runtime-services.mjs

@@ -128,6 +128,7 @@ export function createMindSpaceLocalRuntimeServices({
       syncWorkspaceAssets,
       conversationArtifactService,
       workspacePageDeliveryService,
+      getQuotaPool: () => pool,
     });
   const cleanupService = createCleanupService(pool, {
     storageRoot: runtime.storageRoot,

mindspace-pages.mjs

@@ -22,6 +22,7 @@ import { prepareHtmlPageBrandMarkers } from './mindspace-page-tag.mjs';
 import { purgeWorkspacePageArtifacts, extractAssetIdsFromHtml } from './mindspace-page-purge.mjs';
 import { ensureWorkspaceHtmlThumbnail, workspaceThumbnailRelativePath } from './mindspace-workspace-thumbnails.mjs';
 import { upsertMindspaceCoverMeta } from './mindspace-cover-meta.mjs';
+import { assertPageWriteQuota } from './mindspace-space-quota.mjs';
 
 const MAX_TITLE_LENGTH = 255;
 const MAX_SUMMARY_LENGTH = 1000;
@@ -393,13 +394,10 @@ export function createPageService(pool, options = {}) {
       if (!space || space.status !== 'active') {
         throw pageError('用户空间不可用', 'space_unavailable');
       }
-      const available =
-        asNumber(space.quota_bytes) - asNumber(space.used_bytes) - asNumber(space.reserved_bytes);
-      if (available < normalized.contentBytes) {
-        throw pageError('剩余空间不足', 'quota_exceeded', {
-          requiredBytes: normalized.contentBytes,
-          availableBytes: Math.max(0, available),
-        });
+      try {
+        assertPageWriteQuota(space, normalized.contentBytes);
+      } catch (error) {
+        throw pageError(error.message, error.code ?? 'quota_exceeded', error.details);
       }
       const [categories] = await conn.query(
         `SELECT id, category_code FROM h5_space_categories

mindspace-publications.mjs

@@ -21,6 +21,7 @@ import {
   inferWorkspaceHtmlRelativePath,
 } from './mindspace-html-download-links.mjs';
 import { createImgproxySigner } from './imgproxy-signer.mjs';
+import { assertPageWriteQuota } from './mindspace-space-quota.mjs';
 
 const SCANNER_VERSION = 'mindspace-content-v1';
 const PRIVATE_ASSET_DOWNLOAD_URL_PATTERN =
@@ -723,15 +724,10 @@ export function createPublicationService(pool, options = {}) {
          WHERE id = ? AND user_id = ? FOR UPDATE`,
         [page.space_id, userId],
       );
-      const available =
-        Number(spaces[0]?.quota_bytes ?? 0) -
-        Number(spaces[0]?.used_bytes ?? 0) -
-        Number(spaces[0]?.reserved_bytes ?? 0);
-      if (available < htmlBytes) {
-        throw publicationError('剩余空间不足', 'quota_exceeded', {
-          requiredBytes: htmlBytes,
-          availableBytes: Math.max(0, available),
-        });
+      try {
+        assertPageWriteQuota(spaces[0], htmlBytes);
+      } catch (error) {
+        throw publicationError(error.message, error.code ?? 'quota_exceeded', error.details);
       }
       const [publicationUsage] = await conn.query(
         `SELECT COUNT(DISTINCT page_id) AS public_page_used,

mindspace-scan.mjs

@@ -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,

mindspace-scan.test.mjs

@@ -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',

mindspace-space-quota.mjs

@@ -0,0 +1,110 @@
+function asQuotaNumber(value) {
+  return Number(value ?? 0);
+}
+
+export function computeUserSpaceQuotaStats(space = {}) {
+  const quotaBytes = asQuotaNumber(space.quota_bytes);
+  const usedBytes = asQuotaNumber(space.used_bytes);
+  const reservedBytes = asQuotaNumber(space.reserved_bytes);
+  const occupiedBytes = usedBytes + reservedBytes;
+  const availableBytes = quotaBytes - occupiedBytes;
+  return {
+    quotaBytes,
+    usedBytes,
+    reservedBytes,
+    occupiedBytes,
+    availableBytes,
+    isOverQuota: occupiedBytes >= quotaBytes,
+  };
+}
+
+/**
+ * Page write grace policy:
+ * - Already at/above quota: block the next page write entirely.
+ * - Below quota but insufficient headroom: allow this write (may exceed quota).
+ * - Sufficient headroom: allow normally.
+ */
+export function evaluatePageWriteQuota(space, requiredBytes) {
+  const stats = computeUserSpaceQuotaStats(space);
+  const required = Math.max(0, asQuotaNumber(requiredBytes));
+  if (stats.isOverQuota) {
+    return {
+      allowed: false,
+      grace: false,
+      stats,
+      requiredBytes: required,
+      reason: 'over_quota',
+    };
+  }
+  if (stats.availableBytes >= required) {
+    return {
+      allowed: true,
+      grace: false,
+      stats,
+      requiredBytes: required,
+      reason: 'sufficient',
+    };
+  }
+  return {
+    allowed: true,
+    grace: true,
+    stats,
+    requiredBytes: required,
+    reason: 'grace_write',
+  };
+}
+
+export function buildPageWriteQuotaError(
+  evaluation,
+  { messagePrefix = '剩余空间不足' } = {},
+) {
+  const { stats, requiredBytes, reason } = evaluation;
+  const message =
+    reason === 'over_quota'
+      ? '空间已满，请先清理后再创建或修改页面'
+      : messagePrefix;
+  return Object.assign(new Error(message), {
+    code: 'quota_exceeded',
+    details: {
+      requiredBytes,
+      availableBytes: Math.max(0, stats.availableBytes),
+      usedBytes: stats.usedBytes,
+      quotaBytes: stats.quotaBytes,
+      overQuota: reason === 'over_quota',
+      graceWrite: reason === 'grace_write',
+    },
+  });
+}
+
+export function assertPageWriteQuota(space, requiredBytes) {
+  const evaluation = evaluatePageWriteQuota(space, requiredBytes);
+  if (!evaluation.allowed) {
+    throw buildPageWriteQuotaError(evaluation);
+  }
+  return evaluation;
+}
+
+export function isMindSpacePageWriteRelativePath(relativePath) {
+  const normalized = String(relativePath ?? '').replace(/\\/g, '/').trim();
+  if (!normalized.toLowerCase().endsWith('.html')) return false;
+  const zone = normalized.split('/')[0]?.toLowerCase();
+  return zone === 'public' || zone === 'draft';
+}
+
+export async function loadUserSpaceForQuota(pool, userId) {
+  if (!pool || !userId) return null;
+  const [rows] = await pool.query(
+    `SELECT id, quota_bytes, used_bytes, reserved_bytes, status
+     FROM h5_user_spaces WHERE user_id = ? LIMIT 1`,
+    [userId],
+  );
+  return rows[0] ?? null;
+}
+
+export async function assertPageWriteQuotaForUser(pool, userId, requiredBytes) {
+  const space = await loadUserSpaceForQuota(pool, userId);
+  if (!space || space.status !== 'active') {
+    throw Object.assign(new Error('用户空间不可用'), { code: 'space_unavailable' });
+  }
+  return assertPageWriteQuota(space, requiredBytes);
+}

mindspace-space-quota.test.mjs

@@ -0,0 +1,49 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  assertPageWriteQuota,
+  evaluatePageWriteQuota,
+  isMindSpacePageWriteRelativePath,
+} from './mindspace-space-quota.mjs';
+
+const baseSpace = {
+  quota_bytes: 100,
+  used_bytes: 80,
+  reserved_bytes: 0,
+};
+
+test('evaluatePageWriteQuota allows normal writes within headroom', () => {
+  assert.deepEqual(evaluatePageWriteQuota(baseSpace, 15).reason, 'sufficient');
+});
+
+test('evaluatePageWriteQuota allows grace write when headroom is insufficient but not over quota', () => {
+  const result = evaluatePageWriteQuota(baseSpace, 30);
+  assert.equal(result.reason, 'grace_write');
+  assert.equal(result.allowed, true);
+  assert.equal(result.grace, true);
+});
+
+test('evaluatePageWriteQuota blocks next write after quota is exhausted', () => {
+  const over = { quota_bytes: 100, used_bytes: 100, reserved_bytes: 0 };
+  const result = evaluatePageWriteQuota(over, 1);
+  assert.equal(result.reason, 'over_quota');
+  assert.equal(result.allowed, false);
+});
+
+test('assertPageWriteQuota throws over-quota message for subsequent writes', () => {
+  const over = { quota_bytes: 100, used_bytes: 101, reserved_bytes: 0 };
+  assert.throws(
+    () => assertPageWriteQuota(over, 1),
+    (error) =>
+      error.code === 'quota_exceeded' &&
+      error.message.includes('空间已满') &&
+      error.details?.overQuota === true,
+  );
+});
+
+test('isMindSpacePageWriteRelativePath matches public and draft html only', () => {
+  assert.equal(isMindSpacePageWriteRelativePath('public/bug-tracker.html'), true);
+  assert.equal(isMindSpacePageWriteRelativePath('draft/report.html'), true);
+  assert.equal(isMindSpacePageWriteRelativePath('private/notes.html'), false);
+  assert.equal(isMindSpacePageWriteRelativePath('public/data.json'), false);
+});

mindspace-workspace-sync.mjs

@@ -11,6 +11,7 @@ import { resolveAssetWorkspaceRelativePath } from './mindspace-workspace-path.mj
 import { assetInternals } from './mindspace-assets.mjs';
 import { runBasicFileScan } from './mindspace-scan.mjs';
 import { buildWorkspaceStorageKey } from './workspace-storage.mjs';
+import { assertPageWriteQuota } from './mindspace-space-quota.mjs';
 
 const SKIP_FILENAMES = new Set(['index.html', '.tkmindhints', '.goosehints', '.ls_output']);
 const SKIP_ZONE_DIR_NAMES = new Set([
@@ -186,10 +187,13 @@ export function createWorkspaceAssetSync({
       if (!space || space.status !== 'active') {
         throw Object.assign(new Error('用户空间不可用'), { code: 'space_unavailable' });
       }
-      const available =
-        asNumber(space.quota_bytes) - asNumber(space.used_bytes) - asNumber(space.reserved_bytes);
-      if (available < buffer.length) {
-        throw Object.assign(new Error('剩余空间不足'), { code: 'quota_exceeded' });
+      try {
+        assertPageWriteQuota(space, buffer.length);
+      } catch (error) {
+        throw Object.assign(new Error(error.message), {
+          code: error.code ?? 'quota_exceeded',
+          details: error.details,
+        });
       }
 
       const detectedMimeType = assetInternals.detectMimeType(buffer, file.filename);
@@ -346,10 +350,15 @@ export function createWorkspaceAssetSync({
         };
       }
       const sizeDelta = buffer.length - asNumber(currentAsset.size_bytes);
-      const available =
-        asNumber(space.quota_bytes) - asNumber(space.used_bytes) - asNumber(space.reserved_bytes);
-      if (sizeDelta > 0 && available < sizeDelta) {
-        throw Object.assign(new Error('剩余空间不足'), { code: 'quota_exceeded' });
+      if (sizeDelta > 0) {
+        try {
+          assertPageWriteQuota(space, sizeDelta);
+        } catch (error) {
+          throw Object.assign(new Error(error.message), {
+            code: error.code ?? 'quota_exceeded',
+            details: error.details,
+          });
+        }
       }
       const versionId = currentAsset.current_version_id;
       if (!versionId) {

mindspace-workspace-tool-service.mjs

@@ -13,6 +13,10 @@ import {
 import {
   UPLOAD_ZONE_CODES,
 } from './user-space.mjs';
+import {
+  assertPageWriteQuotaForUser,
+  isMindSpacePageWriteRelativePath,
+} from './mindspace-space-quota.mjs';
 
 function workspaceToolError(message, code) {
   return Object.assign(new Error(message), { code });
@@ -330,6 +334,9 @@ export function createMindSpaceWorkspaceToolService({
   maxBinaryWriteBytes = 8 * 1024 * 1024,
   maxGeneratedBinaryBytes =
     40 * 1024 * 1024,
+  assertPageWriteQuotaForUserFn =
+    assertPageWriteQuotaForUser,
+  getQuotaPool = null,
 } = {}) {
   if (!h5Root) {
     throw new Error(
@@ -395,6 +402,23 @@ export function createMindSpaceWorkspaceToolService({
     };
   };
 
+  const ensurePageWriteAllowed = async ({
+    userId,
+    relativePath,
+    requiredBytes,
+  }) => {
+    if (
+      !getQuotaPool ||
+      typeof assertPageWriteQuotaForUserFn !== 'function' ||
+      !isMindSpacePageWriteRelativePath(relativePath)
+    ) {
+      return;
+    }
+    const pool = getQuotaPool();
+    if (!pool) return;
+    await assertPageWriteQuotaForUserFn(pool, userId, requiredBytes);
+  };
+
   const registerWrite = async ({
     scope,
     relativePath,
@@ -523,6 +547,11 @@ export function createMindSpaceWorkspaceToolService({
         content,
         { relativePath },
       );
+      await ensurePageWriteAllowed({
+        userId: scope.userId,
+        relativePath,
+        requiredBytes: sizeBytes,
+      });
       const target =
         await resolveWritableWorkspacePath(
           scope.workspaceRoot,
@@ -620,6 +649,12 @@ export function createMindSpaceWorkspaceToolService({
         updated,
         { relativePath },
       );
+      const originalSizeBytes = mimeSafeByteLength(original);
+      await ensurePageWriteAllowed({
+        userId: scope.userId,
+        relativePath,
+        requiredBytes: Math.max(0, sizeBytes - originalSizeBytes),
+      });
       await fs.writeFile(target, updated, 'utf8');
       const registration = await registerWrite({
         scope,

package.json

@@ -48,6 +48,7 @@
     "test:release-gate:all": "node scripts/run-release-gate.mjs --mode all",
     "verify:release-gate-report": "node scripts/verify-release-gate-report.mjs",
     "build:imgproxy-runtime": "bash scripts/build-imgproxy-runtime-image.sh",
+    "build:imgproxy-runtime-native": "bash scripts/build-imgproxy-runtime-native.sh",
     "build:mindspace-service-runtime": "node scripts/build-mindspace-service-runtime.mjs",
     "check:mindspace-public-links": "node scripts/check-mindspace-public-links.mjs --downloads-only",
     "check:mindspace-public-links:all": "node scripts/check-mindspace-public-links.mjs --all-links",

page-data-browser-client.mjs

@@ -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'));
     },

page-data-collect-skill.test.mjs

@@ -18,3 +18,16 @@ test('page-data-collect skill pins deletion to the public client API', () => {
   assert.match(skillText, /禁止发明 `softDeleteRows`/);
   assert.match(skillText, /表必须包含 `deleted_at TIMESTAMPTZ`/);
 });
+
+test('page-data-collect skill documents page quota grace and delivery URLs', () => {
+  assert.match(skillText, /本次写完、下次再拦/);
+  assert.match(skillText, /127\.0\.0\.1:8081\/MindSpace/);
+  assert.match(skillText, /禁止.*本地服务/);
+  assert.match(skillText, /pageId.*UUID/);
+});
+
+test('page-data-collect skill requires independent table per delivery task', () => {
+  assert.match(skillText, /每个独立交付任务必须独立建表/);
+  assert.match(skillText, /禁止复用已有表/);
+  assert.match(skillText, /禁止.*为新的独立页面复用已有 dataset/);
+});

public/assets/page-data-client.js

@@ -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'));
       },

release-gate/deepseek-production-parity.test.mjs

@@ -56,6 +56,7 @@ test('Gate, artifact, candidate routing and rollback share one compatibility con
   const [
     builder,
     localStack,
+    stableRunner,
     candidateRunner,
     compatRunner,
     canaryRelease,
@@ -63,6 +64,7 @@ test('Gate, artifact, candidate routing and rollback share one compatibility con
   ] = await Promise.all([
     fs.readFile(path.join(ROOT, 'scripts', 'build-portal-runtime.mjs'), 'utf8'),
     fs.readFile(path.join(ROOT, 'release-gate', 'local-stack.mjs'), 'utf8'),
+    fs.readFile(path.join(ROOT, 'scripts', 'run-memind-portal-prod.sh'), 'utf8'),
     fs.readFile(path.join(ROOT, 'scripts', 'run-memind-portal-candidate.sh'), 'utf8'),
     fs.readFile(
       path.join(ROOT, 'scripts', 'run-deepseek-compat-proxy-candidate.sh'),
@@ -77,6 +79,8 @@ test('Gate, artifact, candidate routing and rollback share one compatibility con
     localStack,
     /path\.join\(resolvedPortalRoot, 'deepseek-no-think-proxy\.mjs'\)/,
   );
+  assert.match(stableRunner, /export MEMIND_DEEPSEEK_DISABLE_THINKING="\$\{MEMIND_DEEPSEEK_DISABLE_THINKING:-1\}"/);
+  assert.match(stableRunner, /export MEMIND_GOOSED_HOST_GATEWAY="\$\{MEMIND_GOOSED_HOST_GATEWAY:-host\.docker\.internal\}"/);
   assert.match(candidateRunner, /export MEMIND_DEEPSEEK_DISABLE_THINKING=1/);
   assert.match(candidateRunner, /export MEMIND_GOOSED_HOST_GATEWAY=host\.docker\.internal/);
   assert.match(compatRunner, /source "\$\{STABLE_ROOT\}\/\.env"/);

release-gate/local-stack.mjs

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import fsp from 'node:fs/promises';
+import net from 'node:net';
 import path from 'node:path';
 
 import mysql from 'mysql2/promise';
@@ -13,6 +14,37 @@ import { assertNonProductionTarget } from './safety.mjs';
 const { Client: PgClient } = pg;
 const SAFE_DB_NAME = /^[a-z][a-z0-9_]{5,62}$/;
 
+const ISOLATED_GATE_REMOTE_ENV_KEYS = [
+  'MINDSPACE_REMOTE_BASE_URL',
+  'MINDSPACE_REMOTE_AUTH_TOKEN',
+  'MINDSPACE_MCP_BASE_URL',
+  'MINDSPACE_MCP_TOKEN_SECRET',
+];
+
+/**
+ * Release gate stacks must not inherit split-service MindSpace MCP routing from
+ * the developer .env. Scoped MCP tokens would target the standalone 8082 service
+ * and resolve workspace paths against the host H5 root instead of the isolated
+ * gate sandbox, causing sandbox-fs write_file/publish_page ENOENT failures.
+ */
+export function sanitizeIsolatedGatePortalEnv(
+  env,
+  { port, runtimeProfile = 'local' } = {},
+) {
+  const sanitized = { ...env };
+  for (const key of ISOLATED_GATE_REMOTE_ENV_KEYS) {
+    delete sanitized[key];
+  }
+  sanitized.MEMIND_RUNTIME_PROFILE = runtimeProfile;
+  sanitized.MINDSPACE_SERVER_ADAPTER = 'local';
+  if (port != null) {
+    const portalBase = `http://127.0.0.1:${port}`;
+    sanitized.H5_PORTAL_BASE_URL = portalBase;
+    sanitized.MINDSPACE_AGENT_API_BASE_URL = `${portalBase}/api`;
+  }
+  return sanitized;
+}
+
 function assertLoopbackHost(host, label) {
   const normalized = String(host ?? '').toLowerCase();
   if (!['localhost', '127.0.0.1', '::1', '/tmp'].includes(normalized)) {
@@ -173,14 +205,44 @@ export async function selectBackendLlmProvider({
   }
 }
 
+export function assertGatePortAvailable(port, host = '127.0.0.1') {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.once('error', (error) => {
+      if (error?.code === 'EADDRINUSE') {
+        reject(new Error(
+          `Release gate port ${host}:${port} is already in use; stop the stale local gate process before retrying`,
+        ));
+        return;
+      }
+      reject(error);
+    });
+    server.once('listening', () => {
+      server.close((closeError) => {
+        if (closeError) reject(closeError);
+        else resolve();
+      });
+    });
+    server.listen(port, host);
+  });
+}
+
 async function waitForPortal(baseUrl, child, timeoutMs = 60_000) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     if (child.exitCode !== null) throw new Error(`isolated Portal exited with code ${child.exitCode}`);
     try {
       const response = await fetch(`${baseUrl}/auth/status`, { signal: AbortSignal.timeout(1_000) });
-      if (response.ok) return;
-    } catch {
+      if (response.ok) {
+        if (child.exitCode !== null) {
+          throw new Error(`isolated Portal exited with code ${child.exitCode} after health check`);
+        }
+        return;
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('isolated Portal exited')) {
+        throw error;
+      }
       // Startup can take several seconds while the isolated schema is initialized.
     }
     await new Promise((resolve) => setTimeout(resolve, 250));
@@ -188,6 +250,42 @@ async function waitForPortal(baseUrl, child, timeoutMs = 60_000) {
   throw new Error(`isolated Portal did not become ready: ${baseUrl}`);
 }
 
+export async function grantGateUserSkillsByUsername({
+  targetUrl,
+  username,
+  skillNames,
+}) {
+  assertNonProductionTarget(targetUrl, 'isolated gate database');
+  const normalizedUsername = String(username ?? '').trim();
+  const skills = [...new Set(
+    (Array.isArray(skillNames) ? skillNames : [])
+      .map((name) => String(name ?? '').trim())
+      .filter(Boolean),
+  )];
+  if (!normalizedUsername || skills.length === 0) return { userId: null, granted: [] };
+  const target = await mysql.createConnection(targetUrl);
+  try {
+    const [rows] = await target.query(
+      'SELECT id FROM h5_users WHERE username = ? LIMIT 1',
+      [normalizedUsername],
+    );
+    const userId = rows[0]?.id ?? null;
+    if (!userId) throw new Error(`Release gate user not found for skill grant: ${normalizedUsername}`);
+    const now = Date.now();
+    for (const skillName of skills) {
+      await target.execute(
+        `INSERT INTO h5_user_skill_grants (subject_type, subject_id, skill_name, enabled, updated_at)
+         VALUES ('user', ?, ?, 1, ?)
+         ON DUPLICATE KEY UPDATE enabled = VALUES(enabled), updated_at = VALUES(updated_at)`,
+        [userId, skillName, now],
+      );
+    }
+    return { userId, granted: skills };
+  } finally {
+    await target.end();
+  }
+}
+
 async function waitForHttpHealth(baseUrl, child, label, timeoutMs = 30_000) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -377,6 +475,7 @@ export async function createLocalGateStack({
   async function startPortal() {
     if (!childEnv || !baseUrl) throw new Error('isolated Portal environment is not initialized');
     if (child && child.exitCode === null) throw new Error('isolated Portal is already running');
+    await assertGatePortAvailable(port);
     deepseekProxyLogFd = fs.openSync(deepseekProxyLogPath, 'a');
     deepseekProxyChild = spawn(
       process.execPath,
@@ -408,10 +507,10 @@ export async function createLocalGateStack({
   try {
     mysqlUrl = await createMysqlDatabase(baseEnv.DATABASE_URL, mysqlDatabase);
     pgUrl = await createPgDatabase(baseEnv.MINDSPACE_USERDATA_PG_URL, pgDatabase);
+    childEnv = sanitizeIsolatedGatePortalEnv(baseEnv, { port, runtimeProfile });
     childEnv = {
-      ...baseEnv,
+      ...childEnv,
       NODE_ENV: nodeEnv,
-      ...(runtimeProfile ? { MEMIND_RUNTIME_PROFILE: runtimeProfile } : {}),
       H5_HOST: '127.0.0.1',
       H5_PORT: String(port),
       H5_PUBLIC_BASE_URL: `http://127.0.0.1:${port}`,

release-gate/local-stack.test.mjs

@@ -1,10 +1,13 @@
 import assert from 'node:assert/strict';
+import net from 'node:net';
 import test from 'node:test';
 
 import {
+  assertGatePortAvailable,
   buildContainerPgConnectionString,
   buildPgConnectionString,
   makeIsolatedDatabaseName,
+  sanitizeIsolatedGatePortalEnv,
 } from './local-stack.mjs';
 
 test('isolated database names are bounded and identifier-safe', () => {
@@ -41,3 +44,40 @@ test('container PostgreSQL DSN keeps credentials and host while isolating databa
 test('isolated database names reject empty or unsafe prefixes', () => {
   assert.throws(() => makeIsolatedDatabaseName('abc', '../bad'), /Unsafe/);
 });
+
+test('sanitizeIsolatedGatePortalEnv drops split-service MCP routing', () => {
+  const sanitized = sanitizeIsolatedGatePortalEnv({
+    MINDSPACE_SERVER_ADAPTER: 'remote',
+    MINDSPACE_REMOTE_BASE_URL: 'http://127.0.0.1:8082',
+    MINDSPACE_REMOTE_AUTH_TOKEN: 'local-dev-secret',
+    MINDSPACE_MCP_BASE_URL: 'http://127.0.0.1:8082',
+    MINDSPACE_MCP_TOKEN_SECRET: 'local-dev-secret',
+    MINDSPACE_AGENT_API_BASE_URL: 'http://127.0.0.1:8081/api',
+  }, { port: 19087, runtimeProfile: 'local' });
+
+  assert.equal(sanitized.MINDSPACE_SERVER_ADAPTER, 'local');
+  assert.equal(sanitized.MEMIND_RUNTIME_PROFILE, 'local');
+  assert.equal(sanitized.H5_PORTAL_BASE_URL, 'http://127.0.0.1:19087');
+  assert.equal(sanitized.MINDSPACE_AGENT_API_BASE_URL, 'http://127.0.0.1:19087/api');
+  assert.equal(sanitized.MINDSPACE_REMOTE_BASE_URL, undefined);
+  assert.equal(sanitized.MINDSPACE_MCP_BASE_URL, undefined);
+  assert.equal(sanitized.MINDSPACE_MCP_TOKEN_SECRET, undefined);
+});
+
+test('assertGatePortAvailable rejects occupied loopback ports', async () => {
+  const server = net.createServer();
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', resolve);
+  });
+  const address = server.address();
+  assert.ok(address && typeof address === 'object');
+  await assert.rejects(
+    () => assertGatePortAvailable(address.port),
+    /already in use/,
+  );
+  await new Promise((resolve, reject) => {
+    server.close((error) => (error ? reject(error) : resolve()));
+  });
+  await assertGatePortAvailable(address.port);
+});

scripts/aider-goose-wrapper.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="/Users/john/Project/Memind"
+ENV_SCRIPT="${ROOT_DIR}/scripts/executor-env.mjs"
+AIDER_BIN_DEFAULT="/Users/john/.local/bin/aider"
+AIDER_BIN="${AIDER_CLI_BIN:-${AIDER_BIN:-${AIDER_BIN_DEFAULT}}}"
+NODE_BIN="${NODE_BIN:-$(command -v node || true)}"
+
+if [[ -z "${NODE_BIN}" ]]; then
+  echo "node not found in PATH" >&2
+  exit 1
+fi
+
+if [[ ! -x "${AIDER_BIN}" ]]; then
+  echo "Aider CLI not executable: ${AIDER_BIN}" >&2
+  exit 1
+fi
+
+eval "$("${NODE_BIN}" "${ENV_SCRIPT}" aider --shell)"
+
+exec "${AIDER_BIN}" "$@"

scripts/build-imgproxy-runtime-native.sh

@@ -0,0 +1,118 @@
+#!/usr/bin/env bash
+# Materialize a darwin/arm64 imgproxy vendor binary into .runtime/imgproxy-native/.
+# Prefers the local Homebrew Cellar binary; bundles non-system dylibs for 103.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+OUT_DIR="${IMGPROXY_NATIVE_OUT_DIR:-${ROOT}/.runtime/imgproxy-native}"
+VENDOR_DIR="${OUT_DIR}/vendor/imgproxy-runtime"
+BIN_DIR="${VENDOR_DIR}/bin"
+LIB_DIR="${VENDOR_DIR}/lib"
+IMGPROXY_VERSION="${IMGPROXY_VERSION:-4.0.7}"
+BREW_PREFIX="${HOMEBREW_PREFIX:-/opt/homebrew}"
+DRY_RUN=0
+
+# shellcheck source=scripts/lib/bundle-mach-dylibs.sh
+source "${ROOT}/scripts/lib/bundle-mach-dylibs.sh"
+
+case "${1:-}" in
+  --dry-run) DRY_RUN=1 ;;
+  --help|-h)
+    cat <<'EOF'
+Usage: bash scripts/build-imgproxy-runtime-native.sh [--dry-run]
+
+Builds .runtime/imgproxy-native with:
+  vendor/imgproxy-runtime/bin/imgproxy
+  vendor/imgproxy-runtime/lib/*.dylib
+  vendor/imgproxy-runtime/VERSION.txt
+  vendor/imgproxy-runtime/SHA256SUMS
+  scripts/install-imgproxy-native-prod.sh
+  scripts/run-imgproxy-prod.sh
+  imgproxy-compat-proxy.mjs
+  RUNBOOK.txt
+
+Set IMGPROXY_SOURCE_BIN to copy a specific binary, or IMGPROXY_VERSION for Cellar lookup.
+EOF
+    exit 0
+    ;;
+esac
+
+resolve_imgproxy_binary() {
+  if [[ -n "${IMGPROXY_SOURCE_BIN:-}" ]]; then
+    [[ -x "${IMGPROXY_SOURCE_BIN}" ]] || {
+      echo "IMGPROXY_SOURCE_BIN is not executable: ${IMGPROXY_SOURCE_BIN}" >&2
+      exit 1
+    }
+    printf '%s\n' "${IMGPROXY_SOURCE_BIN}"
+    return
+  fi
+
+  local cellar_bin="${BREW_PREFIX}/Cellar/imgproxy/${IMGPROXY_VERSION}/bin/imgproxy"
+  if [[ -x "${cellar_bin}" ]]; then
+    printf '%s\n' "${cellar_bin}"
+    return
+  fi
+
+  if command -v brew >/dev/null 2>&1; then
+    local tmp cache_glob candidate
+    tmp="$(mktemp -d "${TMPDIR:-/tmp}/imgproxy-bottle.XXXXXX")"
+    brew fetch --force-bottle imgproxy >/dev/null
+    cache_glob="${HOME}/Library/Caches/Homebrew/downloads/*imgproxy*${IMGPROXY_VERSION}*.bottle.tar.gz"
+    candidate="$(ls -1 ${cache_glob} 2>/dev/null | head -1 || true)"
+    [[ -n "${candidate}" ]] || {
+      echo "imgproxy ${IMGPROXY_VERSION} bottle not found after brew fetch" >&2
+      exit 1
+    }
+    tar -xzf "${candidate}" -C "${tmp}"
+    find "${tmp}" -path "*/bin/imgproxy" -type f | head -1
+    return
+  fi
+
+  echo "imgproxy binary not found; install via brew or set IMGPROXY_SOURCE_BIN" >&2
+  exit 1
+}
+
+if [[ "${DRY_RUN}" == 1 ]]; then
+  candidate="$(resolve_imgproxy_binary || true)"
+  printf 'version=%s\nsource=%s\nout_dir=%s\n' "${IMGPROXY_VERSION}" "${candidate:-missing}" "${OUT_DIR}"
+  exit 0
+fi
+
+mkdir -p "${BIN_DIR}" "${LIB_DIR}" "${OUT_DIR}/scripts"
+source_bin="$(resolve_imgproxy_binary)"
+cp "${source_bin}" "${BIN_DIR}/imgproxy"
+chmod 755 "${BIN_DIR}/imgproxy"
+bundle_mach_dylibs "${BIN_DIR}/imgproxy" "${LIB_DIR}" "${source_bin}"
+"${BIN_DIR}/imgproxy" version > "${VENDOR_DIR}/VERSION.txt"
+(
+  cd "${VENDOR_DIR}"
+  shasum -a 256 bin/imgproxy VERSION.txt lib/* > SHA256SUMS
+)
+
+cp "${ROOT}/scripts/install-imgproxy-native-prod.sh" "${OUT_DIR}/scripts/"
+cp "${ROOT}/scripts/run-imgproxy-prod.sh" "${OUT_DIR}/scripts/"
+cp "${ROOT}/scripts/imgproxy-compat-proxy.mjs" "${OUT_DIR}/"
+chmod 755 "${OUT_DIR}/scripts/install-imgproxy-native-prod.sh" "${OUT_DIR}/scripts/run-imgproxy-prod.sh"
+
+cat > "${OUT_DIR}/RUNBOOK.txt" <<EOF
+TKMind imgproxy native runtime (vendor binary)
+
+Production base: /Users/john/Project/imgproxy-runtime
+Persistent env: Portal /Users/john/Project/Memind/.env (IMGPROXY_SIGNING_KEY/SALT)
+Active release:  current -> releases/<release-id>/
+LaunchAgent:     cn.tkmind.imgproxy (127.0.0.1:20082)
+Compat proxy:    cn.tkmind.imgproxy-compat (10.10.0.2:20081)
+Health:          http://127.0.0.1:20082/health
+Public:          https://img.tkmind.cn/health
+
+Vendor binary:   vendor/imgproxy-runtime/bin/imgproxy
+Bundled libs:    vendor/imgproxy-runtime/lib/
+Built from:      ${source_bin}
+
+This runtime replaces the Docker imgproxy container on 103.
+Portal runtime releases stay separate.
+EOF
+
+lib_count="$(find "${LIB_DIR}" -name '*.dylib' | wc -l | tr -d ' ')"
+printf 'imgproxy native runtime built at %s (%s, %s dylibs)\n' \
+  "${OUT_DIR}" "$(cat "${VENDOR_DIR}/VERSION.txt")" "${lib_count}"

scripts/check-local-goosed-pool.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { Agent, fetch as undiciFetch } from 'undici';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const root = path.join(__dirname, '..');
+const insecureDispatcher = new Agent({ connect: { rejectUnauthorized: false } });
+
+function loadEnvFile(filePath) {
+  if (!fs.existsSync(filePath)) return;
+  for (const line of fs.readFileSync(filePath, 'utf8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const idx = trimmed.indexOf('=');
+    if (idx < 0) continue;
+    const key = trimmed.slice(0, idx).trim();
+    const value = trimmed.slice(idx + 1).trim();
+    if (!process.env[key]) process.env[key] = value;
+  }
+}
+
+loadEnvFile(path.join(root, '.env'));
+
+const targets = (process.env.TKMIND_API_TARGETS || process.env.GOOSED_NATIVE_POOL_PORTS || '18006,18007')
+  .split(/[,\s]+/)
+  .map((value) => value.trim())
+  .filter(Boolean)
+  .flatMap((value) => (
+    value.startsWith('http')
+      ? [value]
+      : [`https://127.0.0.1:${value.replace(/^:/, '')}`]
+  ));
+
+if (targets.length === 0) {
+  console.error('No targets configured. Set TKMIND_API_TARGETS or GOOSED_NATIVE_POOL_PORTS.');
+  process.exit(2);
+}
+
+const results = [];
+for (const target of targets) {
+  const started = Date.now();
+  try {
+    const res = await undiciFetch(`${target.replace(/\/$/, '')}/status`, {
+      dispatcher: insecureDispatcher,
+    });
+    const body = (await res.text()).trim();
+    results.push({
+      target,
+      ok: res.ok && body === 'ok',
+      status: res.status,
+      body,
+      ms: Date.now() - started,
+    });
+  } catch (err) {
+    results.push({
+      target,
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+      ms: Date.now() - started,
+    });
+  }
+}
+
+console.log(JSON.stringify({
+  ok: results.every((item) => item.ok),
+  count: results.length,
+  results,
+}, null, 2));
+
+process.exit(results.every((item) => item.ok) ? 0 : 1);

scripts/check-tool-runtime.mjs

@@ -78,17 +78,22 @@ try {
     codeHasCodeTools: grantedTools.includes('aider') || grantedTools.includes('openhands'),
   }));
 
+  const roleCodeToolsDefault = ['1', 'true', 'yes', 'on'].includes(
+    String(process.env.MEMIND_ROLE_CODE_TOOLS_DEFAULT ?? '').trim().toLowerCase(),
+  );
+  const expectedRoleCodeTools = roleCodeToolsDefault;
   const ok = Boolean(
-    roleDefaults.aider === false &&
-    roleDefaults.openhands === false &&
+    roleDefaults.aider === expectedRoleCodeTools &&
+    roleDefaults.openhands === expectedRoleCodeTools &&
     sampledUsers.every((user) => user.chatHasCodeTools === false) &&
-    sampledUsers.every((user) => user.codeHasCodeTools === true),
+    (roleCodeToolsDefault || sampledUsers.every((user) => user.codeHasCodeTools === true)),
   );
 
   console.log(JSON.stringify({
     ok,
     checkedAt: new Date().toISOString(),
     roleDefaults,
+    roleCodeToolsDefault,
     whitelistUserCount: grantsByUser.size,
     sampledUsers,
     runtimePolicy: {

scripts/fix-deepseek-no-think-prod.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+/**
+ * Standalone recovery: point every stable goosed target at the 18036 no-think proxy.
+ * Works on bundled 103 runtime (no db.mjs / llm-providers.mjs required).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Agent, fetch as undiciFetch } from 'undici';
+
+const GOOSED_PROVIDER_ID = 'custom_memind_deepseek_no_think';
+const DEFAULT_MODEL = 'deepseek-v4-pro';
+const MODELS = ['deepseek-v4-pro', 'deepseek-v4-flash'];
+
+const root = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
+const insecureDispatcher = new Agent({ connect: { rejectUnauthorized: false } });
+
+function loadEnvFile(filePath) {
+  const env = {};
+  if (!fs.existsSync(filePath)) return env;
+  for (const line of fs.readFileSync(filePath, 'utf8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eq = trimmed.indexOf('=');
+    if (eq < 0) continue;
+    const key = trimmed.slice(0, eq).trim();
+    let value = trimmed.slice(eq + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"'))
+      || (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    env[key] = value;
+  }
+  return env;
+}
+
+const fileEnv = loadEnvFile(path.join(root, '.env'));
+const env = { ...fileEnv, ...process.env };
+const apiSecret = String(env.TKMIND_SERVER__SECRET_KEY ?? '').trim();
+const apiKey = String(env.DEEPSEEK_API_KEY ?? '').trim();
+const apiTargets = String(
+  env.TKMIND_API_TARGETS
+    ?? env.TKMIND_API_TARGET
+    ?? 'https://127.0.0.1:18006',
+)
+  .split(',')
+  .map((item) => item.trim())
+  .filter(Boolean);
+
+if (!apiSecret) {
+  console.error('missing TKMIND_SERVER__SECRET_KEY');
+  process.exit(1);
+}
+if (!apiKey) {
+  console.error('missing DEEPSEEK_API_KEY');
+  process.exit(1);
+}
+
+const host = String(env.MEMIND_GOOSED_HOST_GATEWAY ?? 'host.docker.internal').trim() || 'host.docker.internal';
+const port = Number(env.MEMIND_DEEPSEEK_NO_THINK_PORT ?? 18036);
+const proxyBaseUrl = `http://${host}:${port}/v1`;
+
+async function goosedFetch(apiTarget, pathname, init = {}) {
+  const url = new URL(pathname, apiTarget);
+  const headers = {
+    ...(init.headers ?? {}),
+    'X-Secret-Key': apiSecret,
+  };
+  if (init.body && !headers['Content-Type']) {
+    headers['Content-Type'] = 'application/json';
+  }
+  const dispatcher = apiTarget.startsWith('https://') ? insecureDispatcher : undefined;
+  return undiciFetch(url, { ...init, headers, dispatcher });
+}
+
+async function upsertConfig(apiTarget, key, value, isSecret = false) {
+  const res = await goosedFetch(apiTarget, '/config/upsert', {
+    method: 'POST',
+    body: JSON.stringify({ key, value, is_secret: isSecret }),
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`upsert ${key} on ${apiTarget} failed: ${res.status} ${text}`);
+  }
+}
+
+async function upsertProvider(apiTarget) {
+  const body = {
+    engine: 'openai',
+    display_name: 'memind_deepseek_no_think',
+    api_url: proxyBaseUrl,
+    api_key: apiKey,
+    models: MODELS,
+    supports_streaming: true,
+    requires_auth: true,
+    preserves_thinking: false,
+  };
+
+  let res = await goosedFetch(
+    apiTarget,
+    `/config/custom-providers/${encodeURIComponent(GOOSED_PROVIDER_ID)}`,
+    { method: 'PUT', body: JSON.stringify(body) },
+  );
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    const missing = res.status === 404 || /provider not found/i.test(text);
+    if (!missing) {
+      throw new Error(`upsert provider on ${apiTarget} failed: ${res.status} ${text}`);
+    }
+    res = await goosedFetch(apiTarget, '/config/custom-providers', {
+      method: 'POST',
+      body: JSON.stringify(body),
+    });
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`create provider on ${apiTarget} failed: ${res.status} ${text}`);
+  }
+
+  await upsertConfig(apiTarget, 'DEEPSEEK_API_KEY', apiKey, true);
+  for (const [key, value] of [
+    ['GOOSE_PROVIDER', GOOSED_PROVIDER_ID],
+    ['GOOSE_MODEL', DEFAULT_MODEL],
+    ['TKMIND_PROVIDER', GOOSED_PROVIDER_ID],
+    ['TKMIND_MODEL', DEFAULT_MODEL],
+    ['GOOSE_THINKING_EFFORT', 'off'],
+  ]) {
+    await upsertConfig(apiTarget, key, value, false);
+  }
+}
+
+const results = [];
+for (const target of apiTargets) {
+  await upsertProvider(target);
+  results.push({ target, provider: GOOSED_PROVIDER_ID, model: DEFAULT_MODEL, proxyBaseUrl });
+}
+
+console.log(JSON.stringify({ ok: true, results }, null, 2));

scripts/fix-openhands-local-link.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+/**
+ * 本机代码工具能力修复：role 默认 aider/openhands + 可选 canary 用户白名单。
+ * 用法: MEMIND_ENV_FILE=.env node scripts/fix-openhands-local-link.mjs
+ *
+ * MEMIND_ROLE_CODE_TOOLS_DEFAULT=1  → role=user 默认开启 aider/openhands（本地开发）
+ * 未设置或为 0                      → role=user 默认关闭（生产基线）
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createDbPool } from '../db.mjs';
+import { applyRoleSecurityBaseline } from '../security-baseline.mjs';
+
+const root = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
+const CANARY_USER_ID = process.env.LOCAL_OPENHANDS_CANARY_USER_ID
+  ?? '32035858-9a20-425b-89da-c118ef0779aa';
+const CODE_TOOLS = ['aider', 'openhands'];
+
+function loadEnvFile(filePath) {
+  if (!fs.existsSync(filePath)) return;
+  for (const line of fs.readFileSync(filePath, 'utf8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const idx = trimmed.indexOf('=');
+    if (idx < 0) continue;
+    const key = trimmed.slice(0, idx).trim();
+    const value = trimmed.slice(idx + 1).trim();
+    if (!process.env[key]) process.env[key] = value;
+  }
+}
+
+function roleCodeToolsDefaultEnabled() {
+  return ['1', 'true', 'yes', 'on'].includes(
+    String(process.env.MEMIND_ROLE_CODE_TOOLS_DEFAULT ?? '').trim().toLowerCase(),
+  );
+}
+
+loadEnvFile(process.env.MEMIND_ENV_FILE || path.join(root, '.env'));
+loadEnvFile(path.join(root, '.env.local'));
+
+async function readRoleDefaults(pool) {
+  const [rows] = await pool.query(
+    `SELECT capability_key, allowed
+     FROM h5_capability_grants
+     WHERE subject_type = 'role'
+       AND subject_id = 'user'
+       AND capability_key IN ('aider', 'openhands')
+     ORDER BY capability_key`,
+  );
+  return Object.fromEntries(rows.map((row) => [row.capability_key, Boolean(row.allowed)]));
+}
+
+async function readUserGrants(pool, userId) {
+  const [rows] = await pool.query(
+    `SELECT capability_key, allowed
+     FROM h5_capability_grants
+     WHERE subject_type = 'user'
+       AND subject_id = ?
+       AND capability_key IN ('aider', 'openhands')
+     ORDER BY capability_key`,
+    [userId],
+  );
+  return Object.fromEntries(rows.map((row) => [row.capability_key, Boolean(row.allowed)]));
+}
+
+async function grantRoleTools(pool, role, tools, allowed) {
+  const now = Date.now();
+  for (const key of tools) {
+    await pool.query(
+      `INSERT INTO h5_capability_grants (subject_type, subject_id, capability_key, allowed, updated_at)
+       VALUES ('role', ?, ?, ?, ?)
+       ON DUPLICATE KEY UPDATE allowed = VALUES(allowed), updated_at = VALUES(updated_at)`,
+      [role, key, allowed ? 1 : 0, now],
+    );
+  }
+}
+
+async function grantUserTools(pool, userId, tools) {
+  const now = Date.now();
+  for (const key of tools) {
+    await pool.query(
+      `INSERT INTO h5_capability_grants (subject_type, subject_id, capability_key, allowed, updated_at)
+       VALUES ('user', ?, ?, 1, ?)
+       ON DUPLICATE KEY UPDATE allowed = VALUES(allowed), updated_at = VALUES(updated_at)`,
+      [userId, key, now],
+    );
+  }
+}
+
+const roleCodeToolsDefault = roleCodeToolsDefaultEnabled();
+const pool = createDbPool();
+try {
+  const beforeRole = await readRoleDefaults(pool);
+  const beforeUser = await readUserGrants(pool, CANARY_USER_ID);
+
+  if (roleCodeToolsDefault) {
+    await grantRoleTools(pool, 'user', CODE_TOOLS, true);
+  } else {
+    await applyRoleSecurityBaseline(pool, 'user');
+    await grantUserTools(pool, CANARY_USER_ID, CODE_TOOLS);
+  }
+
+  const afterRole = await readRoleDefaults(pool);
+  const afterUser = await readUserGrants(pool, CANARY_USER_ID);
+  const expectedRole = roleCodeToolsDefault;
+
+  console.log(JSON.stringify({
+    ok: afterRole.aider === expectedRole
+      && afterRole.openhands === expectedRole
+      && (!roleCodeToolsDefault || CODE_TOOLS.every((key) => afterRole[key] === true)),
+    roleCodeToolsDefault,
+    canaryUserId: CANARY_USER_ID,
+    before: { role: beforeRole, user: beforeUser },
+    after: { role: afterRole, user: afterUser },
+  }, null, 2));
+} finally {
+  await pool.end();
+}

scripts/goosed-native-103-migrate.sh

@@ -0,0 +1,445 @@
+#!/usr/bin/env bash
+# 103 production: Docker goosed pool -> native launchd pool (18006-18014).
+# Keeps goosed-prod-1 container stopped as Docker hot standby.
+#
+# Usage on 103:
+#   bash scripts/goosed-native-103-migrate.sh backup
+#   bash scripts/goosed-native-103-migrate.sh migrate
+#   bash scripts/goosed-native-103-migrate.sh verify
+#   bash scripts/goosed-native-103-migrate.sh rollback   # emergency Docker standby on 18006 only
+set -euo pipefail
+
+export PATH="/opt/homebrew/bin:/usr/local/bin:${PATH}"
+
+ROOT="${MEMIND_ROOT:-/Users/john/Project/Memind}"
+GOOSED_NATIVE_ROOT="${GOOSED_NATIVE_ROOT:-/Users/john/Project/tkmind_go-native}"
+GOOSED_PROD_ROOT="${GOOSED_PROD_ROOT:-/Users/john/Project/goosed-prod}"
+PORTS=(18006 18007 18008 18009 18010 18011 18012 18013 18014)
+DOCKER_STANDBY="goosed-prod-1"
+LAUNCHD_DIR="${HOME}/Library/LaunchAgents"
+GUI="gui/$(id -u)"
+BACKUP_ROOT="${ROOT}/backups/goosed-native-migration"
+STAMP="$(date +%Y%m%d-%H%M%S)"
+BACKUP_DIR="${BACKUP_ROOT}/pre-native-${STAMP}"
+
+log() { printf '[goosed-native-103] %s\n' "$*"; }
+die() { log "ERROR: $*"; exit 1; }
+
+require_103() {
+  [[ "$(hostname -s 2>/dev/null || hostname)" == "johndeMac-Studio" || "$(hostname)" == *Studio* ]] || true
+  [[ -d "${ROOT}" ]] || die "Memind root not found: ${ROOT}"
+}
+
+free_disk_headroom() {
+  log "Rotating oversized logs to free disk headroom before backup"
+  for f in \
+    "${HOME}/Library/Logs/memind-agent-run-worker.log" \
+    "${HOME}/Library/Logs/memind-runtime-heartbeat.log" \
+    "${HOME}/Library/Logs/memind-frontend-5173.log"; do
+    if [[ -f "${f}" ]] && [[ "$(wc -c <"${f}" | tr -d ' ')" -gt 50000000 ]]; then
+      mv "${f}" "${f}.bak-${STAMP}"
+      : >"${f}"
+      log "rotated ${f}"
+    fi
+  done
+  df -h "${ROOT}" | tail -1
+}
+
+phase_backup() {
+  require_103
+  free_disk_headroom
+  mkdir -p "${BACKUP_DIR}"
+
+  log "Backup directory: ${BACKUP_DIR}"
+
+  {
+    echo "stamp=${STAMP}"
+    echo "hostname=$(hostname)"
+    date -Iseconds
+    cat "${ROOT}/.release-manifest.txt" 2>/dev/null || true
+    grep '^TKMIND_API_TARGETS=' "${ROOT}/.env" || true
+    grep '^GOOSED_TAG=' "${GOOSED_PROD_ROOT}/.env" 2>/dev/null || true
+    docker ps -a --format '{{.Names}}\t{{.ID}}\t{{.Status}}\t{{.Ports}}' | grep goosed || true
+  } >"${BACKUP_DIR}/baseline.txt"
+
+  cp "${ROOT}/.env" "${BACKUP_DIR}/portal.env"
+  cp "${GOOSED_PROD_ROOT}/.env" "${BACKUP_DIR}/goosed-prod.env" 2>/dev/null || true
+  cp "${GOOSED_PROD_ROOT}/docker-compose.prod.yml" "${BACKUP_DIR}/" 2>/dev/null || true
+
+  log "pg_dump memind_sessions"
+  local session_url
+  session_url="$(grep '^GOOSE_SESSION_DB_URL=' "${GOOSED_PROD_ROOT}/.env" 2>/dev/null | cut -d= -f2- | sed 's|@host.docker.internal|@127.0.0.1|' || true)"
+  if [[ -z "${session_url}" ]]; then
+    session_url="postgresql://boot:@Abc888888@127.0.0.1:5432/memind_sessions"
+  fi
+  pg_dump "${session_url}" | gzip -1 >"${BACKUP_DIR}/memind_sessions.sql.gz"
+
+  log "pg_dump mindspace_userdata_prod"
+  local userdata_url
+  userdata_url="$(grep '^MINDSPACE_USERDATA_PG_URL=' "${ROOT}/.env" | cut -d= -f2-)"
+  pg_dump "${userdata_url}" | gzip -1 >"${BACKUP_DIR}/mindspace_userdata_prod.sql.gz"
+
+  log "persisted assets tar"
+  tar -czf "${BACKUP_DIR}/memind-persisted-${STAMP}.tar.gz" \
+    -C "${ROOT}" \
+    .env MindSpace data users .tailscale public/plaza-covers logs 2>/dev/null \
+    || tar -czf "${BACKUP_DIR}/memind-persisted-${STAMP}.tar.gz" \
+    -C "${ROOT}" .env data users logs 2>/dev/null
+
+  log "MindSpace storage tar"
+  tar -czf "${BACKUP_DIR}/mindspace-storage-${STAMP}.tar.gz" \
+    -C /Users/john/MindSpace data/mindspace 2>/dev/null || true
+
+  log "goosed-prod directory tar"
+  tar -czf "${BACKUP_DIR}/goosed-prod-${STAMP}.tar.gz" \
+    -C "${GOOSED_PROD_ROOT}" .env docker-compose.prod.yml README.md 2>/dev/null || true
+
+  log "tkmind_go-native directory tar"
+  tar -czf "${BACKUP_DIR}/tkmind_go-native-${STAMP}.tar.gz" \
+    -C "${GOOSED_NATIVE_ROOT}" \
+    .env.18006 run-goosed-18006.sh deploy releases goosed 2>/dev/null || true
+
+  log "docker inspect goosed containers"
+  docker ps -aq --filter 'name=goosed-prod' | xargs docker inspect >"${BACKUP_DIR}/docker-goosed-inspect.json" 2>/dev/null || true
+
+  log "full Memind source tar (may take a few minutes)"
+  tar -czf "${BACKUP_DIR}/memind-full-${STAMP}.tar.gz" \
+    --exclude='./node_modules' \
+    --exclude='./backups' \
+    --exclude='./.git' \
+    -C "${ROOT}" . 2>/dev/null || log "WARN: full tar skipped or partial — check disk space"
+
+  ln -sfn "${BACKUP_DIR}" "${BACKUP_ROOT}/latest"
+  du -sh "${BACKUP_DIR}"/*
+  df -h "${ROOT}" | tail -1
+  log "Backup complete: ${BACKUP_DIR}"
+}
+
+install_native_env_files() {
+  local port base="${GOOSED_NATIVE_ROOT}/.env.18006"
+  [[ -f "${base}" ]] || die "missing ${base}"
+  for port in "${PORTS[@]}"; do
+    local env_file="${GOOSED_NATIVE_ROOT}/.env.${port}"
+    if [[ ! -f "${env_file}" ]]; then
+      sed "s/^GOOSE_PORT=.*/GOOSE_PORT=${port}/" "${base}" >"${env_file}"
+      log "created ${env_file}"
+    fi
+  done
+}
+
+install_native_run_script() {
+  local script="${GOOSED_NATIVE_ROOT}/run-goosed-native.sh"
+  cat >"${script}" <<'EOF'
+#!/usr/bin/env bash
+set -euo pipefail
+PORT="${1:?missing port argument}"
+ROOT="/Users/john/Project/tkmind_go-native"
+cd "${ROOT}"
+set -a
+# shellcheck source=/dev/null
+source "${ROOT}/.env.${PORT}"
+set +a
+exec "${ROOT}/goosed" agent
+EOF
+  chmod +x "${script}"
+}
+
+install_native_launchd() {
+  local port label plist
+  install_native_run_script
+  for port in "${PORTS[@]}"; do
+    label="cn.tkmind.goosed-native-${port}"
+    plist="${LAUNCHD_DIR}/${label}.plist"
+    cat >"${plist}" <<EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${label}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${GOOSED_NATIVE_ROOT}/run-goosed-native.sh</string>
+    <string>${port}</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${GOOSED_NATIVE_ROOT}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${HOME}/Library/Logs/goosed-native-${port}.log</string>
+  <key>StandardErrorPath</key>
+  <string>${HOME}/Library/Logs/goosed-native-${port}.log</string>
+</dict>
+</plist>
+EOF
+    plutil -lint "${plist}" >/dev/null
+    launchctl bootout "${GUI}/${label}" 2>/dev/null || true
+    launchctl bootstrap "${GUI}" "${plist}"
+    launchctl enable "${GUI}/${label}"
+    launchctl kickstart -k "${GUI}/${label}" 2>/dev/null || launchctl kickstart "${GUI}/${label}"
+    log "launchd ${label} installed"
+  done
+}
+
+phase_start_deepseek_proxy() {
+  local plist="${LAUNCHD_DIR}/cn.tkmind.memind-deepseek-no-think.plist"
+  cat >"${plist}" <<EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>cn.tkmind.memind-deepseek-no-think</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/opt/homebrew/opt/node@24/bin/node</string>
+    <string>${ROOT}/deepseek-no-think-proxy.mjs</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>MEMIND_DEEPSEEK_PROXY_ENTRYPOINT</key><string>1</string>
+    <key>MEMIND_DEEPSEEK_DISABLE_THINKING</key><string>1</string>
+    <key>MEMIND_DEEPSEEK_NO_THINK_PORT</key><string>18036</string>
+    <key>MEMIND_DEEPSEEK_NO_THINK_HOST</key><string>127.0.0.1</string>
+  </dict>
+  <key>WorkingDirectory</key><string>${ROOT}</string>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${HOME}/Library/Logs/memind-deepseek-no-think.log</string>
+  <key>StandardErrorPath</key><string>${HOME}/Library/Logs/memind-deepseek-no-think.log</string>
+</dict>
+</plist>
+EOF
+  launchctl bootout "${GUI}/cn.tkmind.memind-deepseek-compat-candidate" 2>/dev/null || true
+  launchctl bootout "${GUI}/cn.tkmind.memind-deepseek-no-think" 2>/dev/null || true
+  launchctl bootstrap "${GUI}" "${plist}"
+  curl -fsS "http://127.0.0.1:18036/health" >/dev/null || die "DeepSeek no-think proxy :18036 failed"
+  log "DeepSeek no-think proxy listening on :18036"
+}
+
+phase_reconfigure_monitor() {
+  local plist="${LAUNCHD_DIR}/cn.tkmind.goosed-monitor.plist"
+  local monitor_script="${ROOT}/scripts/monitor-goosed-fds.mjs"
+  [[ -f "${monitor_script}" ]] || die "missing ${monitor_script}"
+  cp "${plist}" "${plist}.bak-docker-${STAMP}" 2>/dev/null || true
+  cat >"${plist}" <<EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>GOOSED_NATIVE_POOL_PORTS</key>
+    <string>18006,18007,18008,18009,18010,18011,18012,18013,18014</string>
+    <key>GOOSED_NATIVE_LAUNCHD_LABEL_TEMPLATE</key>
+    <string>cn.tkmind.goosed-native-{port}</string>
+    <key>GOOSED_FD_RESTART</key>
+    <string>3200</string>
+    <key>GOOSED_FD_WARN</key>
+    <string>180</string>
+    <key>PATH</key>
+    <string>/opt/homebrew/bin:/opt/homebrew/opt/node@24/bin:/usr/local/bin:/usr/bin:/bin</string>
+    <key>SANDBOX_MCP_MAX_PER_ROOT</key>
+    <string>2</string>
+    <key>SANDBOX_MCP_MAX_TOTAL</key>
+    <string>80</string>
+  </dict>
+  <key>Label</key>
+  <string>cn.tkmind.goosed-monitor</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/opt/homebrew/opt/node@24/bin/node</string>
+    <string>${monitor_script}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>StandardErrorPath</key>
+  <string>${HOME}/Library/Logs/goosed-monitor.log</string>
+  <key>StandardOutPath</key>
+  <string>${HOME}/Library/Logs/goosed-monitor.log</string>
+  <key>StartInterval</key>
+  <integer>60</integer>
+  <key>WorkingDirectory</key>
+  <string>${ROOT}</string>
+</dict>
+</plist>
+EOF
+  plutil -lint "${plist}" >/dev/null
+  launchctl bootout "${GUI}/cn.tkmind.goosed-monitor" 2>/dev/null || true
+  launchctl bootstrap "${GUI}" "${plist}"
+  log "goosed-monitor switched to native FD monitor"
+}
+
+stop_docker_pool_keep_standby() {
+  local name
+  for name in goosed-prod-{1..9}; do
+    docker update --restart=no "${name}" 2>/dev/null || true
+  done
+  for name in goosed-prod-{2..9}; do
+    if docker ps -q --filter "name=^/${name}$" | grep -q .; then
+      log "stopping docker ${name}"
+      docker stop "${name}" >/dev/null
+    fi
+  done
+  if docker ps -q --filter "name=^/${DOCKER_STANDBY}$" | grep -q .; then
+    log "stopping docker standby ${DOCKER_STANDBY} (container kept, restart=no)"
+    docker stop "${DOCKER_STANDBY}" >/dev/null
+  fi
+  docker ps -a --filter 'name=goosed-prod' --format '{{.Names}}\t{{.Status}}' || true
+}
+
+update_portal_env() {
+  local env_file="${ROOT}/.env"
+  local targets=""
+  local port
+  for port in "${PORTS[@]}"; do
+    targets="${targets}https://127.0.0.1:${port},"
+  done
+  targets="${targets%,}"
+
+  cp "${env_file}" "${env_file}.bak-native-${STAMP}"
+
+  if grep -q '^GOOSED_RUNTIME=' "${env_file}"; then
+    sed -i '' 's/^GOOSED_RUNTIME=.*/GOOSED_RUNTIME=native/' "${env_file}"
+  else
+    printf '\nGOOSED_RUNTIME=native\n' >>"${env_file}"
+  fi
+
+  sed -i '' "s|^TKMIND_API_TARGETS=.*|TKMIND_API_TARGETS=${targets}|" "${env_file}"
+  sed -i '' 's|^TKMIND_API_TARGET=.*|TKMIND_API_TARGET=https://127.0.0.1:18006|' "${env_file}"
+
+  if grep -q '^GOOSED_MCP_NODE_PATH=' "${env_file}"; then
+    sed -i '' 's|^GOOSED_MCP_NODE_PATH=.*|GOOSED_MCP_NODE_PATH=/opt/homebrew/opt/node@24/bin/node|' "${env_file}"
+  fi
+  if grep -q '^MEMIND_GOOSED_HOST_GATEWAY=' "${env_file}"; then
+    sed -i '' 's|^MEMIND_GOOSED_HOST_GATEWAY=.*|MEMIND_GOOSED_HOST_GATEWAY=127.0.0.1|' "${env_file}"
+  fi
+  if grep -q '^TKMIND_SEARCH_MCP_HOST_GATEWAY=' "${env_file}"; then
+    sed -i '' 's|^TKMIND_SEARCH_MCP_HOST_GATEWAY=.*|TKMIND_SEARCH_MCP_HOST_GATEWAY=127.0.0.1|' "${env_file}"
+  fi
+
+  grep -E '^(GOOSED_RUNTIME|TKMIND_API_TARGET|TKMIND_API_TARGETS|GOOSED_MCP_NODE_PATH|MEMIND_GOOSED_HOST_GATEWAY)=' "${env_file}" \
+    | tee "${BACKUP_ROOT}/latest-portal-env-snippet.txt" 2>/dev/null || true
+}
+
+wait_for_status() {
+  local port deadline=$((SECONDS + 90))
+  while (( SECONDS < deadline )); do
+    if curl -kfsS --connect-timeout 2 "https://127.0.0.1:${port}/status" >/dev/null 2>&1; then
+      return 0
+    fi
+    sleep 2
+  done
+  return 1
+}
+
+phase_migrate() {
+  require_103
+  [[ -L "${BACKUP_ROOT}/latest" || -d "${BACKUP_ROOT}" ]] || die "run backup first"
+  install_native_env_files
+  free_disk_headroom
+  stop_docker_pool_keep_standby
+  phase_reconfigure_monitor
+  phase_start_deepseek_proxy
+  install_native_launchd
+  sleep 5
+  for port in "${PORTS[@]}"; do
+    wait_for_status "${port}" || die "native /status failed on ${port}"
+    log "${port}: OK"
+  done
+  update_portal_env
+  log "restarting Portal"
+  launchctl kickstart -k "${GUI}/cn.tkmind.memind-portal"
+  sleep 5
+  curl -fsS "http://127.0.0.1:8081/api/status" >/dev/null || die "Portal /api/status failed"
+  log "syncing LLM provider to all native targets"
+  (
+    cd "${ROOT}"
+    node <<'NODE'
+import fs from 'node:fs';
+import path from 'node:path';
+import { createDbPool } from './db.mjs';
+import { createLlmProviderService } from './llm-providers.mjs';
+
+function loadEnv(file) {
+  if (!fs.existsSync(file)) return;
+  for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+    const t = line.trim();
+    if (!t || t.startsWith('#')) continue;
+    const eq = t.indexOf('=');
+    if (eq < 0) continue;
+    const k = t.slice(0, eq).trim();
+    const v = t.slice(eq + 1).trim();
+    if (!process.env[k]) process.env[k] = v;
+  }
+}
+
+loadEnv(path.join(process.cwd(), '.env'));
+const targets = String(process.env.TKMIND_API_TARGETS ?? '')
+  .split(',')
+  .map((v) => v.trim())
+  .filter(Boolean);
+const pool = createDbPool();
+const svc = createLlmProviderService(pool, {
+  apiTarget: targets[0] ?? 'https://127.0.0.1:18006',
+  apiTargets: targets,
+  apiSecret: process.env.TKMIND_SERVER__SECRET_KEY ?? 'local-dev-secret',
+});
+const synced = await svc.syncSelectedToGoosed();
+if (!synced.ok) {
+  console.error('provider sync failed:', synced.message);
+  process.exit(1);
+}
+console.log('provider synced to', synced.targets?.join(', '));
+await pool.end();
+NODE
+  ) || log "WARN: provider sync failed — verify manually"
+  log "Migration complete. Docker standby: docker start ${DOCKER_STANDBY} (requires stopping native 18006 first)"
+}
+
+phase_verify() {
+  require_103
+  for port in "${PORTS[@]}"; do
+    printf '%s: ' "${port}"
+    curl -kfsS --connect-timeout 3 "https://127.0.0.1:${port}/status" && echo || echo FAIL
+  done
+  echo "---"
+  curl -fsS "http://127.0.0.1:8081/api/status" | head -c 400; echo
+  echo "---"
+  docker ps -a --filter 'name=goosed-prod' --format '{{.Names}}\t{{.Status}}'
+  launchctl list | grep 'goosed-native' || true
+}
+
+phase_rollback() {
+  require_103
+  log "Emergency rollback: stop native pool, start Docker standby on 18006 only"
+  local port label
+  for port in "${PORTS[@]}"; do
+    label="cn.tkmind.goosed-native-${port}"
+    launchctl bootout "${GUI}/${label}" 2>/dev/null || true
+  done
+  docker start "${DOCKER_STANDBY}"
+  if [[ -f "${ROOT}/.env.bak-native-${STAMP}" ]]; then
+    cp "${ROOT}/.env.bak-native-${STAMP}" "${ROOT}/.env"
+  elif [[ -f "${BACKUP_ROOT}/latest/portal.env" ]]; then
+    cp "${BACKUP_ROOT}/latest/portal.env" "${ROOT}/.env"
+  fi
+  launchctl kickstart -k "${GUI}/cn.tkmind.memind-portal"
+  curl -kfsS --connect-timeout 5 "https://127.0.0.1:18006/status"
+  log "Rollback to Docker standby on 18006 done. Full pool: cd goosed-prod && docker compose up -d"
+}
+
+cmd="${1:-}"
+case "${cmd}" in
+  backup) phase_backup ;;
+  migrate) phase_migrate ;;
+  verify) phase_verify ;;
+  rollback) phase_rollback ;;
+  *)
+    echo "Usage: $0 {backup|migrate|verify|rollback}" >&2
+    exit 2
+    ;;
+esac

scripts/imgproxy-runtime-package.test.mjs

@@ -38,3 +38,34 @@ test('release verifies checksums before loading the image and backs up launch st
   assert.match(release, /release\/\*/);
   assert.match(release, /rev-parse origin\/main/);
 });
+
+test('native builder vendors a pinned darwin arm64 imgproxy binary', () => {
+  const builder = read('scripts/build-imgproxy-runtime-native.sh');
+  assert.match(builder, /vendor\/imgproxy-runtime\/bin\/imgproxy/);
+  assert.match(builder, /vendor\/imgproxy-runtime\/lib/);
+  assert.match(builder, /bundle_mach_dylibs/);
+  assert.match(builder, /shasum -a 256 bin\/imgproxy VERSION\.txt lib\/\*/);
+  assert.match(builder, /IMGPROXY_SOURCE_BIN/);
+  assert.match(builder, /run-imgproxy-prod\.sh/);
+});
+
+test('native installer uses the vendored binary and retires docker imgproxy', () => {
+  const installer = read('scripts/install-imgproxy-native-prod.sh');
+  assert.match(installer, /vendor\/imgproxy-runtime\/bin\/imgproxy/);
+  assert.match(installer, /ProgramArguments/);
+  assert.match(installer, /IMGPROXY_KEY/);
+  assert.match(installer, /127\.0\.0\.1:20082/);
+  assert.match(installer, /10\.10\.0\.2/);
+  assert.match(installer, /"\$\{DOCKER_BIN\}" stop/);
+  assert.match(installer, /"\$\{DOCKER_BIN\}" rm -f/);
+  assert.match(installer, /cn\.tkmind\.imgproxy/);
+});
+
+test('native release bundles vendor artifacts and verifies health on 103', () => {
+  const release = read('scripts/release-imgproxy-native-prod.sh');
+  assert.match(release, /build-imgproxy-runtime-native\.sh/);
+  assert.match(release, /vendor\/imgproxy-runtime\/bin\/imgproxy/);
+  assert.match(release, /install-imgproxy-native-prod\.sh/);
+  assert.match(release, /imgproxy-native-runtime-\$RELEASE_ID\.tar\.gz/);
+  assert.match(release, /img\.tkmind\.cn\/health/);
+});

scripts/install-imgproxy-native-prod.sh

@@ -0,0 +1,128 @@
+#!/usr/bin/env bash
+# Runs only on 103 from a verified imgproxy native release directory.
+set -euo pipefail
+
+ROOT="${ROOT:-/Users/john/Project/Memind}"
+RUNTIME_BASE="${IMGPROXY_RUNTIME_BASE:-/Users/john/Project/imgproxy-runtime}"
+RUNTIME_DIR="${IMGPROXY_RUNTIME_DIR:?IMGPROXY_RUNTIME_DIR is required}"
+IMGPROXY_BIN="${RUNTIME_DIR}/vendor/imgproxy-runtime/bin/imgproxy"
+RUN_SCRIPT="${RUNTIME_DIR}/scripts/run-imgproxy-prod.sh"
+NODE_BIN="${NODE_BIN:-/opt/homebrew/opt/node@24/bin/node}"
+DOCKER_BIN="${DOCKER_BIN:-/opt/homebrew/bin/docker}"
+CONTAINER="${IMGPROXY_CONTAINER:-memind-imgproxy}"
+NATIVE_LABEL="cn.tkmind.imgproxy"
+COMPAT_LABEL="cn.tkmind.imgproxy-compat"
+NATIVE_PLIST="${HOME}/Library/LaunchAgents/${NATIVE_LABEL}.plist"
+COMPAT_PLIST="${HOME}/Library/LaunchAgents/${COMPAT_LABEL}.plist"
+LOG_DIR="${HOME}/Library/Logs"
+GUI="gui/$(id -u)"
+
+[[ -x "${IMGPROXY_BIN}" ]] || {
+  echo "missing vendor imgproxy binary: ${IMGPROXY_BIN}" >&2
+  exit 1
+}
+[[ -x "${RUN_SCRIPT}" ]] || {
+  echo "missing imgproxy run script: ${RUN_SCRIPT}" >&2
+  exit 1
+}
+
+set -a
+source "${ROOT}/.env"
+set +a
+: "${IMGPROXY_SIGNING_KEY:?missing IMGPROXY_SIGNING_KEY}"
+: "${IMGPROXY_SIGNING_SALT:?missing IMGPROXY_SIGNING_SALT}"
+: "${MINDSPACE_STORAGE_ROOT:?missing MINDSPACE_STORAGE_ROOT}"
+
+cd "${RUNTIME_DIR}/vendor/imgproxy-runtime"
+shasum -a 256 -c SHA256SUMS >/dev/null
+
+mkdir -p "${HOME}/Library/LaunchAgents" "${LOG_DIR}"
+
+cat > "${NATIVE_PLIST}" <<EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${NATIVE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${IMGPROXY_BIN}</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>IMGPROXY_BIND</key>
+    <string>127.0.0.1:20082</string>
+    <key>IMGPROXY_LOCAL_FILESYSTEM_ROOT</key>
+    <string>${MINDSPACE_STORAGE_ROOT}</string>
+    <key>IMGPROXY_KEY</key>
+    <string>${IMGPROXY_SIGNING_KEY}</string>
+    <key>IMGPROXY_SALT</key>
+    <string>${IMGPROXY_SIGNING_SALT}</string>
+    <key>IMGPROXY_USE_ETAG</key>
+    <string>true</string>
+    <key>IMGPROXY_ENABLE_WEBP_DETECTION</key>
+    <string>true</string>
+  </dict>
+  <key>WorkingDirectory</key>
+  <string>${ROOT}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>StandardOutPath</key>
+  <string>${LOG_DIR}/imgproxy.log</string>
+  <key>StandardErrorPath</key>
+  <string>${LOG_DIR}/imgproxy.log</string>
+</dict>
+</plist>
+EOF
+
+xattr -cr "${RUNTIME_DIR}" 2>/dev/null || true
+
+if [[ -x "${DOCKER_BIN}" ]]; then
+  "${DOCKER_BIN}" stop "${CONTAINER}" >/dev/null 2>&1 || true
+  "${DOCKER_BIN}" rm -f "${CONTAINER}" >/dev/null 2>&1 || true
+  "${DOCKER_BIN}" update --restart=no "${CONTAINER}" >/dev/null 2>&1 || true
+fi
+
+launchctl bootout "${GUI}/${NATIVE_LABEL}" 2>/dev/null || true
+plutil -lint "${NATIVE_PLIST}" >/dev/null
+launchctl enable "${GUI}/${NATIVE_LABEL}" 2>/dev/null || true
+launchctl bootstrap "${GUI}" "${NATIVE_PLIST}"
+launchctl kickstart -k "${GUI}/${NATIVE_LABEL}"
+
+for _ in $(seq 1 30); do
+  curl -fsS --max-time 2 http://127.0.0.1:20082/health >/dev/null && break
+  sleep 1
+done
+curl -fsS --max-time 3 http://127.0.0.1:20082/health >/dev/null
+
+cat > "${COMPAT_PLIST}" <<EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>Label</key><string>${COMPAT_LABEL}</string>
+<key>ProgramArguments</key><array><string>${NODE_BIN}</string><string>${RUNTIME_DIR}/imgproxy-compat-proxy.mjs</string></array>
+<key>WorkingDirectory</key><string>${RUNTIME_DIR}</string>
+<key>EnvironmentVariables</key><dict><key>IMGPROXY_COMPAT_HOST</key><string>10.10.0.2</string><key>IMGPROXY_COMPAT_PORT</key><string>20081</string><key>IMGPROXY_UPSTREAM</key><string>http://127.0.0.1:20082</string></dict>
+<key>RunAtLoad</key><true/><key>KeepAlive</key><true/><key>ThrottleInterval</key><integer>10</integer>
+<key>StandardOutPath</key><string>${LOG_DIR}/imgproxy-compat.log</string><key>StandardErrorPath</key><string>${LOG_DIR}/imgproxy-compat.log</string>
+</dict></plist>
+EOF
+
+launchctl bootout "${GUI}/${COMPAT_LABEL}" 2>/dev/null || true
+plutil -lint "${COMPAT_PLIST}" >/dev/null
+launchctl enable "${GUI}/${COMPAT_LABEL}" 2>/dev/null || true
+launchctl bootstrap "${GUI}" "${COMPAT_PLIST}"
+launchctl kickstart -k "${GUI}/${COMPAT_LABEL}"
+
+for _ in $(seq 1 30); do
+  curl -fsS --max-time 2 http://10.10.0.2:20081/health >/dev/null && break
+  sleep 1
+done
+curl -fsS --max-time 3 http://10.10.0.2:20081/health >/dev/null
+
+printf 'imgproxy native installed from %s (%s)\n' "${RUNTIME_DIR}" "$("${IMGPROXY_BIN}" version)"

scripts/install-local-goosed-pool.sh

@@ -0,0 +1,119 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+GOOSED_ROOT="${GOOSED_ROOT:-/Users/john/Project/tkmind_go-v141-prod-prep}"
+RUN_SCRIPT="${GOOSED_RUN_SCRIPT:-${GOOSED_ROOT}/scripts/run-goosed-local.sh}"
+PORTS="${GOOSED_NATIVE_POOL_PORTS:-18006,18007}"
+LAUNCHD_DIR="${HOME}/Library/LaunchAgents"
+GUI="gui/$(id -u)"
+LOG_ROOT="${GOOSED_ROOT}"
+
+usage() {
+  cat <<EOF
+Install native goosed launchd agents for local multi-instance simulation.
+
+Usage:
+  bash scripts/install-local-goosed-pool.sh [--ports 18006,18007]
+
+Environment:
+  GOOSED_ROOT              goosed checkout (default: tkmind_go-v141-prod-prep)
+  GOOSED_NATIVE_POOL_PORTS comma-separated host ports
+
+This script only targets local dev. It refuses prod Portal port 8081 conflicts.
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --ports)
+      PORTS="${2:?missing value for --ports}"
+      shift 2
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    *)
+      echo "unknown argument: $1" >&2
+      usage >&2
+      exit 2
+      ;;
+  esac
+done
+
+if [[ ! -x "${RUN_SCRIPT}" ]]; then
+  echo "run script not found: ${RUN_SCRIPT}" >&2
+  exit 1
+fi
+
+if lsof -nP -iTCP:8081 -sTCP:LISTEN 2>/dev/null | grep -q "cn.tkmind.memind-portal"; then
+  echo "refusing to continue: production Portal appears to own 8081" >&2
+  exit 1
+fi
+
+mkdir -p "${LAUNCHD_DIR}" "${LOG_ROOT}"
+
+IFS=',' read -r -a port_list <<< "${PORTS}"
+
+install_port() {
+  local port="$1"
+  local label="com.tkmind.local-goosed-${port}"
+  local plist="${LAUNCHD_DIR}/${label}.plist"
+  local stdout_log="${LOG_ROOT}/goosed.local-${port}.launchd.log"
+  local stderr_log="${LOG_ROOT}/goosed.local-${port}.launchd.err.log"
+
+  cat > "${plist}" <<EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${label}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/bash</string>
+    <string>${RUN_SCRIPT}</string>
+    <string>${port}</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${GOOSED_ROOT}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${stdout_log}</string>
+  <key>StandardErrorPath</key>
+  <string>${stderr_log}</string>
+</dict>
+</plist>
+EOF
+
+  plutil -lint "${plist}" >/dev/null
+  launchctl bootout "${GUI}/${label}" 2>/dev/null || true
+  launchctl bootstrap "${GUI}" "${plist}"
+  launchctl enable "${GUI}/${label}"
+  launchctl kickstart -k "${GUI}/${label}"
+  echo "installed ${label} on port ${port}"
+}
+
+# Retire legacy single-instance label in favor of per-port labels.
+launchctl bootout "${GUI}/com.tkmind.local-goosed" 2>/dev/null || true
+legacy_plist="${LAUNCHD_DIR}/com.tkmind.local-goosed.plist"
+if [[ -f "${legacy_plist}" ]]; then
+  mv "${legacy_plist}" "${legacy_plist}.bak-$(date +%Y%m%d-%H%M%S)"
+  echo "archived legacy plist: ${legacy_plist}"
+fi
+
+for port in "${port_list[@]}"; do
+  port="${port// /}"
+  [[ -n "${port}" ]] || continue
+  install_port "${port}"
+done
+
+echo ""
+echo "Verify:"
+echo "  for p in ${PORTS//,/ }; do curl -kfsS https://127.0.0.1:\$p/status; echo \" <- \$p\"; done"
+echo "  node ${ROOT}/scripts/check-local-goosed-pool.mjs"

scripts/lib/bundle-mach-dylibs.sh

@@ -0,0 +1,223 @@
+#!/usr/bin/env bash
+# Recursively copy non-system dylibs next to a Mach-O binary and rewrite load paths.
+set -euo pipefail
+
+find_homebrew_lib() {
+  local base="$1"
+  find "${HOMEBREW_PREFIX:-/opt/homebrew}/Cellar" "${HOMEBREW_PREFIX:-/opt/homebrew}/opt" \
+    -name "${base}" -path '*/lib/*' 2>/dev/null | head -1
+}
+
+resolve_dependency_path() {
+  local owner="$1"
+  local dep="$2"
+  local reference="${3:-${owner}}"
+
+  if [[ "${dep}" != @* ]]; then
+    [[ -f "${dep}" ]] || return 1
+    printf '%s\n' "${dep}"
+    return 0
+  fi
+
+  local owner_dir reference_dir
+  owner_dir="$(cd "$(dirname "${owner}")" && pwd)"
+  reference_dir="$(cd "$(dirname "${reference}")" && pwd)"
+
+  case "${dep}" in
+    @loader_path/*)
+      local candidate="${owner_dir}/${dep#@loader_path/}"
+      [[ -f "${candidate}" ]] || return 1
+      printf '%s\n' "${candidate}"
+      ;;
+    @executable_path/*)
+      local rel="${dep#@executable_path/}"
+      local candidate="${owner_dir}/${rel}"
+      if [[ ! -f "${candidate}" ]]; then
+        candidate="${reference_dir}/${rel}"
+      fi
+      if [[ ! -f "${candidate}" ]]; then
+        candidate="$(find_homebrew_lib "$(basename "${rel}")")"
+      fi
+      [[ -f "${candidate}" ]] || return 1
+      printf '%s\n' "${candidate}"
+      ;;
+    @rpath/*)
+      local rel="${dep#@rpath/}"
+      local rpath candidate
+      while IFS= read -r rpath; do
+        case "${rpath}" in
+          @loader_path/*) candidate="${owner_dir}/${rpath#@loader_path/}/${rel}" ;;
+          @executable_path/*) candidate="${owner_dir}/${rpath#@executable_path/}/${rel}" ;;
+          *) candidate="${rpath}/${rel}" ;;
+        esac
+        if [[ -f "${candidate}" ]]; then
+          printf '%s\n' "${candidate}"
+          return 0
+        fi
+      done < <(
+        otool -l "${owner}" | awk '
+          /cmd LC_RPATH/ { want=1; next }
+          want && /path / {
+            sub(/^.*path /, "", $0)
+            sub(/ \(offset.*$/, "", $0)
+            print
+            want=0
+          }
+        '
+      )
+      candidate="${owner_dir}/${rel}"
+      [[ -f "${candidate}" ]] || return 1
+      printf '%s\n' "${candidate}"
+      ;;
+    *)
+      return 1
+      ;;
+  esac
+}
+
+list_load_dylibs() {
+  local target="$1"
+  otool -l "${target}" | awk '
+    /cmd LC_LOAD_DYLIB/ { want=1; next }
+    want && /name / {
+      sub(/^.*name /, "", $0)
+      sub(/ \(offset.*$/, "", $0)
+      print
+      want=0
+    }
+  '
+}
+
+bundle_mach_dylibs() {
+  local binary="${1:?binary path required}"
+  local lib_dir="${2:?lib directory required}"
+  local reference_binary="${3:-${binary}}"
+
+  [[ -f "${binary}" ]] || {
+    echo "bundle_mach_dylibs: missing binary: ${binary}" >&2
+    return 1
+  }
+
+  mkdir -p "${lib_dir}"
+
+  local -a queue=("${binary}")
+  local seen_list=" "
+  local -a sources=()
+
+  is_system_lib() {
+    case "$1" in
+      /usr/lib/*|/System/*|/Library/*) return 0 ;;
+    esac
+    return 1
+  }
+
+  already_seen() {
+    [[ "${seen_list}" == *" $1 "* ]]
+  }
+
+  remember() {
+    seen_list+=" $1 "
+  }
+
+  while ((${#queue[@]} > 0)); do
+    local target="${queue[0]}"
+    queue=("${queue[@]:1}")
+    [[ -f "${target}" ]] || continue
+
+    local dep resolved
+    while IFS= read -r dep; do
+      [[ -n "${dep}" ]] || continue
+      is_system_lib "${dep}" && continue
+      already_seen "${dep}" && continue
+      remember "${dep}"
+
+      resolved="$(resolve_dependency_path "${target}" "${dep}" "${reference_binary}")" || {
+        echo "bundle_mach_dylibs: missing dependency ${dep} for ${target}" >&2
+        return 1
+      }
+      already_seen "${resolved}" || remember "${resolved}"
+
+      if [[ "${resolved}" != "${binary}" ]]; then
+        sources+=("${resolved}")
+        queue+=("${resolved}")
+      fi
+    done < <(list_load_dylibs "${target}")
+  done
+
+  local src base
+  for src in "${sources[@]}"; do
+    base="$(basename "${src}")"
+    cp -f "${src}" "${lib_dir}/${base}"
+    chmod 755 "${lib_dir}/${base}"
+  done
+
+  rewrite_dep() {
+    local target="$1"
+    local dep="$2"
+    local new_path="$3"
+    install_name_tool -change "${dep}" "${new_path}" "${target}" 2>/dev/null || true
+  }
+
+  rewrite_targets() {
+    local target="$1"
+    local prefix="$2"
+    local dep base
+    while IFS= read -r dep; do
+      [[ -n "${dep}" ]] || continue
+      is_system_lib "${dep}" && continue
+      [[ "${dep}" == @* ]] && continue
+      base="$(basename "${dep}")"
+      [[ -f "${lib_dir}/${base}" ]] || continue
+      rewrite_dep "${target}" "${dep}" "${prefix}${base}"
+    done < <(list_load_dylibs "${target}")
+  }
+
+  rewrite_rpath_targets() {
+    local target="$1"
+    local prefix="$2"
+    local dep base
+    while IFS= read -r dep; do
+      [[ -n "${dep}" ]] || continue
+      [[ "${dep}" == @rpath/* ]] || continue
+      base="$(basename "${dep}")"
+      [[ -f "${lib_dir}/${base}" ]] || continue
+      rewrite_dep "${target}" "${dep}" "${prefix}${base}"
+    done < <(list_load_dylibs "${target}")
+  }
+
+  local changed=1
+  while ((changed)); do
+    changed=0
+    rewrite_targets "${binary}" "@executable_path/../lib/"
+    rewrite_rpath_targets "${binary}" "@executable_path/../lib/"
+    for staged in "${lib_dir}"/*.dylib; do
+      [[ -f "${staged}" ]] || continue
+      before="$(list_load_dylibs "${staged}" | { grep -E 'homebrew|^@rpath/' || true; } | wc -l | tr -d ' ')"
+      rewrite_targets "${staged}" "@loader_path/"
+      rewrite_rpath_targets "${staged}" "@loader_path/"
+      after="$(list_load_dylibs "${staged}" | { grep -E 'homebrew|^@rpath/' || true; } | wc -l | tr -d ' ')"
+      [[ "${before}" != "${after}" ]] && changed=1
+    done
+  done
+
+  local remaining
+  remaining="$(list_load_dylibs "${binary}" | grep homebrew || true)"
+  if [[ -n "${remaining}" ]]; then
+    echo "bundle_mach_dylibs: unresolved homebrew dependencies remain:" >&2
+    printf '%s\n' "${remaining}" >&2
+    return 1
+  fi
+
+  install_name_tool -add_rpath "@executable_path/../lib" "${binary}" 2>/dev/null || true
+
+  local staged
+  for staged in "${lib_dir}"/*.dylib; do
+    [[ -f "${staged}" ]] || continue
+    codesign --force --sign - "${staged}" >/dev/null
+  done
+  codesign --force --sign - "${binary}" >/dev/null
+}
+
+if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
+  bundle_mach_dylibs "$@"
+fi

scripts/monitor-goosed-fds.mjs

@@ -106,8 +106,18 @@ function cleanupSandboxProcesses() {
 }
 
 function goosedLabel(command) {
-  const port = command.match(/\b(18006|18007)\b/)?.[1];
-  return port ? `cn.tkmind.goosed-${port}` : null;
+  const configured = String(process.env.GOOSED_NATIVE_POOL_PORTS ?? '18006,18007')
+    .split(/[,\s]+/)
+    .map((value) => value.trim())
+    .filter(Boolean);
+  const portPattern = configured.length > 0
+    ? configured.map((port) => port.replace(/^:/, '')).join('|')
+    : '1800[6-9]|1801[0-4]';
+  const match = command.match(new RegExp(`\\b(${portPattern})\\b`));
+  const port = match?.[1] ?? null;
+  if (!port) return null;
+  const template = process.env.GOOSED_NATIVE_LAUNCHD_LABEL_TEMPLATE ?? 'com.tkmind.local-goosed-{port}';
+  return template.replace('{port}', port);
 }
 
 function monitorGoosed() {

scripts/release-imgproxy-native-prod.sh

@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+# Release the independently versioned native imgproxy runtime (vendor binary) to 103.
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+HOST="${STUDIO_HOST:-john@58.38.22.103}"
+REMOTE_ROOT="${STUDIO_REMOTE_ROOT:-/Users/john/Project}"
+RUNTIME_BASE="${REMOTE_ROOT}/imgproxy-runtime"
+INCOMING="${REMOTE_ROOT}/incoming/imgproxy-runtime"
+RELEASE_ID="$(date +%Y%m%d-%H%M%S)-$(git -C "$ROOT" rev-parse --short HEAD)"
+TMP="$(mktemp -d "${TMPDIR:-/tmp}/imgproxy-native-release.XXXXXX")"
+DRY_RUN=0
+
+cleanup() { rm -rf "$TMP"; }
+trap cleanup EXIT
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --dry-run) DRY_RUN=1 ;;
+    -h|--help)
+      cat <<'EOF'
+Usage: bash scripts/release-imgproxy-native-prod.sh [--dry-run]
+
+Builds and installs the vendor imgproxy runtime on 103. Portal runtime is unchanged.
+EOF
+      exit 0
+      ;;
+    *)
+      echo "unknown argument: $1" >&2
+      exit 1
+      ;;
+  esac
+  shift
+done
+
+git -C "$ROOT" fetch origin main --quiet
+branch="$(git -C "$ROOT" branch --show-current)"
+[[ "$branch" == release/* ]] || { echo 'imgproxy native production release must run from a release/* branch' >&2; exit 1; }
+[[ -z "$(git -C "$ROOT" status --porcelain)" ]] || { echo 'worktree must be clean' >&2; exit 1; }
+[[ "$(git -C "$ROOT" rev-parse HEAD)" == "$(git -C "$ROOT" rev-parse origin/main)" ]] || {
+  echo 'main must match origin/main' >&2
+  exit 1
+}
+bash "$ROOT/scripts/check-release-ready.sh"
+
+bash "$ROOT/scripts/build-imgproxy-runtime-native.sh"
+RUNTIME_DIR="$ROOT/.runtime/imgproxy-native"
+for file in \
+  vendor/imgproxy-runtime/bin/imgproxy \
+  vendor/imgproxy-runtime/SHA256SUMS \
+  vendor/imgproxy-runtime/VERSION.txt \
+  scripts/install-imgproxy-native-prod.sh \
+  imgproxy-compat-proxy.mjs \
+  RUNBOOK.txt; do
+  [[ -f "$RUNTIME_DIR/$file" ]] || { echo "missing runtime artifact: $file" >&2; exit 1; }
+done
+
+MANIFEST="$TMP/release-manifest.txt"
+{
+  echo "release_id=${RELEASE_ID}"
+  echo "git_head=$(git -C "$ROOT" rev-parse HEAD)"
+  echo "imgproxy_version=$(cat "$RUNTIME_DIR/vendor/imgproxy-runtime/VERSION.txt")"
+  echo "runtime_mode=native-vendor"
+} > "$MANIFEST"
+
+mkdir -p "$TMP/runtime"
+cp -R "$RUNTIME_DIR/." "$TMP/runtime/"
+cp "$MANIFEST" "$TMP/runtime/"
+tar -C "$TMP" -czf "$TMP/imgproxy-native-runtime-$RELEASE_ID.tar.gz" runtime
+(cd "$TMP" && shasum -a 256 "imgproxy-native-runtime-$RELEASE_ID.tar.gz" > "imgproxy-native-runtime-$RELEASE_ID.tar.gz.sha256")
+
+if [[ "$DRY_RUN" == 1 ]]; then
+  shasum -a 256 -c "$TMP/imgproxy-native-runtime-$RELEASE_ID.tar.gz.sha256"
+  echo "imgproxy native dry-run artifact verified: $TMP/imgproxy-native-runtime-$RELEASE_ID.tar.gz"
+  exit 0
+fi
+
+ssh -o BatchMode=yes "$HOST" "mkdir -p '$INCOMING' '$RUNTIME_BASE/releases' '$RUNTIME_BASE/backups'"
+scp -q "$TMP/imgproxy-native-runtime-$RELEASE_ID.tar.gz" "$TMP/imgproxy-native-runtime-$RELEASE_ID.tar.gz.sha256" "$HOST:$INCOMING/"
+ssh -o BatchMode=yes "$HOST" "RELEASE_ID='$RELEASE_ID' RUNTIME_BASE='$RUNTIME_BASE' INCOMING='$INCOMING' bash -s" <<'REMOTE'
+set -euo pipefail
+archive="$INCOMING/imgproxy-native-runtime-$RELEASE_ID.tar.gz"
+sha="$archive.sha256"
+release_dir="$RUNTIME_BASE/releases/$RELEASE_ID"
+backup_dir="$RUNTIME_BASE/backups/$RELEASE_ID"
+current_link="$RUNTIME_BASE/current"
+previous_target="$(readlink "$current_link" 2>/dev/null || true)"
+
+mkdir -p "$release_dir" "$backup_dir"
+cp "$HOME/Library/LaunchAgents/cn.tkmind.imgproxy.plist" "$backup_dir/imgproxy.plist" 2>/dev/null || true
+cp "$HOME/Library/LaunchAgents/cn.tkmind.imgproxy-compat.plist" "$backup_dir/imgproxy-compat.plist" 2>/dev/null || true
+cd "$INCOMING"
+shasum -a 256 -c "$sha"
+tar -xzf "$archive" -C "$release_dir" --strip-components=1
+
+rollback() {
+  launchctl bootout "gui/$(id -u)/cn.tkmind.imgproxy" >/dev/null 2>&1 || true
+  launchctl bootout "gui/$(id -u)/cn.tkmind.imgproxy-compat" >/dev/null 2>&1 || true
+  if [[ -n "$previous_target" && -d "$previous_target" ]]; then
+    ln -sfn "$previous_target" "$current_link"
+  else
+    rm -f "$current_link"
+  fi
+  if [[ -f "$backup_dir/imgproxy.plist" ]]; then
+    cp "$backup_dir/imgproxy.plist" "$HOME/Library/LaunchAgents/cn.tkmind.imgproxy.plist"
+    launchctl bootstrap "gui/$(id -u)" "$HOME/Library/LaunchAgents/cn.tkmind.imgproxy.plist" >/dev/null 2>&1 || true
+  fi
+  if [[ -f "$backup_dir/imgproxy-compat.plist" ]]; then
+    cp "$backup_dir/imgproxy-compat.plist" "$HOME/Library/LaunchAgents/cn.tkmind.imgproxy-compat.plist"
+    launchctl bootstrap "gui/$(id -u)" "$HOME/Library/LaunchAgents/cn.tkmind.imgproxy-compat.plist" >/dev/null 2>&1 || true
+  fi
+}
+trap rollback ERR
+
+IMGPROXY_RUNTIME_DIR="$release_dir" bash "$release_dir/scripts/install-imgproxy-native-prod.sh"
+ln -sfn "$release_dir" "$current_link"
+curl -fsS --max-time 5 http://127.0.0.1:20082/health >/dev/null
+curl -fsS --max-time 5 http://10.10.0.2:20081/health >/dev/null
+trap - ERR
+printf '%s\n' "$RELEASE_ID" > "$RUNTIME_BASE/current-release.txt"
+REMOTE
+
+curl -kfsS --max-time 15 https://img.tkmind.cn/health >/dev/null
+printf 'imgproxy native release verified: %s\n' "$RELEASE_ID"

scripts/run-imgproxy-prod.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+RUNTIME_BASE="${IMGPROXY_RUNTIME_BASE:-/Users/john/Project/imgproxy-runtime}"
+RUNTIME_DIR="${IMGPROXY_RUNTIME_DIR:-${RUNTIME_BASE}/current}"
+ROOT="${ROOT:-/Users/john/Project/Memind}"
+IMGPROXY_BIN="${RUNTIME_DIR}/vendor/imgproxy-runtime/bin/imgproxy"
+
+[[ -x "${IMGPROXY_BIN}" ]] || {
+  echo "[imgproxy-start] missing binary: ${IMGPROXY_BIN}" >&2
+  exit 1
+}
+
+if [[ -f "${ROOT}/.env" ]]; then
+  set -a
+  # shellcheck disable=SC1090
+  source "${ROOT}/.env"
+  set +a
+fi
+
+: "${IMGPROXY_SIGNING_KEY:?missing IMGPROXY_SIGNING_KEY}"
+: "${IMGPROXY_SIGNING_SALT:?missing IMGPROXY_SIGNING_SALT}"
+: "${MINDSPACE_STORAGE_ROOT:?missing MINDSPACE_STORAGE_ROOT}"
+
+export IMGPROXY_BIND="${IMGPROXY_BIND:-127.0.0.1:20082}"
+export IMGPROXY_LOCAL_FILESYSTEM_ROOT="${MINDSPACE_STORAGE_ROOT}"
+export IMGPROXY_KEY="${IMGPROXY_SIGNING_KEY}"
+export IMGPROXY_SALT="${IMGPROXY_SIGNING_SALT}"
+export IMGPROXY_USE_ETAG="${IMGPROXY_USE_ETAG:-true}"
+export IMGPROXY_ENABLE_WEBP_DETECTION="${IMGPROXY_ENABLE_WEBP_DETECTION:-true}"
+
+exec "${IMGPROXY_BIN}"

scripts/run-memind-portal-prod.sh

@@ -26,6 +26,12 @@ fi
 export GOOSED_MCP_NODE_PATH="${GOOSED_MCP_NODE_PATH:-${NODE_BIN}}"
 export GOOSED_MCP_SERVER_PATH="${GOOSED_MCP_SERVER_PATH:-${ROOT}/mindspace-sandbox-mcp.mjs}"
 
+# DeepSeek V4 tool rounds require reasoning_content replay; stable goosed must use the
+# host no-think compat proxy (see docs/发包必看.md §4.7).
+export MEMIND_DEEPSEEK_DISABLE_THINKING="${MEMIND_DEEPSEEK_DISABLE_THINKING:-1}"
+export MEMIND_DEEPSEEK_NO_THINK_PORT="${MEMIND_DEEPSEEK_NO_THINK_PORT:-18036}"
+export MEMIND_GOOSED_HOST_GATEWAY="${MEMIND_GOOSED_HOST_GATEWAY:-host.docker.internal}"
+
 free_port_if_stale_memind_listener() {
   local port="${H5_PORT:-8081}"
   local pids

scripts/run-release-gate-page-scenarios.mjs

@@ -4,6 +4,7 @@ import path from 'node:path';
 
 import {
   createLocalGateStack,
+  grantGateUserSkillsByUsername,
   selectBackendLlmProvider,
   seedSelectedProviderKeys,
 } from '../release-gate/local-stack.mjs';
@@ -16,8 +17,12 @@ const scenarioIds = [
 
 async function runScenario(scenarioId, port) {
   const childTimeoutMs = Math.max(
-    30_000,
-    Number(process.env.RELEASE_GATE_SCENARIO_PROCESS_TIMEOUT_MS ?? 360_000) || 360_000,
+    60_000,
+    Number(process.env.RELEASE_GATE_SCENARIO_PROCESS_TIMEOUT_MS ?? 900_000) || 900_000,
+  );
+  const stepTimeoutMs = Math.max(
+    60_000,
+    Number(process.env.RELEASE_GATE_SCENARIO_TIMEOUT_MS ?? 900_000) || 900_000,
   );
   const code = await new Promise((resolve, reject) => {
     const child = spawn(
@@ -28,9 +33,7 @@ async function runScenario(scenarioId, port) {
         env: {
           ...process.env,
           JOHN_PASSWORD: '888888',
-          RELEASE_GATE_SCENARIO_TIMEOUT_MS: String(
-            Number(process.env.RELEASE_GATE_SCENARIO_TIMEOUT_MS ?? 300_000) || 300_000,
-          ),
+          RELEASE_GATE_SCENARIO_TIMEOUT_MS: String(stepTimeoutMs),
         },
         stdio: 'inherit',
       },
@@ -77,10 +80,18 @@ async function register(username) {
 
 try {
   await register('john2');
-  const results = await Promise.all(scenarioIds.map(async (scenarioId) => ({
-    scenarioId,
-    code: await runScenario(scenarioId, new URL(stack.baseUrl).port),
-  })));
+  await grantGateUserSkillsByUsername({
+    targetUrl: stack.mysqlUrl,
+    username: 'john2',
+    skillNames: ['static-page-publish'],
+  });
+  const results = [];
+  for (const scenarioId of scenarioIds) {
+    results.push({
+      scenarioId,
+      code: await runScenario(scenarioId, new URL(stack.baseUrl).port),
+    });
+  }
   for (const result of results) {
     console.log(`${result.code === 0 ? 'PASS' : 'FAIL'} ${result.scenarioId}`);
   }

scripts/runtime-worker-metrics.mjs

@@ -54,16 +54,40 @@ function parseMemUsage(value) {
   };
 }
 
+function resolveRuntimeMode() {
+  const configured = String(process.env.GOOSED_RUNTIME ?? 'auto').trim().toLowerCase();
+  if (configured === 'native' || configured === 'docker') return configured;
+  try {
+    const line = sh("docker ps --filter 'label=com.docker.compose.project=goosed-prod' --format '{{.Names}}' 2>/dev/null | head -1");
+    return line ? 'docker' : 'native';
+  } catch {
+    return 'native';
+  }
+}
+
+function portFromTarget(target) {
+  try {
+    return new URL(target).port || '443';
+  } catch {
+    return null;
+  }
+}
+
 function targetWorkerIds() {
   const targets = (process.env.TKMIND_API_TARGETS || process.env.TKMIND_API_TARGET || '')
     .split(',')
     .map((value) => value.trim())
     .filter(Boolean);
-  return targets.map((target, index) => ({
-    id: `goosed-${index + 1}`,
-    target,
-    container: `goosed-prod-${index + 1}`,
-  }));
+  return targets.map((target, index) => {
+    const port = portFromTarget(target);
+    return {
+      id: `goosed-${index + 1}`,
+      target,
+      port,
+      container: `goosed-prod-${index + 1}`,
+      launchdLabel: port ? `com.tkmind.local-goosed-${port}` : null,
+    };
+  });
 }
 
 function readDockerStats(container) {
@@ -92,26 +116,51 @@ function readContainerFdCount(container) {
   }
 }
 
-function workerKey(namespace, id, field) {
-  return [namespace, 'worker', id, field].join(':');
+function readListenPid(port) {
+  if (!port) return null;
+  try {
+    const pid = sh(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t 2>/dev/null | head -1`);
+    const n = Number(pid);
+    return Number.isFinite(n) && n > 0 ? n : null;
+  } catch {
+    return null;
+  }
 }
 
-loadEnvFile(process.env.MEMIND_ENV_FILE || path.join(process.cwd(), '.env'));
-
-const redisUrl = process.env.MEMIND_RUNTIME_REDIS_URL || 'redis://127.0.0.1:6379/0';
-const namespace = process.env.MEMIND_RUNTIME_REDIS_NAMESPACE || 'memind:runtime';
-const action = process.argv[2] || 'sample';
-const dryRun = process.argv.includes('--dry-run') || action === 'status';
-const fdWarn = Number(process.env.GOOSED_FD_WARN ?? 180);
-const now = Date.now();
-
-if (!['sample', 'status'].includes(action)) {
-  console.error('Usage: node scripts/runtime-worker-metrics.mjs <sample|status> [--dry-run]');
-  process.exit(2);
+function readNativeFdCount(pid) {
+  if (!pid) return 0;
+  try {
+    return Number(sh(`lsof -n -p ${pid} 2>/dev/null | wc -l | tr -d ' '`)) || 0;
+  } catch {
+    return 0;
+  }
 }
 
-const workers = [];
-for (const worker of targetWorkerIds()) {
+function readNativeProcessStats(pid) {
+  if (!pid) return null;
+  try {
+    const line = sh(`ps -p ${pid} -o %cpu=,rss= 2>/dev/null | tail -1`);
+    const match = line.trim().match(/^([\d.]+)\s+(\d+)$/);
+    if (!match) return null;
+    return {
+      cpuLoad: Number(match[1]) || 0,
+      rssBytes: (Number(match[2]) || 0) * 1024,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function readLaunchdState(label) {
+  if (!label) return null;
+  try {
+    return sh(`launchctl print gui/$(id -u)/${label} 2>/dev/null | awk '/state =/ {print $3; exit}'`) || null;
+  } catch {
+    return null;
+  }
+}
+
+function sampleDockerWorker(worker, fdWarn, now) {
   const stats = readDockerStats(worker.container);
   const state = readDockerInspect(worker.container);
   const fdCount = readContainerFdCount(worker.container);
@@ -119,8 +168,9 @@ for (const worker of targetWorkerIds()) {
   const cpuLoad = parsePercent(stats?.CPUPerc);
   const memoryPressure = parsePercent(stats?.MemPerc);
   const fdPressure = fdWarn > 0 ? Number((fdCount / fdWarn).toFixed(4)) : 0;
-  workers.push({
+  return {
     ...worker,
+    runtime: 'docker',
     ok: Boolean(stats && state?.Running),
     health: state?.Health?.Status ?? state?.Status ?? null,
     hostPid: Number(state?.Pid ?? 0) || null,
@@ -132,9 +182,60 @@ for (const worker of targetWorkerIds()) {
     memUsedBytes: mem.usedBytes,
     memLimitBytes: mem.limitBytes,
     sampledAt: now,
-  });
+  };
 }
 
+function sampleNativeWorker(worker, fdWarn, now) {
+  const hostPid = readListenPid(worker.port);
+  const fdCount = readNativeFdCount(hostPid);
+  const proc = readNativeProcessStats(hostPid);
+  const launchdState = readLaunchdState(worker.launchdLabel);
+  const fdPressure = fdWarn > 0 ? Number((fdCount / fdWarn).toFixed(4)) : 0;
+  const memUsedBytes = proc?.rssBytes ?? 0;
+  return {
+    ...worker,
+    runtime: 'native',
+    ok: Boolean(hostPid && launchdState === 'running'),
+    health: launchdState,
+    hostPid,
+    cpuLoad: proc?.cpuLoad ?? 0,
+    memoryPressure: 0,
+    fdPressure,
+    fdCount,
+    pids: hostPid ? 1 : 0,
+    memUsedBytes,
+    memLimitBytes: 0,
+    sampledAt: now,
+    container: worker.launchdLabel ?? worker.container,
+  };
+}
+
+function workerKey(namespace, id, field) {
+  return [namespace, 'worker', id, field].join(':');
+}
+
+loadEnvFile(process.env.MEMIND_ENV_FILE || path.join(process.cwd(), '.env'));
+
+const runtimeMode = resolveRuntimeMode();
+const redisUrl = process.env.MEMIND_RUNTIME_REDIS_URL || 'redis://127.0.0.1:6379/0';
+const namespace = process.env.MEMIND_RUNTIME_REDIS_NAMESPACE || 'memind:runtime';
+const action = process.argv[2] || 'sample';
+const dryRun = process.argv.includes('--dry-run') || action === 'status';
+const fdWarn = Number(process.env.GOOSED_FD_WARN ?? 180);
+const now = Date.now();
+
+if (!['sample', 'status'].includes(action)) {
+  console.error('Usage: node scripts/runtime-worker-metrics.mjs <sample|status> [--dry-run]');
+  console.error('Env: GOOSED_RUNTIME=auto|native|docker (default auto)');
+  process.exit(2);
+}
+
+const workers = targetWorkerIds().map((worker) => (
+  runtimeMode === 'native'
+    ? sampleNativeWorker(worker, fdWarn, now)
+    : sampleDockerWorker(worker, fdWarn, now)
+));
+
 if (!dryRun) {
   const client = createClient({ url: redisUrl });
   client.on('error', (err) => {
@@ -163,6 +264,7 @@ console.log(JSON.stringify({
   ok: workers.every((worker) => worker.ok),
   action,
   dryRun,
+  runtimeMode,
   namespace,
   redisWrites: !dryRun,
   workers,

scripts/soak-local-goosed-pool.mjs

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+/**
+ * Local native goosed pool soak: periodic /status + FD sampling across TKMIND_API_TARGETS.
+ *
+ * Usage:
+ *   node scripts/soak-local-goosed-pool.mjs [--minutes 30] [--interval 60]
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { Agent, fetch as undiciFetch } from 'undici';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const root = path.join(__dirname, '..');
+const insecureDispatcher = new Agent({ connect: { rejectUnauthorized: false } });
+
+function loadEnvFile(filePath) {
+  if (!fs.existsSync(filePath)) return;
+  for (const line of fs.readFileSync(filePath, 'utf8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const idx = trimmed.indexOf('=');
+    if (idx < 0) continue;
+    const key = trimmed.slice(0, idx).trim();
+    const value = trimmed.slice(idx + 1).trim();
+    if (!process.env[key]) process.env[key] = value;
+  }
+}
+
+function sh(command) {
+  return execFileSync('/bin/zsh', ['-lc', command], { encoding: 'utf8' }).trim();
+}
+
+function parseArgs(argv) {
+  const options = {
+    minutes: Number(process.env.GOOSED_SOAK_MINUTES ?? 30),
+    intervalSec: Number(process.env.GOOSED_SOAK_INTERVAL_SEC ?? 60),
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--minutes') {
+      options.minutes = Number(argv[++i]);
+    } else if (arg === '--interval') {
+      options.intervalSec = Number(argv[++i]);
+    } else if (arg === '-h' || arg === '--help') {
+      console.log(`Usage: node scripts/soak-local-goosed-pool.mjs [--minutes 30] [--interval 60]`);
+      process.exit(0);
+    }
+  }
+  if (!Number.isFinite(options.minutes) || options.minutes <= 0) {
+    throw new Error('invalid --minutes');
+  }
+  if (!Number.isFinite(options.intervalSec) || options.intervalSec <= 0) {
+    throw new Error('invalid --interval');
+  }
+  return options;
+}
+
+function resolveTargets() {
+  return (process.env.TKMIND_API_TARGETS || process.env.GOOSED_NATIVE_POOL_PORTS || '18006,18007')
+    .split(/[,\s]+/)
+    .map((value) => value.trim())
+    .filter(Boolean)
+    .flatMap((value) => (
+      value.startsWith('http')
+        ? [value.replace(/\/$/, '')]
+        : [`https://127.0.0.1:${value.replace(/^:/, '')}`]
+    ));
+}
+
+function portFromTarget(target) {
+  try {
+    return new URL(target).port || '443';
+  } catch {
+    return null;
+  }
+}
+
+function nativeLaunchdLabel(port) {
+  return port ? `com.tkmind.local-goosed-${port}` : null;
+}
+
+function readListenPid(port) {
+  if (!port) return null;
+  try {
+    const pid = sh(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t 2>/dev/null | head -1`);
+    const n = Number(pid);
+    return Number.isFinite(n) && n > 0 ? n : null;
+  } catch {
+    return null;
+  }
+}
+
+function readFdCount(pid) {
+  if (!pid) return 0;
+  try {
+    return Number(sh(`lsof -n -p ${pid} 2>/dev/null | wc -l | tr -d ' '`)) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+function readLaunchdState(label) {
+  if (!label) return null;
+  try {
+    const output = sh(`launchctl print gui/$(id -u)/${label} 2>/dev/null | awk '/state =/ {print $3; exit}'`);
+    return output || null;
+  } catch {
+    return null;
+  }
+}
+
+async function probeTarget(target) {
+  const started = Date.now();
+  try {
+    const res = await undiciFetch(`${target}/status`, { dispatcher: insecureDispatcher });
+    const body = (await res.text()).trim();
+    return {
+      ok: res.ok && body === 'ok',
+      status: res.status,
+      body,
+      latencyMs: Date.now() - started,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      latencyMs: Date.now() - started,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+loadEnvFile(path.join(root, '.env'));
+
+const options = parseArgs(process.argv.slice(2));
+const targets = resolveTargets();
+if (targets.length === 0) {
+  console.error('No targets configured.');
+  process.exit(2);
+}
+
+const fdWarn = Number(process.env.GOOSED_FD_WARN ?? 180);
+const fdRestart = Number(process.env.GOOSED_FD_RESTART ?? 3200);
+const endAt = Date.now() + options.minutes * 60_000;
+const summary = {
+  startedAt: new Date().toISOString(),
+  minutes: options.minutes,
+  intervalSec: options.intervalSec,
+  targets,
+  ticks: 0,
+  failures: 0,
+  maxFdByTarget: Object.fromEntries(targets.map((target) => [target, 0])),
+  samples: [],
+};
+
+console.log(`[soak] starting ${options.minutes}m interval=${options.intervalSec}s targets=${targets.join(', ')}`);
+
+while (Date.now() < endAt) {
+  summary.ticks += 1;
+  const tickStarted = Date.now();
+  const tick = {
+    at: new Date().toISOString(),
+    targets: [],
+    ok: true,
+  };
+
+  for (const target of targets) {
+    const port = portFromTarget(target);
+    const label = nativeLaunchdLabel(port);
+    const pid = readListenPid(port);
+    const fdCount = readFdCount(pid);
+    const launchdState = readLaunchdState(label);
+    const probe = await probeTarget(target);
+
+    summary.maxFdByTarget[target] = Math.max(summary.maxFdByTarget[target], fdCount);
+    const entry = {
+      target,
+      port,
+      launchdLabel: label,
+      launchdState,
+      pid,
+      fdCount,
+      fdWarn,
+      fdRestart,
+      fdPressure: fdWarn > 0 ? Number((fdCount / fdWarn).toFixed(4)) : 0,
+      ...probe,
+    };
+    tick.targets.push(entry);
+    if (!entry.ok || fdCount >= fdWarn) tick.ok = false;
+
+    const status = entry.ok ? 'ok' : 'FAIL';
+    console.log(
+      `[soak] tick=${summary.ticks} ${target} ${status} pid=${pid ?? '-'} fd=${fdCount} launchd=${launchdState ?? '-'} latency=${entry.latencyMs}ms`,
+    );
+  }
+
+  if (!tick.ok) summary.failures += 1;
+  summary.samples.push(tick);
+
+  const elapsed = Date.now() - tickStarted;
+  const waitMs = Math.max(0, options.intervalSec * 1000 - elapsed);
+  if (Date.now() + waitMs >= endAt) break;
+  await sleep(waitMs);
+}
+
+summary.finishedAt = new Date().toISOString();
+summary.ok = summary.failures === 0;
+
+console.log(JSON.stringify({
+  ok: summary.ok,
+  ticks: summary.ticks,
+  failures: summary.failures,
+  maxFdByTarget: summary.maxFdByTarget,
+  fdWarn,
+  fdRestart,
+}, null, 2));
+
+insecureDispatcher.close();
+process.exit(summary.ok ? 0 : 1);

scripts/test-goosed-page-direct.mjs

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+/**
+ * Direct goosed page smoke on TKMIND_API_TARGET (default https://127.0.0.1:18006).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { Readable } from 'node:stream';
+import { fileURLToPath } from 'node:url';
+import { Agent, fetch } from 'undici';
+
+import { buildChatSkillPrompt } from '../chat-skills.mjs';
+
+const root = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+function loadEnvFile(filePath) {
+  if (!fs.existsSync(filePath)) return;
+  for (const line of fs.readFileSync(filePath, 'utf8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eq = trimmed.indexOf('=');
+    if (eq < 0) continue;
+    const key = trimmed.slice(0, eq).trim();
+    const value = trimmed.slice(eq + 1).trim();
+    if (!process.env[key]) process.env[key] = value;
+  }
+}
+
+loadEnvFile(path.join(root, '.env'));
+
+const secret = process.env.TKMIND_SERVER__SECRET_KEY ?? 'local-dev-secret';
+const base = process.env.TKMIND_API_TARGET ?? 'https://127.0.0.1:18006';
+const workingDir = path.resolve(
+  process.argv[2] ?? path.join(root, '.release-gate/local/goosed-direct-page'),
+);
+const targetHtml = process.argv[3] ?? 'public/suzhou-goosed-direct.html';
+const provider = process.argv[4] ?? process.env.GOOSED_PAGE_TEST_PROVIDER ?? 'custom_tkmind_relay_deepseek';
+const model = process.argv[5] ?? process.env.GOOSED_PAGE_TEST_MODEL ?? 'deepseek-chat';
+const timeoutMs = Number(process.env.GOOSED_PAGE_TEST_TIMEOUT_MS ?? 600_000);
+
+const dispatcher = new Agent({ connect: { rejectUnauthorized: false } });
+
+async function apiFetch(pathname, init = {}) {
+  const headers = {
+    ...(init.headers ?? {}),
+    'X-Secret-Key': secret,
+  };
+  if (init.body && !headers['Content-Type']) {
+    headers['Content-Type'] = 'application/json';
+  }
+  return fetch(`${base}${pathname}`, {
+    ...init,
+    headers,
+    dispatcher,
+  });
+}
+
+async function apiJson(pathname, body) {
+  const response = await apiFetch(pathname, {
+    method: 'POST',
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  if (!response.ok) throw new Error(`${pathname} ${response.status}: ${text.slice(0, 800)}`);
+  if (!text.trim()) return {};
+  return JSON.parse(text);
+}
+
+function messageVisibleText(message) {
+  return (message?.content ?? [])
+    .filter((item) => item?.type === 'text')
+    .map((item) => String(item.text ?? ''))
+    .join('\n')
+    .trim();
+}
+
+async function executeSessionReply(sessionId, requestId, prompt) {
+  const eventsResponse = await apiFetch(`/sessions/${sessionId}/events`, {
+    method: 'GET',
+    headers: { Accept: 'text/event-stream' },
+  });
+  if (!eventsResponse.ok || !eventsResponse.body) {
+    const text = await eventsResponse.text().catch(() => '');
+    throw new Error(text || '无法建立 goosed 事件流');
+  }
+
+  const replyResponse = await apiFetch(`/sessions/${sessionId}/reply`, {
+    method: 'POST',
+    body: JSON.stringify({
+      request_id: requestId,
+      user_message: {
+        role: 'user',
+        created: Date.now(),
+        content: [{ type: 'text', text: prompt }],
+        metadata: { userVisible: true, agentVisible: true, displayText: prompt },
+      },
+    }),
+  });
+  if (!replyResponse.ok) {
+    const text = await replyResponse.text().catch(() => '');
+    throw new Error(text || 'reply 失败');
+  }
+  replyResponse.body?.cancel?.();
+
+  const reader = Readable.fromWeb(eventsResponse.body);
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let messages = [];
+  let finishSeen = false;
+  let errorText = '';
+
+  const pushMessage = (list, message) => {
+    const index = list.findIndex((item) => item.id === message.id);
+    if (index >= 0) {
+      const next = [...list];
+      next[index] = message;
+      return next;
+    }
+    return [...list, message];
+  };
+
+  const deadline = Date.now() + timeoutMs;
+  for await (const chunk of reader) {
+    if (Date.now() > deadline) throw new Error(`goosed 事件流超时 ${timeoutMs}ms`);
+    buffer += decoder.decode(chunk, { stream: true });
+    const frames = buffer.split('\n\n');
+    buffer = frames.pop() ?? '';
+    for (const frame of frames) {
+      let data = '';
+      for (const line of frame.split('\n')) {
+        if (line.startsWith('data:')) data += line.slice(5).trim();
+      }
+      if (!data) continue;
+      let event;
+      try {
+        event = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      const routingId = event.chat_request_id ?? event.request_id;
+      if (routingId && routingId !== requestId) continue;
+
+      if (event.type === 'Message' && event.message?.metadata?.userVisible !== false) {
+        messages = pushMessage(messages, event.message);
+      } else if (event.type === 'UpdateConversation') {
+        messages = (event.conversation ?? []).filter((item) => item.metadata?.userVisible !== false);
+      } else if (event.type === 'Error') {
+        errorText = String(event.error ?? event.message ?? 'goose 执行失败');
+        throw new Error(errorText);
+      } else if (event.type === 'Finish') {
+        finishSeen = true;
+        break;
+      }
+    }
+    if (finishSeen) break;
+  }
+
+  const assistantTexts = messages
+    .filter((item) => item.role === 'assistant')
+    .map((item) => messageVisibleText(item))
+    .filter(Boolean);
+  return {
+    finishSeen,
+    combined: assistantTexts.join('\n\n').trim(),
+    toolCalls: messages.flatMap((item) => (item.content ?? [])
+      .filter((part) => part?.type === 'toolRequest' || part?.type === 'toolResponse')
+      .map((part) => ({
+        role: item.role,
+        type: part.type,
+        name: part.toolCall?.value?.name ?? part.toolResponse?.value?.name ?? part.name ?? null,
+      }))),
+  };
+}
+
+async function main() {
+  fs.mkdirSync(path.join(workingDir, 'public'), { recursive: true });
+  console.log(`goosed base: ${base}`);
+  console.log(`working_dir: ${workingDir}`);
+  console.log(`target: ${targetHtml}`);
+  console.log(`provider: ${provider} / ${model}`);
+
+  const start = await apiJson('/agent/start', { working_dir: workingDir });
+  const sessionId = start.id;
+  console.log(`session: ${sessionId}`);
+
+  await apiJson('/agent/update_provider', {
+    session_id: sessionId,
+    provider,
+    model,
+  });
+
+  const skillPrefix = buildChatSkillPrompt('generate-page', 'static-page-publish');
+  const userText = `${skillPrefix}请帮我做一个全新的苏州一日游攻略页面，保存为 ${targetHtml}，不要修改或复用已有页面，做完直接给我链接。`;
+  const requestId = crypto.randomUUID();
+
+  const reply = await executeSessionReply(sessionId, requestId, userText);
+  const htmlPath = path.join(workingDir, targetHtml);
+  const htmlExists = fs.existsSync(htmlPath);
+  const htmlSize = htmlExists ? fs.statSync(htmlPath).size : 0;
+
+  console.log('\n=== result ===');
+  console.log(`finish_seen: ${reply.finishSeen}`);
+  console.log(`html_exists: ${htmlExists}`);
+  console.log(`html_bytes: ${htmlSize}`);
+  console.log(`tool_calls: ${reply.toolCalls.length}`);
+  for (const call of reply.toolCalls.slice(-12)) {
+    console.log(`  - ${call.role} ${call.type} ${call.name ?? ''}`);
+  }
+  if (reply.combined) {
+    console.log('\n--- assistant excerpt ---');
+    console.log(reply.combined.slice(-1500));
+  }
+
+  if (!htmlExists || htmlSize <= 0) {
+    console.error('\nFAIL: goosed did not materialize target HTML in working_dir');
+    process.exit(1);
+  }
+  const html = fs.readFileSync(htmlPath, 'utf8');
+  if (!/苏州/u.test(html)) {
+    console.error('\nFAIL: generated HTML missing expected keyword 苏州');
+    process.exit(1);
+  }
+  console.log('\nPASS: goosed wrote deliverable HTML on 18006');
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack ?? error.message : error);
+  process.exit(1);
+});

skills/page-data-collect/SKILL.md

@@ -130,6 +130,16 @@ load_skill → page-data-collect
 
 ### 2. 数据层：建表 + 注册 dataset
 
+**每个独立交付任务必须独立建表、独立 dataset，禁止复用已有表。**
+
+| 场景 | 正确做法 |
+|------|----------|
+| 用户要做一个**新页面 / 新功能**（即使主题相似，如第二个日记本、另一个问卷） | 新建专用表 + 新 dataset 名，例如 `safe_diary_entries`、`children_hobby_survey_20260729` |
+| 用户明确说「在**这个已有页面**里加一块表单」 | 才可复用该页已 bind 的 dataset |
+| Agent 在 registry 里看到同名/同主题旧表 | **不得**直接拿来给新 HTML 用；必须新建 |
+
+命名建议：`{页面slug}_entries` / `{页面slug}_responses`，表名与 dataset 名一致。两个页面即使业务相似（日记、台账、问卷），也必须是**两套** `{table, dataset, policy}`，避免字段约束、口令策略、软删除配置互相污染。
+
 用 `private_data_execute` 建表（示例）：
 
 ```sql
@@ -164,6 +174,25 @@ CREATE TABLE IF NOT EXISTS survey_responses (
 - PostgreSQL 连接错误应原样报告，不得把 `/tmp/.s.PGSQL.*`、`ECONNREFUSED` 或 `permission denied` 解释成“稍后会自动恢复”。
 - dataset 配置了 `soft_delete` 时，表必须包含 `deleted_at TIMESTAMPTZ`；配置了 `own_rows` 时，表必须包含 policy 指定的所有者字段。
 
+### 用户空间配额（页面写入 grace 策略）
+
+MindSpace **页面 HTML**（`public/*.html`、`draft/*.html`）写入采用 **「本次写完、下次再拦」**：
+
+| 状态 | 平台行为 |
+|------|----------|
+| 尚未超配额，但剩余空间 < 本次页面大小 | ✅ **允许写完**（grace write；本次 bind 必须继续完成） |
+| 已经超配额（used ≥ quota） | ❌ **直接拦截** `write_file` / `edit_file` / bind / 发布 |
+| 空间充足 | ✅ 正常写入 |
+
+**Agent 必须遵守：**
+
+- grace 只保证**当次**页面 HTML 能落盘并完成 bind；**不是**可以跳过 bind 或只写 policy 文件。
+- bind 失败（含 `quota_exceeded` 且已超配额、`dataset_schema_mismatch`、PG 连接错误）时，**禁止**向用户交付「已就绪」链接；必须如实报告失败原因。
+- 用户空间已满时，提示其在 MindSpace「我的空间」清理旧页面/资产，或购买/扩容后再继续写新页面。
+- grace **不覆盖**图片/附件等非页面 HTML 资产上传；那些仍按原有配额硬拦截。
+
+**禁止**只写 `.mindspace/page-data-policies/<slug>.json` 或使用非 UUID 的 `pageId` 冒充 bind 成功；policy 的 `pageId` 必须来自 `private_data_bind_workspace_page` 返回的真实 UUID，且数据库中存在对应 `h5_page_records`。
+
 ### 3. 页面层：写 HTML
 
 - 用 `write_file` / `edit_file` 写入或更新 `public/*.html`
@@ -234,9 +263,18 @@ await client.deleteRow('dataset_name', rowId);
 }
 ```
 
-返回 `pageId` 与 **`workspaceUrl`**（`/MindSpace/<用户ID>/public/xxx.html`）。
+返回 `pageId`（UUID）与 **`workspaceUrl` / `deliveryUrl`**（`/MindSpace/<用户ID>/public/xxx.html`）。
 
-**交付时必须优先给用户 workspaceUrl**；`/u/用户名/pages/...` 仅作补充。bind 会同步工作区 HTML 到发布快照，但禁止先发布占位内容再补文件。
+**交付时必须优先给用户真实可点击 URL**：
+
+| 环境 | 链接前缀示例 |
+|------|-------------|
+| **本地开发** | `http://127.0.0.1:8081/MindSpace/<用户ID>/public/xxx.html`（Page Data API 走 Portal 8081；5173 仅 UI 预览） |
+| **生产** | `https://m.tkmind.cn/MindSpace/<用户ID>/public/xxx.html` |
+
+- **禁止**交付占位 host（如 `http://本地服务/...`）；聊天展示层不得把 `127.0.0.1:8081` 替换成不可点击文字。
+- `/u/用户名/pages/...` 仅作补充，用户可见主链接必须是 MindSpace `/public/` 路径。
+- bind 会同步工作区 HTML 到发布快照，但禁止先发布占位内容再补文件。
 
 **dataset 名称必须与 HTML 一致**：`private_data_register_dataset` 的 `name`、`private_data_bind_workspace_page` 的 `datasets` 键名、以及 HTML 里 `insertRow('...')` / `listRows('...')` 的字符串必须完全相同（例如都用 `tkmind_exp_survey`）。若不一致，提交会报「dataset 未授权 insert/read」。
 
@@ -293,17 +331,28 @@ await client.deleteRow('dataset_name', rowId);
 11. **禁止**未配置 `private_data_set_page_policy` 就让页面调用公开 API
 12. **禁止**先发布占位页（如 `<p>问卷页面</p>`）再让用户访问 `/u/.../pages/...`
 13. **禁止**在 Agent 生成的 HTML/JavaScript 中使用 `localStorage` / `sessionStorage` / `IndexedDB` 保存任何数据或做 API fallback；所有需持久化的数据必须进入当前用户专属 PostgreSQL schema，禁止 SQLite、静态 JSON/JS 文件和内存 fallback
+14. **禁止**在空间已满（已超配额）时继续 `write_file` / bind 新页面；必须先提示清理或扩容
+15. **禁止**bind 未完成或 `pageId` 非 UUID 时声称 Page Data 页面已就绪；控制台出现 `pageId 未配置` 说明 bind/发布链路未闭环
+16. **禁止**为新的独立页面复用已有 dataset / 表（例如第二个日记页继续用 `diary_entries`）；除非用户明确要求改同一页面上的表单
 
 ## 交付前自检
 
 0. 已选定分支 A～E，方案摘要已确认；`password` 页口令 ≥8 位且 bind 已传入
-1. `__page_data_datasets` 中存在对应 dataset
-2. `.mindspace/page-data-policies/<pageId>.json` 已写入
-3. HTML 含 `page-data-client.js`；已 bind 或发布后平台会注入 pageId
-4. HTML **不含** `127.0.0.1:`、`/api/survey/`、`PLACEHOLDER_PAGE_ID`
-5. 向用户说明：访客如何提交、管理员如何用口令查看记录
-6. HTML 未调用 `softDeleteRows` / `deleteRows` 等客户端不存在的方法；删除使用 `deleteRow(dataset, rowId)`
+1. `private_data_register_dataset` 已注册；PostgreSQL 表字段与 policy 一致（含 `deleted_at` 等）
+2. `private_data_bind_workspace_page` **已成功**，返回 UUID 形式 `pageId` 与 `deliveryUrl`
+3. `.mindspace/page-data-policies/<pageId>.json` 已写入（文件名必须是 UUID，不是 slug）
+4. 通过 Portal 打开 `deliveryUrl` 时，页面源码含 `__MINDSPACE_PAGE_DATA__`
+5. HTML 含 `page-data-client.js`；已 bind 或发布后平台会注入 pageId
+6. HTML **不含**硬编码 `127.0.0.1:` 作为 API 基址；不含 `/api/survey/`、`PLACEHOLDER_PAGE_ID`
+7. 本地交付链接使用 `http://127.0.0.1:8081/MindSpace/...`；生产使用 `https://m.tkmind.cn/MindSpace/...`；禁止 `http://本地服务/...`
+8. 向用户说明：访客如何提交、管理员如何用口令查看记录
+9. HTML 未调用 `softDeleteRows` / `deleteRows` 等客户端不存在的方法；删除使用 `deleteRow(dataset, rowId)`
+10. 若 bind 报 `quota_exceeded` 且 `overQuota: true`，停止交付并提示清理空间；grace 仅适用于「当次写完、尚未超配额」场景
 
 ## 回复格式
 
-除数据能力外，优先返回 **workspaceUrl** 的 Markdown 链接 `[标题](workspaceUrl)`，并简要说明后台入口与口令（如有）。
+除数据能力外，优先返回 **deliveryUrl / workspaceUrl** 的 Markdown 链接 `[标题](完整URL)`，并简要说明后台入口与口令（如有）。
+
+- 本地：`http://127.0.0.1:8081/MindSpace/<用户ID>/public/xxx.html`
+- 生产：`https://m.tkmind.cn/MindSpace/<用户ID>/public/xxx.html`
+- 必须附带 bind 返回的 `pageId`（UUID），便于用户在「页面数据」面板排查

skills/static-page-publish/SKILL.md

@@ -29,6 +29,7 @@ description: 在专属 MindSpace 目录生成可公开访问的静态 HTML 报
 12. **微信分享必须使用 MindSpace 路径**：该路由会在服务端注入 `og:site_name=TKMind 智趣`、封面缩略图（`*.thumbnail.png`）与微信 JS-SDK 分享桥；禁止交付 `/u/用户名/pages/...` 作为用户可见链接
 13. **只要页面接收用户输入并要求以后查看、汇总、统计、修改或删除，就不是纯静态页**。禁止使用 `localStorage` / `sessionStorage` / `IndexedDB` 保存任何数据；必须立即 `load_skill` → `page-data-collect`，通过 Page Data API 写入当前用户专属 PostgreSQL schema。禁止 SQLite、静态 JSON/JS 文件或内存 fallback 冒充持久化。记账、日记、打卡、清单、台账、问卷、报名及其管理页都适用。
 14. 当编排提示为“图片策略：强制生成”或用户明确要求新图片、背景图、主图、封面、插画、照片时，必须先 `load_skill` → `image-generation`，由该技能补齐提示词并调用 `sandbox-fs__generate_image`；不得要求用户自己提供专业生图参数，不得用 SVG、CSS 绘图、旧素材或网页搜索图片冒充本次生成结果。
+15. **页面 HTML 空间配额**：尚未超配额时，平台允许当次页面写完（grace write）；**已超配额**后 `write_file` / `edit_file` 会被直接拦截。空间已满时提示用户清理 MindSpace 旧页面/资产后再继续。
 
 详细约束以工作区内的 `.goosehints` 与 `.agents/skills/static-page-publish/SKILL.md` 为准。
 
@@ -74,7 +75,10 @@ description: 在专属 MindSpace 目录生成可公开访问的静态 HTML 报
 
 - **必须**使用 `[页面标题](完整URL)`，不要只给裸 URL 或「点这里」
 - 页面写入 `public/` 时，URL **必须**包含 `/public/` 路径段（与磁盘路径一致）
-- 域名严格按本节模板拼接（`https://goo.tkmind.cn/MindSpace/<用户ID>/public/...`）；拿不到真实前缀时，先给相对路径 `public/xxx.html` 说明，不要自己猜一个域名
+- 域名严格按环境拼接，**禁止**使用 `http://本地服务/...` 等占位 host：
+  - **本地开发**：`http://127.0.0.1:8081/MindSpace/<用户ID>/public/...`（MindSpace 公开页 + Page Data API）
+  - **生产**：`https://m.tkmind.cn/MindSpace/<用户ID>/public/...` 或环境配置的 `H5_PUBLIC_BASE_URL`
+- 拿不到真实前缀时，先给相对路径 `public/xxx.html` 说明，不要自己猜一个域名
 - 标题用页面真实主题名
 - 可同时给出相对路径（如 `public/malaysia-travel-guide.html`）
 - 说明：保存即生效，无需重启

tkmind-proxy-vision.test.mjs

@@ -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 ?? '', /蓝色方块/);
+});

tkmind-proxy.mjs

@@ -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'}`,
         );

tkmind-proxy.test.mjs

@@ -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,

wechat-mp.test.mjs

@@ -3288,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/);
 });
 
@@ -3631,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/);
 });
@@ -3965,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/);
 });
 

wechat/handlers/page-generate.mjs

@@ -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',
+  };
 }

wechat/wechat-channel.test.mjs

@@ -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');
+});