@nextclaw/x-harness 0.2.57 → 0.2.59

package/SOURCE.md

@@ -1,8 +1,8 @@
 # Corresponding source
 
-Version 0.2.57, commit b9b2f4172170380da329027f31a6526062e41218.
+Version 0.2.59, commit e0c324f79b77f50662ea2969c68ade82a31cb0b5.
 
-Complete source, build scripts and dependencies: https://github.com/Peiiii/x-harness/tree/b9b2f4172170380da329027f31a6526062e41218
+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";
@@ -7,6 +8,7 @@ export class BusinessHarness {
     #store;
     #core;
     #readCache;
+    #clock;
     constructor(dependencies) {
         this.replyBatch = this.replyBatch.bind(this);
         this.likeIncomingBatch = this.likeIncomingBatch.bind(this);
@@ -31,6 +33,7 @@ export class BusinessHarness {
         this.readBookmarks = this.readBookmarks.bind(this);
         this.readCreator = this.readCreator.bind(this);
         const { store, platform } = dependencies;
+        this.#clock = dependencies.clock ?? Date.now;
         this.#platform = platform;
         this.#store = store;
         this.#core = createGrowthHarness(dependencies);
@@ -303,18 +306,31 @@ export class BusinessHarness {
                 text: action.text,
                 preparedAction: action,
             });
-            if (result.status === "unknown") {
-                const current = (await this.#store.load()).state.actions.find((a) => a.id === action.id);
-                if (current?.observedPublicURL && current?.observedPublicEvidenceRef)
-                    result = await this.verifySubmission({
+            if (result.status === "waiting" &&
+                result.reason === "incoming-interaction-pacing" &&
+                result.resumeAt) {
+                const delay = Date.parse(result.resumeAt) - this.#clock();
+                if (Number.isFinite(delay) && delay <= 30000) {
+                    if (delay > 0)
+                        await new Promise((resolve) => setTimeout(resolve, delay));
+                    result = await this.replyToPost({
                         taskId: args.taskId,
-                        actionId: action.id,
+                        postId: action.postId,
+                        text: action.text,
+                        preparedAction: action,
                     });
+                }
             }
+            if (result.status === "unknown")
+                result = await this.verifySubmission({
+                    taskId: args.taskId,
+                    actionId: action.id,
+                });
             results.push(result);
             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))
@@ -323,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/browser-dom-submission.d.ts

@@ -3,5 +3,6 @@ export declare class DOMSubmission {
     #private;
     constructor(dependencies: Pick<DOMDependencies, "submitAX" | "session" | "tab" | "observe" | "unique" | "locator">);
     finishDOMAction(command: any, prepared: any, query: any, result: any): Promise<void>;
+    private waitSubmittedEditor;
 }
 export declare function createDOMSubmission(...args: ConstructorParameters<typeof DOMSubmission>): (command: any, prepared: any, query: any, result: any) => Promise<void>;

package/dist/browser-dom-submission.js

@@ -1,4 +1,4 @@
-import { xURL } from "./platform-rules.js";
+import { xURL, sameHandle, sameText } from "./platform-rules.js";
 import { valueOf } from "./browser-common.js";
 export class DOMSubmission {
     #submitAX;
@@ -29,6 +29,7 @@ export class DOMSubmission {
             : null;
         let nativeSubmitIndex;
         if (this.#submitAX &&
+            command.activation !== "keyboard" &&
             ["submitPost", "submitReply"].includes(command.operation)) {
             const native = await this.#submitAX.observe({ mode: "composer" });
             const editors = native.evidence?.filter((e) => /^(?:文本输入区(?:域)?|文本区域|文本栏) /.test(e.label)) ?? [];
@@ -88,7 +89,7 @@ export class DOMSubmission {
         // Inline replies keep the editor mounted. Wait for this submitted text to clear before
         // receipt navigation/reload can interrupt the actual submission request.
         if (submittedEditor)
-            await submittedEditor.waitFor({ state: "hidden", timeoutMs: 10000 });
+            await this.waitSubmittedEditor(submittedEditor, result);
         if (["submitPost", "submitReply"].includes(command.operation)) {
             try {
                 await this.#tab.playwright.waitForLoadState({
@@ -104,6 +105,36 @@ export class DOMSubmission {
             }
         }
     }
+    async waitSubmittedEditor(editor, submitted) {
+        const deadline = Date.now() + 10000;
+        for (let attempt = 0; attempt < 4; attempt++) {
+            const remaining = deadline - Date.now();
+            if (remaining <= 0)
+                throw Error("submitted-editor-clear-timeout");
+            try {
+                await editor.waitFor({ state: "hidden", timeoutMs: remaining });
+                return;
+            }
+            catch (error) {
+                if (!/timed out|timeout|deadline exceeded/i.test(error.message) ||
+                    attempt === 3 ||
+                    Date.now() >= deadline)
+                    throw error;
+                // Resume only the wait, never the submission or a navigation that could interrupt it.
+                const current = await this.#observe({ view: "composer" });
+                if (current.alerts?.length ||
+                    !current.accountHandle ||
+                    !submitted.accountHandle ||
+                    !sameHandle(current.accountHandle, submitted.accountHandle) ||
+                    xURL(current.page).href !== xURL(submitted.page).href ||
+                    (typeof current.editorText === "string" &&
+                        current.editorText.trim() &&
+                        (!sameText(current.editorText, submitted.editorText) ||
+                            current.replyToId !== submitted.replyToId)))
+                    throw error;
+            }
+        }
+    }
 }
 export function createDOMSubmission(...args) {
     return new DOMSubmission(...args).finishDOMAction;

package/dist/growth-execution.js

@@ -170,10 +170,7 @@ export class GrowthExecution {
         if (action.kind !== "follow") {
             let baseline;
             try {
-                baseline = await this.#platform.findSubmission({
-                    ...action,
-                    intentAt: this.#stamp(),
-                });
+                baseline = await this.#platform.findSubmission({ ...action, intentAt: this.#stamp() }, { phase: "baseline" });
             }
             catch (error) {
                 return {

package/dist/platform-rules.d.ts

@@ -12,6 +12,7 @@ export declare const source: (post: any, page: any) => {
     images: any;
     media: any;
     links: any;
+    metrics: any;
     needsExpansion: any;
     missing: any[];
 };

package/dist/platform-rules.js

@@ -33,6 +33,7 @@ export const source = (post, page) => ({
     images: post.images ?? [],
     media: post.media ?? [],
     links: post.links ?? [],
+    metrics: post.metrics ?? post.buttons ?? [],
     needsExpansion: post.needsExpansion,
     missing: [
         ...(post.missing ?? []),

package/dist/results.js

@@ -46,6 +46,17 @@ export function source(value, page) {
             /* explicit missing below */
         }
     }
+    if (raw.metrics !== undefined)
+        out.metrics = [
+            ...new Set(list(raw.metrics).flatMap((m) => {
+                const label = typeof m === "string" ? m : object(m).label;
+                return typeof label === "string" &&
+                    /\d/.test(label) &&
+                    /回复|转帖|喜欢|书签|观看|查看|replies|reposts?|likes?|bookmarks?|views?/i.test(label)
+                    ? [label]
+                    : [];
+            })),
+        ];
     if (raw.quoteCards)
         out.quoteCards = list(raw.quoteCards).map((v) => pick(v, ["text", "datetime", "body"]));
     if (raw.quoteSource)

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,7 @@
 {
   "name": "@nextclaw/x-harness",
-  "version": "0.2.57",
+  "version": "0.2.59",
+  "private": false,
   "type": "module",
   "description": "Typed X task harness with compact business results and explicit diagnostics.",
   "main": "./dist/index.js",
@@ -24,6 +25,29 @@
     "LICENSE",
     "SOURCE.md"
   ],
+  "scripts": {
+    "build": "npm run maintainability && tsc -p tsconfig.json && node scripts/generate-observation.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --test test/*.test.mjs",
+    "check": "npm run maintainability && npm run format:check && npm run typecheck && npm run typecheck:cli && npm run build && npm run typecheck:contracts && npm run test && node scripts/check-skill.mjs && node scripts/generate-observation.mjs --check",
+    "prepack": "node release/build.mjs --root-pack",
+    "typecheck:contracts": "tsc -p tsconfig.contracts.json",
+    "format:check": "prettier --check src test scripts release site",
+    "maintainability": "node scripts/check-maintainability.mjs",
+    "release:build": "node release/build.mjs",
+    "test:release": "node --test release/test/*.test.mjs",
+    "site:build": "node site/build.mjs",
+    "site:deploy": "node site/deploy.mjs",
+    "bootstrap": "node scripts/bootstrap.mjs",
+    "ai:check": "qingtian check --target .",
+    "typecheck:cli": "tsc -p release/tsconfig.json --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "22",
+    "typescript": "^5.9.3",
+    "prettier": "^3.9.9",
+    "@nextclaw/qingtian": "0.1.3"
+  },
   "license": "AGPL-3.0-only",
   "homepage": "https://x-harness.gemigo.app/",
   "repository": {
@@ -41,6 +65,5 @@
   },
   "publishConfig": {
     "access": "public"
-  },
-  "gitHead": "b9b2f4172170380da329027f31a6526062e41218"
+  }
 }

package/skill/references/reads.md

@@ -21,10 +21,12 @@ observed ≠ field completeness; pageComplete:false = scope. View media before d
 
 `readIncomingReplies`: ledger account; skip settled/intent/unknown and processedIds across dates. readPost(includeContext:true) for ancestors; missing context blocks review. Dedup publicly.
 
-Incoming: `readIncomingConversations({targets?,...window})` combines discovery/context (≤5); no preceding `readIncomingReplies`. Preflight/source failures remain visible. Returns ancestorPath, nodes, confirmed edges, unknown parents and attempts; rootCandidateId is only the earliest loaded ancestor. Missing context blocks review; never guess roots/edges or inbox clearance. Use `readIncomingReplies` only when the candidate list alone is the goal; it excludes settled/intent/unknown + cross-date processedIds.
+Incoming: `readIncomingConversations({targets?,...window})` combines discovery/context (≤5); no preceding `readIncomingReplies`. Preflight/source failures remain visible. Returns ancestorPath, nodes, confirmed edges, unknown parents and attempts; rootCandidateId is only the earliest loaded ancestor. Missing context blocks review; never guess roots/edges or inbox clearance.
 
 `resolveQuote:true` follows one observed card and returns `post.quoteSource` only after exact destination/body/author/time binding.
 
 `readPeople`: observed follower/following; offset reuses cells; advance scrolls a fresh unique handle. Full bio/blue/relationship; dedup; unknowns need profiles. No Native.
 
 Discovery: names only.
+
+Source decisions retain visible metric labels for batch screening; absent counts stay unknown.

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; waiting returns unfinished work. 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({