flower-trellis 0.5.2 → 0.5.4

package/enhancements/common/.common/.claude/skills/craft-rpa/recorder/test/network-capture.test.js

@@ -0,0 +1,199 @@
+const assert = require('node:assert/strict');
+const { EventEmitter } = require('node:events');
+const test = require('node:test');
+const { MAX_NETWORK_BODY_BYTES } = require('../config');
+const {
+    captureBody,
+    installNetworkCapture,
+    isRecorderRequest,
+    parseMultipartMetadata,
+    truncateUtf8,
+} = require('../network-capture');
+
+class FakeContext extends EventEmitter {}
+
+function createFrame(url = 'https://example.test/page') {
+    return {
+        url: () => url,
+        name: () => '',
+        parentFrame: () => null,
+        page: () => ({ url: () => url }),
+    };
+}
+
+function createResponse(options = {}) {
+    return {
+        status: () => options.status ?? 200,
+        allHeaders: async () => options.headers || { 'content-type': 'application/json' },
+        body: async () => {
+            if (options.onBody) options.onBody();
+            return Buffer.from(options.body ?? '{"ok":true}');
+        },
+    };
+}
+
+function createRequest(options = {}) {
+    const response = options.response === undefined ? createResponse() : options.response;
+    return {
+        resourceType: () => options.resourceType || 'fetch',
+        url: () => options.url || 'https://api.example.test/items',
+        method: () => options.method || 'POST',
+        redirectedFrom: () => options.redirectedFrom || null,
+        allHeaders: async () => options.headers || { 'content-type': 'application/json', authorization: 'Bearer raw-token' },
+        postDataBuffer: () => Buffer.from(options.body ?? '{"name":"测试"}'),
+        response: async () => response,
+        frame: () => options.frame || createFrame(),
+        serviceWorker: () => options.serviceWorker || null,
+        failure: () => options.failure || null,
+    };
+}
+
+function nextTurn() {
+    return new Promise(resolve => setImmediate(resolve));
+}
+
+test('默认网络正文捕获上限为单方向 20 MiB', () => {
+    assert.equal(MAX_NETWORK_BODY_BYTES, 20 * 1024 * 1024);
+});
+
+test('文本正文可完整保存到 20 MiB 并在下一字节截断', () => {
+    const input = Buffer.alloc(MAX_NETWORK_BODY_BYTES + 1, 0x61);
+    const result = captureBody(input, 'text/plain');
+    assert.equal(Buffer.byteLength(result.body), MAX_NETWORK_BODY_BYTES);
+    assert.equal(result.size, MAX_NETWORK_BODY_BYTES + 1);
+    assert.equal(result.truncated, true);
+});
+
+test('UTF-8 截断不切断多字节字符且不超过字节上限', () => {
+    const result = truncateUtf8(Buffer.from('你你你你'), 10);
+    assert.equal(result.text, '你你你');
+    assert.equal(Buffer.byteLength(result.text), 9);
+    assert.equal(result.size, 12);
+    assert.equal(result.truncated, true);
+});
+
+test('异常 UTF-8 字节也不会让替换字符突破上限', () => {
+    const result = truncateUtf8(Buffer.from([0xff, 0xff, 0x61]), 3);
+    assert.ok(Buffer.byteLength(result.text) <= 3);
+    assert.equal(result.text.includes('\ufffd'), true);
+});
+
+test('文本正文、二进制正文和无类型响应按契约分类', () => {
+    const text = captureBody(Buffer.from('{"ok":true}'), 'application/json', { maxBytes: 20 });
+    assert.equal(text.body, '{"ok":true}');
+    assert.equal(text.bodySkipped, undefined);
+
+    const binary = captureBody(Buffer.from([0, 1, 2]), 'image/png');
+    assert.equal(binary.body, null);
+    assert.equal(binary.bodySkipped, 'binary-content-type');
+
+    const unknownResponse = captureBody(Buffer.from('plain'), '', { allowUnknownText: false });
+    assert.equal(unknownResponse.body, null);
+    assert.equal(unknownResponse.bodySkipped, 'missing-content-type');
+});
+
+test('multipart 仅保留普通字段和文件元数据', () => {
+    const raw = Buffer.from([
+        '--abc',
+        'Content-Disposition: form-data; name="title"',
+        '',
+        'hello',
+        '--abc',
+        'Content-Disposition: form-data; name="file"; filename="a.txt"',
+        'Content-Type: text/plain',
+        '',
+        'secret-file-body',
+        '--abc--',
+        '',
+    ].join('\r\n'));
+    const result = parseMultipartMetadata(raw, 'multipart/form-data; boundary=abc', 1024);
+    assert.equal(result.parsed, true);
+    assert.deepEqual(result.parts[0], { name: 'title', value: 'hello', size: 5, truncated: false });
+    assert.equal(result.parts[1].filename, 'a.txt');
+    assert.equal(result.parts[1].fileBodySkipped, true);
+    assert.equal(result.parts[1].size, Buffer.byteLength('secret-file-body'));
+    assert.equal(result.parts[1].value, undefined);
+});
+
+test('multipart boundary 保持大小写', () => {
+    const raw = Buffer.from('--AbC\r\nContent-Disposition: form-data; name="v"\r\n\r\nx\r\n--AbC--\r\n');
+    const result = captureBody(raw, 'multipart/form-data; boundary=AbC');
+    assert.equal(result.bodySkipped, 'multipart-metadata-only');
+    assert.equal(result.multipart[0].value, 'x');
+});
+
+test('recorder 自身路径只在匹配本机 host 与端口时过滤', () => {
+    assert.equal(isRecorderRequest('http://localhost:7777/log', { port: 7777 }), true);
+    assert.equal(isRecorderRequest('http://localhost:7777/session', { port: 7777 }), true);
+    assert.equal(isRecorderRequest('http://127.0.0.1:7777/control/click', { port: 7777 }), true);
+    assert.equal(isRecorderRequest('http://localhost:8888/log', { port: 7777 }), false);
+    assert.equal(isRecorderRequest('https://example.test/log', { port: 7777 }), false);
+});
+
+test('已知超限响应不调用会整块物化正文的 response.body', async () => {
+    const context = new FakeContext();
+    const events = [];
+    let bodyCalled = false;
+    const response = createResponse({
+        headers: {
+            'content-type': 'text/plain',
+            'content-length': String(1025),
+        },
+        onBody: () => { bodyCalled = true; },
+    });
+    const request = createRequest({ response });
+    installNetworkCapture(context, { appendEvents: batch => events.push(...batch), port: 7777, maxBodyBytes: 1024 });
+    context.emit('request', request);
+    context.emit('requestfinished', request);
+    await nextTurn();
+
+    assert.equal(bodyCalled, false);
+    assert.equal(events[0].responseSize, 1025);
+    assert.equal(events[0].responseBody, null);
+    assert.equal(events[0].responseBodyTruncated, true);
+    assert.equal(events[0].responseBodySkipped, 'content-length-exceeds-capture-limit');
+});
+
+test('成功请求只 finalize 一次并保存完整请求响应上下文', async () => {
+    const context = new FakeContext();
+    const events = [];
+    installNetworkCapture(context, { appendEvents: batch => events.push(...batch), port: 7777, maxBodyBytes: 1024 });
+    const request = createRequest();
+    context.emit('request', request);
+    context.emit('requestfinished', request);
+    context.emit('requestfinished', request);
+    await nextTurn();
+
+    assert.equal(events.length, 1);
+    assert.equal(events[0].status, 200);
+    assert.equal(events[0].requestHeaders.authorization, 'Bearer raw-token');
+    assert.equal(events[0].requestBody, '{"name":"测试"}');
+    assert.equal(events[0].responseBody, '{"ok":true}');
+    assert.equal(events[0].context.frameDepth, 0);
+    assert.equal(events[0].failure, null);
+});
+
+test('失败请求与 redirect 链保留结构化失败和来源 requestId', async () => {
+    const context = new FakeContext();
+    const events = [];
+    installNetworkCapture(context, { appendEvents: batch => events.push(...batch), port: 7777, maxBodyBytes: 1024 });
+
+    const first = createRequest({ url: 'https://api.example.test/start', response: createResponse({ status: 302, headers: { location: '/next' }, body: '' }) });
+    const second = createRequest({ url: 'https://api.example.test/next', redirectedFrom: first });
+    const failed = createRequest({ url: 'https://127.0.0.1:1/fail', response: null, failure: { errorText: 'net::ERR_CONNECTION_REFUSED' } });
+    context.emit('request', first);
+    context.emit('request', second);
+    context.emit('request', failed);
+    context.emit('requestfinished', first);
+    context.emit('requestfinished', second);
+    context.emit('requestfailed', failed);
+    await nextTurn();
+
+    const firstEvent = events.find(event => event.requestUrl.endsWith('/start'));
+    const secondEvent = events.find(event => event.requestUrl.endsWith('/next'));
+    const failedEvent = events.find(event => event.requestUrl.includes('/fail'));
+    assert.equal(secondEvent.redirectedFromRequestId, firstEvent.requestId);
+    assert.equal(failedEvent.status, null);
+    assert.equal(failedEvent.failure.errorText, 'net::ERR_CONNECTION_REFUSED');
+    assert.equal(failedEvent.error, 'net::ERR_CONNECTION_REFUSED');
+});

