@runweave/server-linux-x64 0.1.8 → 0.1.9

package/payload/plugins/toolkit/skills/daily-record/scripts/job.py

@@ -0,0 +1,416 @@
+#!/usr/bin/env python3
+"""One local Daily Record workflow, reused by scheduled Agents on every machine."""
+import argparse
+import datetime as dt
+import hashlib
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import time
+from types import SimpleNamespace
+import uuid
+
+sys.dont_write_bytecode = True
+from job_state import Failure, State, config, date, digest, directory, process_identity, read, require, scopes, stamp, window, write, browser_enabled, screen_enabled, materials_enabled, migrate_sources
+import job_isolation
+import job_facts
+import job_screen
+
+
+def suiji_module():
+    location = Path(__file__).resolve().parents[2] / "suiji" / "scripts"
+    require((location / "suiji.py").is_file(), "SUIJI_SKILL_REQUIRED: install the matching suiji skill")
+    sys.path.insert(0, str(location))
+    import suiji
+    return suiji
+
+
+def command(argv, accepted=(0,)):
+    try:
+        result = subprocess.run(argv, capture_output=True, text=True, timeout=600, check=False)
+    except (OSError, subprocess.TimeoutExpired):
+        raise Failure("COLLECTOR_UNAVAILABLE_OR_TIMEOUT") from None
+    require(result.returncode in accepted, "COLLECTION_FAILED: inspect the private source manifest")
+    return result
+
+
+def adapter_receipts(c, day, rows, receipts, errors):
+    suiji_module()  # Loads only helpers; no connection or credentials are opened.
+    import source_adapter
+    results = []
+    for actual in receipts:
+        scope = actual["sourceScope"]
+        if actual["status"] != "complete" and not errors.get(scope):
+            errors[scope] = ["SOURCE_" + actual["status"].upper()]
+        selected = [r for r in rows if r["day"] == day and r["ref"]["sourceScope"] == scope]
+        effective = c["sources"]["screen"]["effectiveFrom"] if scope.startswith("screen:") else c["startDate"]
+        args = ("work", scope, actual["from"], actual["to"], effective, actual["collectedAt"])
+        try:
+            items = [{"id": r["anchor"] + ":" + r["role"] if r["ref"]["channel"] == "local-agent" else r["id"],
+                      "version": r["sourceVersion"], "occurredAt": r["occurredAt"]} for r in selected]
+            result = source_adapter.receipt(*args, actual["status"], items, errors.get(scope, []))
+        except (ValueError, KeyError, TypeError):
+            # An invalid adapter cannot invalidate evidence from another source.
+            rows[:] = [r for r in rows if not (r["day"] == day and r["ref"]["sourceScope"] == scope)]
+            actual.update(status="unavailable", collectedAt=stamp(), **window(day))
+            errors[scope] = ["INVALID_ADAPTER_RESULT"]
+            result = source_adapter.receipt("work", scope, actual["from"], actual["to"], effective, actual["collectedAt"], "unavailable", [], errors[scope])
+        results.append(result)
+    return results
+
+
+def collect(state, path, meta):
+    c = state.c
+    rows, meta["receipts"], meta["sourceDirs"] = [], {}, {}
+    meta["sourceErrors"], meta["adapterReceipts"] = {}, {}
+    for day in meta["days"]:
+        day_root = directory(path / (day + "-g" + str(meta["generation"])))
+        meta["sourceDirs"][day] = str(day_root)
+        receipts, errors = [], {}
+        local = c["sources"]["localAgent"]
+        for provider in local["providers"]:
+            bundle = day_root / ("agent-" + provider)
+            scope = "agent:" + c["producerId"] + ":" + provider
+            argv = c["collectorArgv"] + ["collect", "--from", day, "--to", day, "--timezone", c["timeZone"], "--out", str(bundle), "--providers", provider, "--machine-id", c["producerId"]]
+            if local.get("home"):
+                argv += ["--home", local["home"]]
+            for thread in state.data["excludedThreads"]:
+                argv += ["--exclude-thread", thread]
+            try:
+                command(argv, (0, 2))
+                material, actual = job_facts.native_rows(bundle, c, day)
+                require(len(actual) == 1 and actual[0]["sourceScope"] == scope and all(m["ref"]["sourceScope"] == scope for m in material), "AGENT_SOURCE_IDENTITY_CHANGED")
+                rows.extend(material)
+                receipts.extend(actual)
+            except (Failure, OSError, ValueError, KeyError, TypeError) as error:
+                errors[scope] = [str(error) if isinstance(error, Failure) else "INVALID_SOURCE_DATA"]
+                receipts.append({"sourceScope": scope, "status": "unavailable", "collectedAt": stamp(), **window(day)})
+        if c["sources"]["feishu"]["enabled"]:
+            bundle = day_root / "feishu"
+            try:
+                command([sys.executable, str(Path(__file__).with_name("feishu.py")), "discover", "--from", day, "--to", day, "--channels", "messages", "--timezone", c["timeZone"], "--out", str(bundle)], (0, 2))
+                material, receipt, identity = job_facts.feishu_rows(bundle, day, c)
+                require(identity and identity.get("openId"), "FEISHU_IDENTITY_UNAVAILABLE")
+                previous = state.data.get("feishuIdentity")
+                require(previous in (None, identity["openId"]), "FEISHU_IDENTITY_CHANGED")
+                state.data["feishuIdentity"] = identity["openId"]
+                rows.extend(material)
+                receipts.append(receipt)
+            except (Failure, OSError, ValueError, KeyError, TypeError) as error:
+                scope = "feishu:" + c["sources"]["feishu"]["accountScope"] + ":messages"
+                errors[scope] = [str(error) if isinstance(error, Failure) else "INVALID_SOURCE_DATA"]
+                receipts.append({"sourceScope": scope, "status": "unavailable", "collectedAt": stamp(), **window(day)})
+        if screen_enabled(c, day):
+            bundle = day_root / "screen"
+            try:
+                job_screen.export(c, day, bundle)
+                material, receipt, revision = job_screen.rows(bundle, day, c)
+                rows.extend(material)
+                receipts.append(receipt)
+                meta.setdefault("screenRevisions", {})[day] = revision
+            except (Failure, OSError, ValueError, KeyError, TypeError):
+                receipts.append(job_screen.unavailable(day, c))
+        reports = adapter_receipts(c, day, rows, receipts, errors)
+        write(day_root / "adapter-receipts.json", reports)
+        meta["adapterReceipts"][day] = str(day_root / "adapter-receipts.json")
+        meta["sourceErrors"][day] = errors
+        meta["receipts"][day] = receipts
+    write(path / "evidence.json", rows)
+    meta.update(phase="reviewed", evidenceHash=digest(rows), read={}, imageReads={})
+    template(path, meta)
+
+
+def template(path, meta):
+    write(path / "facts.template.json", {"batchId": meta["id"], "generation": meta["generation"], "evidenceHash": meta["evidenceHash"], "days": [{"date": d, "items": []} for d in meta["days"]]})
+
+
+def prepare(state, args):
+    require(args.thread_id not in state.data.get("forbiddenWorkThreads", []), "NEW_WORK_CONTEXT_REQUIRED")
+    require(args.run_id and args.thread_id and args.owner_pid and args.owner_pid > 1, "RUN_THREAD_AND_AGENT_PID_REQUIRED")
+    owner = process_identity(args.owner_pid)
+    require(owner, "OWNER_PROCESS_NOT_RUNNING")
+    require(state.data.get("workIsolationVersion") == 1 or not state.data.get("identities"), "LEGACY_IDENTITIES_REQUIRE_ISOLATE_WORK")
+    state.data["workIsolationVersion"] = 1
+    active = state.data.get("active")
+    if active:
+        path = Path(state.data["batches"][active]["path"])
+        meta = read(path / "batch.json")
+        require(meta.get("workIsolationVersion") == 1, "LEGACY_BATCH_REQUIRES_ISOLATE_WORK")
+        # batch.json is the durable journal if a process exits before state.json commits.
+        if meta.get("identitySnapshot") is not None:
+            state.data["identities"] = meta["identitySnapshot"]
+        state.data["days"].update(meta.get("confirmations", {}))
+        if meta["phase"] == "confirmed":
+            state.data["active"] = None
+            return prepare(state, args)
+        same_owner = meta["ownerPid"] == args.owner_pid and meta["ownerProcess"] == owner
+        # A scheduled continuation retains its run ID but starts a new process.
+        if meta["runId"] != args.run_id or not same_owner:
+            require(not (process_identity(meta["ownerPid"]) == meta["ownerProcess"]), "BUSY: original Agent is still active")
+            require(args.recover_run_id == meta["runId"], "EXPLICIT_RECOVERY_REQUIRED")
+            meta.update(runId=args.run_id, generation=meta["generation"] + 1, ownerPid=args.owner_pid, ownerProcess=owner)
+            if "evidenceHash" in meta:
+                template(path, meta)
+    else:
+        job_screen.reconcile_revisions(state)
+        days = state.missing()[:state.c["maxDaysPerRun"]]
+        if days:
+            days = [d for d in days if (date(d) - date(days[0])).days < 366]
+        if not days:
+            return {"complete": True, "remainingDays": []}
+        batch = str(uuid.uuid4())
+        path = directory(directory(state.root / "batches") / batch)
+        meta = {"workIsolationVersion": 1, "id": batch, "phase": "prepared", "days": days, "runId": args.run_id, "generation": 1,
+                "ownerPid": args.owner_pid, "ownerProcess": owner, "sentDays": [], "pending": None}
+        state.data["active"] = batch
+    if args.recollect:
+        require(not meta.get("pending") and not meta["sentDays"], "PUBLISHED_OR_PENDING_BATCH_CANNOT_BE_RECOLLECTED")
+        meta.update(phase="prepared", generation=meta["generation"] + 1)
+    if args.thread_id not in state.data["excludedThreads"]:
+        state.data["excludedThreads"].append(args.thread_id)
+    # Persist ownership before subprocess collection, including interruptions.
+    state.save_batch(path, meta)
+    write(state.file, state.data)
+    if meta["phase"] in ("prepared", "collecting"):
+        meta["phase"] = "collecting"
+        state.save_batch(path, meta)
+        try:
+            collect(state, path, meta)
+        except Exception:
+            meta["phase"] = "collection-failed"
+            state.save_batch(path, meta)
+            raise
+    require(meta["phase"] != "collection-failed", "COLLECTION_INTERRUPTED: recover with a new run and --recollect")
+    state.save_batch(path, meta)
+    return {"batch": str(path), "runId": meta["runId"], "generation": meta["generation"], "phase": meta["phase"],
+            "template": str(path / "facts.template.json"), "receipts": meta.get("receipts"), "priorFacts": state.data["identities"],
+            "adapterReceipts": meta.get("adapterReceipts", {}),
+            "next": "reconcile" if meta.get("pending") else "publish" if meta["phase"] in ("validated", "pending") else "review/read then validate/publish", "remainingDays": state.missing()}
+
+
+def confirm(state, path, meta, suiji):
+    pending = meta["pending"]
+    request, receipt = Path(pending["request"]), Path(pending["receipt"])
+    if request.exists():
+        intent = read(request)
+        require(digest(intent) == pending["hash"], "FROZEN_REQUEST_CHANGED")
+        recovery_args = SimpleNamespace(job_config=state.config_path, request=str(request), config=state.c["suiji"]["configPath"])
+        connection = json.loads(suiji.private_read(recovery_args.config))
+        frozen = suiji.work_records.recovery_intent(recovery_args, connection, suiji.Failure, suiji.private_read)
+        client, info = suiji.connect(connection, state.c["suiji"]["tokenFile"])
+        require(info.get("features", {}).get("workRecords"), "WORK_RECORDS_UNAVAILABLE")
+        if any(scope.startswith("screen:") for day in frozen["arguments"]["input"]["days"] for scope in day["requestedScopes"]):
+            require(info.get("features", {}).get("workScreenTimeline"), "SCREEN_TIMELINE_UNAVAILABLE")
+        try:
+            suiji.work_records.reconcile(client, str(request), frozen, suiji.Failure, suiji.run_intent)
+        except suiji.Failure as error:
+            if str(error) in ("WORK_FEED_CHANGED", "VERSION_CONFLICT"):
+                os.rename(request, str(request) + ".rejected")
+                meta["pending"] = None
+                if str(error) == "VERSION_CONFLICT":
+                    meta["days"] = [d for d in meta["days"] if d not in meta["sentDays"]]
+                    meta["sentDays"] = []
+                    meta["phase"] = "collection-failed"
+                else:
+                    meta["phase"] = "validated"
+                state.save_batch(path, meta)
+            raise
+    result = read(receipt)
+    require(result.get("importId"), "INVALID_IMPORT_RECEIPT")
+    # run_intent persisted this receipt only after its independent readback.
+    for day in pending["days"]:
+        state.data["days"][day] = {"complete": all(r["status"] == "complete" for r in meta["receipts"][day]), "receipts": meta["receipts"][day], "importId": result["importId"]}
+        if day in meta.get("screenRevisions", {}):
+            state.data["days"][day]["screenRevision"] = meta["screenRevisions"][day]
+        meta.setdefault("confirmations", {})[day] = state.data["days"][day]
+        if day not in meta["sentDays"]:
+            meta["sentDays"].append(day)
+    meta["pending"] = None
+    state.save_batch(path, meta)
+    return result
+
+
+def publish(state, path, meta):
+    require(state.c["suiji"]["autoPublish"], "AUTO_PUBLISH_DISABLED")
+    require(meta["phase"] in ("validated", "pending"), "VALIDATED_BATCH_REQUIRED")
+    suiji = suiji_module()
+    job_isolation.assert_payload(read(path / "export.json"))
+    if meta.get("pending"):
+        confirm(state, path, meta, suiji)
+    payload = read(path / "export.json")
+    job_isolation.assert_payload(payload)
+    require(digest(payload) == meta["exportHash"], "VALIDATED_EXPORT_CHANGED")
+    connection = read(state.c["suiji"]["configPath"])
+    client, info = suiji.connect(connection, state.c["suiji"]["tokenFile"])
+    require(info.get("features", {}).get("workRecords"), "WORK_RECORDS_UNAVAILABLE")
+    require(info.get("features", {}).get("workSources"), "WORK_SOURCES_UNAVAILABLE")
+    if any(scope.startswith("screen:") for day in payload["days"] for scope in day["requestedScopes"]):
+        require(info.get("features", {}).get("workScreenTimeline"), "SCREEN_TIMELINE_UNAVAILABLE")
+    source_page = client.call("list_work_sources", {"from": meta["days"][0], "to": meta["days"][-1]})
+    for day in meta["days"]:
+        for scope in scopes(state.c, day):
+            require(any(s["sourceScope"] == scope and s["sourceNamespace"] == state.c["sourceNamespace"] and s["producerId"] == state.c["producerId"] and s["effectiveFrom"] <= day and (not s["effectiveTo"] or s["effectiveTo"] > day) for s in source_page["items"]), "SOURCE_NOT_REGISTERED")
+    conflicts = 0
+    while len(meta["sentDays"]) < len(meta["days"]):
+        remaining = {**payload, "days": [d for d in payload["days"] if d["date"] not in meta["sentDays"]]}
+        if "materialResults" in payload:
+            remaining["materialResults"] = [r for r in payload["materialResults"] if meta["materialDates"][r["recordId"]] not in meta["sentDays"]]
+        remaining["sourceCollectedAt"] = max((r["collectedAt"] for d in remaining["days"] for r in d["receipts"]), key=lambda v: dt.datetime.fromisoformat(v.replace("Z", "+00:00")))
+        attempt = directory(path / ("publish-" + str(uuid.uuid4())))
+        write(attempt / "input.json", remaining)
+        args = SimpleNamespace(input=str(attempt / "input.json"), out=str(attempt / "prepared"), config=state.c["suiji"]["configPath"])
+        prepared = suiji.work_records.prepare(client, args, suiji.Failure, suiji.private_read, suiji.exclusive_write)
+        value = read(prepared["prepared"])
+        receipt = attempt / "receipt.json"
+        request = attempt / "request.json"
+        intent = {"identity": value["identity"], "operation": "import_work_facts", "arguments": {"idempotencyKey": str(uuid.uuid4()), "input": value["payload"]}, "indexPath": value["indexPath"], "receiptPath": str(receipt)}
+        suiji.exclusive_write(request, json.dumps(intent, ensure_ascii=False).encode())
+        meta["pending"] = {"request": str(request), "receipt": str(receipt), "hash": digest(intent), "days": [d["date"] for d in value["payload"]["days"]]}
+        meta["phase"] = "pending"
+        state.save_batch(path, meta)
+        write(state.file, state.data)
+        try:
+            confirm(state, path, meta, suiji)
+        except suiji.Failure as error:
+            if str(error) != "WORK_FEED_CHANGED":
+                raise
+            conflicts += 1
+            if conflicts >= 3:
+                raise
+            time.sleep(conflicts)
+    meta["phase"] = "confirmed"
+    state.data["active"] = None
+    state.save_batch(path, meta)
+    return {"confirmedDays": meta["sentDays"], "remainingDays": state.missing(), "complete": not state.missing()}
+
+
+def context(state, path, meta, args):
+    require(meta["phase"] == "reviewed" and state.c["sources"]["feishu"]["enabled"], "CONTEXT_NOT_ALLOWED")
+    require(args.date in meta["days"] and args.message_id, "CONTEXT_DAY_AND_SEED_REQUIRED")
+    source_dir = Path(meta["sourceDirs"][args.date])
+    bundle = source_dir / "feishu"
+    out = source_dir / ("context-" + str(uuid.uuid4()))
+    try:
+        command([sys.executable, str(Path(__file__).with_name("feishu.py")), "context", "--bundle", str(bundle), "--message-id", args.message_id, "--minutes", str(args.minutes), "--out", str(out)])
+        rows, receipt, identity = job_facts.feishu_rows(out, args.date, state.c)
+        require(identity and identity["openId"] == state.data["feishuIdentity"], "FEISHU_IDENTITY_CHANGED")
+    except (Failure, OSError, ValueError, KeyError, TypeError):
+        for r in meta["receipts"][args.date]:
+            if r["sourceScope"].startswith("feishu:"):
+                r.update(status="partial", collectedAt=stamp())
+        if meta.get("adapterReceipts", {}).get(args.date):
+            reports = adapter_receipts(state.c, args.date, job_facts.evidence(path, meta), meta["receipts"][args.date], meta.setdefault("sourceErrors", {}).setdefault(args.date, {}))
+            write(Path(meta["adapterReceipts"][args.date]), reports)
+        state.save_batch(path, meta)
+        raise
+    materials = job_facts.evidence(path, meta)
+    previous = {m["id"]: m for m in materials}
+    additions = {}
+    for row in rows:
+        existing = previous.get(row["id"], additions.get(row["id"]))
+        if existing is not None:
+            if any(value != row.get(key) for key, value in existing.items()):
+                for r in meta["receipts"][args.date]:
+                    if r["sourceScope"].startswith("feishu:"):
+                        r.update(status="partial", collectedAt=stamp())
+                if meta.get("adapterReceipts", {}).get(args.date):
+                    reports = adapter_receipts(state.c, args.date, materials, meta["receipts"][args.date], meta.setdefault("sourceErrors", {}).setdefault(args.date, {}))
+                    write(Path(meta["adapterReceipts"][args.date]), reports)
+                state.save_batch(path, meta)
+                raise Failure("FEISHU_MESSAGE_CHANGED: recollect instead of mixing snapshots")
+        else:
+            additions[row["id"]] = row
+    materials.extend(additions.values())
+    for r in meta["receipts"][args.date]:
+        if r["sourceScope"] == receipt["sourceScope"]:
+            r["collectedAt"] = receipt["collectedAt"]
+    if meta.get("adapterReceipts", {}).get(args.date):
+        reports = adapter_receipts(state.c, args.date, materials, meta["receipts"][args.date], meta.setdefault("sourceErrors", {}).setdefault(args.date, {}))
+        write(Path(meta["adapterReceipts"][args.date]), reports)
+    write(path / "evidence.json", materials)
+    meta["evidenceHash"] = digest(materials)
+    template(path, meta)
+    state.save_batch(path, meta)
+    return {"messages": len(rows), "template": str(path / "facts.template.json")}
+
+
+def main():
+    os.umask(0o077)
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("command", choices=["prepare", "review", "read", "context", "validate", "publish", "reconcile", "status", "migrate-sources", "image-read", "isolate-work"])
+    parser.add_argument("--config", required=True)
+    for name in ("batch", "facts", "run-id", "thread-id", "recover-run-id", "id", "date", "message-id", "next-config"):
+        parser.add_argument("--" + name)
+    parser.add_argument("--image-receipt")
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--verify-source", action="store_true")
+    parser.add_argument("--recollect", action="store_true")
+    parser.add_argument("--generation", type=int)
+    parser.add_argument("--owner-pid", type=int)
+    parser.add_argument("--offset", type=int, default=0)
+    parser.add_argument("--limit", type=int, default=30)
+    parser.add_argument("--max-chars", type=int, default=8000)
+    parser.add_argument("--minutes", type=int, default=30)
+    args = parser.parse_args()
+    c = config(args.config)
+    if args.command not in ("status", "isolate-work"):
+        require(read(c["suiji"]["configPath"]).get("mcpPath") == "/mcp/work", "WORK_ONLY_CREDENTIAL_REQUIRED")
+        require(not browser_enabled(c) and not materials_enabled(c), "BROWSING_SOURCES_MOVED: run isolate-work, then start a new work context")
+    if args.command == "status":
+        file = Path(c["stateDir"]) / "state.json"
+        stored = read(file) if file.exists() else {}
+        return {"producerId": c["producerId"], "sources": scopes(c), "days": stored.get("days", {}), "active": stored.get("active"), "batches": stored.get("batches", {})}
+    with State(c, migrating=args.command in ("migrate-sources", "isolate-work")) as state:
+        state.config_path = str(Path(args.config).resolve())
+        if args.command == "isolate-work":
+            return job_isolation.migrate(state, args.config, args.dry_run, suiji_module())
+        if args.command == "migrate-sources":
+            require(args.next_config, "NEXT_CONFIG_REQUIRED")
+            return migrate_sources(state, args.config, args.next_config, args.dry_run)
+        if args.command == "prepare":
+            return prepare(state, args)
+        require(args.batch and args.run_id and args.generation, "BATCH_OWNER_REQUIRED")
+        path, meta = state.batch(args)
+        require(meta.get("workIsolationVersion") == 1, "LEGACY_BATCH_REQUIRES_ISOLATE_WORK")
+        if args.command == "context":
+            return context(state, path, meta, args)
+        if args.command in ("review", "read", "image-read"):
+            materials = job_facts.evidence(path, meta)
+            require(args.offset >= 0 and 1 <= args.limit <= 100 and 1 <= args.max_chars <= 100000, "INVALID_READ_RANGE")
+            if args.command == "review":
+                selected = [m for m in materials if not args.date or m["day"] == args.date]
+                return {"total": len(selected), "items": [{k: v for k, v in m.items() if k not in ("text", "browserVisits", "browserBundle")} | {"preview": m["text"][:500], "truncated": len(m["text"]) > 500} for m in selected[args.offset:args.offset + args.limit]], "nextOffset": args.offset + args.limit if len(selected) > args.offset + args.limit else None}
+            m = next((m for m in materials if m["id"] == args.id), None)
+            require(m, "MATERIAL_NOT_FOUND")
+            require(args.command != "image-read" and not args.verify_source, "BROWSE_READ_REQUIRES_BROWSE_SKILL")
+            end = min(len(m["text"]), args.offset + args.max_chars)
+            require(args.offset <= len(m["text"]), "INVALID_READ_OFFSET")
+            seen = meta.setdefault("read", {}).get(m["id"], 0)
+            if args.offset <= seen:
+                meta["read"][m["id"]] = max(seen, end)
+            state.save_batch(path, meta)
+            return {**{k: v for k, v in m.items() if k not in ("text", "browserVisits", "browserBundle")}, "text": m["text"][args.offset:end], "offset": args.offset, "nextOffset": end if end < len(m["text"]) else None}
+        if args.command == "validate":
+            require(args.facts, "FACTS_REQUIRED")
+            result = job_facts.validate(path, meta, args.facts, state, suiji_module().work_records)
+            state.save_batch(path, meta)
+            return result
+        if args.command == "publish":
+            # The validated immutable export is the only publish input.
+            return publish(state, path, meta)
+        require(meta.get("pending"), "NO_PENDING_REQUEST")
+        require(c["suiji"]["autoPublish"], "AUTO_PUBLISH_DISABLED")
+        result = confirm(state, path, meta, suiji_module())
+        return {"receipt": result, "next": "publish to finish remaining days"}
+
+
+if __name__ == "__main__":
+    try:
+        print(json.dumps(main(), ensure_ascii=False))
+    except Exception as error:
+        # Never echo provider stderr, tokens or private input bodies.
+        known = isinstance(error, Failure) or type(error).__module__ == "suiji"
+        print(json.dumps({"ok": False, "error": str(error) if known else type(error).__name__}), file=sys.stderr)
+        sys.exit(1)

