@anytowork/cli 0.12.17 → 0.12.19

package/README.md

@@ -128,18 +128,18 @@ anytowork task reject <task_id> --reason "不符合要求"   # 先看报价（
 anytowork libra quote --task <task_id> [--claim full|partial:30|libra] [--evidence <file_id>]...   # 申请裁决前报价
 anytowork libra file --task <task_id> [--quote <quote_id>]   # 不再提交：发起裁决需用户本人在网页完成，只打印网页链接（退出码 5）
 anytowork libra status --task <task_id>                 # 阶段、倒计时、双方陈述情况
-anytowork libra statement --task <task_id> --text-file ./s.txt [--evidence <file_id>]...   # 陈述 / 补充（文字免费）
+anytowork libra statement --task <task_id> --text-file ./s.txt   # 陈述 / 补充陈述（文字免费）；证据在申请裁决时一次交齐，开审后不能再补
 #   写陈述时请分段、用序号：一条一个要点。双方看到的是原文，换行与分段都会保留。
 anytowork libra answer --task <task_id> --question <q_id> --text "回答"   # 回答追问（仅一轮）
 anytowork libra ruling --task <task_id> [--round 1|2]   # 读裁决书
 anytowork libra accept --task <task_id>                 # 接受裁决（需主人在网页完成）
-anytowork libra review quote --task <task_id> ...      # 复核报价（不扣费）
+anytowork libra review quote --task <task_id> ...      # 复核报价（不扣费）；复核期只能补充陈述
 anytowork libra review file --task <task_id> [--quote <quote_id>]   # 同 libra file：申请复核需用户本人在网页完成（退出码 5）
 anytowork libra withdraw --task <task_id>              # 撤回裁决（发起方；只能本人在网页操作，Agent 会得到退出码 5 和网页链接）
 anytowork libra concede --task <task_id> --expect-pct 30     # 提前结案：接单方认可对方公开的退款主张，比例必须是你读到的那个
 anytowork libra settle propose --task <task_id> --pct 30     # 提前结案：提出和解
 anytowork libra settle accept --task <task_id> --expect-pct 30   # 接受对方的和解提议（reject 拒绝，withdraw 撤回自己的提议）
-# 争议裁决：服务费用于审理成本，与结果无关；审理开始前提前结案（撤回 / 认可 / 和解）服务费原路退回，审理开始后不退还；对方会收到通知并有陈述期（默认 48 小时）；
+# 争议裁决：审理费用于审理成本，与结果无关；审理开始前提前结案（撤回 / 认可 / 和解）审理费原路退回，审理开始后不退还；对方会收到通知并有陈述期（默认 48 小时）；
 # 它是平台内部的争议裁决规则，不是法律意义上的仲裁，不影响依法起诉或申请仲裁的权利。
 # 退出码：0 成功 · 2 本机参数问题 · 3 报价过期 · 4 当前不允许该操作 · 5 需要用户本人在网页完成（请把输出的链接交给用户）；均支持 --json（退出码 5 时输出 {"ok":false,"error":"human_required","web_url":…}）。
 anytowork task revise <task_id> --note "请修改第二段"
@@ -181,7 +181,7 @@ anytowork ping
 - **需要本人在网页完成的步骤**（付款、撤回裁决、带图评价等）：Agent 一律得到退出码 5（`human_required`），请把输出里的链接交给用户。
 - **再改一轮**：改稿次数用完后，发起方可向接单方申请再改一轮，可附加费用和顺延期限（用 `--defer-hours` 按小时给，最长 3 天；旧的 `--defer-days` 仍可用）。接单方可同意、婉拒（不影响接单方信用）或改条件；婉拒、撤回、超时未回应，已付的附加费用都原路退回。省略申请号时自动取这个任务进行中的那一条。
 - **评价标签**：`--tag` 的 key 来自平台（买方评接单方、接单方评发起方用的是两套标签）。评价提交后不能修改；被评的人可在网页回复一次。
-- **提前结案**：AI 法庭出裁决书之前，发起方可撤回裁决（网页），接单方可认可对方公开的退款主张，双方也可协商一个退还比例。认可退款和接受和解都必须带 `--expect-pct`，写你读到的那个比例，比例变了会被拒绝（退出码 3），先 `libra status` 再决定。审理开始前结案服务费原路退回；全额退款后交付物归还接单方，发起方不能再查看或下载（只对功能上线后新发生的退款生效）。
+- **提前结案**：AI 法庭出裁决书之前，发起方可撤回裁决（网页），接单方可认可对方公开的退款主张，双方也可协商一个退还比例。认可退款和接受和解都必须带 `--expect-pct`，写你读到的那个比例，比例变了会被拒绝（退出码 3），先 `libra status` 再决定。审理开始前结案审理费原路退回；全额退款后交付物归还接单方，发起方不能再查看或下载（只对功能上线后新发生的退款生效）。
 - **事件**：`libra.settle_proposed / settle_rejected / settle_withdrawn / settle_expired / closed_early`、`task_revision_extension_requested / countered / resolved`。旧版本遇到不认识的新事件，会按通用格式列出事件名，不会报错；升级后才有上面的详细说明。
 
 ### 接单安全与卖方退出（v0.20.0 / CLI 0.10.2 新增）
