@nextclaw/x-harness 0.1.0 → 0.1.1

package/dist/browser-native.js

@@ -1,7 +1,36 @@
-import { createAXHarness, readAX } from "./readers.js";
-import { xURL } from "./platform.js";
+import { createAXHarness } from "./readers-ax-host.js";
+import { readAX } from "./readers-ax-parser.js";
+import { xURL } from "./platform-rules.js";
 import { serialized, missingMethods, plain, valueOf, } from "./browser-common.js";
 export function createNativeXBrowser(app) {
+    async function navigateNativeTarget(command) {
+        xURL(command.url);
+        if (!command.evidenceRef)
+            throw new Error("导航URL缺原观察证据");
+        await low.observe({ mode: "navigation" }).then((raw) => {
+            current = { raw };
+        });
+        let index = one((e) => /^文本栏 .*地址和搜索栏/.test(e.label));
+        await low
+            .act({
+            index,
+            operation: "fill",
+            value: command.url,
+            read: { mode: "navigation" },
+        })
+            .then((raw) => {
+            current = { raw };
+        });
+        index = one((e) => /^文本栏 .*地址和搜索栏/.test(e.label));
+        await low.act({
+            index,
+            operation: "pressKey",
+            value: "Return",
+            read: { mode: "navigation" },
+        });
+        current = null;
+        return;
+    }
     let latestAX;
     const delegated = {};
     for (const name of [
@@ -124,32 +153,7 @@ export function createNativeXBrowser(app) {
         observe,
         async act(command) {
             if (command.operation === "openObserved") {
-                xURL(command.url);
-                if (!command.evidenceRef)
-                    throw new Error("导航URL缺原观察证据");
-                await low.observe({ mode: "navigation" }).then((raw) => {
-                    current = { raw };
-                });
-                let index = one((e) => /^文本栏 .*地址和搜索栏/.test(e.label));
-                await low
-                    .act({
-                    index,
-                    operation: "fill",
-                    value: command.url,
-                    read: { mode: "navigation" },
-                })
-                    .then((raw) => {
-                    current = { raw };
-                });
-                index = one((e) => /^文本栏 .*地址和搜索栏/.test(e.label));
-                await low.act({
-                    index,
-                    operation: "pressKey",
-                    value: "Return",
-                    read: { mode: "navigation" },
-                });
-                current = null;
-                return;
+                return navigateNativeTarget(command);
             }
             if (command.operation === "refreshPerson") {
                 xURL(command.url);

package/dist/browser.js

@@ -1,4 +1,7 @@
-import { readProfile, readPosts, readComposer, readMediaEditor, readNavigation, readMenu, } from "./readers.js";
+import { readProfile } from "./readers-profile.js";
+import { readPosts } from "./readers-posts.js";
+import { readComposer, readMediaEditor } from "./readers-composer.js";
+import { readNavigation, readMenu } from "./readers-navigation.js";
 export { createDOMXBrowser, readXNetworkDiagnostics } from "./browser-dom.js";
 export { createNativeXBrowser } from "./browser-native.js";
 // Read-only supplement: account identity, composer context and exact tweet bodies.
@@ -106,7 +109,8 @@ export function readXSurface({ view, posts = [], targetId, replyTargetId, } = {}
                             const read = (node) => {
                                 if (node.nodeType === 3)
                                     return node.textContent ?? "";
-                                if (node.nodeType === 1 && node.tagName === "A") {
+                                if (node.nodeType === 1 &&
+                                    node.tagName === "A") {
                                     const href = node.getAttribute("href") ?? "";
                                     if (/^\/\w{1,15}\/status\/\d+$/.test(href))
                                         return `https://x.com${href}`;

package/dist/creator.js

@@ -1,4 +1,4 @@
-import { readProfile } from "./readers.js";
+import { readProfile } from "./readers-profile.js";
 import { readXObservation } from "./observation.js";
 // Read-only DOM metadata. Counts retain the platform's displayed precision.
 export function readCreatorMeta() {

package/dist/growth-batch.d.ts

@@ -0,0 +1,5 @@
+import type { BoundaryRecord } from "./boundary.js";
+import type { GrowthDependencies } from "./growth-dependencies.js";
+export declare function createFollowBatch(dependencies: Pick<GrowthDependencies, "prepareActionsForCall" | "store" | "scope" | "stamp" | "clock" | "evidenceExists" | "executor" | "parallelRound" | "round">): {
+    followBatch: ({ taskId, handles, preparedActions }?: any) => Promise<BoundaryRecord>;
+};

package/dist/growth-batch.js

@@ -0,0 +1,168 @@
+import { followWindows, same } from "./growth-constants.js";
+export function createFollowBatch(dependencies) {
+    const { prepareActionsForCall, store, scope, stamp, clock, evidenceExists, executor, parallelRound, round, } = dependencies;
+    return {
+        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 = summarizeFollowBatch(taskId, batchId, handles, after, original, result, exceptional, 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;
+        },
+    };
+}
+function summarizeFollowBatch(taskId, batchId, handles, after, original, result, exceptional, evidenceRef) {
+    return {
+        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,
+    };
+}

package/dist/growth-constants.d.ts

@@ -0,0 +1,5 @@
+import type { BoundaryRecord } from "./boundary.js";
+export declare const kinds: string[];
+export declare const followWindows: number[][];
+export declare const operations: BoundaryRecord;
+export declare const same: (a: any, b: any) => boolean;

package/dist/growth-constants.js

@@ -0,0 +1,13 @@
+export const kinds = ["follow", "original", "reply"];
+export const followWindows = [
+    [600000, 20],
+    [3600000, 100],
+];
+export const operations = {
+    follow: "submitFollow",
+    original: "submitPost",
+    reply: "submitReply",
+};
+export const same = (a, b) => typeof a === "string" &&
+    typeof b === "string" &&
+    a.toLowerCase() === b.toLowerCase();

package/dist/growth-dependencies.d.ts

@@ -0,0 +1,33 @@
+import type { BoundaryRecord } from "./boundary.js";
+import type { RoundStore } from "./store.js";
+/** Explicit instance dependencies; each owner accepts only its declared subset. */
+export interface GrowthDependencies {
+    platform: BoundaryRecord;
+    store: RoundStore;
+    clock: () => number;
+    executor: BoundaryRecord | undefined;
+    stamp: () => string;
+    evidenceExists: (path: string) => boolean;
+    runtimeId: string;
+    session: {
+        claim: any;
+        running: boolean;
+    };
+    authorizedWindow: (state: any, kind: string) => boolean;
+    scope: (state: any) => any;
+    project: (state: any) => any;
+    load: (taskId: any) => Promise<any>;
+    save: (snapshot: any, state: any) => Promise<any>;
+    result: (snapshot: any, needs?: any) => any;
+    capability: (operation: any, input?: any) => any;
+    waitBudget: (state: any) => any;
+    guardInput: (state: any, action: any, independentExecution?: any) => any;
+    settleProof: (snapshot: any, action: any, observation: any, { preserveStatus }?: any) => Promise<any>;
+    execute: (snapshot: any, action: any) => Promise<any>;
+    parallelRound: ({ taskId, decision, selector, requestedKind, maxActions, }?: any) => Promise<any>;
+    round: ({ taskId, decision, selector, requestedKind }?: any) => Promise<any>;
+    publishIndependent: ({ taskId, draftPath, preparedAction, independentExecution, }: any) => Promise<any>;
+    releaseSession: (taskId?: any) => Promise<any>;
+    readTask: (operation: any, { mode, ...input }?: any) => Promise<any>;
+    prepareActionsForCall: (taskId: string, actions?: any[]) => Promise<void>;
+}

package/dist/growth-execution.d.ts

@@ -0,0 +1,11 @@
+import type { BoundaryRecord } from "./boundary.js";
+import type { RoundSnapshot } from "./store.js";
+interface ExecutionStep {
+    snapshot: RoundSnapshot;
+    need: BoundaryRecord | null;
+}
+import type { GrowthDependencies } from "./growth-dependencies.js";
+export declare function createGrowthExecution(dependencies: Pick<GrowthDependencies, "capability" | "platform" | "settleProof" | "clock" | "save" | "guardInput" | "waitBudget" | "authorizedWindow" | "stamp" | "store" | "executor" | "session">): {
+    execute: (snapshot: any, action: any) => Promise<ExecutionStep>;
+};
+export {};

package/dist/growth-execution.js

@@ -0,0 +1,315 @@
+import { operations, same } from "./growth-constants.js";
+export function createGrowthExecution(dependencies) {
+    const { capability, platform, settleProof, clock, save, guardInput, waitBudget, authorizedWindow, stamp, store, executor, session, } = dependencies;
+    async function checkExecutionIdentity(snapshot, action) {
+        const state = snapshot.state;
+        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",
+                },
+            };
+        return null;
+    }
+    async function admitAction(snapshot, action) {
+        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,
+                },
+            };
+        const identity = await checkExecutionIdentity(snapshot, action);
+        if (identity)
+            return identity;
+        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 >= (action.kind === "reply" ? 24 : 22)) &&
+                !authorizedWindow(state, action.kind))
+                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);
+        }
+        return { beforeIds };
+    }
+    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 admission = await admitAction(snapshot, action);
+        if ("snapshot" in admission)
+            return admission;
+        const { beforeIds } = admission;
+        const state = snapshot.state;
+        // Persist intent BEFORE any externally visible submission. Even a failed attempt consumes budget.
+        const next = structuredClone(state);
+        const entry = next.actions.find((a) => a.id === action.id);
+        entry.status = "intent";
+        entry.intentAt = stamp();
+        entry.beforeIds = beforeIds;
+        next.items.find((i) => i.kind === action.kind).unknown += 1;
+        next.attempts ??= [];
+        next.attempts.push({
+            actionId: action.id,
+            kind: action.kind,
+            at: entry.intentAt,
+        });
+        if (action.kind === "follow") {
+            next.execution ??= {};
+            const old = next.execution.followGroup;
+            next.execution.followGroup = {
+                attempts: old?.attempts < 10 && clock() < Date.parse(old.lastAt) + 180000
+                    ? old.attempts + 1
+                    : 1,
+                lastAt: entry.intentAt,
+            };
+        }
+        snapshot = await save(snapshot, next);
+        let observation, submissionMayHaveStarted = false;
+        try {
+            await platform[operations[action.kind]]({
+                ...entry,
+                beforeSubmit: async () => {
+                    const latest = await store.load();
+                    if (executor) {
+                        const current = latest.state.actions.find((a) => a.id === entry.id);
+                        if (latest.state.batchId !== snapshot.state.batchId ||
+                            current?.claim?.token !== session.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 >= (action.kind === "reply" ? 24 : 22)) &&
+                        !authorizedWindow(latest.state, action.kind))
+                        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),
+                },
+        };
+    }
+    return { execute };
+}

package/dist/growth-parallel.d.ts

@@ -0,0 +1,4 @@
+import type { GrowthDependencies } from "./growth-dependencies.js";
+export declare function createParallelRound(dependencies: Pick<GrowthDependencies, "load" | "scope" | "result" | "store" | "executor" | "runtimeId" | "stamp" | "evidenceExists" | "execute" | "clock" | "releaseSession" | "session">): {
+    parallelRound: ({ taskId, decision, selector, requestedKind, maxActions, }?: any) => Promise<any>;
+};