package/enhancements/common/.common/.claude/skills/craft-rpa/recorder/test/runtime-layout.test.js

@@ -0,0 +1,96 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const test = require('node:test');
+
+/**
+ * 写入可执行的测试替身。
+ *
+ * @param {string} target 文件路径。
+ * @param {string} content 脚本内容。
+ * @return {void}
+ */
+function writeExecutable(target, content) {
+    fs.writeFileSync(target, content, { mode: 0o755 });
+}
+
+test('run.sh 将旧运行时产物迁出 Plugin 管理树', { skip: process.platform === 'win32' }, t => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'craft-rpa-runtime-layout-'));
+    const sourceSkill = path.resolve(__dirname, '..', '..');
+    const skillRoot = path.join(tempRoot, 'skill');
+    const recorderRoot = path.join(skillRoot, 'recorder');
+    const projectRoot = path.join(tempRoot, 'project');
+    const dataRoot = path.join(projectRoot, '.craft-rpa');
+    const fakeBin = path.join(tempRoot, 'bin');
+    let launchPid = null;
+
+    t.after(() => {
+        if (launchPid !== null) {
+            try { process.kill(launchPid, 'SIGTERM'); } catch (error) { /* 测试进程可能已结束。 */ }
+        }
+        fs.rmSync(tempRoot, { recursive: true, force: true });
+    });
+
+    fs.cpSync(sourceSkill, skillRoot, { recursive: true });
+    fs.mkdirSync(projectRoot, { recursive: true });
+    fs.mkdirSync(fakeBin, { recursive: true });
+
+    const profileTarget = path.join(dataRoot, 'profile');
+    const sessionTarget = path.join(dataRoot, 'sessions', 'old', 'session.jsonl');
+    fs.mkdirSync(profileTarget, { recursive: true });
+    fs.mkdirSync(path.dirname(sessionTarget), { recursive: true });
+    fs.writeFileSync(path.join(profileTarget, 'preserved.txt'), 'profile\n');
+    fs.writeFileSync(sessionTarget, '{"kind":"legacy"}\n');
+    fs.symlinkSync(profileTarget, path.join(recorderRoot, 'profile'), 'dir');
+    fs.symlinkSync(sessionTarget, path.join(recorderRoot, 'session.jsonl'));
+    fs.mkdirSync(path.join(recorderRoot, 'node_modules', 'playwright'), { recursive: true });
+    fs.writeFileSync(path.join(recorderRoot, 'node_modules', 'playwright', 'package.json'), '{}\n');
+
+    writeExecutable(path.join(fakeBin, 'npm'), `#!/usr/bin/env bash
+mkdir -p "$PWD/node_modules/playwright"
+printf '{}\\n' > "$PWD/node_modules/playwright/package.json"
+`);
+    writeExecutable(path.join(fakeBin, 'node'), `#!/usr/bin/env bash
+printf '%s\\n' "$CRAFT_RPA_SESSION_FILE" > "$CRAFT_RPA_HOME/fake-session-file"
+printf '%s\\n' "$CRAFT_RPA_PROFILE_DIR" > "$CRAFT_RPA_HOME/fake-profile-dir"
+printf '%s\\n' "$CRAFT_RPA_PLAYWRIGHT_MODULE" > "$CRAFT_RPA_HOME/fake-playwright-module"
+while true; do /bin/sleep 1; done
+`);
+
+    const result = spawnSync('bash', [path.join(skillRoot, 'scripts', 'run.sh'), 'start', 'about:blank'], {
+        cwd: projectRoot,
+        env: {
+            ...process.env,
+            CRAFT_RPA_HOME: dataRoot,
+            PATH: `${fakeBin}${path.delimiter}${process.env.PATH}`,
+        },
+        encoding: 'utf8',
+        timeout: 10000,
+    });
+
+    assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+    launchPid = Number.parseInt(fs.readFileSync(path.join(dataRoot, '.launch.pid'), 'utf8'), 10);
+    assert.equal(Number.isInteger(launchPid), true);
+    assert.equal(fs.existsSync(path.join(recorderRoot, 'profile')), false);
+    assert.equal(fs.existsSync(path.join(recorderRoot, 'session.jsonl')), false);
+    assert.equal(fs.existsSync(path.join(recorderRoot, 'node_modules')), false);
+    assert.equal(fs.readFileSync(path.join(profileTarget, 'preserved.txt'), 'utf8'), 'profile\n');
+    assert.equal(fs.readFileSync(sessionTarget, 'utf8'), '{"kind":"legacy"}\n');
+
+    const runtimeRoot = path.join(dataRoot, 'runtime', 'recorder');
+    assert.equal(fs.existsSync(path.join(runtimeRoot, 'node_modules', 'playwright', 'package.json')), true);
+    assert.equal(
+        fs.readFileSync(path.join(dataRoot, 'fake-profile-dir'), 'utf8').trim(),
+        profileTarget,
+    );
+    assert.equal(
+        fs.readFileSync(path.join(dataRoot, 'fake-playwright-module'), 'utf8').trim(),
+        path.join(runtimeRoot, 'node_modules', 'playwright'),
+    );
+    const sessionFile = fs.readFileSync(path.join(dataRoot, 'fake-session-file'), 'utf8').trim();
+    assert.equal(sessionFile.startsWith(path.join(dataRoot, 'sessions')), true);
+    assert.equal(sessionFile.endsWith(path.join('', 'session.jsonl')), true);
+    assert.equal(fs.existsSync(sessionFile), true);
+});