@@ -216,7 +216,7 @@ anytowork deliver upload --task <task_id> --file ./分析报告.docx --file ./
 
 一条命令完成：逐个申请上传（带原文件名和类型）→ 直传 → 交付；这一轮上传的文件归入同一版，重跑同一条命令不会重复交付。
 
-- **限制**：一次最多 20 个文件，单个 ≤ 50MB（文件夹请先压成 zip）；`--note` ≤ 5000 字。本机先检查文件存在、不是空文件、不超限，不通过时退出码 2，不向平台发请求。
+- **限制**：一次最多 20 个文件，单个 ≤ 1GB（超过 16MB 的文件自动分片上传，断线只重传出问题的那一片；文件夹请先压成 zip）；`--note` ≤ 5000 字。本机先检查文件存在、不是空文件、不超限，不通过时退出码 2，不向平台发请求。
 - **交付说明**：`--note` 就是买家在交付物页看到的「交付说明」，请写给买家看。没写时平台用你交付前后 30 分钟内发的协作留言作说明（标注「来自协作留言」）；都没有就不显示。
 - 已用 `task request-upload` 自行上传时，可用 `anytowork task deliver <task_id> --file-id <id> --note "说明"`；`request-upload` 请带 `--filename`，否则买家看到的是平台起的名字「任务标题_交付文件N」。
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@anytowork/cli",
-  "version": "0.12.17",
+  "version": "0.12.19",
   "description": "AnytoWork 平台命令行工具——让任何能执行 shell 命令的 Agent 用一条命令接入 AnytoWork：登录、发单接单、管理能力。",
   "type": "module",
   "bin": {
-    "anytowork": "./bin/anytowork.js"
+    "anytowork": "bin/anytowork.js"
   },
   "exports": {
     ".": "./src/index.js"

package/src/file-deliver.js

@@ -11,15 +11,16 @@
 // PUT by itself and `task deliver --file-id` (no room for a note) - files arrived nameless and without a note.
 
 import { createHash } from 'node:crypto';
-import { readFileSync, realpathSync, statSync } from 'node:fs';
+import { closeSync, openSync, readFileSync, readSync, realpathSync, statSync } from 'node:fs';
 import { basename, extname } from 'node:path';
 import { getTaskDeliverables, requestUpload, runtimeAct } from './api.js';
 import { humanSize } from './media-upload.js';
 import { buildWebDeliverIdemKey, usageFields, WebDeliverError } from './web-deliver.js';
 import { putWithRetry } from './storage-put.js';
+import { MULTIPART_THRESHOLD, uploadMultipart } from './multipart-upload.js';
 
-/** Same cap as the backend upload route (_MAX_FILE_SIZE_BYTES). */
-export const FILE_MAX_BYTES = 50 * 1024 * 1024;
+/** Same default as the platform (RISK_DELIVERABLE_FILE_MAX_MB); the platform stays the judge and refuses anything above its own cap. */
+export const FILE_MAX_BYTES = 1024 * 1024 * 1024;
 /** Files per delivery command (keeps one command reasonable; more files -> zip them). */
 export const FILES_MAX = 20;
 /** Upper bound for the note; long reports belong in a file. */
@@ -68,6 +69,23 @@ export function mimeFor(path) {
  * @returns {Array<{absPath:string, filename:string, mime:string, size:number, buf:Buffer, sha:string}>}
  * @throws {WebDeliverError} exit code 2 (the caller can fix it and retry)
  */
+/** SHA-256 of a file read in 4 MB chunks, so a 1 GB file never sits in memory. */
+function hashFileSync(absPath) {
+  const hash = createHash('sha256');
+  const chunk = Buffer.alloc(4 * 1024 * 1024);
+  const fd = openSync(absPath, 'r');
+  try {
+    for (;;) {
+      const n = readSync(fd, chunk, 0, chunk.length, null);
+      if (n === 0) break;
+      hash.update(chunk.subarray(0, n));
+    }
+  } finally {
+    closeSync(fd);
+  }
+  return hash.digest('hex');
+}
+
 export function prepareFiles(paths, note, previewPaths = []) {
   const list = (paths || []).filter((p) => p != null && p !== '');
   const previewSet = new Set();
@@ -103,11 +121,18 @@ export function prepareFiles(paths, note, previewPaths = []) {
       throw new WebDeliverError(`${file} 是空文件。请确认内容已生成，再重新交付。`, { exitCode: 2 });
     }
     if (st.size > FILE_MAX_BYTES) {
-      throw new WebDeliverError(`${file} 有 ${humanSize(st.size)}，超过单个文件 50MB 上限。请压缩或拆分后再交付。`, { exitCode: 2 });
+      throw new WebDeliverError(`${file} 有 ${humanSize(st.size)}，超过单个文件 1GB 上限。请压缩或拆分后再交付。`, { exitCode: 2 });
     }
-    let buf;
+    // big files are not read into memory: they are streamed for the hash now and cut into parts when uploaded
+    let buf = null;
+    let sha;
     try {
-      buf = readFileSync(absPath);
+      if (st.size > MULTIPART_THRESHOLD) {
+        sha = hashFileSync(absPath);
+      } else {
+        buf = readFileSync(absPath);
+        sha = createHash('sha256').update(buf).digest('hex');
+      }
     } catch {
       throw new WebDeliverError(`读不了文件：${file}。`, { exitCode: 2 });
     }
@@ -118,7 +143,7 @@ export function prepareFiles(paths, note, previewPaths = []) {
       mime: mimeFor(absPath),
       size: st.size,
       buf,
-      sha: createHash('sha256').update(buf).digest('hex'),
+      sha,
     });
   }
   return out;
@@ -151,6 +176,29 @@ export async function deliverFiles(ctx) {
     // command reuses the same file_id; after a storage 403 the second try asks with a new key (fresh address).
     progress(`申请上传（${f.filename}，${humanSize(f.size)}）…`);
     const baseKey = `file-upload-${taskId}-${f.sha.slice(0, 32)}${f.preview ? '-pv' : ''}`;
+    if (f.buf === null) {
+      // big file: register it, then send it in parts (a break only costs the part in flight)
+      let reg;
+      try {
+        reg = await requestUpload(baseUrl, credOpts, {
+          task_id: taskId,
+          kind: 'deliverable',
+          mime_type: f.mime,
+          size_bytes: f.size,
+          filename: f.filename,
+          ...(f.preview ? { preview: true } : {}),
+        }, { fetchImpl, idempotencyKey: baseKey });
+      } catch (e) {
+        throw wrap(e, `申请上传 ${f.filename} `);
+      }
+      await uploadMultipart({
+        baseUrl, credOpts, fetchImpl, putFetch,
+        fileId: reg.file_id, absPath: f.absPath, size: f.size, filename: f.filename,
+        progress, makeError: (msg, o) => new WebDeliverError(msg, o),
+      });
+      uploaded.push({ fileId: reg.file_id, filename: f.filename, sizeBytes: f.size });
+      continue;
+    }
     const req = await putWithRetry({
         requestAddress: async (attempt) => {
           try {

package/src/format.js

@@ -505,7 +505,7 @@ export function formatTaskDetail(data, { json = false } = {}) {
   const feePct = bpsToPercent(data.commission_rate_bps);
   const sharePct = bpsToPercent(data.owner_share_bps);
   if (feePct != null) {
-    lines.push(`  平台技术服务费：${fmtPct(feePct)}（接单时锁定）`);
+    lines.push(`  平台服务费：${fmtPct(feePct)}（接单时锁定）`);
     if (sharePct) lines.push(`  原发起方分成：${fmtPct(sharePct)}（同款单，从你的份额里扣）`);
   }
   if (data.est_net_cents != null) {
@@ -847,7 +847,7 @@ function negotiationEventDetailLines(e) {
 }
 
 const CLOSE_KIND_WORDS = { withdraw: '发起方撤回裁决', concede: '接单方认可退款', settle: '双方和解' };
-const FEE_REFUND_WORDS = { refund: '审理尚未开始，服务费已原路退回', keep: '服务费不退还', free: '本案系统送入，不收服务费' };
+const FEE_REFUND_WORDS = { refund: '审理尚未开始，审理费已原路退回', keep: '审理费不退还', free: '本案系统送入，不收审理费' };
 
 /** Detail lines of a Libra event: what it means, the deadline and the next command (payload is pre-redacted). */
 function libraEventDetailLines(e) {
@@ -869,7 +869,7 @@ function libraEventDetailLines(e) {
   if (t === 'libra.closed_early') {
     if (p.close_kind) out.push(`      结案方式：${CLOSE_KIND_WORDS[p.close_kind] || p.close_kind}`);
     if (p.refund_pct != null) out.push(`      退还比例：${p.refund_pct}%`);
-    if (p.fee_refund) out.push(`      服务费：${FEE_REFUND_WORDS[p.fee_refund] || p.fee_refund}`);
+    if (p.fee_refund) out.push(`      审理费：${FEE_REFUND_WORDS[p.fee_refund] || p.fee_refund}`);
     if (p.deliverable_returned) out.push('      全额退款：交付物已归还接单方，发起方不能再查看或下载');
   }
   if (p.next) out.push(`      下一步：${p.next}`);

package/src/index.js

@@ -116,6 +116,7 @@ import { selectedTaskIds, autoAcceptSelected, formatAutoAccept } from './auto-ac
 import { resolveIntroInput, PROFILE_INTRO_MAX_CHARS, PROFILE_INTRO_LENGTH_HINT, codePointLength } from './profile-intro-input.js';
 import { runMediaUpload, prepareIntroMedia } from './media-commands.js';
 import { findLocalLikeTargets } from './local-media-refs.js';
+import { MULTIPART_THRESHOLD, uploadMultipart } from './multipart-upload.js';
 import { deliverWebPackage, formatWebDeliver, usageFields, WebDeliverError } from './web-deliver.js';
 import { deliverFiles, formatFileDeliver, mimeFor } from './file-deliver.js';
 import { runLibra, isLibraCommand } from './libra-commands.js';
@@ -338,7 +339,7 @@ const HELP = `${BRAND.name} CLI v${PKG_VERSION}
 
   deliver upload --task <task_id> --file <路径> [--file <路径>…] [--note "<说明>"]
                                       交付文件（卖方·推荐·一步完成：上传 → 交付；文件名、类型、大小自动带上）
-    --file <路径>                     要交付的文件，可写多个（最多 20 个，单个 ≤ 50MB；文件夹请先压成 zip）
+    --file <路径>                     要交付的文件，可写多个（最多 20 个，单个 ≤ 1GB；文件夹请先压成 zip）
     [--note "<说明>"]                 交付说明：交付了什么、怎么用、关键结论（≤ 5000 字），买家在交付物页看到
     [--preview <路径>]                这份文件同时是「展示文件」（可写多个）：成果要靠专门软件或下载后才能看（压缩包、设计源文件、
                                       工程文件、数据、代码等）时，另附一份能直接预览的（一两张截图或效果图，内容多的可以是 PDF），
@@ -468,7 +469,7 @@ const HELP = `${BRAND.name} CLI v${PKG_VERSION}
 ── 争议裁决（AI 法庭）──────────────────────────────────────────
   协商谈不拢时，发起方本人可以在网页申请裁决（Agent 不能发起，只能报价、查询、陈述、答追问、接受）；AI 法庭只对照需求基线裁决，结果以裁决书为准。
   这是平台内部的争议裁决规则，不是法律意义上的仲裁，不影响依法起诉或申请仲裁的权利。
-  服务费用于审理成本；审理开始前结案（撤回 / 认可 / 和解）会原路退回，审理开始后不退还，与裁决结果无关；对方会收到通知并有陈述期（默认 48 小时）。
+  审理费用于审理成本；审理开始前结案（撤回 / 认可 / 和解）会原路退回，审理开始后不退还，与裁决结果无关；对方会收到通知并有陈述期（默认 48 小时）。
 
   libra quote --task <task_id> [--claim full|partial:<10-90>|libra]      先报价（不扣费）
     [--evidence <file_id>]...          选择关键证据（可重复；先用 task request-upload 取得 file_id）
@@ -478,14 +479,14 @@ const HELP = `${BRAND.name} CLI v${PKG_VERSION}
   libra file --task <task_id> [--quote <quote_id>]
                                       不再提交：发起裁决需要用户本人在网页完成。只打印报价（如已有）和网页链接，
                                       请把链接交给用户；退出码 5（--json: {ok:false, error:"human_required", web_url}）
-  libra status --task <task_id>        阶段、倒计时、双方是否已陈述、服务费明细
+  libra status --task <task_id>        阶段、倒计时、双方是否已陈述、审理费明细
   libra statement --task <task_id> (--text-file <路径> | --text "文字")
-    [--evidence <file_id>]...          陈述 / 补充（文字免费；补充计费证据会返回应付金额与收银台链接）
+                                       陈述 / 补充陈述（文字免费）；证据在申请裁决时一次交齐，开审后不能再补
                                        请分段、用序号写清楚：一条一个要点。双方看到的是你的原文（换行保留）
   libra answer --task <task_id> --question <q_id> (--text "回答" | --text-file <路径>)   回答追问（仅一轮，逾期视为放弃）
   libra ruling --task <task_id> [--round 1|2]      读裁决书（初裁 / 复核）
   libra accept --task <task_id>        接受裁决（需主人在网页完成；双方都接受则立即执行，到期无人复核则自动执行）
-  libra review quote --task <task_id> [--evidence <file_id>]... [--points 1,3]    复核报价（每案一次，终局）
+  libra review quote --task <task_id> [--points 1,3]    复核报价（每案一次，终局；复核期只能补充陈述，不能再补证据）
   libra review file --task <task_id> [--quote <quote_id>]      同 libra file：申请复核需要用户本人在网页完成，打印网页链接，退出码 5
   提前结案（出裁决书之前，三种方式；libra status 会列出现在能用哪些、区间和待回应的提议）：
   libra withdraw --task <task_id>      发起方撤回自己付费立案的裁决（视为确认验收）；只能本人在网页操作，Agent 会得到退出码 5 和网页链接
@@ -494,7 +495,7 @@ const HELP = `${BRAND.name} CLI v${PKG_VERSION}
   libra settle accept --task <task_id> --expect-pct <比例> [--offer <提议号>]   接受对方的和解提议，按此结案（需主人在网页完成）
   libra settle reject --task <task_id> [--offer <提议号>]  拒绝对方的和解提议，审理继续
   libra settle withdraw --task <task_id> [--offer <提议号>]   撤回自己提出的提议
-  concede / settle 命令也可以用 --case <case_id> 代替 --task。审理开始前结案，服务费原路退回；审理开始后结案不退。
+  concede / settle 命令也可以用 --case <case_id> 代替 --task。审理开始前结案，审理费原路退回；审理开始后结案不退。
   全额退款（退还 100%）的案件，交付物归还接单方，发起方不能再查看或下载（仅对本功能上线后新发生的退款生效）。
   退出码：0 成功 · 2 本机参数问题 · 3 报价过期（重新 quote） · 4 任务/案件当前不允许这个操作 · 5 需要用户本人在网页完成
   所有 libra 命令支持 --json（标准输出只有一个 JSON 对象）。
@@ -1424,12 +1425,12 @@ export async function run(argv, deps = {}) {
       if (!flags.file) { err('缺少 --file 参数（本地文件路径，如 --file /tmp/spec.pdf）'); return 2; }
 
       // 从本地文件推导 mime-type 和 size
-      let fileContent;
+      let fileContent = null; // stays null for big files: they are sent in parts straight from disk
       let sizeBytes;
       let mimeType;
       try {
-        fileContent = readFileSync(flags.file);
         sizeBytes = statSync(flags.file).size;
+        if (sizeBytes <= MULTIPART_THRESHOLD) fileContent = readFileSync(flags.file);
       } catch (e) {
         err(`无法读取文件 ${flags.file}：${e.message}`);
         return 1;
@@ -1490,6 +1491,24 @@ export async function run(argv, deps = {}) {
         return 1;
       }
 
+      // 大文件（超过 16MB）：分片并发直传，中断只重传出问题的那一片
+      if (fileContent === null) {
+        try {
+          await uploadMultipart({
+            baseUrl, credOpts, fetchImpl,
+            fileId: uploadResp.file_id, absPath: flags.file, size: sizeBytes, filename: derivedFilename,
+            progress: (m) => { if (!flags.json) process.stderr.write(`${m}\n`); },
+            makeError: (msg) => new Error(msg),
+          });
+        } catch (e) {
+          if (e && e.upgradeRequired) throw e;
+          err(e && e.message ? e.message : String(e));
+          return 1;
+        }
+        log(formatAddAttachment({ file_id: uploadResp.file_id, visibility: visibilityApi }, { json: flags.json }));
+        return 0;
+      }
+
       // 第二步：CLI 代执行 PUT 直传 OSS（降低 agent 负担）
       const putUrl = uploadResp.signed_put_url;
       if (!putUrl) {

package/src/libra-commands.js

@@ -24,7 +24,7 @@ import path from 'node:path';
 import { atomicWriteFile } from './atomic-write.js';
 import { resolveCredDir } from './profile.js';
 import {
-  libraQuote, libraTaskCase, libraStatement, libraAddEvidence, libraAnswer,
+  libraQuote, libraTaskCase, libraStatement, libraAnswer,
   libraRulings, libraAccept, libraReviewQuote,
   libraGetCase, libraWithdrawCase, libraConcede, libraProposeOffer, libraAcceptOffer, libraRejectOffer, libraWithdrawOffer,
 } from './api.js';
@@ -38,11 +38,12 @@ const MAX_PAGES_PER_FILE = 5000;
 export { EXIT_HUMAN_REQUIRED };
 
 /** One generic sentence about how to write a statement (v0.22.x C6). Never names a particular Agent product. */
+export const EVIDENCE_CLOSED_MSG = '已不支持 --evidence：证据在申请裁决时一次交齐，开审后不再补充。陈述期和复核期只能补充文字陈述。';
 export const STATEMENT_TIP = '请分段、用序号写清楚：一条一个要点。';
 
 /** Plain-language notices every fee-taking command must show (PRD section 6.2 / 16, docs section 5). */
 export const FEE_NOTICES = [
-  '服务费用于审理成本，与裁决结果无关；审理开始前提前结案（撤回、认可退款、和解）服务费原路退回，审理开始后不退还。',
+  '审理费用于审理成本，与裁决结果无关；审理开始前提前结案（撤回、认可退款、和解）审理费原路退回，审理开始后不退还。',
   '对方会收到通知，并在陈述期（默认 48 小时）内提交自己的陈述；陈述期截止后材料锁定。',
   'AI 法庭只对照需求基线裁决，结果以裁决书为准；对结果不服可申请一次复核，复核即终局。',
   'AI 法庭是平台内部的争议裁决规则，不是法律意义上的仲裁，不影响依法起诉或申请仲裁的权利。',
@@ -356,9 +357,9 @@ function earlyCloseLines(ec) {
     if (!o.mine) out.push(`      接受：anytowork libra settle accept --task <task_id> --expect-pct ${o.refund_pct}`);
   }
   if (ec.fee) {
-    out.push(ec.fee.refund_if_closed_now ? '    服务费：现在结案，审理尚未开始，服务费原路退回'
-      : (ec.fee.blocked_by_cooldown ? '    服务费：近期多次撤回，这次结案服务费不退还'
-        : '    服务费：审理已开始，现在结案服务费不退还'));
+    out.push(ec.fee.refund_if_closed_now ? '    审理费：现在结案，审理尚未开始，审理费原路退回'
+      : (ec.fee.blocked_by_cooldown ? '    审理费：近期多次撤回，这次结案审理费不退还'
+        : '    审理费：审理已开始，现在结案审理费不退还'));
   }
   return out;
 }
@@ -384,7 +385,7 @@ async function cmdStatus(ctx, io) {
     ...(c.cooling_deadline ? [`  复核期截止：${fmtTime(c.cooling_deadline)}`] : []),
     `  陈述：发起方${subm.buyer ? '已提交' : '未提交'}，接单方${subm.seller ? '已提交' : '未提交'}`,
     ...(c.statement_limits ? [`  你的补充次数：${c.statement_limits.appends_used}/${c.statement_limits.appends_max}，单次不超过 ${c.statement_limits.chars_max} 字`] : []),
-    ...(orders.length ? ['  你的服务费：', ...orders.map((o) => `    - ${o.kind} ${yuan(o.amount_cents)} ${o.status}`)] : []),
+    ...(orders.length ? ['  你的审理费：', ...orders.map((o) => `    - ${o.kind} ${yuan(o.amount_cents)} ${o.status}`)] : []),
     `  复核轮次：${c.review_round || 0}`,
     ...earlyCloseLines(c.early_close),
   ].join('\n');
@@ -396,9 +397,9 @@ async function cmdStatement(ctx, io) {
   if (!flags.task) return io.fail(2, 'missing_task', '缺少 --task <task-id>');
   const st = readText(flags.textFile, flags.text[0], '陈述', io);
   if (st.fail !== undefined) return st.fail;
-  const evid = flags.evidence.length ? evidenceInputs(flags, io) : { evidence: [] };
-  if (evid.fail !== undefined) return evid.fail;
-  if (!st.text && !evid.evidence.length) return io.fail(2, 'nothing_to_submit', '没有内容：--text-file <路径> / --text "文字"，或 --evidence <file-id>');
+  // v0.29.46: evidence is handed in once when the ruling is applied for; no more evidence after the hearing opens.
+  if (flags.evidence.length) return io.fail(2, 'evidence_closed', EVIDENCE_CLOSED_MSG);
+  if (!st.text) return io.fail(2, 'nothing_to_submit', '没有内容：--text-file <路径> / --text "文字"');
   if (cpLen(st.text) > STATEMENT_MAX_CHARS) return io.fail(2, 'statement_too_long', `单次陈述不能超过 ${STATEMENT_MAX_CHARS} 字（现在 ${cpLen(st.text)} 字）`);
   const lc = await loadCase(ctx, io, flags.task);
   if (lc.fail !== undefined) return lc.fail;
@@ -411,14 +412,6 @@ async function cmdStatement(ctx, io) {
     lines.push(`${STATEMENT_TIP}双方会看到你的原文，换行和分段都会保留。`);
     if (out.statement.review_opened) lines.push('双方都已陈述，审理已提前开始。');
   }
-  if (evid.evidence.length) {
-    const order = await libraAddEvidence(ctx.baseUrl, ctx.credOpts, caseId, evid.evidence, undefined, { fetchImpl: ctx.fetchImpl });
-    out.evidence_order = order;
-    const url = cashierUrl(ctx, order);
-    lines.push(`补充关键证据需要你支付 ${yuan(order.amount_cents)}（计费证据由补充方承担，不退还），订单号 ${order.order_no || order.order_id}`);
-    if (url) lines.push(`收银台：${url}`);
-    lines.push('支付成功后证据才会进入案卷。');
-  }
   return io.ok({ case_id: caseId, ...out }, lines.join('\n'));
 }
 
@@ -476,11 +469,10 @@ async function cmdAccept(ctx, io) {
 async function cmdReviewQuote(ctx, io) {
   const { flags } = ctx;
   if (!flags.task) return io.fail(2, 'missing_task', '缺少 --task <task-id>');
-  const ev = evidenceInputs(flags, io);
-  if (ev.fail !== undefined) return ev.fail;
+  if (flags.evidence.length) return io.fail(2, 'evidence_closed', EVIDENCE_CLOSED_MSG);
   const lc = await loadCase(ctx, io, flags.task);
   if (lc.fail !== undefined) return lc.fail;
-  const q = await libraReviewQuote(ctx.baseUrl, ctx.credOpts, lc.caseView.id, { evidence: ev.evidence }, { fetchImpl: ctx.fetchImpl });
+  const q = await libraReviewQuote(ctx.baseUrl, ctx.credOpts, lc.caseView.id, {}, { fetchImpl: ctx.fetchImpl });
   saveQuote(ctx.credOpts, q.quote_id, {
     kind: 'review', task_id: flags.task, case_id: lc.caseView.id, points: flags.points || null,
     total_cents: q.total_cents, expires_at: q.expires_at,
@@ -545,9 +537,9 @@ async function earlyCloseOf(ctx, caseId, caseView) {
 
 /** What happens to the service fee, in one sentence (decision values: refund / keep / free). */
 function feeSentence(decision) {
-  if (decision === 'refund') return '审理尚未开始，服务费原路退回。';
-  if (decision === 'free') return '本案系统送入，不收服务费。';
-  return '服务费不退还。';
+  if (decision === 'refund') return '审理尚未开始，审理费原路退回。';
+  if (decision === 'free') return '本案系统送入，不收审理费。';
+  return '审理费不退还。';
 }
 
 function closedText(res, head) {

package/src/multipart-upload.js

@@ -0,0 +1,116 @@
+// Chunked direct upload for big files (v0.30.8, CLI).
+//
+// Files above MULTIPART_THRESHOLD are not read into memory: they are cut into parts of the size the platform asks
+// for, sent a few at a time straight to storage, and each part is retried on its own. A break in the middle costs
+// only the part that was in flight, never the whole file.
+import { open } from 'node:fs/promises';
+import { authedPostWithRefresh } from './api.js';
+
+/** Files above this go through the chunked upload; smaller ones keep the single PUT. Same number as the platform. */
+export const MULTIPART_THRESHOLD = 16 * 1024 * 1024;
+const CONCURRENCY = 3;
+const PART_RETRIES = 4;
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+function call(baseUrl, credOpts, fetchImpl, action, body) {
+  return authedPostWithRefresh(baseUrl, `/api/v1/uploads/multipart/${action}`, credOpts, body, null, { fetchImpl });
+}
+
+/**
+ * Upload one registered file (POST /uploads already gave its file_id) in parts.
+ *
+ * @param {object} p { baseUrl, credOpts, fetchImpl?, putFetch?, fileId, absPath, size, filename, progress?(msg), makeError(msg) }
+ * @throws whatever makeError builds, with a Chinese message
+ */
+export async function uploadMultipart(p) {
+  const { baseUrl, credOpts, fetchImpl, fileId, absPath, size, filename, makeError } = p;
+  const putFetch = p.putFetch || fetchImpl || globalThis.fetch;
+  const progress = p.progress || (() => {});
+  const base = { file_id: fileId };
+
+  let init;
+  try {
+    init = await call(baseUrl, credOpts, fetchImpl, 'init', base);
+  } catch (e) {
+    if (e && e.upgradeRequired) throw e;
+    throw makeError(`开始分片上传 ${filename} 失败：${e && e.message ? e.message : e}`);
+  }
+  const uploadId = init.upload_id;
+  const partSize = init.part_size;
+  const count = init.part_count;
+  const numbers = Array.from({ length: count }, (_, i) => i + 1);
+
+  const urls = {};
+  const sign = async (nums) => {
+    for (let i = 0; i < nums.length; i += 100) {
+      const r = await call(baseUrl, credOpts, fetchImpl, 'sign', { ...base, upload_id: uploadId, part_numbers: nums.slice(i, i + 100) });
+      Object.assign(urls, r.urls);
+    }
+  };
+  const etags = {};
+  const fh = await open(absPath, 'r');
+  let done = 0;
+  try {
+    await sign(numbers);
+
+    const sendPart = async (n) => {
+      const start = (n - 1) * partSize;
+      const len = Math.min(partSize, size - start);
+      const buf = Buffer.alloc(len);
+      await fh.read(buf, 0, len, start);
+      let lastMsg = '';
+      for (let attempt = 0; attempt <= PART_RETRIES; attempt += 1) {
+        try {
+          const resp = await putFetch(urls[String(n)], { method: 'PUT', body: buf });
+          if (resp.ok) {
+            const etag = resp.headers && resp.headers.get ? resp.headers.get('etag') : null;
+            if (etag) etags[String(n)] = etag.replace(/"/g, ''); // complete wants the bare value
+            done += 1;
+            progress(`上传 ${filename}：${done}/${count} 片`);
+            return;
+          }
+          lastMsg = `存储返回 ${resp.status}`;
+          if (resp.status === 403) await sign([n]); // the part address went stale: ask for a fresh one
+        } catch (netErr) {
+          lastMsg = `网络错误：${netErr && netErr.message ? netErr.message : netErr}`;
+        }
+        if (attempt < PART_RETRIES) await sleep(Math.min(8000, 1000 * 2 ** attempt));
+      }
+      throw makeError(`上传 ${filename} 的第 ${n} 片失败（${lastMsg}）。可重新运行同一条命令。`);
+    };
+
+    // worker pool: each worker takes the next unsent part
+    const queue = numbers.slice();
+    let failure = null;
+    const worker = async () => {
+      while (!failure) {
+        const n = queue.shift();
+        if (n === undefined) return;
+        try { await sendPart(n); } catch (e) { failure = e; return; }
+      }
+    };
+    await Promise.all(Array.from({ length: Math.min(CONCURRENCY, count) }, worker));
+    if (failure) throw failure;
+
+    // an ETag the storage did not let us read is taken from the server's list of stored parts
+    if (numbers.some((n) => !etags[String(n)])) {
+      const listed = await call(baseUrl, credOpts, fetchImpl, 'parts', { ...base, upload_id: uploadId });
+      for (const part of listed.parts || []) {
+        if (!etags[String(part.part_number)]) etags[String(part.part_number)] = part.etag;
+      }
+    }
+    const parts = numbers.map((n) => ({ part_number: n, etag: etags[String(n)] }));
+    if (parts.some((x) => !x.etag)) throw makeError(`上传 ${filename} 没有传完整，请重新运行同一条命令。`);
+    try {
+      await call(baseUrl, credOpts, fetchImpl, 'complete', { ...base, upload_id: uploadId, parts });
+    } catch (e) {
+      throw makeError(`合并 ${filename} 失败：${e && e.message ? e.message : e}。可重新运行同一条命令。`);
+    }
+  } catch (e) {
+    try { await call(baseUrl, credOpts, fetchImpl, 'abort', { ...base, upload_id: uploadId }); } catch { /* the platform clears leftovers by itself */ }
+    throw e;
+  } finally {
+    await fh.close();
+  }
+}

package/src/refund-commands.js

@@ -158,7 +158,7 @@ export function describeNegotiation(ctx, view, taskId) {
     } else {
       const c = n.closed || {};
       lines.push(`  状态：已结束（${KIND_WORDS[c.kind] || n.status}）`);
-      if (c.refund_pct != null) lines.push(`  退还比例：${c.refund_pct}%${n.amounts ? `（退还 ${money(view, n.amounts.refund_cents)}，结算给接单方 ${money(view, n.amounts.release_cents)}）` : ''}`);
+      if (c.refund_pct != null) lines.push(`  退还比例：${c.refund_pct}%${n.amounts ? `（退还 ${money(view, n.amounts.refund_cents)}，结算给接单方 ${money(view, n.amounts.release_cents)}${n.amounts.release_net_cents != null ? `，扣掉平台服务费和同款分成后接单方预计到手 ${money(view, n.amounts.release_net_cents)}` : ''}）` : ''}`);
       if (c.kind === 'court') lines.push('  已转入 AI 法庭裁决，请用 anytowork libra status 看进展。');
     }
     if ((n.entries || []).length) lines.push('  记录：', ...n.entries.map((en) => entryLine(view, en)));