@nextclaw/x-harness 0.2.58 → 0.2.59

package/SOURCE.md

@@ -1,8 +1,8 @@
 # Corresponding source
 
-Version 0.2.58, commit 4fa6559a68ec71e78c7d655732c4b570496f08b9.
+Version 0.2.59, commit e0c324f79b77f50662ea2969c68ade82a31cb0b5.
 
-Complete source, build scripts and dependencies: https://github.com/Peiiii/x-harness/tree/4fa6559a68ec71e78c7d655732c4b570496f08b9
+Complete source, build scripts and dependencies: https://github.com/Peiiii/x-harness/tree/e0c324f79b77f50662ea2969c68ade82a31cb0b5
 
 Clone this revision, run npm ci, npm run bootstrap and npm run release:build.
 

package/dist/api.d.ts

@@ -26,6 +26,7 @@ export declare class BusinessHarness implements XGrowthHarness {
         results: ActionResult[];
         reason?: undefined;
     }>;
+    private recoverBatchReplyLinks;
     likeIncomingBatch(args: import("./types.js").IncomingLikeOptions): Promise<import("./types.js").IncomingLikeResult>;
     readCreator(args: import("./types.js").CreatorOptions): Promise<ReadResult>;
     readBookmarks(args: import("./types.js").BookmarkOptions): Promise<ReadResult>;

package/dist/api.js

@@ -1,3 +1,4 @@
+import { sameHandle, samePublishedText } from "./platform-rules.js";
 import { IncomingReactions } from "./incoming-reactions.js";
 import { createGrowthHarness } from "./growth.js";
 import { readResult, decisions, diagnostic, stableReason } from "./results.js";
@@ -329,6 +330,7 @@ export class BusinessHarness {
             if (["waiting", "needsCapability", "needsDecision"].includes(result.status))
                 break;
         }
+        await this.recoverBatchReplyLinks(args.taskId, results);
         return {
             status: results.length === args.actions.length &&
                 results.every((r) => ["verified", "preexisting"].includes(r.status))
@@ -337,6 +339,82 @@ export class BusinessHarness {
             results,
         };
     }