package/enhancements/common/.common/.claude/skills/craft-rpa/recorder/test/trace.test.js

@@ -0,0 +1,36 @@
+const assert = require('node:assert/strict');
+const { execFileSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const test = require('node:test');
+
+test('trace 同时兼容旧网络事件并展示新字段与 body 反查', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'craft-rpa-trace-'));
+    const jsonl = path.join(dir, 'session.jsonl');
+    const events = [
+        {
+            kind: 'network', type: 'fetch', method: 'GET', requestUrl: 'https://example.test/old', status: 200,
+            clientTime: '2026-01-01T00:00:00.000Z', serverTime: '2026-01-01T00:00:00.100Z',
+        },
+        {
+            kind: 'network', type: 'xhr', source: 'playwright', requestId: 'net-2', method: 'POST',
+            requestUrl: 'https://example.test/new', status: 500, requestHeaders: { authorization: 'Bearer raw' },
+            requestContentType: 'application/json', requestBody: JSON.stringify({ value: '你'.repeat(1000) }),
+            requestSize: 3012, requestBodyTruncated: false, responseHeaders: { 'content-type': 'text/plain' },
+            responseContentType: 'text/plain', responseBody: 'failed\n```\nkept', responseSize: 15,
+            failure: null, context: { pageUrl: 'https://example.test/form', frameDepth: 0 },
+            clientTime: '2026-01-01T00:00:01.000Z', serverTime: '2026-01-01T00:00:01.100Z',
+        },
+    ];
+    fs.writeFileSync(jsonl, `${events.map(event => JSON.stringify(event)).join('\n')}\n`);
+    const script = path.join(__dirname, '..', '..', 'scripts', 'jsonl-to-trace.js');
+    const output = execFileSync(process.execPath, [script, '--max-body-bytes', '1024', jsonl], { encoding: 'utf8' });
+    assert.match(output, /GET .*old/);
+    assert.match(output, /requestHeaders/);
+    assert.match(output, /Bearer raw/);
+    assert.match(output, /trace 展示截断/);
+    assert.match(output, /jsonl#2 字段 `\.requestBody`/);
+    assert.match(output, /frameDepth/);
+    assert.match(output, /````text\n  failed\n  ```\n  kept\n  ````/);
+});

package/enhancements/common/.common/.claude/skills/craft-rpa/scripts/control-client.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+const http = require('http');
+const https = require('https');
+const path = require('path');
+const { getLoggerOrigin } = require(path.join(__dirname, '..', 'recorder', 'config'));
+
+/**
+ * 调用本地 browser control API。
+ *
+ * @param {string} action 控制动作。
+ * @param {Object} [payload] 动作参数。
+ * @param {Object} [options] 客户端配置。
+ * @param {string} [options.origin] logger origin。
+ * @param {number} [options.timeoutMs] 请求超时。
+ * @return {Promise<Object|Array<Object>>} 结构化响应。
+ */
+function callControl(action, payload = {}, options = {}) {
+    const endpoint = new URL(`/control/${encodeURIComponent(action)}`, options.origin || getLoggerOrigin());
+    const body = JSON.stringify(payload);
+    const transport = endpoint.protocol === 'https:' ? https : http;
+    return new Promise((resolve, reject) => {
+        const request = transport.request(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(body),
+            },
+            timeout: options.timeoutMs || 125000,
+        }, response => {
+            const chunks = [];
+            response.on('data', chunk => chunks.push(chunk));
+            response.on('end', () => {
+                const raw = Buffer.concat(chunks).toString('utf8');
+                let parsed;
+                try {
+                    parsed = raw ? JSON.parse(raw) : {};
+                } catch (error) {
+                    reject(new Error(`control returned invalid JSON: ${raw.slice(0, 500)}`));
+                    return;
+                }
+                if (response.statusCode >= 400) {
+                    const detail = parsed.error || {};
+                    const failure = new Error(detail.message || `control failed with HTTP ${response.statusCode}`);
+                    failure.code = detail.code || 'CONTROL_FAILED';
+                    failure.details = detail.details || null;
+                    failure.statusCode = response.statusCode;
+                    failure.response = parsed;
+                    reject(failure);
+                    return;
+                }
+                resolve(parsed);
+            });
+        });
+        request.on('timeout', () => request.destroy(new Error('control request timed out')));
+        request.on('error', reject);
+        request.end(body);
+    });
+}
+
+/**
+ * 解析 CLI 参数并输出 JSON 结果。
+ *
+ * @param {string[]} argv 命令行参数。
+ * @return {Promise<void>} 执行完成。
+ */
+async function main(argv) {
+    const action = argv[0];
+    if (!action) throw new Error('usage: control-client.js <action> [JSON]');
+    let payload = {};
+    if (argv[1]) {
+        try {
+            payload = JSON.parse(argv[1]);
+        } catch (error) {
+            throw new Error(`invalid JSON payload: ${error.message}`);
+        }
+    }
+    const result = await callControl(action, payload);
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
+
+if (require.main === module) {
+    main(process.argv.slice(2)).catch(error => {
+        const payload = {
+            error: {
+                code: error.code || 'CLIENT_FAILED',
+                message: error.message,
+                details: error.details || null,
+            },
+        };
+        process.stderr.write(`${JSON.stringify(payload, null, 2)}\n`);
+        process.exit(1);
+    });
+}
+
+module.exports = { callControl, main };

package/enhancements/common/.common/.claude/skills/craft-rpa/scripts/jsonl-to-trace.js

@@ -21,14 +21,17 @@
  *       sed -n '<N>p' <session.jsonl> | jq .url
  *
  * 用法:
- *   node jsonl-to-trace.js [--max-url-len <N>] <input.jsonl> [output.md]
- *   cat session.jsonl | node jsonl-to-trace.js [--max-url-len <N>]
+ *   node jsonl-to-trace.js [--max-url-len <N>] [--max-body-bytes <N>] <input.jsonl> [output.md]
+ *   cat session.jsonl | node jsonl-to-trace.js [--max-url-len <N>] [--max-body-bytes <N>]
  */
 
 const fs = require('fs');
 const path = require('path');
+const { truncateUtf8 } = require('../recorder/network-capture');
 
 const DEFAULT_MAX_URL_LEN = 800;
+const DEFAULT_MAX_BODY_DISPLAY_BYTES = 16 * 1024;
+const DEFAULT_MAX_HEADERS_DISPLAY_BYTES = 64 * 1024;
 
 /**
  * 默认 noise hosts pattern（匹配 network 事件的 URL host 部分）。
@@ -89,6 +92,7 @@ const BIZ_NOISE_MIN_NEIGHBORS = 2;
     let inputPath = null;
     let outputPath = null;
     let maxUrlLen = DEFAULT_MAX_URL_LEN;
+    let maxBodyBytes = DEFAULT_MAX_BODY_DISPLAY_BYTES;
     const extraNoiseHosts = [];     // 用户通过 --noise-host 追加的 pattern
     let withContextHtml = false;     // --with-context-html: 全 interaction 渲染 contextHTML
 
@@ -101,6 +105,13 @@ const BIZ_NOISE_MIN_NEIGHBORS = 2;
                 process.exit(2);
             }
             maxUrlLen = v;
+        } else if (a === '--max-body-bytes') {
+            const v = parseInt(argv[++i], 10);
+            if (!Number.isFinite(v) || v < 1024) {
+                process.stderr.write('[err] --max-body-bytes 必须是 ≥ 1024 的整数\n');
+                process.exit(2);
+            }
+            maxBodyBytes = v;
         } else if (a === '--noise-host') {
             const p = argv[++i];
             if (!p) {
@@ -141,11 +152,11 @@ const BIZ_NOISE_MIN_NEIGHBORS = 2;
     }
 
     const events = parseJsonl(raw);
-    const md = generateTrace(events, { inputPath, maxUrlLen, noiseHosts, withContextHtml });
+    const md = generateTrace(events, { inputPath, maxUrlLen, maxBodyBytes, noiseHosts, withContextHtml });
 
     if (outputPath) {
         fs.writeFileSync(outputPath, md);
-        process.stderr.write(`[ok] wrote ${outputPath} (${events.length} events, maxUrlLen=${maxUrlLen}, noiseHosts=${noiseHosts.length}, withContextHtml=${withContextHtml})\n`);
+        process.stderr.write(`[ok] wrote ${outputPath} (${events.length} events, maxUrlLen=${maxUrlLen}, maxBodyBytes=${maxBodyBytes}, noiseHosts=${noiseHosts.length}, withContextHtml=${withContextHtml})\n`);
     } else {
         process.stdout.write(md);
     }
@@ -161,6 +172,7 @@ function printHelp() {
         '',
         'Options:',
         '  --max-url-len <N>      单个 URL 字段最大长度(默认 800),超过则截断 + 标注反查行号',
+        '  --max-body-bytes <N>   单个 request/response body 在 trace 中最大展示字节数(默认 16384)',
         '  --noise-host <p>       追加 noise host pattern(可多次):',
         '                           - "online-metrix.net" → 子串匹配',
         '                           - "/^foo\\..*$/i"      → 正则字面量',
@@ -292,6 +304,7 @@ function generateTrace(events, ctx) {
     lines.push(`- 时长: \`${formatDuration(duration)}\``);
     lines.push(`- 事件总数: **${events.length}**`);
     lines.push(`- 超长 URL 截断: ${truncatedCount} 处(阈值 maxUrlLen=${ctx.maxUrlLen};完整原文在原 jsonl,通过 jsonlLine 反查)`);
+    lines.push(`- 网络正文展示上限: 每个 body ${ctx.maxBodyBytes} bytes；session.jsonl 中的捕获上限与截断状态以事件字段为准`);
     lines.push(`- noise/business 分类: NOISE ${noiseEventCount} · BUSINESS-IN-NOISE ${businessInNoiseCount} (基于 ${ctx.noiseHosts.length} 个 noise host pattern;仅标注,不删事件)`);
     lines.push(`- contextHTML 渲染: ${contextHtmlRenderedCount} 处${ctx.withContextHtml ? ' (全 interaction;--with-context-html 启用)' : ' (仅 BUSINESS-IN-NOISE;session.jsonl 仍存全量,反查见下)'}`);
     lines.push(`- URL 覆盖(去 query+hash):`);
@@ -580,11 +593,33 @@ function renderEvent(ev, ctx, classification) {
 
     // network
     if (ev.kind === 'network') {
+        if (ev.source) out.push(`- source: \`${ev.source}\``);
+        if (ev.requestId) out.push(`- requestId: \`${ev.requestId}\``);
+        if (ev.redirectedFromRequestId) out.push(`- redirectedFromRequestId: \`${ev.redirectedFromRequestId}\``);
         if (ev.method) out.push(`- method: \`${ev.method}\``);
         const reqLine = urlField('requestUrl', ev.requestUrl, ctx, ev.__jsonlLine);
         if (reqLine) out.push(reqLine);
-        if (ev.status !== undefined) out.push(`- status: ${ev.status}`);
+        if (ev.completedTime) out.push(`- completedTime: \`${ev.completedTime}\``);
+        if (ev.status !== undefined && ev.status !== null) out.push(`- status: ${ev.status}`);
         if (ev.durationMs !== undefined) out.push(`- durationMs: ${ev.durationMs}`);
+        if (ev.requestContentType) out.push(`- requestContentType: \`${ev.requestContentType}\``);
+        if (ev.requestHeaders && Object.keys(ev.requestHeaders).length) {
+            out.push(...renderJsonField('requestHeaders', ev.requestHeaders, DEFAULT_MAX_HEADERS_DISPLAY_BYTES, ev.__jsonlLine));
+        }
+        out.push(...renderNetworkBody('request', ev, ctx));
+        if (ev.responseContentType) out.push(`- responseContentType: \`${ev.responseContentType}\``);
+        if (ev.responseHeaders && Object.keys(ev.responseHeaders).length) {
+            out.push(...renderJsonField('responseHeaders', ev.responseHeaders, DEFAULT_MAX_HEADERS_DISPLAY_BYTES, ev.__jsonlLine));
+        }
+        out.push(...renderNetworkBody('response', ev, ctx));
+        if (ev.requestMultipart) {
+            out.push(...renderJsonField('requestMultipart', ev.requestMultipart, ctx.maxBodyBytes, ev.__jsonlLine));
+        }
+        if (ev.context) out.push(...renderJsonField('context', ev.context, 16 * 1024, ev.__jsonlLine));
+        if (ev.failure) out.push(...renderJsonField('failure', ev.failure, 16 * 1024, ev.__jsonlLine));
+        for (const field of ['requestHeaderCaptureError', 'requestBodyCaptureError', 'responseHeaderCaptureError', 'responseBodyCaptureError']) {
+            if (ev[field]) out.push(`- ${field}: \`${truncate(ev[field], 500)}\``);
+        }
         if (ev.error) out.push(`- error: \`${ev.error}\``);
     }
 
@@ -615,6 +650,88 @@ function renderEvent(ev, ctx, classification) {
     return out;
 }
 
+/**
+ * 渲染 JSON 字段并限制 trace 展示体积，完整值仍保留在 JSONL。
+ *
+ * @param {string} label 字段名。
+ * @param {Object|Array<Object>} value JSON 值。
+ * @param {number} maxBytes 展示上限。
+ * @param {number} jsonlLine JSONL 行号。
+ * @return {string[]} Markdown 行。
+ */
+function renderJsonField(label, value, maxBytes, jsonlLine) {
+    const raw = JSON.stringify(value, null, 2);
+    const limited = truncateUtf8(Buffer.from(raw, 'utf8'), maxBytes);
+    const fence = markdownFence(limited.text);
+    const lines = [`- ${label}:`, `  ${fence}json`];
+    for (const line of limited.text.split('\n')) lines.push(`  ${line}`);
+    lines.push(`  ${fence}`);
+    if (limited.truncated) {
+        lines.push(`  - trace 展示截断: ${limited.size} → ${maxBytes} bytes；完整值见 jsonl#${jsonlLine} 字段 \`.${label}\``);
+    }
+    return lines;
+}
+
+/**
+ * 渲染 request/response body 的大小、跳过原因和有界正文。
+ *
+ * @param {'request'|'response'} prefix 字段前缀。
+ * @param {Object} event 网络事件。
+ * @param {Object} ctx trace 配置。
+ * @return {string[]} Markdown 行。
+ */
+function renderNetworkBody(prefix, event, ctx) {
+    const fieldPrefix = prefix === 'request' ? 'request' : 'response';
+    const bodyField = `${fieldPrefix}Body`;
+    const sizeField = `${fieldPrefix}Size`;
+    const truncatedField = `${fieldPrefix}BodyTruncated`;
+    const skippedField = `${fieldPrefix}BodySkipped`;
+    const body = event[bodyField];
+    const lines = [];
+    if (event[sizeField] !== undefined) lines.push(`- ${sizeField}: ${event[sizeField]} bytes`);
+    if (event[truncatedField]) lines.push(`- ${truncatedField}: true（session.jsonl 捕获时已截断）`);
+    if (event[skippedField]) lines.push(`- ${skippedField}: \`${event[skippedField]}\``);
+    if (body === undefined || body === null) return lines;
+
+    let display = String(body);
+    let language = 'text';
+    const contentType = String(event[`${fieldPrefix}ContentType`] || '');
+    if (/json/i.test(contentType)) {
+        try {
+            display = JSON.stringify(JSON.parse(display), null, 2);
+            language = 'json';
+        } catch (error) {
+            language = 'text';
+        }
+    } else if (/xml|html|svg/i.test(contentType)) {
+        language = 'html';
+    } else if (/javascript|ecmascript/i.test(contentType)) {
+        language = 'javascript';
+    }
+    const limited = truncateUtf8(Buffer.from(display, 'utf8'), ctx.maxBodyBytes);
+    const fence = markdownFence(limited.text);
+    lines.push(`- ${bodyField}:`);
+    lines.push(`  ${fence}${language}`);
+    for (const line of limited.text.split('\n')) lines.push(`  ${line}`);
+    lines.push(`  ${fence}`);
+    if (limited.truncated) {
+        lines.push(`  - trace 展示截断: ${limited.size} → ${ctx.maxBodyBytes} bytes；完整捕获值见 jsonl#${event.__jsonlLine} 字段 \`.${bodyField}\``);
+    }
+    return lines;
+}
+
+/**
+ * 选择不会与正文反引号序列冲突的 Markdown 围栏。
+ *
+ * @param {string} value 围栏内正文。
+ * @return {string} 至少三个反引号组成的安全围栏。
+ */
+function markdownFence(value) {
+    const runs = String(value || '').match(/`+/g) || [];
+    const longest = runs.reduce((max, run) => Math.max(max, run.length), 0);
+    return '`'.repeat(Math.max(3, longest + 1));
+}
+
 // ========== URL 字段(超长截断 + 反查标注) ==========
 
 function urlField(label, url, ctx, jsonlLine) {

package/enhancements/common/.common/.claude/skills/craft-rpa/scripts/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}