package/payload/plugins/toolkit/skills/daily-record/scripts/job_browser.py

@@ -0,0 +1,77 @@
+"""Read-only browser adapter: merge page visits locally, publish concise themes."""
+import datetime as dt
+import hashlib
+import json
+from pathlib import Path
+from urllib.parse import urlsplit
+from zoneinfo import ZoneInfo
+
+from job_state import digest, read, require, stamp, window
+
+
+MAX_THEMES = 3
+MAX_THEME_CHARS = 160
+
+
+def source_scope(c):
+    return "browser:" + c["producerId"] + ":observed"
+
+
+def rows(bundle, day, c):
+    manifest = read(bundle / "manifest.json")
+    raw = (bundle / "visits.jsonl").read_bytes()
+    require(hashlib.sha256(raw).hexdigest() == manifest["materialsSha256"], "BROWSER_MATERIALS_CHANGED")
+    require(manifest["schemaVersion"] == 1 and manifest["coverage"] == "observed-only" and manifest["from"] == day and manifest["to"] == day and manifest["timeZone"] == c["timeZone"], "INVALID_BROWSER_MANIFEST")
+    require(Path(manifest["sourceRoot"]).resolve() == Path(c["sources"]["browser"]["root"]).resolve(), "BROWSER_ROOT_CHANGED")
+    expected = set(c["sources"]["browser"]["expectedSourceIds"])
+    receipts = manifest["receipts"]
+    require({r["sourceId"] for r in receipts} == expected and len(receipts) == len(expected), "BROWSER_SOURCE_SET_CHANGED")
+    require(all(r["readStatus"] in ("complete", "partial", "unavailable") for r in receipts), "INVALID_BROWSER_RECEIPTS")
+    groups, identities = {}, set()
+    for line in raw.decode().splitlines():
+        material = json.loads(line)
+        visit = material["visit"]
+        require(visit["sourceId"] in expected and material["id"] == visit["sourceId"] + ":" + visit["visitId"] and material["id"] not in identities, "INVALID_BROWSER_IDENTITY")
+        identities.add(material["id"])
+        require(visit["schemaVersion"] == 1 and visit["actor"] == "unknown", "INVALID_BROWSER_OBSERVATION")
+        url = urlsplit(visit["url"])
+        require(url.scheme in ("http", "https") and not (url.query or url.fragment or url.username or url.password), "UNSAFE_BROWSER_URL")
+        occurred = dt.datetime.fromisoformat(visit["visitedAt"].replace("Z", "+00:00"))
+        require(occurred.tzinfo and occurred.astimezone(ZoneInfo(c["timeZone"])).date().isoformat() == day, "BROWSER_DAY_MISMATCH")
+        groups.setdefault(visit["url"], []).append(material)
+    result = []
+    for url, visits in sorted(groups.items()):
+        visits.sort(key=lambda m: m["id"])
+        page_key = hashlib.sha256(url.encode()).hexdigest()
+        titles = sorted({m["visit"]["title"] for m in visits if m["visit"]["title"]})
+        text = json.dumps({"url": url, "titles": titles, "browsers": sorted({m["visit"]["browser"] for m in visits}), "visits": len(visits), "actor": "unknown", "coverage": "observed-only"}, ensure_ascii=False)
+        ref = {"channel": "browser-visit", "sourceScope": source_scope(c), "nativeId": "page:" + page_key, "hash": digest([m["visit"] for m in visits])}
+        result.append({"id": "browser:" + day + ":" + page_key, "day": day, "role": "observation", "text": text,
+                       "anchor": source_scope(c) + ":" + day + ":" + page_key, "project": None,
+                       "ref": ref, "browserBundle": str(bundle), "browserVisits": visits})
+    statuses = [r["readStatus"] for r in receipts]
+    status = "complete" if all(s == "complete" for s in statuses) else "unavailable" if all(s == "unavailable" for s in statuses) else "partial"
+    if result and status == "unavailable":
+        status = "partial"
+    receipt = {"sourceScope": source_scope(c), "status": status, "collectedAt": manifest["collectedAt"], **window(day)}
+    return result, receipt
+
+
+def unavailable(day, c):
+    return {"sourceScope": source_scope(c), "status": "unavailable", "collectedAt": stamp(), **window(day)}
+
+
+def compact_ref(materials):
+    """One digest-backed reference per theme; every original visit stays local."""
+    visits = sorted((v for m in materials for v in m["browserVisits"]), key=lambda v: v["id"])
+    require(len({v["id"] for v in visits}) == len(visits), "DUPLICATE_BROWSER_VISITS")
+    ref = {"channel": "browser-visit", "sourceScope": materials[0]["ref"]["sourceScope"],
+           "nativeId": "visits:" + digest([v["id"] for v in visits]), "hash": digest([v["visit"] for v in visits])}
+    return ref, {"materialIds": [m["id"] for m in materials], "visits": visits, "ref": ref}
+
+
+def verify(material, c, command):
+    for visit in material["browserVisits"]:
+        response = command(c["sources"]["browser"]["collectorArgv"] + ["read", "--bundle", material["browserBundle"], "--id", visit["id"], "--verify-source"])
+        value = json.loads(response.stdout)
+        require(value.get("verifiedSource") is True and value["visit"] == visit["visit"] and value["locator"] == visit["locator"], "BROWSER_SOURCE_MISMATCH")

