create-windy 0.8.0 → 0.8.1

package/template/apps/web/src/pages/system/composables/useResourceEditor.webtest.ts

@@ -40,6 +40,10 @@ describe("账户编辑保存闭环", () => {
     expect(editor.item.value).toBeUndefined();
     expect(save.mock.calls[0]?.[1]).toBeUndefined();
     expect(mutated).not.toHaveBeenCalled();
+    expect(await editor.submit({ ...payload, temporaryPassword: "" })).toBe(
+      false,
+    );
+    expect(save).toHaveBeenCalledTimes(1);
     expect(await editor.submit(payload)).toBe(true);
     expect(save.mock.calls[1]?.[1]).toBe("user_created");
     expect(api.reset).toHaveBeenLastCalledWith(

package/template/docs/architecture/log-governance-implementation.md

@@ -0,0 +1,79 @@
+# 结构化运行日志技术实现
+
+状态：SDK、平台适配与利剑四条链的本地定向联调已实现；正式发布/升级及集中查询/告警平台未验收。
+对应业务方案见
+[日志治理方案](./log-governance-plan.md)。
+
+## 当前调用链
+
+- `packages/shared/src/structured-log.ts` 提供跨服务字段契约与 TypeScript SDK。调用者提交稳定
+  `event`、关联 ID、结果、错误码和少量明确允许的数值字段；序列化器生成时间、等级、组件和
+  `retentionClass=operational`，只输出白名单字段，并限制单行 2048 UTF-8 字节。任意 message、
+  原始 Error、请求内容、Token 与未知字段不会进入记录。
+  公共入口 `@southwind-ai/shared/structured-log` 可独立消费日志 SDK；利剑用真实打包候选的
+  同一入口验证，保留原 workspace shared，避免同名同版本 package identity 的类型去重冲突。
+  字段同时支持 `diagnosticId`、登记的 `route` 模板、`handlerKey/queue/attemptNumber` 及
+  有界 `completedUnits/totalUnits/count`。路由不能传实际 URL、query、fragment 或对象路径；
+  SDK 做词法校验，调用方负责从框架登记模板取得它。
+- `apps/server/src/observability/structured-logger.ts` 将该契约接入 Pino。
+  `platform-bootstrap.ts` 创建同一 logger，HTTP 请求完成、启动、审计降级及 Workflow continuation
+  的现有日志路径继续使用它。Workflow continuation 只把原始异常字段改为稳定错误码，不改派发和
+  错误处理行为。
+- `createLegacyServiceRuntime` 将统一 Logger 注入 `DurableJobWorker`；每次实际 claim 记录
+  `job.attempt.started` 和唯一的 `job.attempt.completed`，包括未注册 Handler、失败、取消和租约
+  丢失。只读 canonical claim 的 Job/阶段/重试/Handler/Queue 坐标，不扫描 payload 或记录租约
+  Token。idle 不产生日志。
+- `apps/agent-server/src/southwind_agent_server/structured_logging.py` 为 Python 包级日志安装对等
+  适配器。`asgi.py` 保留原 FastAPI app 对象，在生产 ASGI 入口安装 handler；Dockerfile 与开发
+  启动命令均指向该入口。恢复轮询和报表写入失败映射为稳定事件/错误码，不输出异常堆栈或任意
+  `extra`。Uvicorn 自身 access/error 日志仍由 Uvicorn 配置管理。
+  `AgentRunTrace.start/finish` 同时调用 `AgentOperationalAttempt`，记录固定的
+  `agent.run.attempt.started/completed`、Run/Trace、耗时及安全结果；幂等重放不重新启动 attempt。
+  进程停止等非终态结束标为 interrupted，不能伪装成 canonical Run failed。详细输入输出仍由
+  Run/Artifact 受管查询负责。
+
+业务审计继续走 `system.audit` 的 Manifest 与 Audit Port；Agent Run/Provider/Workflow 的持久
+事实仍由各自 canonical store 维护。运行日志只用于排障，不能替代这两类记录。
+
+## 利剑候选消费与四条链
+
+利剑先 fetch 并 fast-forward `origin/main` 至 `3a51d6edf`，再创建
+`rayjason/logging-integration`。变更仅在日志、Host 装配、候选依赖和验证文档；矛盾分析和聊天
+记录分析的业务文件没有修改。利剑方案在 `docs/architecture/logging-integration-plan.md`，
+最终实现和证据在 `docs/operations/windy-logging-integration.md`。
+
+| 链路         | 当前本地联调证据                                                     | 业务结果                                                           |
+| ------------ | -------------------------------------------------------------------- | ------------------------------------------------------------------ |
+| HTTP 写请求  | 真实 `createPlatformHttpApp` / Elysia 生命周期与候选 SDK/Pino        | 一次完成记录、请求关联、正文和身份明细不入日志                     |
+| 慢请求与失败 | 慢 GET、错误诊断 Hook 和完成去重                                     | 保留阈值采样、诊断编号与登记路由模板                               |
+| Durable Job  | 真实 Worker + 隔离内存 Repository                                    | 开始、进度、终态按 Job/阶段/重试串联；Sink 故障不改状态机          |
+| Agent        | 利剑 Remote Runtime 到本地 HTTP 协议 fixture；独立安装的 Python 候选 | Host 请求到 Trace/Run 的关联、当前进程采样去重、canonical 结果保持 |
+
+利剑 `ObservedAgentRuntime` 的终态观测最多保留 1000 个 Run，仅用于进程内采样，重启或淘汰
+后可能再次观测同一 Run；它不承诺全局 exactly-once。Run store 和业务审计仍是权威事实。
+本地 fixture 不调用真实模型 Provider，也没有写入生产案件数据。
+
+## 验证与限制
+
+- Bun 定向测试：共享契约、Server Pino 输出与 HTTP 观测共 8 项通过，包含 Sink 故障不影响业务。
+- Agent Server Python 定向测试：4 项通过，包含日志输出失败不影响 Run；ASGI 导入确认复用原
+  app 对象。
+- Server/Shared 类型检查及相关格式、Lint 检查通过；提交钩子的工作区类型检查作为静态证据。
+- SDK 新字段及 Job 旁路定向检查各 4 项通过；Agent 日志、真实 ASGI Run、坏 Sink 与幂等重放
+  共 11 项 Python 定向检查通过，Ruff/Mypy 通过。
+  平台最终合并的 SDK/Job/Pino/HTTP 定向检查共 12 项通过。
+- Python 候选源码 `8c045684` 用 `uv build apps/agent-server --wheel` 打包，安装到独立 venv，
+  依赖由 `uv export --locked --no-dev --no-emit-project` 固定。`scripts/agent-log-wheel-consumer.py`
+  用独立解释器的 `-I` 模式在仓库外执行，验证导入来自 site-packages，正常和坏 stdout 两种
+  场景均完成真实 ASGI Run、canonical 结果、幂等重放、关联/脱敏与大小预算。
+  该 wheel SHA256 为 `8fd5bbb3fb5f6d92cc6c4dd9d7237df8c3dd1d9afe425448c0b61f7997ad2a95`。
+
+利剑消费 SDK 源码 `11df0eb4`，归档 SHA256 为
+`aa48ef04927edd9245ce7dde2b6a6415d35ac4c911c3535fd10192f859010e3b`。实际 Elysia/Worker/Remote
+协议链及既有授权定向检查 26 项通过；交付构建输入/增量角色映射检查 22 项通过。候选包的
+本地依赖必须在 Docker 的 frozen install 前复制，Server/Web/Seeder 已补齐该输入及 SDK 导入。
+容器依赖层安装和已有静态失败在利剑最终文档分别记录。
+候选 SDK 用真实本地归档消费，没有改 `.windy` 元数据或手改版本号冒充正式升级。
+
+本轮完成日志契约与四条真实适配链的本地定向联调；未完成真实 Provider/完整 Agent 部署、正式
+Windy 发布和 `windy update` 事务、生产采集留存、集中查询或告警验收。这些不能由定向检查替代。

package/template/docs/architecture/log-governance-plan.md

@@ -0,0 +1,39 @@
+# 日志治理方案
+
+状态：运行日志 SDK、平台适配及利剑四条链的本地定向联调已实现；正式发布、下游升级与部署留存
+另行验收。集中管理界面尚未实施。
+
+## 业务需求先行
+
+| 场景     | 使用者与问题                                  | 权威记录                 | 成功标准                               |
+| -------- | --------------------------------------------- | ------------------------ | -------------------------------------- |
+| 故障定位 | 运维定位写请求、慢请求、Job 或 Agent Run 失败 | 有界结构化运行日志与指标 | 用关联 ID 找到失败阶段，不暴露敏感输入 |
+| 责任追溯 | 审计人员确认谁在什么权限下执行了业务动作      | `system.audit` 审计事实  | 权限控制、完整性和导出可验证           |
+| 合规取证 | 管理人员按部署约定查询、留存和导出            | 审计事实及受管保留策略   | 保留期、访问授权和交付责任明确         |
+
+## 模块边界
+
+`system.audit` 已有 Manifest、Module Audit Port、可靠写入、权限控制及管理端查询/导出。
+业务/安全审计继续由它维护；普通 stdout、HTTP 访问日志和 Agent Trace 不写成它的审计事实。
+Agent Run/Provider/Workflow 仍保留各自 canonical 事实，借关联 ID 串联。
+
+Windy 平台层提供结构化运行日志契约和 TypeScript SDK；Python Agent Server 使用对等适配器。
+它们统一 `timestamp`、`level`、`component`、`event`、`requestId`、`runId`、`jobId`、
+`traceId`、`outcome` 和稳定错误码，限定字段白名单、脱敏、采样、大小预算与 retention 分类。
+日志内容不成为业务授权来源，也不替代 Trace Event。对客户数据、密钥、模型输入输出、Tool 参数、
+stdout/stderr 采用默认不记录的规则；确需详查时走当前权限复核和有 TTL 的受管 payload/Artifact。
+
+集中采集、索引、备份和保留由部署层管理。只有在运维确有统一查询、告警配置和多租户隔离的
+需求与责任人时，新增独立可选 `system.observability` module，提供受权的控制面和查询代理；
+不把日志引擎塞进 `system.audit`，也不复制一份日志事实数据库。
+
+## 迁移与验证
+
+1. 清点 Windy 的 Server Pino/HTTP、Job、Agent 日志及利剑已有写请求、慢请求和 Docker 轮转字段。
+2. 固定跨语言 schema、上下文传播、等级/采样、脱敏和稳定错误码；SDK 只负责产出，不控制业务审计。
+3. 对接 Windy 后，用利剑的四条真实链路做兼容映射：写请求、慢请求、Durable Job、Agent Run。
+   检查敏感字段泄漏、重复事件、丢关联 ID 和日志系统不可用时业务是否按既定审计策略处理。
+4. 和 Agent 平台候选共同发布；利剑在官方更新事务中升级，分别验收排障、审计导出和部署保留。
+
+集中管理平台是否实施以这些业务验收后的缺口决定。当前任务状态见
+[上游任务清单](https://github.com/RayJason/windy-platform/blob/main/docs/product/tasks.md)。

package/template/docs/operations/observability.md

@@ -29,14 +29,41 @@ Web、Server、License 和 Signing 接受 `x-request-id`。只保留 1 至 128
 
 ## 结构化日志
 
-应用启动、运行模式警告和 HTTP 完成事件使用单行 JSON。HTTP 完成事件的稳定字段为：
-
-- `timestamp`、`level`、`event`、`component`；
-- `requestId`、`method`、`statusCode`、`durationMs`；
+应用启动、运行模式警告和 HTTP 完成事件使用单行 JSON。Server 使用
+`@southwind-ai/shared` 的结构化日志契约清洗字段，再交给 Pino 输出；Agent Server
+生产 ASGI 入口使用同一契约的 Python 适配器处理运行时异常。单行上限为 2048 UTF-8
+字节，自由文本 message 和原始异常不会输出。`retentionClass=operational` 表示排障日志，
+不赋予它审计事实或六个月留存语义。
+
+通用稳定字段是 `timestamp`、`level`、`component`、`event`、`retentionClass`；
+可选 `requestId`、`runId`、`jobId`、`traceId`、`diagnosticId`、`outcome`、`errorCode` 和
+`stageKey`。关联 ID 只接受 1 至 128 位安全字符，不合法就省略，不猜测或生成假的关联。
+`event`、`errorCode` 和阶段只接受有界稳定 Key。未列字段包括 body、headers、Token、
+Prompt、Tool 参数和原始 Error 均被丢弃；超出大小预算时先丢弃次要关联字段。
+运行日志输出失败时由 SDK/适配器吞掉写出异常，不改变原请求、Run 或审计结果；
+日志丢失需由部署层的采集健康和告警发现。
+HTTP 完成事件另外允许：
+
+- `method`、`statusCode`、`durationMs`；
+- `route` 只允许框架登记的模板，由调用方提供；SDK 拒绝 query、fragment、编码或纯数字路径段，
+  不以词法校验代替模板来源保证；
 - Server 可额外记录粗粒度 `actorType`，不记录用户或资源 ID。
 
 请求完成日志禁止记录完整 URL、query、请求或响应 body、Cookie、Authorization、Secret、连接串和原始异常。需要增加字段时，必须先判断其基数和敏感性，并补充防泄漏测试。生产日志采集器应按 JSON 字段解析，按 `requestId` 关联，不依赖自由文本。
 
+Agent Server 的生产入口为 `southwind_agent_server.asgi:app`，它不改动 FastAPI
+应用对象，而是在现有包级 Python logging 上安装结构化输出。当前恢复轮询和报表写入失败
+映射到稳定事件/错误码；报表失败可携带合法的 `runId` 与 `stageKey`。实际执行的
+`AgentRunTrace` 同时发出 `agent.run.attempt.started/completed`、Run/Trace、耗时与安全结果，
+幂等重放不重发，非终态执行中断标记 interrupted。异常堆栈、
+Python `extra` 中的任意字段和报表正文都不进入 stdout。直接使用旧的
+`southwind_agent_server.app:app` 入口不会安装该适配器。
+
+后台 Durable Worker 每次实际 claim 发出 `job.attempt.started/completed`，字段只取 canonical
+`jobId/stageKey/attemptNumber/handlerKey/queue`；失败只记录稳定码。`completedUnits/totalUnits/count`
+支持进度或清理计数，均限制为 0 至 10 亿的整数。日志不记录 payload、租约 Token 或进度正文，
+也不从业务 payload 猜测关联 ID；Worker idle 不产生日志。
+
 请求观测在全局 `onRequest` 建立，在响应完成时原子取出并结束。未匹配路由、Guard
 拒绝和 handler 异常与正常请求遵循同一生命周期；即使框架同时触发 error 与
 after-response 路径，同一个请求也只能扣减一次活跃计数并写一条完成日志。业务路由
@@ -58,5 +85,10 @@ after-response 路径，同一个请求也只能扣减一次活跃计数并写
 Server/License 请求完成日志字段、Web 到 Server 的标识透传，以及 Server 未匹配路由、
 异常路由只完成一次观测且不会终止进程，均有 Bun 单元或边界测试；工作区 typecheck 和
 Oxlint 已通过。Dockerfile 已声明 readiness `HEALTHCHECK`。
+新增结构化日志切片的共享契约、Pino 输出和 HTTP 观测定向测试共 8 项通过；Agent Server
+Python 适配定向测试 4 项通过，ASGI 导入复用原 app 对象。完整记录见
+[结构化运行日志技术实现](../architecture/log-governance-implementation.md)。
+利剑四条真实适配链已完成候选包本地定向联调；平台 Job 定向检查 4 项、Agent 日志/ASGI
+检查 11 项及独立 wheel 消费通过。实际 Provider、正式更新事务和部署采集留存仍须独立验收。
 
 尚未由本页证明：生产 Compose、新环境部署、备份恢复、升级回滚、原生 Linux amd64 runner、告警规则、长稳运行、多实例和大容量。这些项必须由后续生产恢复演练和目标环境记录单独闭环；Docker Desktop 或 QEMU 上的 amd64 运行不能写成原生 Linux amd64 已认证。

package/template/packages/modules/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@southwind-ai/modules",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {

package/template/packages/modules/src/ai-isolated-execution-policy.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from "bun:test";
+import type { AiIsolatedExecutionPolicyV1 } from "./manifest.js";
+import { validateModuleComposition } from "./composition.js";
+import { fixture, operation } from "./ai-operation-composition.test-support.js";
+
+const policy: AiIsolatedExecutionPolicyV1 = {
+  version: 1,
+  mode: "isolated",
+  languages: ["python", "node"],
+  inputArtifactTypes: ["text/plain", "application/json"],
+  network: "forbidden",
+  limits: {
+    maxWorkspaceBytes: 8_388_608,
+    maxFileBytes: 2_097_152,
+    maxOutputBytes: 1_048_576,
+    maxDurationSeconds: 30,
+    maxCpuMillis: 30_000,
+    maxMemoryBytes: 268_435_456,
+    maxPids: 8,
+    maxConcurrentProcesses: 1,
+    maxToolCalls: 8,
+    maxToolRounds: 4,
+  },
+};
+
+describe("Agent 隔离执行 Manifest", () => {
+  test("缺省关闭；显式策略可通过组合校验", () => {
+    const module = fixture("business");
+    module.aiOperations = [operation("business.answer")];
+    expect(() => validateModuleComposition([module])).not.toThrow();
+    module.aiOperations = [
+      {
+        ...module.aiOperations[0]!,
+        toolNetworkPolicy: { mode: "forbidden" },
+        isolatedExecution: policy,
+      },
+    ];
+    expect(() => validateModuleComposition([module])).not.toThrow();
+  });
+
+  test("未知语言、网络和越界预算在装配时拒绝", () => {
+    const module = fixture("business");
+    const base = operation("business.answer");
+    const check = (candidate: AiIsolatedExecutionPolicyV1) => {
+      module.aiOperations = [
+        {
+          ...base,
+          toolNetworkPolicy: { mode: "forbidden" },
+          isolatedExecution: candidate,
+        },
+      ];
+      expect(() => validateModuleComposition([module])).toThrow();
+    };
+    check({
+      ...policy,
+      languages: [
+        "ruby",
+      ] as unknown as AiIsolatedExecutionPolicyV1["languages"],
+    });
+    check({
+      ...policy,
+      network: "allowed" as AiIsolatedExecutionPolicyV1["network"],
+    });
+    check({
+      ...policy,
+      limits: { ...policy.limits, maxMemoryBytes: 2_147_483_648 },
+    });
+    check({ ...policy, limits: { ...policy.limits, maxToolRounds: 9 } });
+  });
+});

package/template/packages/modules/src/ai-isolated-execution-policy.ts

@@ -0,0 +1,76 @@
+import type { ModuleAiOperationDefinition } from "./manifest.js";
+
+const ceilings = {
+  maxWorkspaceBytes: 256 * 1024 * 1024,
+  maxFileBytes: 64 * 1024 * 1024,
+  maxOutputBytes: 16 * 1024 * 1024,
+  maxDurationSeconds: 300,
+  maxCpuMillis: 300_000,
+  maxMemoryBytes: 1024 * 1024 * 1024,
+  maxPids: 64,
+  maxConcurrentProcesses: 4,
+  maxToolCalls: 128,
+  maxToolRounds: 32,
+} as const;
+
+export function validateAiIsolatedExecutionPolicy(
+  operation: ModuleAiOperationDefinition,
+): void {
+  const policy = operation.isolatedExecution;
+  if (policy === undefined) return;
+  if (
+    !policy ||
+    operation.kind !== "agent" ||
+    policy.version !== 1 ||
+    policy.mode !== "isolated" ||
+    Object.keys(policy).sort().join(",") !==
+      "inputArtifactTypes,languages,limits,mode,network,version"
+  ) {
+    throw new Error(
+      `${operation.key} 隔离执行只允许 Agent Operation 的 V1 策略`,
+    );
+  }
+  if (
+    !Array.isArray(policy.languages) ||
+    !policy.languages.length ||
+    new Set(policy.languages).size !== policy.languages.length ||
+    policy.languages.some((language) => !["python", "node"].includes(language))
+  ) {
+    throw new Error(`${operation.key} 隔离执行语言无效`);
+  }
+  if (
+    !Array.isArray(policy.inputArtifactTypes) ||
+    !policy.inputArtifactTypes.length ||
+    new Set(policy.inputArtifactTypes).size !==
+      policy.inputArtifactTypes.length ||
+    policy.inputArtifactTypes.some(
+      (type) =>
+        typeof type !== "string" ||
+        !/^[a-z][a-z0-9.+-]*\/[a-z0-9.+-]+$/u.test(type),
+    )
+  ) {
+    throw new Error(`${operation.key} 隔离执行输入 Artifact 类型无效`);
+  }
+  if (
+    policy.network !== "forbidden" ||
+    operation.toolNetworkPolicy?.mode !== "forbidden"
+  ) {
+    throw new Error(`${operation.key} 隔离执行必须禁止 Tool 网络`);
+  }
+  const limits = policy.limits;
+  if (
+    !limits ||
+    Object.keys(limits).length !== Object.keys(ceilings).length ||
+    Object.entries(ceilings).some(([key, ceiling]) => {
+      const value = limits[key as keyof typeof ceilings];
+      return !Number.isSafeInteger(value) || value <= 0 || value > ceiling;
+    }) ||
+    limits.maxFileBytes > limits.maxWorkspaceBytes ||
+    limits.maxOutputBytes > limits.maxWorkspaceBytes ||
+    limits.maxDurationSeconds > operation.limits.maxDurationSeconds ||
+    limits.maxOutputBytes > operation.limits.maxOutputBytes ||
+    limits.maxToolRounds > limits.maxToolCalls
+  ) {
+    throw new Error(`${operation.key} 隔离执行预算越过 Operation 或 Host 上限`);
+  }
+}

package/template/packages/modules/src/ai-operation-composition.ts

@@ -6,6 +6,7 @@ import { validateAiNetworkPolicy } from "./ai-network-policy.js";
 import { validateAiOperationReadinessContract } from "./ai-operation-readiness-contract.js";
 import { validateAiScreenshotContext } from "./ai-screenshot-context.js";
 import { validateClientExecution } from "./ai-client-execution-policy.js";
+import { validateAiIsolatedExecutionPolicy } from "./ai-isolated-execution-policy.js";
 
 interface AiOperationCatalogs {
   permissions: ReadonlySet<string>;
@@ -107,6 +108,7 @@ function validateOperation(
   validateAiNetworkPolicy(operation);
   validateProviderDataPolicy(operation);
   validateClientExecution(operation);
+  validateAiIsolatedExecutionPolicy(operation);
   validateLimits(operation);
   validateAiOperationReadinessContract(operation);
   validateAiScreenshotContext(operation);

package/template/packages/modules/src/manifest.ts

@@ -167,6 +167,27 @@ export interface AiOperationLimits {
   maxPixelsPerArtifact?: number;
 }
 
+/** Opt-in policy for a future, separate Python/Node Execution Runtime. Absence disables execution. */
+export interface AiIsolatedExecutionPolicyV1 {
+  readonly version: 1;
+  readonly mode: "isolated";
+  readonly languages: readonly ("python" | "node")[];
+  readonly inputArtifactTypes: readonly string[];
+  readonly network: "forbidden";
+  readonly limits: {
+    readonly maxWorkspaceBytes: number;
+    readonly maxFileBytes: number;
+    readonly maxOutputBytes: number;
+    readonly maxDurationSeconds: number;
+    readonly maxCpuMillis: number;
+    readonly maxMemoryBytes: number;
+    readonly maxPids: number;
+    readonly maxConcurrentProcesses: number;
+    readonly maxToolCalls: number;
+    readonly maxToolRounds: number;
+  };
+}
+
 /**
  * 允许受治理的宿主客户端在本地编排模型循环。
  *
@@ -234,6 +255,8 @@ export interface ModuleAiOperationDefinition {
   providerDataPolicy?: AiProviderDataPolicy;
   /** 缺省不允许浏览器或其它宿主客户端执行本地 Agent 循环。 */
   clientExecution?: AiClientExecutionPolicy;
+  /** Missing means no workspace or process execution capability. */
+  isolatedExecution?: AiIsolatedExecutionPolicyV1;
   toolNetworkPolicy?: AiToolNetworkPolicy;
   limits: AiOperationLimits;
 }

package/template/packages/modules/src/system-features.ts

@@ -1,10 +1,11 @@
-import { featureKey, licenseVersionKey } from "@southwind-ai/shared";
+import * as shared from "@southwind-ai/shared";
 import type { ModuleManifest } from "./manifest.js";
 
 // @windy-module system.scheduler begin
-const standardAndAdvanced = ["standard", "advanced"].map(licenseVersionKey);
+const standardAndAdvanced = ["standard", "advanced"].map(
+  shared.licenseVersionKey,
+);
 // @windy-module system.scheduler end
-const advancedOnly = [licenseVersionKey("advanced")];
 
 export const systemFeatures: ModuleManifest["features"] = [
   feature(
@@ -109,7 +110,7 @@ export const systemFeatures: ModuleManifest["features"] = [
       "Agent 长期会话",
       "恢复受治理的长期 Session，并解释 Context 与 Memory 来源。",
     ),
-    dependencies: [featureKey("system.agent")],
+    dependencies: [shared.featureKey("system.agent")],
   },
   {
     ...feature(
@@ -117,7 +118,7 @@ export const systemFeatures: ModuleManifest["features"] = [
       "AI Runtime 报表",
       "查看受数据范围约束的 Agent Run、模型用量、缓存与失败事实。",
     ),
-    dependencies: [featureKey("system.agent")],
+    dependencies: [shared.featureKey("system.agent")],
   },
   {
     ...feature(
@@ -125,8 +126,8 @@ export const systemFeatures: ModuleManifest["features"] = [
       "Agent Workflow",
       "查看和运行具备预算、恢复、委派与持久审计边界的不可变 Agent Workflow Release。",
     ),
-    dependencies: [featureKey("system.agent")],
-    allowedLicenseVersions: advancedOnly,
+    dependencies: [shared.featureKey("system.agent")],
+    allowedLicenseVersions: [shared.licenseVersionKey("advanced")],
   },
   // @windy-module system.agent end
   // @windy-module system.operations begin
@@ -167,7 +168,7 @@ export const systemFeatures: ModuleManifest["features"] = [
       "批量数据任务",
       "受控的大批量导入、导出、失败明细和结果留存。",
     ),
-    allowedLicenseVersions: advancedOnly,
+    allowedLicenseVersions: [shared.licenseVersionKey("advanced")],
   },
   // @windy-module system.bulk-data end
 ];
@@ -178,7 +179,7 @@ function feature(
   description?: string,
 ): ModuleManifest["features"][number] {
   return {
-    key: featureKey(key),
+    key: shared.featureKey(key),
     label,
     module: "system",
     description,
@@ -195,6 +196,6 @@ function rbacFeature(
 ): ModuleManifest["features"][number] {
   return {
     ...feature(key, label, description),
-    dependencies: [featureKey("system.rbac")],
+    dependencies: [shared.featureKey("system.rbac")],
   };
 }

package/template/packages/server-sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@southwind-ai/server-sdk",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {

package/template/packages/shared/index.ts

@@ -17,6 +17,7 @@ export * from "./src/migration-bundle-validation.js";
 export * from "./src/mcp.js";
 export * from "./src/module-configuration.js";
 export * from "./src/correlation.js";
+export * from "./src/structured-log.js";
 export * from "./src/notification.js";
 export * from "./src/password.js";
 export * from "./src/platform-settings.js";

package/template/packages/shared/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@southwind-ai/shared",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {
@@ -15,7 +15,8 @@
     "typecheck": "tsc --noEmit --project tsconfig.json"
   },
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./structured-log": "./src/structured-log.ts"
   },
   "publishConfig": {
     "access": "public"

package/template/packages/shared/src/structured-log.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from "bun:test";
+import {
+  createStructuredLogger,
+  STRUCTURED_LOG_MAX_BYTES,
+} from "./structured-log.js";
+
+describe("structured operational log", () => {
+  test("保留跨服务关联标识与稳定排障字段", () => {
+    const records: Record<string, unknown>[] = [];
+    const logger = createStructuredLogger(
+      {
+        info: (record) => records.push(record),
+        warn: (record) => records.push(record),
+        error: (record) => records.push(record),
+      },
+      "windy-server",
+      () => new Date("2026-09-29T00:00:00.000Z"),
+    );
+    logger.error({
+      event: "agent.workflow.continuation.failed",
+      requestId: "request-1",
+      runId: "run-1",
+      jobId: "job-1",
+      traceId: "trace-1",
+      diagnosticId: "diag-1",
+      route: "/api/agent/runs/:runId/events",
+      outcome: "failure",
+      errorCode: "AGENT_WORKFLOW_CONTINUATION_FAILED",
+      stageKey: "dispatch",
+      handlerKey: "system.scheduler.dispatch",
+      queue: "default",
+      attemptNumber: 2,
+      count: 10,
+    });
+    expect(records).toEqual([
+      {
+        timestamp: "2026-09-29T00:00:00.000Z",
+        level: "error",
+        component: "windy-server",
+        event: "agent.workflow.continuation.failed",
+        retentionClass: "operational",
+        requestId: "request-1",
+        runId: "run-1",
+        jobId: "job-1",
+        traceId: "trace-1",
+        diagnosticId: "diag-1",
+        route: "/api/agent/runs/:runId/events",
+        outcome: "failure",
+        errorCode: "AGENT_WORKFLOW_CONTINUATION_FAILED",
+        stageKey: "dispatch",
+        handlerKey: "system.scheduler.dispatch",
+        queue: "default",
+        attemptNumber: 2,
+        count: 10,
+      },
+    ]);
+  });
+
+  test("拒绝未列字段、原始错误和不安全关联标识", () => {
+    const records: Record<string, unknown>[] = [];
+    const logger = createStructuredLogger(
+      {
+        info: (record) => records.push(record),
+        warn: (record) => records.push(record),
+        error: (record) => records.push(record),
+      },
+      "windy-server",
+    );
+    logger.error(
+      {
+        event: "unsafe\nrequest",
+        requestId: "bad\nsecret-request",
+        runId: "x".repeat(200),
+        errorCode: "provider secret payload",
+        handlerKey: "payload secret-handler",
+        queue: "secret\nqueue",
+        attemptNumber: -1,
+        diagnosticId: "secret\ndiag",
+        route: "/api/users/123?secret-route",
+        completedUnits: -1,
+        totalUnits: Number.POSITIVE_INFINITY,
+        count: -1,
+        body: "secret-body",
+        authorization: "Bearer secret-token",
+        error: new Error("secret-stack"),
+      } as unknown as Parameters<typeof logger.error>[0],
+      "secret-message",
+      "secret-handler",
+      "secret-route",
+      "secret\\nqueue",
+    );
+    const serialized = JSON.stringify(records);
+    expect(records[0]?.event).toBe("logging.event.invalid");
+    for (const secret of [
+      "secret-request",
+      "secret-body",
+      "secret-token",
+      "secret-stack",
+      "secret-message",
+    ]) {
+      expect(serialized).not.toContain(secret);
+    }
+    expect(Buffer.byteLength(serialized)).toBeLessThanOrEqual(
+      STRUCTURED_LOG_MAX_BYTES + 2,
+    );
+  });
+
+  test("长字段不撑破单行预算", () => {
+    const records: Record<string, unknown>[] = [];
+    const logger = createStructuredLogger(
+      {
+        info: (record) => records.push(record),
+        warn: (record) => records.push(record),
+        error: (record) => records.push(record),
+      },
+      "windy-server",
+    );
+    logger.info({
+      event: "http.request.completed",
+      requestId: "x".repeat(128),
+      runId: "x".repeat(128),
+      jobId: "x".repeat(128),
+      traceId: "x".repeat(128),
+      diagnosticId: "x".repeat(128),
+      stageKey: "x".repeat(64),
+      handlerKey: "x".repeat(64),
+      queue: "x".repeat(64),
+      attemptNumber: 1_000_000_000,
+    });
+    expect(Buffer.byteLength(JSON.stringify(records[0]))).toBeLessThanOrEqual(
+      STRUCTURED_LOG_MAX_BYTES,
+    );
+  });
+
+  test("输出端故障不影响业务调用", () => {
+    const fail = () => {
+      throw new Error("stdout unavailable");
+    };
+    const logger = createStructuredLogger(
+      { info: fail, warn: fail, error: fail },
+      "windy-server",
+    );
+    expect(() =>
+      logger.error({ event: "agent.workflow.continuation.failed" }),
+    ).not.toThrow();
+  });
+});