@nextclaw/x-harness 0.1.0 → 0.2.0

package/dist/growth.js

@@ -1,1918 +1,221 @@
-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;
+import { kinds } from "./growth-constants.js";
+import { createGrowthPolicy } from "./growth-policy.js";
+import { createGrowthState } from "./growth-state.js";
+import { createGrowthExecution } from "./growth-execution.js";
+import { createParallelRound } from "./growth-parallel.js";
+import { createPlannedRound } from "./growth-plan.js";
+import { createIndependentPublishing } from "./growth-publishing.js";
+import { createGrowthReading } from "./growth-reading.js";
+import { createGrowthRecovery } from "./growth-recovery.js";
+import { createFollowBatch } from "./growth-batch.js";
+import { createGrowthTasks } from "./growth-tasks.js";
+/** Synchronous composition only; owners retain one original ledger and settlement path. */
+export class GrowthHarness {
+    #platform;
+    #store;
+    #clock;
+    #executor;
+    #session;
+    #evidenceExists;
+    #runtimeId;
+    #authorizedWindow;
+    #scope;
+    #project;
+    #capability;
+    #waitBudget;
+    #guardInput;
+    #load;
+    #save;
+    #result;
+    #settleProof;
+    #releaseSession;
+    #execute;
+    #parallelRound;
+    #round;
+    #publishIndependent;
+    #prepareActionsForCall;
+    #readTask;
+    #createGrowthRecoveryResult;
+    #createFollowBatchResult;
+    #createGrowthTasksResult;
+    verifyPublishedPost;
+    verifySubmission;
+    verifyFollow;
+    followBatch;
+    preflight;
+    readCreator;
+    inspectAccount;
+    readPost;
+    readPerson;
+    readBookmarks;
+    searchSources;
+    readFeedback;
+    runGrowthRound;
+    resumeGrowthRound;
+    inspectRound;
+    followOne;
+    publishPost;
+    replyToPost;
+    constructor({ platform, store, clock = () => Date.now(), executor, } = {}) {
+        this.#platform = platform;
+        this.#store = store;
+        this.#clock = clock;
+        this.#executor = executor;
+        this.#session = { claim: undefined, running: false };
+        this.#evidenceExists = this.#store.evidenceExists ?? (() => false);
+        this.#runtimeId = randomUUID();
+        if (this.#executor &&
+            (!this.#executor.id ||
+                !this.#executor.tabId ||
+                !Array.isArray(this.#executor.scopeKinds) ||
+                !this.#executor.scopeKinds.length ||
+                new Set(this.#executor.scopeKinds).size !==
+                    this.#executor.scopeKinds.length ||
+                this.#executor.scopeKinds.some((k) => !kinds.includes(k)) ||
+                !this.#evidenceExists(this.#executor.evidenceRef) ||
+                typeof this.#store.transaction !== "function"))
+            throw new Error("并行执行者需ID、独立tab、有效职责及原合同证据与transaction");
+        const { authorizedWindow, scope, project, capability, waitBudget, guardInput, } = createGrowthPolicy({
+            executor: this.#executor,
+            clock: this.#clock,
+            evidenceExists: this.#evidenceExists,
+            platform: this.#platform,
+            store: this.#store,
         });
-    }
-    function result(snapshot, needs = []) {
-        const gate = checkRound(project(snapshot.state), {
-            now: clock(),
-            evidenceExists,
+        this.#authorizedWindow = authorizedWindow;
+        this.#scope = scope;
+        this.#project = project;
+        this.#capability = capability;
+        this.#waitBudget = waitBudget;
+        this.#guardInput = guardInput;
+        const { load, save, result, settleProof, releaseSession } = createGrowthState({
+            store: this.#store,
+            project: this.#project,
+            clock: this.#clock,
+            evidenceExists: this.#evidenceExists,
+            stamp: this.stamp.bind(this),
+            executor: this.#executor,
+            waitBudget: this.#waitBudget,
+            platform: this.#platform,
+            runtimeId: this.#runtimeId,
+            session: this.#session,
         });
-        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,
+        this.#load = load;
+        this.#save = save;
+        this.#result = result;
+        this.#settleProof = settleProof;
+        this.#releaseSession = releaseSession;
+        const { execute } = createGrowthExecution({
+            capability: this.#capability,
+            platform: this.#platform,
+            settleProof: this.#settleProof,
+            clock: this.#clock,
+            save: this.#save,
+            guardInput: this.#guardInput,
+            waitBudget: this.#waitBudget,
+            authorizedWindow: this.#authorizedWindow,
+            stamp: this.stamp.bind(this),
+            store: this.#store,
+            executor: this.#executor,
+            session: this.#session,
         });
-        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;
+        this.#execute = execute;
+        const { parallelRound } = createParallelRound({
+            load: this.#load,
+            scope: this.#scope,
+            result: this.#result,
+            store: this.#store,
+            executor: this.#executor,
+            runtimeId: this.#runtimeId,
+            stamp: this.stamp.bind(this),
+            evidenceExists: this.#evidenceExists,
+            execute: this.#execute,
+            clock: this.#clock,
+            releaseSession: this.#releaseSession,
+            session: this.#session,
         });
-    }
-    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,
+        this.#parallelRound = parallelRound;
+        const { round } = createPlannedRound({
+            store: this.#store,
+            load: this.#load,
+            result: this.#result,
+            evidenceExists: this.#evidenceExists,
+            save: this.#save,
+            execute: this.#execute,
+            clock: this.#clock,
+            stamp: this.stamp.bind(this),
+        });
+        this.#round = round;
+        const { publishIndependent, prepareActionsForCall } = createIndependentPublishing({
+            clock: this.#clock,
+            evidenceExists: this.#evidenceExists,
+            capability: this.#capability,
+            store: this.#store,
+            load: this.#load,
+            guardInput: this.#guardInput,
+            save: this.#save,
+            platform: this.#platform,
+            stamp: this.stamp.bind(this),
+            settleProof: this.#settleProof,
+        });
+        this.#publishIndependent = publishIndependent;
+        this.#prepareActionsForCall = prepareActionsForCall;
+        const { readTask } = createGrowthReading({
+            platform: this.#platform,
+            executor: this.#executor,
+            store: this.#store,
+            runtimeId: this.#runtimeId,
+            stamp: this.stamp.bind(this),
+            releaseSession: this.#releaseSession,
+            session: this.#session,
         });
-        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;
-            }
-        }
+        this.#readTask = readTask;
+        this.composeTasks();
     }
-    // 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;
+    composeTasks() {
+        this.#createGrowthRecoveryResult = createGrowthRecovery({
+            capability: this.#capability,
+            platform: this.#platform,
+            load: this.#load,
+            evidenceExists: this.#evidenceExists,
+            clock: this.#clock,
+            store: this.#store,
+            settleProof: this.#settleProof,
+            executor: this.#executor,
+            parallelRound: this.#parallelRound,
+            round: this.#round,
+            readTask: this.#readTask,
         });
+        this.#createFollowBatchResult = createFollowBatch({
+            prepareActionsForCall: this.#prepareActionsForCall,
+            store: this.#store,
+            scope: this.#scope,
+            stamp: this.stamp.bind(this),
+            clock: this.#clock,
+            evidenceExists: this.#evidenceExists,
+            executor: this.#executor,
+            parallelRound: this.#parallelRound,
+            round: this.#round,
+        });
+        this.#createGrowthTasksResult = createGrowthTasks({
+            platform: this.#platform,
+            capability: this.#capability,
+            executor: this.#executor,
+            readTask: this.#readTask,
+            parallelRound: this.#parallelRound,
+            round: this.#round,
+            load: this.#load,
+            result: this.#result,
+            publishIndependent: this.#publishIndependent,
+            prepareActionsForCall: this.#prepareActionsForCall,
+        });
+        Object.assign(this, Object.assign({}, this.#createGrowthRecoveryResult, this.#createFollowBatchResult, this.#createGrowthTasksResult));
     }
-    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,
-            });
-        },
-    };
+    stamp() {
+        return new Date(this.#clock()).toISOString();
+    }
+}
+export function createGrowthHarness(...args) {
+    return new GrowthHarness(...args);
 }