package/payload/plugins/toolkit/skills/daily-record/scripts/job_facts.py

@@ -0,0 +1,132 @@
+"""Bind cross-channel candidate facts to collected, read evidence and stable keys."""
+import copy
+import json
+from pathlib import Path
+import uuid
+
+from job_state import Failure, date, digest, read, require, scopes, window, write
+
+
+def evidence(path, meta):
+    value = read(path / "evidence.json")
+    require(digest(value) == meta["evidenceHash"], "MATERIALS_CHANGED")
+    require(all(m.get("ref", {}).get("channel") not in ("browser-visit", "suiji-material") and not any(m.get("ref", {}).get("sourceScope", "").startswith(p) for p in ("browser:", "materials:", "browse:")) for m in value), "BROWSING_INPUT_REJECTED: start a new work context")
+    return value
+
+
+def native_rows(bundle, c, day=None):
+    manifest = read(bundle / "manifest.json")
+    require(isinstance(manifest, dict), "INVALID_NATIVE_MANIFEST")
+    require(manifest.get("schemaVersion") == 1 and manifest.get("machineId") == c["producerId"] and manifest.get("timeZone") == c["timeZone"], "NATIVE_COLLECTION_IDENTITY_CHANGED")
+    require(manifest.get("from") == manifest.get("to") and (day is None or manifest["from"] == day), "NATIVE_COLLECTION_RANGE_CHANGED")
+    require(isinstance(manifest.get("sources"), list) and all(isinstance(r, dict) and r.get("status") in ("complete", "partial", "unavailable") for r in manifest["sources"]), "INVALID_NATIVE_RECEIPTS")
+    raw = (bundle / "materials.jsonl").read_bytes()
+    import hashlib
+    require(hashlib.sha256(raw).hexdigest() == manifest["materialsSha256"], "NATIVE_MATERIALS_CHANGED")
+    result = []
+    for line in raw.decode().splitlines():
+        m = json.loads(line)
+        require(m["day"] == manifest["from"], "NATIVE_DAY_MISMATCH")
+        require(hashlib.sha256(m["text"].encode()).hexdigest() == m["textSha256"], "NATIVE_TEXT_CHANGED")
+        scope = "agent:" + c["producerId"] + ":" + m["provider"]
+        project = m.get("project", {})
+        result.append({"id": "agent:" + m["id"], "day": m["day"], "role": m["role"], "text": m["text"],
+                       "occurredAt": m["occurredAt"], "sourceVersion": m["textSha256"],
+                       "anchor": scope + ":" + m["threadId"] + ":" + str(m.get("nativeId", m["locator"]["byteOffset"])),
+                       "threadId": m["threadId"], "origin": m["origin"], "phase": m.get("phase"),
+                       "project": c["projectAliases"].get(project.get("id"), project.get("name") if project.get("id") != "unclassified" else None),
+                       "ref": {"channel": "local-agent", "sourceScope": scope, "nativeId": m["threadId"], "hash": m["textSha256"]}})
+    receipts = [{"sourceScope": "agent:" + c["producerId"] + ":" + r["provider"], "status": r["status"],
+                 "collectedAt": manifest["collectedAt"], **window(manifest["from"])} for r in manifest["sources"]]
+    return result, receipts
+
+
+def feishu_rows(bundle, day, c):
+    manifest = read(bundle / "manifest.json")
+    path = bundle / "messages.json"
+    rows = read(path) if path.exists() else []
+    if rows:
+        import hashlib
+        require(hashlib.sha256(path.read_bytes()).hexdigest() == manifest["messagesSha256"], "FEISHU_MATERIALS_CHANGED")
+    result = []
+    scope = "feishu:" + c["sources"]["feishu"]["accountScope"] + ":messages"
+    from feishu import stamp as message_stamp
+    from zoneinfo import ZoneInfo
+    for m in rows:
+        when = message_stamp(m["create_time"], ZoneInfo("Asia/Shanghai")).astimezone(ZoneInfo("Asia/Shanghai"))
+        occurred = when.date().isoformat()
+        require(occurred == day, "FEISHU_DAY_MISMATCH")
+        text = m.get("content", "")
+        text = text if isinstance(text, str) else json.dumps(text, ensure_ascii=False)
+        result.append({"id": "feishu:" + m["message_id"], "day": day, "role": "user", "text": text,
+                       "occurredAt": when.isoformat(),
+                       "author": m.get("sender", {}).get("id"), "anchor": scope + ":" + m["message_id"], "project": None,
+                       "ref": {"channel": "feishu-message", "sourceScope": scope, "nativeId": m["message_id"], "hash": digest({"id": m["message_id"], "author": m.get("sender", {}).get("id"), "text": text, "day": occurred})}})
+        result[-1]["sourceVersion"] = result[-1]["ref"]["hash"]
+    receipt = {"sourceScope": scope, "status": "complete" if manifest["status"] == "complete" else "partial",
+               "collectedAt": manifest["collectedAt"], **window(day)}
+    return result, receipt, manifest.get("identity")
+
+
+def validate(path, meta, candidate_path, state, work_records):
+    require(meta["phase"] not in ("pending", "confirmed"), "BATCH_FROZEN")
+    materials = evidence(path, meta)
+    candidates = read(candidate_path)
+    require(isinstance(candidates, dict) and set(candidates) >= {"batchId", "generation", "evidenceHash", "days"} and not set(candidates) - {"batchId", "generation", "evidenceHash", "days", "materialReviews"}, "INVALID_FACTS_FIELDS")
+    require(candidates["batchId"] == meta["id"] and candidates["generation"] == meta["generation"] and candidates["evidenceHash"] == meta["evidenceHash"], "FACTS_BATCH_CHANGED")
+    require([d["date"] for d in candidates["days"]] == meta["days"], "FACT_DAYS_MISMATCH")
+    by_id = {m["id"]: m for m in materials}
+    read_ids = meta.get("read", {})
+    require(all(read_ids.get(m["id"], 0) >= len(m["text"]) for m in materials if m["role"] != "tool"), "UNREAD_MESSAGES: use job read, including all continuation chunks")
+    identities = copy.deepcopy(state.data["identities"])
+    exported = []
+    for day in candidates["days"]:
+        require(set(day) == {"date", "items"} and isinstance(day["items"], list), "INVALID_FACT_DAY")
+        date(day["date"])
+        facts, used = [], set()
+        for item in day["items"]:
+            require(isinstance(item, dict) and set(item) >= {"title", "statement", "status", "project", "sourceIds"} and not set(item) - {"title", "statement", "status", "project", "sourceIds", "eventKey"}, "INVALID_CANDIDATE_FIELDS")
+            ids = item["sourceIds"]
+            require(isinstance(ids, list) and ids and len(set(ids)) == len(ids) and all(i in by_id for i in ids), "INVALID_SOURCE_IDS")
+            sources = [by_id[i] for i in ids]
+            require(all(m["day"] == day["date"] for m in sources), "FACT_DAY_MISMATCH")
+            require(all(read_ids.get(m["id"], 0) >= len(m["text"]) for m in sources), "UNREAD_FACT_SOURCE")
+            if all(m["ref"]["channel"] == "screen-timeline" for m in sources):
+                require(item["status"] in ("documented", "discussed"), "SCREEN_ONLY_IS_OBSERVATION")
+            if item["status"] == "verified":
+                require(any(m["role"] == "tool" and m["ref"]["channel"] == "local-agent" for m in sources), "VERIFIED_REQUIRES_TOOL_RECEIPT")
+            projects = {m["project"] for m in sources if m["ref"]["channel"] == "local-agent"}
+            if projects:
+                expected = next(iter(projects)) if len(projects) == 1 else None
+                require(item["project"] == expected, "PROJECT_SOURCE_MISMATCH")
+            anchors = {m["anchor"] for m in sources}
+            matching = {key for key, old in identities.items() if old["date"] == day["date"] and anchors.intersection(old["anchors"])}
+            if item.get("eventKey"):
+                matching.update(k for k, old in identities.items() if old["date"] == day["date"] and old["eventKey"] == item["eventKey"])
+            require(len(matching) <= 1, "AMBIGUOUS_FACT_MERGE")
+            key = next(iter(matching)) if matching else str(uuid.uuid4())
+            require(key not in used, "AMBIGUOUS_FACT_SPLIT")
+            used.add(key)
+            old = identities.get(key)
+            event = old["eventKey"] if old else item.get("eventKey") or str(uuid.uuid4())
+            require(not item.get("eventKey") or item["eventKey"] == event, "EVENT_IDENTITY_CHANGED")
+            identities[key] = {"date": day["date"], "eventKey": event, "externalKey": old["externalKey"] if old else str(uuid.uuid4()), "anchors": sorted(anchors | set(old["anchors"] if old else []))}
+            refs = {digest(m["ref"]): m["ref"] for m in sources}
+            facts.append({k: item[k] for k in ("title", "statement", "status", "project")} | {"eventKey": event, "externalKey": identities[key]["externalKey"], "sourceRefs": list(refs.values())})
+        old_keys = {k for k, v in state.data["identities"].items() if v["date"] == day["date"]}
+        # An omission cannot silently leave an earlier, now contradictory fact behind.
+        require(not all(r["status"] == "complete" for r in meta["receipts"][day["date"]]) or old_keys <= used, "OMITTED_PRIOR_FACT: preserve or explicitly resolve existing fact identities")
+        receipts = meta["receipts"][day["date"]]
+        exported.append({"date": day["date"], "requestedScopes": scopes(state.c, day["date"]), "receipts": receipts, "facts": facts})
+    payload = {"schemaVersion": 1, "sourceNamespace": state.c["sourceNamespace"], "sourceCollectedAt": max(r["collectedAt"] for d in exported for r in d["receipts"]), "days": exported}
+    require(not candidates.get("materialReviews"), "BROWSING_IS_NOT_WORK")
+    work_records.validate(payload, Failure, enforce_limits=False)
+    for day in exported:
+        single = {**payload, "days": [day], "sourceCollectedAt": max(r["collectedAt"] for r in day["receipts"])}
+        if "materialResults" in payload:
+            single["materialResults"] = [r for r in payload["materialResults"] if meta["materialDates"][r["recordId"]] == day["date"]]
+        work_records.validate(single, Failure)
+    write(path / "export.json", payload)
+    state.data["identities"] = identities
+    meta.update(phase="validated", exportHash=digest(payload), identitySnapshot=identities)
+    return {"valid": True, "facts": sum(len(d["facts"]) for d in exported), "export": str(path / "export.json")}