@nextclaw/x-harness 0.0.0-stage → 0.1.0

package/dist/growth.js

@@ -0,0 +1,1918 @@
+import { checkRound } from "./round-state.js";
+import { xURL } from "./platform.js";
+import { randomUUID } from "node:crypto";
+const kinds = ["follow", "original", "reply"];
+const followWindows = [
+    [600000, 20],
+    [3600000, 100],
+];
+const operations = {
+    follow: "submitFollow",
+    original: "submitPost",
+    reply: "submitReply",
+};
+const same = (a, b) => typeof a === "string" &&
+    typeof b === "string" &&
+    a.toLowerCase() === b.toLowerCase();
+// No UI implementation, hidden state, scheduling or LLM calls in this layer.
+export function createGrowthHarness({ platform, store, clock = () => Date.now(), executor, } = {}) {
+    const stamp = () => new Date(clock()).toISOString();
+    const evidenceExists = store.evidenceExists ?? (() => false);
+    const runtimeId = randomUUID();
+    let claim, running = false;
+    const readCache = new Map();
+    if (executor &&
+        (!executor.id ||
+            !executor.tabId ||
+            !Array.isArray(executor.scopeKinds) ||
+            !executor.scopeKinds.length ||
+            new Set(executor.scopeKinds).size !== executor.scopeKinds.length ||
+            executor.scopeKinds.some((k) => !kinds.includes(k)) ||
+            !evidenceExists(executor.evidenceRef) ||
+            typeof store.transaction !== "function"))
+        throw new Error("并行执行者需ID、独立tab、有效职责及原合同证据与transaction");
+    const scope = (state) => executor?.scopeKinds ?? state.scopeKinds ?? kinds;
+    const project = (state) => executor
+        ? {
+            ...state,
+            scopeKinds: executor.scopeKinds,
+            scopeEvidenceRef: executor.evidenceRef,
+            status: state.executions?.[executor.id]?.status ?? "RUNNING",
+            stop: state.executions?.[executor.id]?.stop,
+        }
+        : state;
+    async function load(taskId) {
+        const snapshot = await store.load();
+        if (snapshot.state.batchId !== taskId)
+            throw new Error("任务ID不是原台账当前批次");
+        // Expired WAITING is actionable, not a malformed ledger. Validate structure separately from stopping.
+        const gate = checkRound({ ...project(snapshot.state), status: "RUNNING" }, { now: clock(), evidenceExists });
+        if (!gate.valid)
+            throw new Error(`原轮次标记无效：${gate.errors.join("；")}`);
+        const actions = snapshot.state.actions ?? [];
+        if (new Set(actions.map((a) => a.id)).size !== actions.length)
+            throw new Error("原队列动作ID重复");
+        for (const a of actions) {
+            if (!a.id ||
+                !kinds.includes(a.kind) ||
+                ![
+                    "prepared",
+                    "intent",
+                    "unknown",
+                    "verified",
+                    "preexisting",
+                    "skipped",
+                ].includes(a.status))
+                throw new Error("原队列动作结构无效");
+        }
+        return snapshot;
+    }
+    async function save(snapshot, state) {
+        state.updatedAt = stamp();
+        if (!executor)
+            return store.save(snapshot, state);
+        // Batch metadata still uses a short withLock transaction; it never contains browser I/O.
+        if (!claim)
+            return store.save(snapshot, state);
+        return store.transaction((latest) => {
+            const next = structuredClone(latest.state), before = snapshot.state.actions.find((a) => a.id === claim.actionId);
+            const entry = next.actions.find((a) => a.id === claim.actionId), after = state.actions.find((a) => a.id === claim.actionId);
+            if (next.batchId !== snapshot.state.batchId ||
+                entry?.claim?.token !== claim.token ||
+                JSON.stringify({ ...entry, claim: undefined }) !==
+                    JSON.stringify({ ...before, claim: undefined }))
+                throw new Error("action-claim-or-version-conflict");
+            const oldItem = snapshot.state.items.find((i) => i.kind === entry.kind), newItem = state.items.find((i) => i.kind === entry.kind);
+            const item = next.items.find((i) => i.kind === entry.kind);
+            const reservation = before.status === "prepared" && after.status === "intent";
+            if (reservation) {
+                if (!item.actionable || item.verified + item.unknown >= item.planned)
+                    throw new Error("shared-target-capacity-exhausted");
+                if (entry.kind === "follow" && waitBudget(next))
+                    throw new Error("shared-follow-budget-exhausted");
+            }
+            if (after.status === "verified" &&
+                entry.kind !== "follow" &&
+                next.actions.some((a) => a.id !== entry.id &&
+                    a.status === "verified" &&
+                    a.publicId === after.publicId))
+                throw new Error("同一公开结果不能重复结算");
+            Object.assign(entry, after, { claim: entry.claim });
+            item.verified += newItem.verified - oldItem.verified;
+            item.unknown += newItem.unknown - oldItem.unknown;
+            if (item.unknown < 0 || item.verified + item.unknown > item.planned)
+                throw new Error("并行结算越界");
+            item.resultEvidence = [
+                ...new Set([
+                    ...(item.resultEvidence ?? []),
+                    ...(newItem.resultEvidence ?? []),
+                ]),
+            ];
+            for (const key of [
+                "actionable",
+                "reason",
+                "resumeAt",
+                "resumeWhen",
+                "blockEvidence",
+            ]) {
+                if (JSON.stringify(oldItem[key]) !== JSON.stringify(newItem[key])) {
+                    if (key in newItem)
+                        item[key] = newItem[key];
+                    else
+                        delete item[key];
+                }
+            }
+            if (reservation) {
+                const attempt = state.attempts.at(-1);
+                next.attempts ??= [];
+                next.attempts.push(attempt);
+                if (entry.kind === "follow") {
+                    next.execution ??= {};
+                    const old = next.execution.followGroup;
+                    next.execution.followGroup = {
+                        attempts: old?.attempts < 10 && clock() < Date.parse(old.lastAt) + 180000
+                            ? old.attempts + 1
+                            : 1,
+                        lastAt: attempt.at,
+                    };
+                }
+            }
+            next.status = "RUNNING";
+            next.updatedAt = stamp();
+            return next;
+        });
+    }
+    function result(snapshot, needs = []) {
+        const gate = checkRound(project(snapshot.state), {
+            now: clock(),
+            evidenceExists,
+        });
+        return {
+            status: gate.mayEnd
+                ? gate.status === "COMPLETE"
+                    ? "complete"
+                    : "waiting"
+                : needs.some((n) => n.status === "needsCapability")
+                    ? "needsCapability"
+                    : "needsDecision",
+            taskId: snapshot.state.batchId,
+            mayEnd: gate.mayEnd,
+            scopeKinds: gate.scopeKinds,
+            actual: Object.fromEntries(snapshot.state.items.map((i) => [
+                i.kind,
+                { verified: i.verified, unknown: i.unknown },
+            ])),
+            gaps: gate.pending,
+            ...(needs.length ? { decision: needs } : {}),
+            evidenceRef: snapshot.path ?? store.path,
+            ...(gate.errors.length ? { settlementErrors: gate.errors } : {}),
+        };
+    }
+    function capability(operation, input = {}) {
+        const kind = input.kind ??
+            {
+                followOne: "follow",
+                followBatch: "follow",
+                submitFollow: "follow",
+                publishPost: "original",
+                submitPost: "original",
+                replyToPost: "reply",
+                submitReply: "reply",
+            }[operation];
+        const required = [
+            "preflight",
+            "readAccount",
+            "findSubmission",
+            "captureProof",
+            ...(operation === "read" ? [] : [operations[kind]]),
+        ];
+        if (kind === "follow")
+            required.push("readPerson");
+        const missing = required.filter((name) => typeof platform?.[name] !== "function");
+        const storage = ["load", "save", "withLock", "recordProof"].filter((name) => typeof store?.[name] !== "function");
+        if (operation === "followBatch" && typeof store?.transaction !== "function")
+            storage.push("transaction");
+        if (kind === "original" &&
+            operation !== "read" &&
+            typeof store?.fingerprint !== "function")
+            storage.push("fingerprint");
+        const lower = typeof platform?.preflight === "function"
+            ? platform.preflight({
+                operation: operation === "read" ? "read" : operations[kind],
+                input,
+            })
+            : { covered: false, missing: [] };
+        return {
+            covered: !missing.length && !storage.length && lower.covered,
+            missing: [
+                ...missing.map((n) => `platform.${n}`),
+                ...storage.map((n) => `store.${n}`),
+                ...(lower.missing ?? []),
+            ],
+            owner: missing.length
+                ? "scripts/x-harness-platform.mjs"
+                : storage.length
+                    ? "scripts/x-harness-store.mjs"
+                    : lower.owner,
+        };
+    }
+    function waitBudget(state) {
+        const now = clock();
+        const hour = Number(new Intl.DateTimeFormat("en-GB", {
+            timeZone: "Asia/Shanghai",
+            hour: "2-digit",
+            hourCycle: "h23",
+        }).format(now));
+        if (hour < 7 || hour >= 22)
+            return {
+                status: "needsDecision",
+                reason: "outside-contract-write-window",
+            };
+        const coverage = state.attemptsCoverage;
+        if (!coverage?.complete ||
+            !Number.isFinite(Date.parse(coverage.since)) ||
+            Date.parse(coverage.since) > now - 3600000 ||
+            !evidenceExists(coverage.evidenceRef))
+            return {
+                status: "needsDecision",
+                reason: "shared-attempt-history-incomplete",
+            };
+        const attempts = state.attempts ?? [];
+        if (attempts.some((a) => !kinds.includes(a.kind) || !Number.isFinite(Date.parse(a.at))))
+            return { status: "needsDecision", reason: "attempt-history-invalid" };
+        const follows = attempts.filter((a) => a.kind === "follow");
+        for (const [duration, limit] of followWindows) {
+            const recent = follows
+                .filter((a) => Date.parse(a.at) > now - duration)
+                .sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+            if (recent.length >= limit)
+                return {
+                    status: "waiting",
+                    reason: "follow-rolling-budget",
+                    resumeAt: new Date(Date.parse(recent[recent.length - limit].at) + duration).toISOString(),
+                };
+        }
+        const group = state.execution?.followGroup;
+        if (group?.attempts >= 10 && now < Date.parse(group.lastAt) + 180000)
+            return {
+                status: "waiting",
+                reason: "follow-group-cooldown",
+                resumeAt: new Date(Date.parse(group.lastAt) + 180000).toISOString(),
+            };
+        return null;
+    }
+    function guardInput(state, action, independentExecution = undefined) {
+        if (!independentExecution && !scope(state).includes(action.kind))
+            return "kind-outside-round-scope";
+        if (independentExecution) {
+            if (action.kind !== "original" ||
+                !independentExecution.tabId ||
+                !evidenceExists(independentExecution.evidenceRef) ||
+                !evidenceExists(independentExecution.scopeEvidenceRef))
+                return "independent-execution-proof-missing";
+        }
+        else if (!executor &&
+            (!state.execution?.exclusive || state.execution.owner !== "harness"))
+            return "exclusive-account-execution-unconfirmed";
+        if (!same(state.accountHandle, action.accountHandle))
+            return "account-identity-mismatch";
+        if (!evidenceExists(action.accountEvidenceRef) ||
+            xURL(action.accountURL).pathname.toLowerCase() !==
+                `/${state.accountHandle}`.toLowerCase())
+            return "own-profile-proof-missing";
+        if (!action.quality?.approved ||
+            !evidenceExists(action.quality.evidenceRef))
+            return "quality-review-required";
+        if (action.kind === "follow") {
+            if (!same(action.quality.handle, action.handle) ||
+                action.quality.blue !== true ||
+                action.quality.chinese !== true)
+                return "follow-qualification-required";
+            if (!evidenceExists(action.evidenceRef))
+                return "person-observation-proof-missing";
+        }
+        else {
+            if (!action.text || action.quality.approvedText !== action.text)
+                return "exact-text-quality-review-required";
+            if (action.kind === "original" &&
+                (!action.draftPath || !evidenceExists(action.draftPath)))
+                return "draft-source-missing";
+            if (action.kind === "original" &&
+                (!action.draftPath.endsWith(".post.md") ||
+                    action.quality.draftFingerprint !==
+                        store.fingerprint(action.draftPath)))
+                return "draft-changed-since-quality-review";
+            if (action.kind === "original" &&
+                (!evidenceExists(action.composeEvidenceRef) ||
+                    xURL(action.composeURL).pathname !== "/compose/post"))
+                return "observed-composer-proof-missing";
+            if (action.kind === "reply" &&
+                (!/^\d+$/.test(action.postId ?? "") ||
+                    !evidenceExists(action.evidenceRef)))
+                return "reply-target-proof-missing";
+        }
+        return null;
+    }
+    async function settleProof(snapshot, action, observation, { preserveStatus = false } = {}) {
+        const proof = await store.recordProof(await platform.captureProof({ observation }));
+        const state = structuredClone(snapshot.state);
+        const entry = state.actions.find((a) => a.id === action.id);
+        const item = state.items.find((i) => i.kind === action.kind);
+        if (observation.verified) {
+            if (action.kind !== "follow" &&
+                (!/^\d+$/.test(observation.publicId ?? "") ||
+                    state.actions.some((a) => a.id !== action.id &&
+                        a.status === "verified" &&
+                        a.publicId === observation.publicId)))
+                throw new Error("同一公开结果不能重复结算");
+            if (["intent", "unknown"].includes(entry.status))
+                item.unknown -= 1;
+            if (entry.status !== "verified")
+                item.verified += 1;
+            entry.status = "verified";
+            entry.publicId = observation.publicId;
+            entry.resultEvidence = proof;
+            item.resultEvidence = [
+                ...new Set([...(item.resultEvidence ?? []), proof]),
+            ];
+        }
+        else {
+            if (!["intent", "unknown"].includes(entry.status))
+                item.unknown += 1;
+            entry.status = "unknown";
+            entry.resultEvidence = proof;
+        }
+        if (item.verified > item.planned || item.unknown < 0)
+            throw new Error("结算越界：不覆盖原目标或重复计数");
+        if (!preserveStatus)
+            state.status = "RUNNING";
+        return save(snapshot, state);
+    }
+    async function execute(snapshot, action) {
+        const recovering = ["intent", "unknown"].includes(action.status);
+        const caps = capability(recovering ? "read" : operations[action.kind], action);
+        if (!caps.covered)
+            return {
+                snapshot,
+                need: { status: "needsCapability", actionId: action.id, ...caps },
+            };
+        // Recovery is read-only even outside the write window. Never retry an intent.
+        if (recovering) {
+            let observation;
+            try {
+                observation = await platform.findSubmission(action);
+            }
+            catch (error) {
+                observation = {
+                    verified: false,
+                    missing: ["dedup-read-failed"],
+                    error: error.message.slice(0, 240),
+                };
+            }
+            snapshot = await settleProof(snapshot, action, observation);
+            return {
+                snapshot,
+                need: observation.verified
+                    ? null
+                    : {
+                        status: "needsDecision",
+                        actionId: action.id,
+                        reason: "submission-unknown-do-not-resubmit",
+                        accountAlert: Boolean(observation.alerts?.length),
+                    },
+            };
+        }
+        if (snapshot.state.items
+            .find((i) => i.kind === action.kind)
+            .reason?.startsWith("harness:") &&
+            Date.parse(snapshot.state.items.find((i) => i.kind === action.kind).resumeAt) <= clock()) {
+            const next = structuredClone(snapshot.state), pending = next.items.find((i) => i.kind === action.kind);
+            pending.actionable = true;
+            delete pending.reason;
+            delete pending.resumeAt;
+            delete pending.resumeWhen;
+            delete pending.blockEvidence;
+            next.status = "RUNNING";
+            snapshot = await save(snapshot, next);
+        }
+        const state = snapshot.state;
+        const item = state.items.find((i) => i.kind === action.kind);
+        if (!item.actionable)
+            return {
+                snapshot,
+                need: {
+                    status: "needsDecision",
+                    actionId: action.id,
+                    reason: item.reason ?? "original-kind-not-actionable",
+                },
+            };
+        const inputError = guardInput(state, action);
+        if (inputError)
+            return {
+                snapshot,
+                need: {
+                    status: "needsDecision",
+                    actionId: action.id,
+                    reason: inputError,
+                },
+            };
+        let own;
+        try {
+            own = await platform.readAccount();
+        }
+        catch (error) {
+            return {
+                snapshot,
+                need: {
+                    status: "needsDecision",
+                    actionId: action.id,
+                    reason: "account-read-failed",
+                    error: error.message.slice(0, 240),
+                },
+            };
+        }
+        if (own.needsStateCheck ||
+            own.alerts?.length ||
+            !same(own.accountHandle, state.accountHandle))
+            return {
+                snapshot,
+                need: {
+                    status: "needsDecision",
+                    actionId: action.id,
+                    reason: "fresh-account-unconfirmed",
+                },
+            };
+        if (action.kind === "follow") {
+            const budget = waitBudget(state);
+            if (budget)
+                return { snapshot, need: { ...budget, actionId: action.id } };
+            let value;
+            try {
+                value = await platform.readPerson(action);
+            }
+            catch (error) {
+                return {
+                    snapshot,
+                    need: {
+                        status: "needsDecision",
+                        actionId: action.id,
+                        reason: "person-read-failed",
+                        error: error.message.slice(0, 240),
+                    },
+                };
+            }
+            if (value.needsStateCheck ||
+                value.alerts?.length ||
+                value.relationship === "unknown" ||
+                !same(value.accountHandle, state.accountHandle))
+                return {
+                    snapshot,
+                    need: {
+                        status: "needsDecision",
+                        actionId: action.id,
+                        reason: "fresh-person-unconfirmed",
+                    },
+                };
+            if (value.blue === false)
+                return {
+                    snapshot,
+                    need: {
+                        status: "needsDecision",
+                        actionId: action.id,
+                        reason: "fresh-blue-qualification-contradicts-review",
+                    },
+                };
+            if (value.relationship === "following") {
+                const next = structuredClone(state);
+                next.actions.find((a) => a.id === action.id).status =
+                    "preexisting";
+                return { snapshot: await save(snapshot, next), need: null };
+            }
+        }
+        else {
+            const hour = Number(new Intl.DateTimeFormat("en-GB", {
+                timeZone: "Asia/Shanghai",
+                hour: "2-digit",
+                hourCycle: "h23",
+            }).format(clock()));
+            if (hour < 7 || hour >= 22)
+                return {
+                    snapshot,
+                    need: {
+                        status: "needsDecision",
+                        actionId: action.id,
+                        reason: "outside-contract-write-window",
+                    },
+                };
+        }
+        let beforeIds = [];
+        if (action.kind !== "follow") {
+            let baseline;
+            try {
+                baseline = await platform.findSubmission({
+                    ...action,
+                    intentAt: stamp(),
+                });
+            }
+            catch (error) {
+                return {
+                    snapshot,
+                    need: {
+                        status: "needsDecision",
+                        actionId: action.id,
+                        reason: "publication-baseline-read-failed",
+                        error: error.message.slice(0, 240),
+                    },
+                };
+            }
+            if (baseline.needsStateCheck || baseline.alerts?.length)
+                return {
+                    snapshot,
+                    need: {
+                        status: "needsDecision",
+                        actionId: action.id,
+                        reason: "publication-baseline-unconfirmed",
+                    },
+                };
+            beforeIds = (baseline.posts ?? []).map((p) => p.id).filter(Boolean);
+        }
+        // Persist intent BEFORE any externally visible submission. Even a failed attempt consumes budget.
+        const next = structuredClone(state);
+        const entry = next.actions.find((a) => a.id === action.id);
+        entry.status = "intent";
+        entry.intentAt = stamp();
+        entry.beforeIds = beforeIds;
+        next.items.find((i) => i.kind === action.kind).unknown += 1;
+        next.attempts ??= [];
+        next.attempts.push({
+            actionId: action.id,
+            kind: action.kind,
+            at: entry.intentAt,
+        });
+        if (action.kind === "follow") {
+            next.execution ??= {};
+            const old = next.execution.followGroup;
+            next.execution.followGroup = {
+                attempts: old?.attempts < 10 && clock() < Date.parse(old.lastAt) + 180000
+                    ? old.attempts + 1
+                    : 1,
+                lastAt: entry.intentAt,
+            };
+        }
+        snapshot = await save(snapshot, next);
+        let observation, submissionMayHaveStarted = false;
+        try {
+            await platform[operations[action.kind]]({
+                ...entry,
+                beforeSubmit: async () => {
+                    const latest = await store.load();
+                    if (executor) {
+                        const current = latest.state.actions.find((a) => a.id === entry.id);
+                        if (latest.state.batchId !== snapshot.state.batchId ||
+                            current?.claim?.token !== claim.token ||
+                            JSON.stringify(current) !==
+                                JSON.stringify(snapshot.state.actions.find((a) => a.id === entry.id)))
+                            throw new Error("提交前本动作或claim变化");
+                    }
+                    else if (latest.revision !== snapshot.revision)
+                        throw new Error("提交前原台账变化，保留intent并重核执行权");
+                    const inputError = guardInput(latest.state, latest.state.actions.find((a) => a.id === entry.id));
+                    if (inputError)
+                        throw new Error(inputError);
+                    const hour = Number(new Intl.DateTimeFormat("en-GB", {
+                        timeZone: "Asia/Shanghai",
+                        hour: "2-digit",
+                        hourCycle: "h23",
+                    }).format(clock()));
+                    if (hour < 7 || hour >= 22)
+                        throw new Error("实际提交时已越过运营窗口");
+                    if (action.kind === "follow") {
+                        const check = structuredClone(latest.state);
+                        check.attempts = check.attempts.filter((a) => a.actionId !== entry.id);
+                        if (check.execution.followGroup)
+                            check.execution.followGroup.attempts -= 1;
+                        if (waitBudget(check))
+                            throw new Error("实际提交前关注预算不再可用");
+                    }
+                    submissionMayHaveStarted = true;
+                },
+            });
+            observation = await platform.findSubmission(entry);
+        }
+        catch (error) {
+            if (!submissionMayHaveStarted) {
+                const proof = await store.recordProof({
+                    capturedAt: stamp(),
+                    submissionStarted: false,
+                    error: error.message.slice(0, 240),
+                });
+                const unsubmitted = structuredClone(snapshot.state), target = unsubmitted.actions.find((a) => a.id === entry.id);
+                target.status = "prepared";
+                target.preparationEvidence = proof;
+                unsubmitted.items.find((i) => i.kind === action.kind).unknown -= 1;
+                snapshot = await save(snapshot, unsubmitted);
+                return {
+                    snapshot,
+                    need: {
+                        status: "needsDecision",
+                        actionId: action.id,
+                        reason: "pre-submit-preparation-failed",
+                        evidenceRef: proof,
+                    },
+                };
+            }
+            // A transport error does not distinguish a rejected write from a successful write.
+            observation = {
+                verified: false,
+                missing: ["submission-or-verification-failed"],
+                error: error.message.slice(0, 240),
+            };
+        }
+        snapshot = await settleProof(snapshot, entry, observation);
+        return {
+            snapshot,
+            need: observation.verified
+                ? null
+                : {
+                    status: "needsDecision",
+                    actionId: action.id,
+                    reason: "submission-unknown-do-not-resubmit",
+                    accountAlert: Boolean(observation.alerts?.length),
+                },
+        };
+    }
+    async function parallelRound({ taskId, decision, selector, requestedKind, maxActions = 10, } = {}) {
+        if (running)
+            return {
+                status: "needsDecision",
+                mayEnd: false,
+                taskId,
+                decision: [{ reason: "same-tab-operation-running" }],
+            };
+        running = true;
+        let completed = 0;
+        const needs = [];
+        try {
+            if (!Number.isInteger(maxActions) || maxActions < 1 || maxActions > 100)
+                throw new Error("maxActions须为1–100");
+            let snapshot = await load(taskId);
+            const activeKinds = scope(snapshot.state);
+            if (requestedKind && !activeKinds.includes(requestedKind))
+                return {
+                    ...result(snapshot),
+                    status: "needsDecision",
+                    decision: [{ reason: "kind-outside-round-scope" }],
+                };
+            snapshot = await store.transaction((latest) => {
+                if (latest.state.batchId !== taskId)
+                    throw new Error("original-task-changed");
+                const next = structuredClone(latest.state);
+                next.executions ??= {};
+                if (Object.values(next.executions).some((e) => (e.tabId === executor.tabId || e.id === executor.id) &&
+                    e.runtimeId !== runtimeId &&
+                    (e.activity || e.actionId) &&
+                    store.ownerAlive(e.pid)))
+                    throw new Error("same-tab-or-executor-claimed");
+                next.executions[executor.id] = {
+                    ...next.executions[executor.id],
+                    ...executor,
+                    runtimeId,
+                    pid: store.processId,
+                    activity: "round",
+                    status: "RUNNING",
+                    updatedAt: stamp(),
+                };
+                if (decision?.type === "prepareActions") {
+                    if (!Array.isArray(decision.actions) ||
+                        !same(next.accountHandle, decision.accountHandle) ||
+                        !evidenceExists(decision.ownershipEvidenceRef))
+                        throw new Error("需原账号核验和完整动作队列");
+                    next.actions ??= [];
+                    for (const action of decision.actions) {
+                        if (!action.id ||
+                            !activeKinds.includes(action.kind) ||
+                            action.status !== "prepared" ||
+                            next.actions.some((a) => a.id === action.id))
+                            throw new Error("原prepared动作ID无效");
+                        next.actions.push(structuredClone(action));
+                    }
+                    if (next.items.some((i) => next.actions.filter((a) => a.kind === i.kind && a.status === "prepared").length >
+                        i.planned - i.verified - i.unknown))
+                        throw new Error("队列超过原目标");
+                    if (decision.sharedAttempts) {
+                        if (!Array.isArray(decision.sharedAttempts))
+                            throw new Error("共享尝试须为数组");
+                        next.attempts = [
+                            ...(next.attempts ?? []),
+                            ...structuredClone(decision.sharedAttempts),
+                        ];
+                    }
+                    if (decision.attemptsCoverage) {
+                        if (!decision.attemptsCoverage.complete ||
+                            !evidenceExists(decision.attemptsCoverage.evidenceRef))
+                            throw new Error("共享历史缺证据");
+                        next.attemptsCoverage = structuredClone(decision.attemptsCoverage);
+                    }
+                    if (decision.nextScheduledCheckAt)
+                        next.executions[executor.id].nextScheduledCheckAt =
+                            decision.nextScheduledCheckAt;
+                }
+                else if (decision) {
+                    const action = next.actions?.find((a) => a.id === decision.actionId);
+                    if (!action ||
+                        !activeKinds.includes(action.kind) ||
+                        action.status !== "prepared" ||
+                        action.claim ||
+                        typeof decision.approved !== "boolean" ||
+                        !evidenceExists(decision.evidenceRef))
+                        throw new Error("审查只绑定职责内未领取的原prepared动作");
+                    if (!decision.approved)
+                        action.status = "skipped";
+                    else
+                        action.quality = {
+                            approved: true,
+                            evidenceRef: decision.evidenceRef,
+                            ...(action.kind === "follow"
+                                ? {
+                                    handle: action.handle,
+                                    blue: decision.blue === true,
+                                    chinese: decision.chinese === true,
+                                }
+                                : {
+                                    approvedText: decision.approvedText,
+                                    ...(action.kind === "original"
+                                        ? { draftFingerprint: decision.draftFingerprint }
+                                        : {}),
+                                }),
+                        };
+                }
+                next.updatedAt = stamp();
+                return next;
+            });
+            for (const kind of activeKinds) {
+                const queue = (snapshot.state.actions ?? [])
+                    .filter((a) => a.kind === kind && (!selector || selector(a)))
+                    .sort((a, b) => Number(["intent", "unknown"].includes(b.status)) -
+                    Number(["intent", "unknown"].includes(a.status)));
+                if (snapshot.state.items.find((i) => i.kind === kind).unknown >
+                    snapshot.state.actions.filter((a) => a.kind === kind && ["intent", "unknown"].includes(a.status)).length) {
+                    needs.push({
+                        status: "needsDecision",
+                        reason: "original-unmapped-unknown-needs-dedup",
+                        kind,
+                    });
+                    continue;
+                }
+                for (const original of queue) {
+                    if (completed >= maxActions)
+                        break;
+                    if (["verified", "preexisting", "skipped"].includes(original.status))
+                        continue;
+                    try {
+                        snapshot = await store.transaction((latest) => {
+                            const next = structuredClone(latest.state), action = next.actions.find((a) => a.id === original.id);
+                            if (next.batchId !== taskId)
+                                throw new Error("original-task-changed");
+                            if (["verified", "preexisting", "skipped"].includes(action.status))
+                                return null;
+                            const sameTarget = (other) => other.kind === action.kind &&
+                                (kind === "follow"
+                                    ? same(other.handle, action.handle)
+                                    : kind === "original"
+                                        ? other.draftPath === action.draftPath
+                                        : other.postId === action.postId &&
+                                            other.text === action.text);
+                            if (next.actions.some((a) => a.id !== action.id &&
+                                sameTarget(a) &&
+                                (a.claim ||
+                                    ["intent", "unknown", "verified"].includes(a.status))))
+                                throw new Error("same-target-already-claimed-or-submitted");
+                            if (action.claim && store.ownerAlive(action.claim.pid))
+                                throw new Error("same-action-claimed");
+                            if (Object.values(next.executions).some((e) => e.tabId === executor.tabId &&
+                                e.actionId &&
+                                e.runtimeId !== runtimeId &&
+                                store.ownerAlive(e.pid)))
+                                throw new Error("same-tab-claimed");
+                            claim = {
+                                actionId: action.id,
+                                token: randomUUID(),
+                                executorId: executor.id,
+                                runtimeId,
+                                pid: store.processId,
+                                acquiredAt: stamp(),
+                            };
+                            action.claim = claim;
+                            next.executions[executor.id].actionId = action.id;
+                            next.updatedAt = stamp();
+                            return next;
+                        });
+                        if (!claim)
+                            continue;
+                        const outcome = await execute(snapshot, snapshot.state.actions.find((a) => a.id === original.id));
+                        snapshot = outcome.snapshot;
+                        completed++;
+                        if (outcome.need) {
+                            needs.push(outcome.need);
+                            break;
+                        }
+                    }
+                    catch (error) {
+                        needs.push({
+                            status: "needsDecision",
+                            kind,
+                            actionId: original.id,
+                            reason: /claimed|same-target/.test(error.message)
+                                ? "action-or-tab-claimed"
+                                : /budget|capacity/.test(error.message)
+                                    ? "shared-reservation-unavailable"
+                                    : "harness-boundary-error",
+                            error: error.message.slice(0, 240),
+                        });
+                        break;
+                    }
+                    finally {
+                        if (claim) {
+                            const owned = claim;
+                            claim = null;
+                            snapshot = await store.transaction((latest) => {
+                                const next = structuredClone(latest.state), action = next.actions?.find((a) => a.id === owned.actionId);
+                                if (action?.claim?.token !== owned.token)
+                                    return null;
+                                delete action.claim;
+                                if (next.executions[executor.id]?.runtimeId === runtimeId)
+                                    delete next.executions[executor.id].actionId;
+                                next.updatedAt = stamp();
+                                return next;
+                            });
+                        }
+                    }
+                }
+            }
+            snapshot = await store.transaction(async (latest) => {
+                const next = structuredClone(latest.state), own = next.executions[executor.id];
+                const pending = next.items.filter((i) => activeKinds.includes(i.kind) &&
+                    (i.verified < i.planned || i.unknown));
+                own.status = pending.length ? "RUNNING" : "COMPLETE";
+                const scheduled = own.nextScheduledCheckAt ??
+                    next.execution?.nextScheduledCheckAt ??
+                    next.stop?.nextScheduledCheckAt;
+                const waits = pending.map((i) => needs.find((n) => n.status === "waiting" &&
+                    next.actions.find((a) => a.id === n.actionId)?.kind ===
+                        i.kind));
+                if (pending.length &&
+                    pending.every((i) => !i.unknown &&
+                        next.actions.filter((a) => a.kind === i.kind && a.status === "prepared").length >=
+                            i.planned - i.verified) &&
+                    waits.every((w) => w && Date.parse(w.resumeAt) > clock()) &&
+                    Date.parse(scheduled) > clock()) {
+                    for (let i = 0; i < pending.length; i++) {
+                        const proof = await store.recordProof({
+                            observedAt: stamp(),
+                            ...waits[i],
+                            attempts: next.attempts,
+                        });
+                        Object.assign(pending[i], {
+                            actionable: false,
+                            reason: `harness:${waits[i].reason}`,
+                            resumeAt: waits[i].resumeAt,
+                            resumeWhen: `不早于${waits[i].resumeAt}重核`,
+                            blockEvidence: [proof],
+                        });
+                    }
+                    own.status = "WAITING";
+                    own.stop = {
+                        independentActionsHandled: true,
+                        nextScheduledCheckAt: scheduled,
+                        nextEligibleCheckAt: waits.map((w) => w.resumeAt).sort()[0],
+                    };
+                }
+                next.status = next.items.every((i) => i.verified === i.planned && !i.unknown)
+                    ? "COMPLETE"
+                    : "RUNNING";
+                own.updatedAt = next.updatedAt = stamp();
+                return next;
+            });
+            const out = result(snapshot, needs);
+            if (!out.mayEnd && !needs.length && completed >= maxActions)
+                return {
+                    ...out,
+                    status: "checkpoint",
+                    checkpoint: {
+                        taskId,
+                        executorId: executor.id,
+                        completed,
+                        resume: "resumeGrowthRound",
+                    },
+                };
+            if (!out.mayEnd && !needs.length)
+                out.decision = [
+                    { reason: "prepared-queue-does-not-cover-original-targets" },
+                ];
+            return out;
+        }
+        catch (error) {
+            return {
+                status: "needsDecision",
+                mayEnd: false,
+                taskId,
+                evidenceRef: store.path,
+                decision: [
+                    {
+                        reason: "harness-boundary-error",
+                        error: error.message.slice(0, 240),
+                    },
+                ],
+            };
+        }
+        finally {
+            try {
+                await releaseSession(taskId);
+            }
+            finally {
+                running = false;
+            }
+        }
+    }
+    async function round({ taskId, decision, selector, requestedKind, } = {}) {
+        try {
+            return await store.withLock(async () => {
+                let snapshot = await load(taskId);
+                const activeKinds = snapshot.state.scopeKinds ?? kinds;
+                if (requestedKind && !activeKinds.includes(requestedKind))
+                    return {
+                        ...result(snapshot),
+                        status: "needsDecision",
+                        mayEnd: false,
+                        decision: [
+                            { kind: requestedKind, reason: "kind-outside-round-scope" },
+                        ],
+                    };
+                if (decision?.type === "prepareActions") {
+                    if (!Array.isArray(decision.actions) ||
+                        !/^[A-Za-z0-9_]{1,15}$/.test(decision.accountHandle ?? "") ||
+                        !evidenceExists(decision.ownershipEvidenceRef) ||
+                        (snapshot.state.execution?.owner &&
+                            snapshot.state.execution.owner !== "harness"))
+                        throw new Error("需原账号执行权核验和完整动作队列；不接管已有执行者");
+                    if (snapshot.state.accountHandle &&
+                        !same(snapshot.state.accountHandle, decision.accountHandle))
+                        throw new Error("不能变更原账号");
+                    const next = structuredClone(snapshot.state);
+                    next.actions ??= [];
+                    for (const action of decision.actions) {
+                        if (!action.id ||
+                            !activeKinds.includes(action.kind) ||
+                            action.status !== "prepared" ||
+                            next.actions.some((a) => a.id === action.id))
+                            throw new Error("仅添加职责范围内唯一ID的prepared原动作");
+                        next.actions.push(structuredClone(action));
+                    }
+                    if (next.items.some((item) => next.actions.filter((a) => a.kind === item.kind && a.status === "prepared").length >
+                        item.planned - item.verified - item.unknown))
+                        throw new Error("prepared队列不能越过原批次未决目标");
+                    next.accountHandle = decision.accountHandle;
+                    next.execution = {
+                        ...next.execution,
+                        owner: "harness",
+                        exclusive: true,
+                        ownershipEvidenceRef: decision.ownershipEvidenceRef,
+                        ...(decision.nextScheduledCheckAt
+                            ? { nextScheduledCheckAt: decision.nextScheduledCheckAt }
+                            : {}),
+                    };
+                    if (decision.attemptsCoverage) {
+                        if (!decision.attemptsCoverage.complete ||
+                            !evidenceExists(decision.attemptsCoverage.evidenceRef))
+                            throw new Error("共享历史须完整取证；不能默认为零");
+                        next.attemptsCoverage = structuredClone(decision.attemptsCoverage);
+                    }
+                    if (decision.sharedAttempts) {
+                        if (!Array.isArray(decision.sharedAttempts))
+                            throw new Error("共享尝试记录必须为数组");
+                        next.attempts = [
+                            ...(next.attempts ?? []),
+                            ...structuredClone(decision.sharedAttempts),
+                        ];
+                    }
+                    snapshot = await save(snapshot, next);
+                }
+                else if (decision) {
+                    const action = snapshot.state.actions?.find((a) => a.id === decision.actionId);
+                    if (action && !activeKinds.includes(action.kind))
+                        throw new Error("kind-outside-round-scope");
+                    if (!action ||
+                        action.status !== "prepared" ||
+                        typeof decision.approved !== "boolean" ||
+                        !evidenceExists(decision.evidenceRef))
+                        throw new Error("决策仅能绑定原prepared动作及真实审查证据");
+                    const next = structuredClone(snapshot.state), target = next.actions.find((a) => a.id === action.id);
+                    if (!decision.approved)
+                        target.status = "skipped";
+                    else
+                        target.quality = {
+                            approved: true,
+                            evidenceRef: decision.evidenceRef,
+                            ...(action.kind === "follow"
+                                ? {
+                                    handle: action.handle,
+                                    blue: decision.blue === true,
+                                    chinese: decision.chinese === true,
+                                }
+                                : {
+                                    approvedText: decision.approvedText,
+                                    ...(action.kind === "original"
+                                        ? { draftFingerprint: decision.draftFingerprint }
+                                        : {}),
+                                }),
+                        };
+                    snapshot = await save(snapshot, next);
+                }
+                const needs = [];
+                for (const kind of activeKinds) {
+                    const queue = (snapshot.state.actions ?? [])
+                        .filter((a) => a.kind === kind && (!selector || selector(a)))
+                        .sort((a, b) => Number(["intent", "unknown"].includes(b.status)) -
+                        Number(["intent", "unknown"].includes(a.status)));
+                    // A selector narrows this invocation, not the original unresolved ledger.
+                    const unresolved = (snapshot.state.actions ?? []).filter((a) => a.kind === kind && ["intent", "unknown"].includes(a.status)).length;
+                    if (snapshot.state.items.find((i) => i.kind === kind).unknown >
+                        unresolved) {
+                        needs.push({
+                            status: "needsDecision",
+                            reason: "original-unmapped-unknown-needs-dedup",
+                            kind,
+                        });
+                        continue;
+                    }
+                    for (const original of queue) {
+                        const item = snapshot.state.items.find((i) => i.kind === kind);
+                        const action = snapshot.state.actions.find((a) => a.id === original.id);
+                        if (["verified", "preexisting", "skipped"].includes(action.status))
+                            continue;
+                        if (item.verified >= item.planned && action.status === "prepared")
+                            continue;
+                        const outcome = await execute(snapshot, action);
+                        snapshot = outcome.snapshot;
+                        if (outcome.need) {
+                            needs.push(outcome.need);
+                            break;
+                        } // Stop only this kind; continue independent kinds.
+                    }
+                }
+                if (snapshot.state.items
+                    .filter((i) => activeKinds.includes(i.kind))
+                    .every((i) => i.verified === i.planned && i.unknown === 0)) {
+                    const next = structuredClone(snapshot.state);
+                    next.status = "COMPLETE";
+                    snapshot = await save(snapshot, next);
+                }
+                else {
+                    const pending = snapshot.state.items.filter((i) => activeKinds.includes(i.kind) &&
+                        (i.verified < i.planned || i.unknown > 0));
+                    const waits = pending.map((item) => needs.find((n) => n.status === "waiting" &&
+                        snapshot.state.actions.find((a) => a.id === n.actionId)
+                            ?.kind === item.kind));
+                    const scheduled = snapshot.state.execution?.nextScheduledCheckAt ??
+                        snapshot.state.stop?.nextScheduledCheckAt;
+                    const covered = pending.every((item) => item.unknown === 0 &&
+                        (snapshot.state.actions ?? []).filter((a) => a.kind === item.kind && a.status === "prepared").length >=
+                            item.planned - item.verified);
+                    if (covered &&
+                        waits.every((w) => w && Date.parse(w.resumeAt) > clock()) &&
+                        Date.parse(scheduled) > clock()) {
+                        const next = structuredClone(snapshot.state);
+                        for (let i = 0; i < pending.length; i++) {
+                            const item = next.items.find((a) => a.kind === pending[i].kind), wait = waits[i];
+                            const proof = await store.recordProof({
+                                observedAt: stamp(),
+                                reason: wait.reason,
+                                resumeAt: wait.resumeAt,
+                                attempts: next.attempts,
+                            });
+                            Object.assign(item, {
+                                actionable: false,
+                                reason: `harness:${wait.reason}`,
+                                resumeAt: wait.resumeAt,
+                                resumeWhen: `不早于${wait.resumeAt}重核预算及fresh状态`,
+                                blockEvidence: [proof],
+                            });
+                        }
+                        next.status = "WAITING";
+                        next.stop = {
+                            independentActionsHandled: true,
+                            nextScheduledCheckAt: scheduled,
+                            nextEligibleCheckAt: waits.map((w) => w.resumeAt).sort()[0],
+                        };
+                        snapshot = await save(snapshot, next);
+                    }
+                    else if (!needs.length)
+                        needs.push({
+                            status: "needsDecision",
+                            reason: "prepared-queue-does-not-cover-original-targets",
+                        });
+                }
+                return result(snapshot, needs);
+            });
+        }
+        catch (error) {
+            return {
+                status: "needsDecision",
+                mayEnd: false,
+                taskId,
+                evidenceRef: store.path,
+                decision: [
+                    {
+                        reason: error.code === "CONFLICT"
+                            ? "original-ledger-conflict"
+                            : "harness-boundary-error",
+                        error: error.message.slice(0, 240),
+                    },
+                ],
+            };
+        }
+    }
+    // Independent tabs share only short ledger transactions, never a browser-operation lock.
+    async function publishIndependent({ taskId, draftPath, preparedAction, independentExecution, }) {
+        let action, token, submissionStarted = false;
+        const inWindow = () => {
+            const hour = Number(new Intl.DateTimeFormat("en-GB", {
+                timeZone: "Asia/Shanghai",
+                hour: "2-digit",
+                hourCycle: "h23",
+            }).format(clock()));
+            return hour >= 7 && hour < 22;
+        };
+        try {
+            const caps = capability("submitPost", preparedAction ?? {});
+            if (!caps.covered)
+                return { status: "needsCapability", ...caps };
+            if (!inWindow())
+                throw new Error("outside-contract-write-window");
+            await store.withLock(async () => {
+                const snapshot = await load(taskId), state = structuredClone(snapshot.state);
+                state.actions ??= [];
+                action = state.actions.find((a) => a.kind === "original" && a.draftPath === draftPath);
+                if (!action) {
+                    if (!preparedAction?.id ||
+                        preparedAction.kind !== "original" ||
+                        preparedAction.status !== "prepared" ||
+                        preparedAction.draftPath !== draftPath ||
+                        state.actions.some((a) => a.id === preparedAction.id))
+                        throw new Error("unique-prepared-original-required");
+                    const error = guardInput(state, preparedAction, independentExecution);
+                    if (error)
+                        throw new Error(error);
+                    action = structuredClone(preparedAction);
+                    state.actions.push(action);
+                    await save(snapshot, state);
+                }
+                if (action.status !== "prepared")
+                    throw new Error("existing-submission-do-not-resubmit");
+                if (action.claim && store.ownerAlive(action.claim.pid))
+                    throw new Error("same-action-claimed");
+                const error = guardInput(state, action, independentExecution);
+                if (error)
+                    throw new Error(error);
+            });
+            const own = await platform.readAccount();
+            if (own.needsStateCheck ||
+                own.alerts?.length ||
+                !same(own.accountHandle, action.accountHandle))
+                throw new Error("fresh-account-unconfirmed");
+            const baseline = await platform.findSubmission({
+                ...action,
+                intentAt: stamp(),
+            });
+            if (baseline.needsStateCheck || baseline.alerts?.length)
+                throw new Error("publication-baseline-unconfirmed");
+            token = `${action.id}:${stamp()}:${Math.random()}`;
+            await store.withLock(async () => {
+                const snapshot = await load(taskId), state = structuredClone(snapshot.state);
+                const target = state.actions.find((a) => a.id === action.id), item = state.items.find((i) => i.kind === "original");
+                if (target?.status !== "prepared" ||
+                    (target.claim && store.ownerAlive(target.claim.pid)))
+                    throw new Error("action-already-claimed-do-not-resubmit");
+                const error = guardInput(state, target, independentExecution);
+                if (error)
+                    throw new Error(error);
+                if (!inWindow() || item.verified + item.unknown >= item.planned)
+                    throw new Error("window-or-original-capacity-unavailable");
+                Object.assign(target, {
+                    status: "intent",
+                    intentAt: stamp(),
+                    beforeIds: (baseline.posts ?? [])
+                        .map((p) => p.id)
+                        .filter(Boolean),
+                    claimToken: token,
+                    independentExecution,
+                    claim: {
+                        actionId: target.id,
+                        token,
+                        pid: store.processId,
+                        tabId: independentExecution.tabId,
+                        acquiredAt: stamp(),
+                    },
+                });
+                item.unknown += 1;
+                state.attempts ??= [];
+                state.attempts.push({
+                    actionId: target.id,
+                    kind: "original",
+                    at: target.intentAt,
+                });
+                await save(snapshot, state);
+                action = structuredClone(target);
+            });
+            let observation;
+            try {
+                await platform.submitPost({
+                    ...action,
+                    beforeSubmit: async () => {
+                        const latest = await load(taskId), target = latest.state.actions.find((a) => a.id === action.id);
+                        if (target?.status !== "intent" ||
+                            target.claimToken !== token ||
+                            !inWindow())
+                            throw new Error("action-claim-or-window-changed");
+                        const error = guardInput(latest.state, target, independentExecution);
+                        if (error)
+                            throw new Error(error);
+                        submissionStarted = true;
+                    },
+                });
+                observation = await platform.findSubmission(action);
+            }
+            catch (error) {
+                if (!submissionStarted)
+                    throw error;
+                observation = {
+                    verified: false,
+                    missing: ["submission-or-verification-failed"],
+                    error: error.message.slice(0, 240),
+                };
+            }
+            return await store.withLock(async () => {
+                const snapshot = await load(taskId), target = snapshot.state.actions.find((a) => a.id === action.id);
+                if (target?.claimToken !== token || target.status !== "intent")
+                    throw new Error("action-settlement-conflict");
+                await settleProof(snapshot, target, observation, {
+                    preserveStatus: true,
+                });
+                return {
+                    status: observation.verified ? "verified" : "unknown",
+                    taskId,
+                    actionId: action.id,
+                    publicId: observation.publicId,
+                    evidenceRef: store.path,
+                    mayEnd: false,
+                };
+            });
+        }
+        catch (error) {
+            if (token && !submissionStarted)
+                await store.withLock(async () => {
+                    const snapshot = await load(taskId), state = structuredClone(snapshot.state), target = state.actions.find((a) => a.id === action.id);
+                    if (target?.claimToken !== token || target.status !== "intent")
+                        return;
+                    target.status = "prepared";
+                    target.preparationEvidence = await store.recordProof({
+                        observedAt: stamp(),
+                        submissionStarted: false,
+                        error: error.message.slice(0, 240),
+                    });
+                    state.items.find((i) => i.kind === "original").unknown -= 1;
+                    await save(snapshot, state);
+                });
+            return {
+                status: "needsDecision",
+                taskId,
+                mayEnd: false,
+                decision: [
+                    {
+                        reason: error.code === "CONFLICT"
+                            ? "original-ledger-conflict"
+                            : error.message.slice(0, 240),
+                    },
+                ],
+            };
+        }
+        finally {
+            if (token)
+                await store.transaction((snapshot) => {
+                    if (snapshot.state.batchId !== taskId)
+                        return null;
+                    const next = structuredClone(snapshot.state), target = next.actions.find((a) => a.id === action.id);
+                    if (target?.claim?.token !== token)
+                        return null;
+                    delete target.claim;
+                    return next;
+                });
+        }
+    }
+    async function releaseSession(taskId = undefined) {
+        if (!executor)
+            return;
+        await store.transaction((latest) => {
+            const own = latest.state.executions?.[executor.id];
+            if ((taskId && latest.state.batchId !== taskId) ||
+                own?.runtimeId !== runtimeId ||
+                !own.activity)
+                return null;
+            const next = structuredClone(latest.state);
+            delete next.executions[executor.id].activity;
+            next.updatedAt = stamp();
+            return next;
+        });
+    }
+    async function readTask(operation, { mode = "receipt", ...input } = {}) {
+        if (!["decision", "receipt", "delta"].includes(mode))
+            throw new Error("读取模式须为decision/receipt/delta");
+        if (running)
+            return {
+                status: "needsDecision",
+                complete: false,
+                reason: "same-tab-operation-running",
+            };
+        const caps = platform.preflight({
+            operation: ["readAccount", "readPerson", "readPost"].includes(operation)
+                ? "read"
+                : operation,
+            input,
+        });
+        if (!caps.covered || typeof platform[operation] !== "function")
+            return {
+                status: "needsCapability",
+                ...caps,
+                missing: [
+                    ...(caps.missing ?? []),
+                    ...(typeof platform[operation] === "function"
+                        ? []
+                        : [`platform.${operation}`]),
+                ],
+            };
+        running = true;
+        try {
+            if (executor)
+                await store.transaction((latest) => {
+                    const next = structuredClone(latest.state);
+                    next.executions ??= {};
+                    if (Object.values(next.executions).some((e) => (e.tabId === executor.tabId || e.id === executor.id) &&
+                        e.runtimeId !== runtimeId &&
+                        (e.activity || e.actionId) &&
+                        store.ownerAlive(e.pid)))
+                        throw new Error("same-tab-or-executor-claimed");
+                    next.executions[executor.id] = {
+                        ...next.executions[executor.id],
+                        ...executor,
+                        runtimeId,
+                        pid: store.processId,
+                        activity: operation,
+                        status: next.executions[executor.id]?.status ?? "RUNNING",
+                        updatedAt: stamp(),
+                    };
+                    next.updatedAt = stamp();
+                    return next;
+                });
+            const value = await platform[operation](input);
+            const evidenceRef = await store.recordProof(await platform.captureProof({ observation: value }));
+            const status = value.status ??
+                (value.complete === false ||
+                    value.needsStateCheck ||
+                    value.alerts?.length
+                    ? "needsDecision"
+                    : "observed");
+            const receipt = {
+                status,
+                fresh: true,
+                evidenceRef,
+                complete: status === "observed" && (value.complete ?? !value.needsStateCheck),
+                ...((value.sources ?? value.feedback)
+                    ? { ids: (value.sources ?? value.feedback).map((p) => p.id) }
+                    : {}),
+                ...(operation === "readAccount"
+                    ? {
+                        accountHandle: value.accountHandle ?? null,
+                        accountURL: value.accountURL ?? null,
+                    }
+                    : {}),
+                ...(value.missing?.length ? { missing: value.missing } : {}),
+            };
+            if (mode === "receipt")
+                return receipt;
+            const collection = value.sources
+                ? "sources"
+                : value.feedback
+                    ? "feedback"
+                    : null;
+            if (mode === "delta" && collection) {
+                const unchangedIds = [], changed = [];
+                for (const entry of value[collection]) {
+                    const key = JSON.stringify([operation, input, entry.id]);
+                    const normalized = JSON.stringify(entry, (name, val) => name === "observedAt" ? undefined : val);
+                    if (readCache.get(key) === normalized)
+                        unchangedIds.push(entry.id);
+                    else
+                        changed.push(entry);
+                    readCache.set(key, normalized);
+                }
+                return { ...receipt, [collection]: changed, unchangedIds };
+            }
+            return mode === "delta" ? receipt : { ...value, ...receipt };
+        }
+        catch (error) {
+            const category = /connection|transport|interrupted|extension/i.test(error.message)
+                ? "browser-connection"
+                : "ui-not-confirmed";
+            const code = error.code === "CONFLICT"
+                ? "ledger-conflict"
+                : /same-tab-or-executor-claimed/.test(error.message)
+                    ? "tab-busy"
+                    : category === "browser-connection"
+                        ? "connection-failed"
+                        : "observation-unconfirmed";
+            const diagnostic = { operation, category, code };
+            const evidenceRef = await store.recordProof({
+                capturedAt: stamp(),
+                diagnostic: { ...diagnostic, error: error.message },
+            });
+            return {
+                status: "needsDecision",
+                fresh: false,
+                complete: false,
+                evidenceRef,
+                diagnostic: mode === "decision"
+                    ? { ...diagnostic, error: error.message.slice(0, 240) }
+                    : diagnostic,
+            };
+        }
+        finally {
+            try {
+                await releaseSession();
+            }
+            finally {
+                running = false;
+            }
+        }
+    }
+    // Stable prepared actions are adopted in the original ledger, never in a second queue.
+    async function prepareActionsForCall(taskId, actions = []) {
+        if (!actions.length)
+            return;
+        await store.transaction(async (snapshot) => {
+            if (snapshot.state.batchId !== taskId)
+                throw new Error("original-task-id-required");
+            const next = structuredClone(snapshot.state);
+            next.actions ??= [];
+            const ids = new Set();
+            for (const action of actions) {
+                if (!action?.id ||
+                    ids.has(action.id) ||
+                    action.status !== "prepared" ||
+                    !kinds.includes(action.kind))
+                    throw new Error("unique-prepared-action-required");
+                ids.add(action.id);
+                const inputError = guardInput(next, action);
+                if (inputError)
+                    throw new Error(inputError);
+                const existing = next.actions.find((a) => a.id === action.id);
+                if (existing) {
+                    const fields = [
+                        "kind",
+                        "accountHandle",
+                        "handle",
+                        "postId",
+                        "text",
+                        "draftPath",
+                    ];
+                    if (fields.some((field) => existing[field] !== action[field]))
+                        throw new Error("original-action-input-changed");
+                    continue; // intent/unknown/verified stay untouched and follow their original recovery.
+                }
+                const duplicate = next.actions.some((a) => a.kind === action.kind &&
+                    (action.kind === "follow"
+                        ? same(a.handle, action.handle)
+                        : action.kind === "original"
+                            ? a.draftPath === action.draftPath
+                            : a.postId === action.postId && a.text === action.text));
+                if (duplicate)
+                    throw new Error("business-object-already-prepared");
+                const item = next.items.find((i) => i.kind === action.kind);
+                const queued = next.actions.filter((a) => a.kind === action.kind &&
+                    !["skipped", "preexisting"].includes(a.status)).length;
+                if (!item || queued >= item.planned)
+                    throw new Error("prepared-actions-exceed-original-target");
+                next.actions.push(structuredClone(action));
+            }
+            next.updatedAt = stamp();
+            return next;
+        });
+    }
+    return {
+        async verifyPublishedPost({ taskId, draftPath, publicURL, evidenceRef, sourceLink, }) {
+            // Read-only recovery of a single submitted original; never opens a composer.
+            const caps = capability("read");
+            if (!caps.covered || typeof platform.readPost !== "function")
+                return {
+                    status: "needsCapability",
+                    missing: ["platform.readPost", ...caps.missing],
+                };
+            const initial = await load(taskId);
+            const action = initial.state.actions.find((a) => a.kind === "original" && a.draftPath === draftPath);
+            if (!action ||
+                !["intent", "unknown"].includes(action.status) ||
+                !evidenceExists(evidenceRef))
+                throw new Error("submitted-original-and-public-proof-required");
+            const url = xURL(publicURL), postId = url.pathname.match(/\/status\/(\d+)$/)?.[1];
+            if (!postId ||
+                url.pathname.toLowerCase() !==
+                    `/${action.accountHandle}/status/${postId}`.toLowerCase())
+                throw new Error("public-account-mismatch");
+            const observation = await platform.readPost({
+                postId,
+                url: publicURL,
+                evidenceRef,
+            });
+            const trailing = action.text.match(/\n\n(https:\/\/\S+)$/);
+            const matches = (observation.posts ?? []).filter((p) => {
+                const exact = p.body === action.text;
+                const card = trailing &&
+                    sourceLink &&
+                    evidenceExists(sourceLink.evidenceRef) &&
+                    sourceLink.resolvedURL === trailing[1] &&
+                    p.links?.includes(sourceLink.href) &&
+                    p.body === action.text.slice(0, -trailing[0].length);
+                let renderedSource = false;
+                if (trailing &&
+                    sourceLink?.renderedText &&
+                    evidenceExists(sourceLink.evidenceRef) &&
+                    sourceLink.resolvedURL === trailing[1] &&
+                    p.links?.includes(sourceLink.href)) {
+                    try {
+                        renderedSource =
+                            new URL(sourceLink.renderedText.replace(/\s/g, "")).href ===
+                                sourceLink.resolvedURL &&
+                                p.body?.endsWith(sourceLink.renderedText) &&
+                                p.body.slice(0, -sourceLink.renderedText.length).trimEnd() ===
+                                    action.text.slice(0, -trailing[0].length);
+                    }
+                    catch {
+                        /* Invalid rendered URL cannot verify publication. */
+                    }
+                }
+                return (p.id === postId &&
+                    same(p.author, action.accountHandle) &&
+                    (exact || card || renderedSource) &&
+                    !p.needsExpansion &&
+                    !(action.beforeIds ?? []).includes(p.id) &&
+                    Date.parse(p.datetime) >= Date.parse(action.intentAt) &&
+                    Date.parse(p.datetime) <= clock() + 5000 &&
+                    (!action.assets?.length ||
+                        action.assets.every((a) => p.images?.some((i) => i.alt === a.alt))));
+            });
+            Object.assign(observation, {
+                verified: !observation.needsStateCheck &&
+                    !observation.alerts?.length &&
+                    matches.length === 1,
+                publicId: matches.length === 1 ? postId : null,
+                sourceLink,
+            });
+            return store.withLock(async () => {
+                const latest = await load(taskId), target = latest.state.actions.find((a) => a.id === action.id);
+                if (!["intent", "unknown"].includes(target?.status) ||
+                    target.intentAt !== action.intentAt ||
+                    target.text !== action.text)
+                    throw new Error("recovery-action-changed");
+                await settleProof(latest, target, observation, {
+                    preserveStatus: true,
+                });
+                return {
+                    status: observation.verified ? "verified" : "unknown",
+                    publicId: observation.publicId,
+                    taskId,
+                    actionId: action.id,
+                    mayEnd: false,
+                };
+            });
+        },
+        preflight: ({ operation, input = {} }) => {
+            if (["readBookmarks", "searchSources", "readFeedback"].includes(operation))
+                return platform.preflight({ operation, input });
+            if (["inspectRound", "verifySubmission"].includes(operation))
+                return capability("read", input);
+            if (["inspectAccount", "verifyFollow"].includes(operation)) {
+                const name = operation === "verifyFollow" ? "readPerson" : "readAccount";
+                if (typeof platform?.preflight !== "function" ||
+                    typeof platform?.[name] !== "function")
+                    return {
+                        covered: false,
+                        missing: [name],
+                        owner: "scripts/x-harness-platform.mjs",
+                    };
+                return platform.preflight({ operation: "read", input });
+            }
+            if (["runGrowthRound", "resumeGrowthRound"].includes(operation)) {
+                const scoped = executor?.scopeKinds ?? input.scopeKinds ?? kinds;
+                if (!Array.isArray(scoped) ||
+                    !scoped.length ||
+                    scoped.some((k) => !kinds.includes(k)))
+                    return {
+                        covered: false,
+                        missing: ["scopeKinds"],
+                        owner: "scripts/x-growth-harness.mjs",
+                    };
+                const all = scoped.map((kind) => capability(operations[kind], { ...input, kind }));
+                return {
+                    covered: all.every((c) => c.covered),
+                    missing: [...new Set(all.flatMap((c) => c.missing))],
+                    owners: [
+                        ...new Set(all.filter((c) => !c.covered).map((c) => c.owner)),
+                    ],
+                };
+            }
+            if (![
+                "read",
+                "followOne",
+                "followBatch",
+                "publishPost",
+                "replyToPost",
+                ...Object.values(operations),
+            ].includes(operation))
+                return {
+                    covered: false,
+                    missing: [`operation.${operation}`],
+                    owner: "scripts/x-growth-harness.mjs",
+                };
+            return capability(operation, input);
+        },
+        readCreator: (args) => readTask("readCreator", args),
+        inspectAccount: (args) => readTask("readAccount", args),
+        readPost: (args) => readTask("readPost", { ...args, expand: true }),
+        readPerson: (args) => readTask("readPerson", args),
+        readBookmarks: (args) => readTask("readBookmarks", args),
+        searchSources: (args) => readTask("searchSources", args),
+        readFeedback: (args) => readTask("readFeedback", args),
+        verifySubmission: async ({ taskId, actionId }) => {
+            const snapshot = await load(taskId), action = snapshot.state.actions?.find((a) => a.id === actionId);
+            if (!action || !["intent", "unknown"].includes(action.status))
+                return {
+                    status: "needsDecision",
+                    reason: "verification-requires-original-unknown-or-intent",
+                    mayEnd: false,
+                };
+            return (executor ? parallelRound : round)({
+                taskId,
+                requestedKind: action.kind,
+                selector: (a) => a.id === actionId,
+            });
+        },
+        verifyFollow: async (target) => {
+            const mode = target.mode ?? "receipt";
+            if (!["receipt", "decision"].includes(mode))
+                throw new Error("关注核验模式须为receipt/decision");
+            const caps = platform.preflight({ operation: "read" });
+            if (!caps.covered)
+                return {
+                    handle: target.handle,
+                    verified: false,
+                    status: "needsCapability",
+                    ...caps,
+                };
+            if (!target.url || !target.evidenceRef) {
+                const original = (await store.load()).state.actions?.find((a) => a.kind === "follow" && same(a.handle, target.handle));
+                if (!original)
+                    return {
+                        handle: target.handle,
+                        verified: false,
+                        status: "needsDecision",
+                        reason: "original-person-observation-required",
+                    };
+                target = original;
+            }
+            const value = await readTask("readPerson", {
+                ...target,
+                mode: "decision",
+            });
+            return {
+                handle: target.handle,
+                status: value.status,
+                fresh: value.fresh,
+                verified: value.status === "observed" &&
+                    !value.needsStateCheck &&
+                    !value.alerts?.length &&
+                    value.relationship === "following" &&
+                    (!target.accountHandle ||
+                        same(value.accountHandle, target.accountHandle)),
+                ...(value.evidenceRef ? { evidenceRef: value.evidenceRef } : {}),
+                ...(value.missing?.length ? { missing: value.missing } : {}),
+                ...(value.diagnostic
+                    ? {
+                        diagnostic: {
+                            operation: value.diagnostic.operation,
+                            category: value.diagnostic.category,
+                            code: value.diagnostic.code,
+                        },
+                    }
+                    : {}),
+                ...(mode === "decision" ? { observation: value } : {}),
+            };
+        },
+        runGrowthRound: (args) => executor ? parallelRound(args) : round(args),
+        resumeGrowthRound: (args) => executor ? parallelRound(args) : round(args),
+        inspectRound: async ({ taskId }) => {
+            const snapshot = await load(taskId);
+            return result(snapshot);
+        },
+        followOne: ({ taskId, handle }) => (executor ? parallelRound : round)({
+            taskId,
+            requestedKind: "follow",
+            selector: (a) => a.kind === "follow" && same(a.handle, handle),
+        }),
+        followBatch: async ({ taskId, handles, preparedActions } = {}) => {
+            if (!Array.isArray(handles) ||
+                handles.length < 5 ||
+                handles.length > 10 ||
+                handles.some((h) => !/^[A-Za-z0-9_]{1,15}$/.test(h)) ||
+                new Set(handles.map((h) => h.toLowerCase())).size !==
+                    handles.length)
+                throw new Error("正常关注子批需5～10位不同的已准备对象");
+            if (preparedActions?.some((a) => a.kind !== "follow" ||
+                !handles.some((h) => same(h, a.handle))))
+                throw new Error("batch-action-target-mismatch");
+            await prepareActionsForCall(taskId, preparedActions);
+            let batchId, resumedBatch = false;
+            const original = await store.transaction(async (snapshot) => {
+                if (!scope(snapshot.state).includes("follow"))
+                    throw new Error("kind-outside-round-scope");
+                if (snapshot.state.batchId !== taskId ||
+                    handles.some((h) => !snapshot.state.actions?.some((a) => a.kind === "follow" && same(a.handle, h))))
+                    throw new Error("子批名单必须归原任务队列");
+                const next = structuredClone(snapshot.state);
+                next.followBatches ??= [];
+                const previous = next.followBatches.findLast((b) => b.status !== "SETTLED" &&
+                    b.handles.length === handles.length &&
+                    b.handles.every((h, i) => same(h, handles[i])));
+                resumedBatch = Boolean(previous);
+                batchId = previous?.id ?? `${taskId}-FOLLOW-${stamp()}`;
+                if (previous)
+                    Object.assign(previous, {
+                        status: "RUNNING",
+                        lastResumedAt: stamp(),
+                    });
+                else
+                    next.followBatches.push({
+                        id: batchId,
+                        handles,
+                        planned: handles.length,
+                        startedAt: stamp(),
+                        status: "RUNNING",
+                    });
+                next.updatedAt = stamp();
+                return next;
+            });
+            const preparedCount = original.state.actions.filter((a) => a.kind === "follow" &&
+                a.status === "prepared" &&
+                handles.some((h) => same(h, a.handle))).length;
+            let eligibleAt = clock();
+            const previousGroup = original.state.execution?.followGroup;
+            const lastAttempt = (original.state.attempts ?? [])
+                .filter((a) => a.kind === "follow")
+                .sort((a, b) => Date.parse(a.at) - Date.parse(b.at))
+                .at(-1);
+            const lastAction = original.state.actions.find((a) => a.id === lastAttempt?.actionId);
+            const sameBatchRecovery = resumedBatch &&
+                lastAction?.status === "verified" &&
+                evidenceExists(lastAction.resultEvidence) &&
+                handles.some((h) => same(h, lastAction.handle));
+            if (preparedCount && previousGroup?.attempts && !sameBatchRecovery)
+                eligibleAt = Math.max(eligibleAt, Date.parse(previousGroup.lastAt) + 180000);
+            for (const [duration, limit] of followWindows) {
+                const recent = (original.state.attempts ?? [])
+                    .filter((a) => a.kind === "follow" && Date.parse(a.at) > clock() - duration)
+                    .sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+                if (preparedCount > limit - recent.length)
+                    eligibleAt = Math.max(eligibleAt, Date.parse(recent[recent.length - limit + preparedCount - 1].at) +
+                        duration);
+            }
+            if (eligibleAt > clock()) {
+                const resumeAt = new Date(eligibleAt).toISOString();
+                await store.transaction((snapshot) => {
+                    const next = structuredClone(snapshot.state);
+                    Object.assign(next.followBatches.find((b) => b.id === batchId), { status: "WAITING", remaining: preparedCount, resumeAt });
+                    next.updatedAt = stamp();
+                    return next;
+                });
+                return {
+                    taskId,
+                    batchId,
+                    planned: handles.length,
+                    attempted: 0,
+                    verifiedThisCall: 0,
+                    unknownInBatch: original.state.actions.filter((a) => handles.some((h) => same(h, a.handle)) &&
+                        ["unknown", "intent"].includes(a.status)).length,
+                    remaining: preparedCount,
+                    mayEnd: false,
+                    decision: [
+                        {
+                            kind: "follow",
+                            status: "waiting",
+                            reason: "normal-batch-capacity-or-cooldown",
+                            resumeAt,
+                        },
+                    ],
+                    evidenceRef: store.path,
+                };
+            }
+            let result;
+            const exceptional = [];
+            for (const handle of handles) {
+                // A resumed batch submits only its remaining prepared members. Recovery
+                // stays in the read-only API; a frozen member must not disturb that path.
+                if (!original.state.actions.some((a) => a.kind === "follow" &&
+                    same(a.handle, handle) &&
+                    a.status === "prepared"))
+                    continue;
+                result = await (executor ? parallelRound : round)({
+                    taskId,
+                    requestedKind: "follow",
+                    selector: (a) => a.kind === "follow" && same(a.handle, handle),
+                });
+                const relevant = (result.decision ?? []).filter((d) => d.kind === "follow" ||
+                    ["harness-boundary-error", "original-ledger-conflict"].includes(d.reason) ||
+                    original.state.actions.some((a) => a.id === d.actionId && a.kind === "follow"));
+                exceptional.push(...relevant);
+                // A new unconfirmed submission is a diagnostic boundary, not permission
+                // to consume the rest of the batch on the same failing write path.
+                if (relevant.length)
+                    break;
+            }
+            const after = await store.load();
+            const summary = {
+                taskId,
+                batchId,
+                planned: handles.length,
+                attempted: (after.state.attempts ?? [])
+                    .slice(original.state.attempts?.length ?? 0)
+                    .filter((a) => a.kind === "follow" &&
+                    handles.some((h) => same(after.state.actions.find((x) => x.id === a.actionId)
+                        ?.handle, h))).length,
+                verifiedThisCall: after.state.actions.filter((a) => a.kind === "follow" &&
+                    a.status === "verified" &&
+                    handles.some((h) => same(h, a.handle)) &&
+                    original.state.actions.find((old) => old.id === a.id)
+                        ?.status !== "verified").length,
+                unknownInBatch: after.state.actions.filter((a) => a.kind === "follow" &&
+                    handles.some((h) => same(a.handle, h)) &&
+                    ["unknown", "intent"].includes(a.status)).length,
+                remaining: after.state.actions.filter((a) => a.kind === "follow" &&
+                    handles.some((h) => same(a.handle, h)) &&
+                    a.status === "prepared").length,
+                actual: result?.actual,
+                decision: exceptional,
+                mayEnd: result?.mayEnd ?? false,
+                evidenceRef: store.path,
+            };
+            await store.transaction((snapshot) => {
+                const next = structuredClone(snapshot.state), batch = next.followBatches.find((b) => b.id === batchId);
+                Object.assign(batch, {
+                    attempted: (batch.attempted ?? 0) + summary.attempted,
+                    verifiedTotal: (batch.verifiedTotal ?? 0) + summary.verifiedThisCall,
+                    verifiedThisCall: summary.verifiedThisCall,
+                    unknown: summary.unknownInBatch,
+                    remaining: summary.remaining,
+                    finishedAt: stamp(),
+                    status: summary.remaining || summary.unknownInBatch ? "PARTIAL" : "SETTLED",
+                });
+                next.updatedAt = stamp();
+                return next;
+            });
+            return summary;
+        },
+        publishPost: async (input) => {
+            if (!executor && input.independentExecution)
+                return publishIndependent(input);
+            if (input.preparedAction &&
+                (input.preparedAction.kind !== "original" ||
+                    input.preparedAction.draftPath !== input.draftPath))
+                throw new Error("prepared-original-target-mismatch");
+            await prepareActionsForCall(input.taskId, input.preparedAction ? [input.preparedAction] : []);
+            return (executor ? parallelRound : round)({
+                taskId: input.taskId,
+                requestedKind: "original",
+                selector: (a) => a.kind === "original" && a.draftPath === input.draftPath,
+            });
+        },
+        replyToPost: async ({ taskId, postId, text, preparedAction }) => {
+            if (preparedAction &&
+                (preparedAction.kind !== "reply" ||
+                    preparedAction.postId !== postId ||
+                    preparedAction.text !== text))
+                throw new Error("prepared-reply-target-mismatch");
+            await prepareActionsForCall(taskId, preparedAction ? [preparedAction] : []);
+            return (executor ? parallelRound : round)({
+                taskId,
+                requestedKind: "reply",
+                selector: (a) => a.kind === "reply" && a.postId === postId && a.text === text,
+            });
+        },
+    };
+}