dsh-zotero-skill 0.5.1 → 0.5.4

package/package.json

@@ -1,60 +1,60 @@
-{
-  "name": "dsh-zotero-skill",
-  "version": "0.5.1",
-  "description": "Zotero skill for DeepSeek Harness: find papers on OpenAlex or Crossref, import Chinese CNKI export files, track research fronts, screen core papers, manage and classify the library, batch-read, map the landscape, and surface research gaps. Also exports BibTeX and cites into LaTeX/Markdown.",
-  "type": "module",
-  "main": "lib/index.js",
-  "exports": {
-    ".": "./lib/index.js",
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "lib/**/*.js",
-    "zotero/**",
-    "docs/**",
-    "!**/__pycache__/**",
-    "!**/*.pyc",
-    "cordis.patch.yml",
-    "README.md",
-    "LICENSE",
-    "NOTICE.md"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    }
-  },
-  "scripts": {
-    "test": "node --test test/*.test.mjs",
-    "prepublishOnly": "node --test test/*.test.mjs"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Eason-0712/dsh-zotero-skill.git"
-  },
-  "homepage": "https://github.com/Eason-0712/dsh-zotero-skill#readme",
-  "bugs": {
-    "url": "https://github.com/Eason-0712/dsh-zotero-skill/issues"
-  },
-  "keywords": [
-    "dsh",
-    "dsh-plugin",
-    "deepseek-harness",
-    "zotero",
-    "skill",
-    "bibtex",
-    "citation",
-    "literature-review",
-    "openalex",
-    "crossref",
-    "cnki",
-    "research"
-  ]
-}
+{
+  "name": "dsh-zotero-skill",
+  "version": "0.5.4",
+  "description": "Zotero skill for DeepSeek Harness: find papers on OpenAlex or Crossref, import Chinese CNKI export files, track research fronts, screen core papers, manage and classify the library, batch-read, map the landscape, and surface research gaps. Also exports BibTeX and cites into LaTeX/Markdown.",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/**/*.js",
+    "zotero/**",
+    "docs/**",
+    "!**/__pycache__/**",
+    "!**/*.pyc",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE",
+    "NOTICE.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "prepublishOnly": "node --test test/*.test.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Eason-0712/dsh-zotero-skill.git"
+  },
+  "homepage": "https://github.com/Eason-0712/dsh-zotero-skill#readme",
+  "bugs": {
+    "url": "https://github.com/Eason-0712/dsh-zotero-skill/issues"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "zotero",
+    "skill",
+    "bibtex",
+    "citation",
+    "literature-review",
+    "openalex",
+    "crossref",
+    "cnki",
+    "research"
+  ]
+}

package/zotero/references/focused-reading.md

@@ -51,7 +51,7 @@ read ask --jobs read-A read-B --question "两个方法的泛化设定有什么
 }
 ```
 
-`read audit <job>` 检查已有译文的术语、数字和疑似未翻译段。数字检查会正规化百分比、千分位和小数；对引用号变化或主动单位换算可能需要人工判断。`read accept --strict` 可要求这些线索均处理完再接受。一般接受仍会记录线索，不能因此宣称科学正确性已经验证。
+`read audit <job>` 检查已有译文的术语、数字和疑似未翻译段。数字检查会正规化百分比、千分位和小数；对引用号变化或主动单位换算可能需要人工判断。`read status <job>` 只内联前 40 条线索并给出 `translation_audit_total`，完整列表由 `read audit` 提供——线索多时先看总数再决定是否逐条核对。`read accept --strict` 可要求这些线索均处理完再接受。一般接受仍会记录线索，不能因此宣称科学正确性已经验证。
 
 ## 纠错与历史
 

package/zotero/references/reading-workflow.md

@@ -31,6 +31,8 @@
 
 将结果写入一个 UTF-8 JSON 文件，然后执行 `read accept <job> --input result.json`。可分批接受并恢复；普通接受不可覆盖旧结果，新增解释用新的 claim id。需要更正已有译文或结论时使用带 expected-revision 和原因的 `read revise`，并保留历史，详见 focused-reading.md。
 
+`read status <job>` 与 `read accept` 统计的是「已接受快照 + 之后写入的分块结果」：子任务写出的 `t-*.json` 即使还没单独提交，也会被算进译文与结论数量，不会被上一次快照盖住，因此可以分批交付、边写边看。已接受的内容始终优先，后写入的分块不会覆盖它；两个尚未接受的分块互相矛盾时仍会报 `Conflicting translations`，需要先改掉其中一个再接受。
+
 ```json
 {
   "source_hash": "prepare返回的精确SHA256",

package/zotero/scripts/paper_reader/cli.py

@@ -161,7 +161,8 @@ def run(action, args, api):
     if action == "history":
         return jobs.history(args.job)
     if action == "audit":
-        return {"issues": jobs.inspect(args.job)["translation_audit"], "note": "Deterministic checks identify review candidates, not scientific correctness"}
+        issues = jobs.audit(args.job)
+        return {"issues": issues, "total": len(issues), "note": "Deterministic checks identify review candidates, not scientific correctness"}
     if action == "outline":
         return jobs.outline(args.job)
     if action == "annotations":

package/zotero/scripts/paper_reader/jobs.py

@@ -17,6 +17,7 @@ CATEGORIES = {"overview": "研究问题与章节逻辑", "method": "方法与结
               "implementation": "实现与复现"}
 KINDS = {"reported", "interpretation", "proposal"}
 KIND_LABELS = {"reported": "原文报告", "interpretation": "分析解释", "proposal": "待验证建议"}
+AUDIT_INLINE_LIMIT = 40
 
 
 def now():
@@ -176,34 +177,73 @@ def result_store(directory):
 
 
 def aggregate(directory):
-    current = s.read(result_store(directory) / "current.json")
+    """Merge the accepted snapshot with the chunk results written since it.
+
+    The snapshot stays authoritative: it is what someone explicitly accepted, so
+    a later chunk row never silently replaces an accepted translation or claim.
+    Chunk rows only fill in what the snapshot does not cover yet, which is the
+    normal flow after `read accept` was called with partial results — ignoring
+    them made `read accept` report `translations: 0` for work that had already
+    been written to disk.
+    """
+    store = result_store(directory)
+    current = s.read(store / "current.json")
+    translations, claims, missing = {}, {}, {}
+    accepted_blocks, accepted_claims = set(), set()
     if current is not None:
         payload = current["payload"]
         content_hash = s.digest(payload)
         if content_hash != current.get("content_hash") or s.digest({"content_hash": content_hash, "previous": current.get("previous")}) != current.get("revision"):
             raise ValueError("Accepted result snapshot was modified; restore a verified revision")
-        return ({r["block_id"]: r["text"] for r in payload["translations"]}, payload["claims"], payload["missing"])
-    translations, claims, missing = {}, {}, {}
-    for path in sorted(result_store(directory).glob("*.json")):
+        translations = {r["block_id"]: r["text"] for r in payload["translations"]}
+        claims = {c["id"]: c for c in payload["claims"]}
+        missing = dict(payload["missing"])
+        accepted_blocks.update(translations)
+        accepted_claims.update(claims)
+    for path in sorted(store.glob("*.json")):
+        if path.name == "current.json":
+            continue
         record = s.read(path)
+        if not isinstance(record, dict):
+            continue
         for row in record.get("translations", []):
-            old = translations.get(row["block_id"])
-            if old is not None and old != row["text"]:
-                raise ValueError(f"Conflicting translations for {row['block_id']}")
-            translations[row["block_id"]] = row["text"]
+            block_id = row["block_id"]
+            if block_id in translations:
+                if block_id not in accepted_blocks and translations[block_id] != row["text"]:
+                    raise ValueError(f"Conflicting translations for {block_id}")
+                continue
+            translations[block_id] = row["text"]
         for row in record.get("claims", []):
-            if row["id"] in claims and claims[row["id"]] != row:
-                raise ValueError(f"Conflicting claim id: {row['id']}")
-            claims[row["id"]] = row
-        missing.update(record.get("missing", {}))
+            key = row["id"]
+            if key in claims:
+                if key not in accepted_claims and claims[key] != row:
+                    raise ValueError(f"Conflicting claim id: {key}")
+                continue
+            claims[key] = row
+        for category, reason in record.get("missing", {}).items():
+            missing.setdefault(category, reason)
     return translations, list(claims.values()), missing
 
 
 def result_revision(directory):
     translations, claims, missing = aggregate(directory)
     current = s.read(result_store(directory) / "current.json")
+    payload = result_payload(translations, claims, missing)
+    if current is not None and s.digest(payload) == current.get("content_hash"):
+        return current["revision"]
+    return s.digest(payload)
+
+
+def base_revision(directory):
+    """The revision a new snapshot should build on.
+
+    Pending chunk results are not a revision yet, so the chain keeps pointing at
+    the last accepted snapshot instead of at a hash that was never committed.
+    """
+    current = s.read(result_store(directory) / "current.json")
     if current is not None:
         return current["revision"]
+    translations, claims, missing = aggregate(directory)
     return s.digest(result_payload(translations, claims, missing))
 
 
@@ -228,7 +268,10 @@ def commit_results(directory, payload, previous, reason):
 def history(job_id):
     directory, _ = load(job_id)
     store = result_store(directory)
-    revision = result_revision(directory)
+    # Walk the accepted snapshots only: pending chunk rows are merged by aggregate()
+    # but are not revisions, so starting from result_revision() would look for a
+    # history file that does not exist and return an empty chain.
+    revision = base_revision(directory)
     result, visited = [], set()
     while revision not in visited:
         visited.add(revision)
@@ -292,7 +335,7 @@ def accept(job_id, record, *, strict=False):
     result = validate(record, manifest, document)
     with s.lock(directory), s.lock(result_store(directory)):
         previous_t, previous_c, previous_missing = aggregate(directory)
-        previous_revision = result_revision(directory)
+        previous_revision = base_revision(directory)
         old_claims = {c["id"]: c for c in previous_c}
         for row in result["translations"]:
             if row["block_id"] in previous_t and previous_t[row["block_id"]] != row["text"]:
@@ -327,7 +370,7 @@ def revise(job_id, record, expected_revision, reason):
         missing.update(result["missing"])
         for claim in by_id.values():
             missing.pop(claim["category"], None)
-        commit_results(directory, result_payload(translations, list(by_id.values()), missing), expected_revision, reason)
+        commit_results(directory, result_payload(translations, list(by_id.values()), missing), base_revision(directory), reason)
     return inspect(job_id)
 
 
@@ -341,10 +384,21 @@ def inspect(job_id):
     categories = set(CATEGORIES) if manifest["settings"]["mode"] == "deep" else {"overview", "method", "experiment", "contribution", "limitation"}
     absent = sorted(categories - {c["category"] for c in claims} - set(missing)) if outputs & {"notes", "zotero-note", "annotated-pdf"} else []
     unreadable = [p["number"] for p in document["pages"] if not p["readable"]]
+    issues = quality.audit(document, translations, manifest["profile"])
     return {"id": job_id, "revision": result_revision(directory), "translations": len(translations), "claims": len(claims),
             "untranslated_blocks": untranslated, "uncovered_categories": absent,
             "unreadable_pages": unreadable, "ready": not (untranslated or absent or unreadable),
-            "warnings": document["warnings"], "translation_audit": quality.audit(document, translations, manifest["profile"])}
+            "warnings": document["warnings"], "translation_audit": issues[:AUDIT_INLINE_LIMIT],
+            "translation_audit_total": len(issues),
+            "translation_audit_note": "status 只列出前 %d 条，完整列表用 read audit" % AUDIT_INLINE_LIMIT if len(issues) > AUDIT_INLINE_LIMIT else ""}
+
+
+def audit(job_id):
+    """Every deterministic review hint, for `read audit`."""
+    directory, manifest = load(job_id)
+    document = s.read(manifest["document"])
+    translations, _, _ = aggregate(directory)
+    return quality.audit(document, translations, manifest["profile"])
 
 
 def source_link(manifest, page, annotation_key=None):