+    async recoverBatchReplyLinks(taskId, results) {
+        const snapshot = await this.#store.load();
+        if (snapshot.state.batchId !== taskId)
+            return;
+        const pending = results
+            .filter((r) => r.status === "unknown")
+            .map((r) => snapshot.state.actions.find((a) => a.id === r.actionId))
+            .filter((a) => a?.kind === "reply" &&
+            ["unknown", "intent"].includes(a.status) &&
+            !a.observedPublicURL &&
+            typeof a.text === "string" &&
+            a.text.trim() &&
+            /^[A-Za-z0-9_]{1,15}$/.test(a.accountHandle ?? "") &&
+            Number.isFinite(Date.parse(a.intentAt)));
+        if (!pending.length ||
+            !pending.every((a) => sameHandle(a.accountHandle, pending[0].accountHandle)))
+            return;
+        const phrases = pending
+            .map((a) => '"' + a.text.slice(0, 80).replace(/["\\]/g, " ") + '"')
+            .join(" OR ");
+        const query = `from:${pending[0].accountHandle} (${phrases}) since:${new Date(Math.min(...pending.map((a) => Date.parse(a.intentAt)))).toISOString().slice(0, 10)}`;
+        let found = await this.searchSources({
+            query,
+            limit: 5,
+            maxPages: 1,
+            mode: "decision",
+        });
+        if (!found.sources?.length &&
+            found.missing?.includes("source-page-unconfirmed"))
+            found = await this.searchSources({
+                query,
+                limit: 5,
+                maxPages: 1,
+                mode: "decision",
+            });
+        if (!found.fresh || !found.evidenceRef)
+            return;
+        for (const action of pending) {
+            const matches = (found.sources ?? []).filter((p) => sameHandle(p.author, action.accountHandle) &&
+                samePublishedText(p.body, action.text) &&
+                /^\d+$/.test(p.id ?? "") &&
+                !p.needsExpansion &&
+                p.url?.toLowerCase() ===
+                    `https://x.com/${action.accountHandle}/status/${p.id}`.toLowerCase() &&
+                !(action.beforeIds ?? []).includes(p.id) &&
+                Date.parse(p.datetime ?? "") >= Date.parse(action.intentAt) &&
+                Date.parse(p.datetime ?? "") <= this.#clock() + 5000);
+            if (matches.length !== 1)
+                continue;
+            let bound = false;
+            await this.#store.transaction(({ state }) => {
+                const current = state.actions.find((a) => a.id === action.id);
+                if (state.batchId === taskId &&
+                    current?.status === "unknown" &&
+                    current.intentAt === action.intentAt &&
+                    current.postId === action.postId &&
+                    current.text === action.text &&
+                    !current.observedPublicURL &&
+                    !current.claim) {
+                    current.observedPublicURL = matches[0].url;
+                    current.observedPublicEvidenceRef = found.evidenceRef;
+                    bound = true;
+                }
+                return state;
+            });
+            if (bound) {
+                const recovered = await this.verifySubmission({
+                    taskId,
+                    actionId: action.id,
+                });
+                const index = results.findIndex((r) => r.actionId === action.id);
+                if (index >= 0)
+                    results[index] = recovered;
+            }
+        }
+    }
     likeIncomingBatch(args) {
         return this.#reactions.run(args);
     }

package/dist/round-state.js

@@ -157,6 +157,39 @@ export function runRoundCLI() {
                 scopeEvidenceRef: execution.evidenceRef,
                 stop: execution.stop,
             };
+            const gap = execution.followGapCondition;
+            if (gap &&
+                execution.scopeKinds.length === 1 &&
+                execution.scopeKinds[0] === "reply") {
+                const ids = gap.actionIds;
+                if (!gap.sourceExecutor ||
+                    !existsSync(gap.authorizationEvidenceRef ?? "") ||
+                    !Array.isArray(ids) ||
+                    !ids.length ||
+                    new Set(ids).size !== ids.length ||
+                    gap.planned !== ids.length)
+                    throw Error("conditional-reply-scope-unconfirmed");
+                const actions = ids.map((id) => state.actions.find((a) => a.id === id));
+                if (actions.some((a) => !a || a.kind !== "reply"))
+                    throw Error("conditional-reply-actions-unconfirmed");
+                scoped.items = state.items.map((item) => item.kind !== "reply"
+                    ? item
+                    : {
+                        ...state.items.find((i) => i.kind === "reply"),
+                        planned: ids.length,
+                        verified: actions.filter((a) => a.status === "verified")
+                            .length,
+                        unknown: actions.filter((a) => ["intent", "unknown"].includes(a.status)).length,
+                        actionable: actions.some((a) => a.status === "prepared"),
+                        reason: execution.currentWork,
+                        resumeAt: execution.stop?.nextEligibleCheckAt,
+                        resumeWhen: execution.currentWork,
+                        blockEvidence: [execution.stop?.evidenceRef].filter(Boolean),
+                        resultEvidence: actions
+                            .filter((a) => a.status === "verified")
+                            .map((a) => a.resultEvidence),
+                    });
+            }
         }
         const result = checkRound(scoped);
         console.log(JSON.stringify(result));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/x-harness",
-  "version": "0.2.58",
+  "version": "0.2.59",
   "private": false,
   "type": "module",
   "description": "Typed X task harness with compact business results and explicit diagnostics.",

package/skill/references/writes.md

@@ -49,7 +49,7 @@ Optional independentExecution:{tabId,evidenceRef,scopeEvidenceRef} requires real
 
 ## Reply
 
-Additional fields: kind:'reply', postId, url, evidenceRef (observed parent), text; optional assets/activation as above. Common account/quality fields still required. The exact parent is verified by the API. `replyBatch({taskId,actions})` accepts 1–5 reviewed replies, submits serially and recovers an observed receipt once without resending; The batch owns one normal pacing wait (up to 30 seconds) per action and one read-only verification for an unknown result, including when no permalink was captured. Longer or renewed waits and capability/decision failures return unfinished work. Unknown results are never submitted again. Incoming clicks have a ≥30s minimum gap, not a safety guarantee. Incoming conversations require reviewed conversation:{recipientHandle,rootId,round,automatedLoop?}; at most 3 own rounds per recipient/root, with intent/unknown counted. Mark observed automatic loops to stop earlier.
+Additional fields: kind:'reply', postId, url, evidenceRef (observed parent), text; optional assets/activation as above. Common account/quality fields still required. The exact parent is verified by the API. `replyBatch({taskId,actions})` accepts 1–5 reviewed replies, submits serially and recovers an observed receipt once without resending; The batch owns one normal pacing wait (up to 30 seconds) per action and one read-only verification for an unknown result, including when no permalink was captured. Longer or renewed waits and capability/decision failures return unfinished work. Remaining unknowns without permalinks get one batched own-account lookup, then exact-parent verification of unique observed links; unknowns never resubmit. Incoming clicks have a ≥30s minimum gap, not a safety guarantee. Incoming conversations require reviewed conversation:{recipientHandle,rootId,round,automatedLoop?}; at most 3 own rounds per recipient/root, with intent/unknown counted. Mark observed automatic loops to stop earlier.
 
 ```js
 var result = await x.replyToPost({