@nextclaw/x-harness 0.1.1 → 0.2.0

package/dist/growth-parallel.js

@@ -1,54 +1,83 @@
 import { randomUUID } from "node:crypto";
 import { same } from "./growth-constants.js";
-export function createParallelRound(dependencies) {
-    const { load, scope, result, store, executor, runtimeId, stamp, evidenceExists, execute, clock, releaseSession, session, } = dependencies;
-    async function parallelRound({ taskId, decision, selector, requestedKind, maxActions = 10, } = {}) {
+export class ParallelRound {
+    #load;
+    #scope;
+    #result;
+    #store;
+    #executor;
+    #runtimeId;
+    #stamp;
+    #evidenceExists;
+    #execute;
+    #clock;
+    #releaseSession;
+    #session;
+    parallelRound;
+    constructor(dependencies) {
+        const { load, scope, result, store, executor, runtimeId, stamp, evidenceExists, execute, clock, releaseSession, session, } = dependencies;
+        this.#load = load;
+        this.#scope = scope;
+        this.#result = result;
+        this.#store = store;
+        this.#executor = executor;
+        this.#runtimeId = runtimeId;
+        this.#stamp = stamp;
+        this.#evidenceExists = evidenceExists;
+        this.#execute = execute;
+        this.#clock = clock;
+        this.#releaseSession = releaseSession;
+        this.#session = session;
+        this.parallelRound = this.handleParallelRound.bind(this);
+    }
+    async handleParallelRound({ taskId, decision, selector, requestedKind, maxActions = 10, } = {}) {
+        const executor = this.#executor;
         if (!executor)
             throw new Error("parallel-executor-required");
-        if (session.running)
+        if (this.#session.running)
             return {
                 status: "needsDecision",
                 mayEnd: false,
                 taskId,
                 decision: [{ reason: "same-tab-operation-running" }],
             };
-        session.running = true;
+        this.#session.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);
+            let snapshot = await this.#load(taskId);
+            const activeKinds = this.#scope(snapshot.state);
             if (requestedKind && !activeKinds.includes(requestedKind))
                 return {
-                    ...result(snapshot),
+                    ...this.#result(snapshot),
                     status: "needsDecision",
                     decision: [{ reason: "kind-outside-round-scope" }],
                 };
-            snapshot = await store.transaction((latest) => {
+            snapshot = await this.#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.runtimeId !== this.#runtimeId &&
                     (e.activity || e.actionId) &&
-                    store.ownerAlive(e.pid)))
+                    this.#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,
+                    runtimeId: this.#runtimeId,
+                    pid: this.#store.processId,
                     activity: "round",
                     status: "RUNNING",
-                    updatedAt: stamp(),
+                    updatedAt: this.#stamp(),
                 };
                 if (decision?.type === "prepareActions") {
                     if (!Array.isArray(decision.actions) ||
                         !same(next.accountHandle, decision.accountHandle) ||
-                        !evidenceExists(decision.ownershipEvidenceRef))
+                        !this.#evidenceExists(decision.ownershipEvidenceRef))
                         throw new Error("需原账号核验和完整动作队列");
                     next.actions ??= [];
                     for (const action of decision.actions) {
@@ -72,7 +101,7 @@ export function createParallelRound(dependencies) {
                     }
                     if (decision.attemptsCoverage) {
                         if (!decision.attemptsCoverage.complete ||
-                            !evidenceExists(decision.attemptsCoverage.evidenceRef))
+                            !this.#evidenceExists(decision.attemptsCoverage.evidenceRef))
                             throw new Error("共享历史缺证据");
                         next.attemptsCoverage = structuredClone(decision.attemptsCoverage);
                     }
@@ -87,7 +116,7 @@ export function createParallelRound(dependencies) {
                         action.status !== "prepared" ||
                         action.claim ||
                         typeof decision.approved !== "boolean" ||
-                        !evidenceExists(decision.evidenceRef))
+                        !this.#evidenceExists(decision.evidenceRef))
                         throw new Error("审查只绑定职责内未领取的原prepared动作");
                     if (!decision.approved)
                         action.status = "skipped";
@@ -109,7 +138,7 @@ export function createParallelRound(dependencies) {
                                 }),
                         };
                 }
-                next.updatedAt = stamp();
+                next.updatedAt = this.#stamp();
                 return next;
             });
             for (const kind of activeKinds) {
@@ -132,7 +161,7 @@ export function createParallelRound(dependencies) {
                     if (["verified", "preexisting", "skipped"].includes(original.status))
                         continue;
                     try {
-                        snapshot = await store.transaction((latest) => {
+                        snapshot = await this.#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");
@@ -150,29 +179,29 @@ export function createParallelRound(dependencies) {
                                 (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))
+                            if (action.claim && this.#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)))
+                                e.runtimeId !== this.#runtimeId &&
+                                this.#store.ownerAlive(e.pid)))
                                 throw new Error("same-tab-claimed");
-                            session.claim = {
+                            this.#session.claim = {
                                 actionId: action.id,
                                 token: randomUUID(),
                                 executorId: executor.id,
-                                runtimeId,
-                                pid: store.processId,
-                                acquiredAt: stamp(),
+                                runtimeId: this.#runtimeId,
+                                pid: this.#store.processId,
+                                acquiredAt: this.#stamp(),
                             };
-                            action.claim = session.claim;
+                            action.claim = this.#session.claim;
                             next.executions[executor.id].actionId = action.id;
-                            next.updatedAt = stamp();
+                            next.updatedAt = this.#stamp();
                             return next;
                         });
-                        if (!session.claim)
+                        if (!this.#session.claim)
                             continue;
-                        const outcome = await execute(snapshot, snapshot.state.actions.find((a) => a.id === original.id));
+                        const outcome = await this.#execute(snapshot, snapshot.state.actions.find((a) => a.id === original.id));
                         snapshot = outcome.snapshot;
                         completed++;
                         if (outcome.need) {
@@ -195,24 +224,24 @@ export function createParallelRound(dependencies) {
                         break;
                     }
                     finally {
-                        if (session.claim) {
-                            const owned = session.claim;
-                            session.claim = null;
-                            snapshot = await store.transaction((latest) => {
+                        if (this.#session.claim) {
+                            const owned = this.#session.claim;
+                            this.#session.claim = null;
+                            snapshot = await this.#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)
+                                if (next.executions[executor.id]?.runtimeId === this.#runtimeId)
                                     delete next.executions[executor.id].actionId;
-                                next.updatedAt = stamp();
+                                next.updatedAt = this.#stamp();
                                 return next;
                             });
                         }
                     }
                 }
             }
-            snapshot = await store.transaction(async (latest) => {
+            snapshot = await this.#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));
@@ -227,11 +256,11 @@ export function createParallelRound(dependencies) {
                     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()) {
+                    waits.every((w) => w && Date.parse(w.resumeAt) > this.#clock()) &&
+                    Date.parse(scheduled) > this.#clock()) {
                     for (let i = 0; i < pending.length; i++) {
-                        const proof = await store.recordProof({
-                            observedAt: stamp(),
+                        const proof = await this.#store.recordProof({
+                            observedAt: this.#stamp(),
                             ...waits[i],
                             attempts: next.attempts,
                         });
@@ -253,10 +282,10 @@ export function createParallelRound(dependencies) {
                 next.status = next.items.every((i) => i.verified === i.planned && !i.unknown)
                     ? "COMPLETE"
                     : "RUNNING";
-                own.updatedAt = next.updatedAt = stamp();
+                own.updatedAt = next.updatedAt = this.#stamp();
                 return next;
             });
-            const out = result(snapshot, needs);
+            const out = this.#result(snapshot, needs);
             if (!out.mayEnd && !needs.length && completed >= maxActions)
                 return {
                     ...out,
@@ -279,7 +308,7 @@ export function createParallelRound(dependencies) {
                 status: "needsDecision",
                 mayEnd: false,
                 taskId,
-                evidenceRef: store.path,
+                evidenceRef: this.#store.path,
                 decision: [
                     {
                         reason: "harness-boundary-error",
@@ -290,12 +319,14 @@ export function createParallelRound(dependencies) {
         }
         finally {
             try {
-                await releaseSession(taskId);
+                await this.#releaseSession(taskId);
             }
             finally {
-                session.running = false;
+                this.#session.running = false;
             }
         }
     }
-    return { parallelRound };
+}
+export function createParallelRound(...args) {
+    return new ParallelRound(...args);
 }

package/dist/growth-plan.d.ts

@@ -1,4 +1,9 @@
 import type { GrowthDependencies } from "./growth-dependencies.js";
-export declare function createPlannedRound(dependencies: Pick<GrowthDependencies, "store" | "load" | "result" | "evidenceExists" | "save" | "execute" | "clock" | "stamp">): {
-    round: ({ taskId, decision, selector, requestedKind, }?: any) => Promise<any>;
-};
+export declare class PlannedRound {
+    #private;
+    round: ({ taskId, decision, selector, requestedKind }?: any) => Promise<any>;
+    constructor(dependencies: Pick<GrowthDependencies, "store" | "load" | "result" | "evidenceExists" | "save" | "execute" | "clock" | "stamp">);
+    private applyRoundDecision;
+    private handleRound;
+}
+export declare function createPlannedRound(...args: ConstructorParameters<typeof PlannedRound>): PlannedRound;

package/dist/growth-plan.js

@@ -1,11 +1,31 @@
 import { kinds, same } from "./growth-constants.js";
-export function createPlannedRound(dependencies) {
-    const { store, load, result, evidenceExists, save, execute, clock, stamp } = dependencies;
-    async function applyRoundDecision(snapshot, decision, activeKinds) {
+export class PlannedRound {
+    #store;
+    #load;
+    #result;
+    #evidenceExists;
+    #save;
+    #execute;
+    #clock;
+    #stamp;
+    round;
+    constructor(dependencies) {
+        const { store, load, result, evidenceExists, save, execute, clock, stamp } = dependencies;
+        this.#store = store;
+        this.#load = load;
+        this.#result = result;
+        this.#evidenceExists = evidenceExists;
+        this.#save = save;
+        this.#execute = execute;
+        this.#clock = clock;
+        this.#stamp = stamp;
+        this.round = this.handleRound.bind(this);
+    }
+    async applyRoundDecision(snapshot, decision, activeKinds) {
         if (decision?.type === "prepareActions") {
             if (!Array.isArray(decision.actions) ||
                 !/^[A-Za-z0-9_]{1,15}$/.test(decision.accountHandle ?? "") ||
-                !evidenceExists(decision.ownershipEvidenceRef) ||
+                !this.#evidenceExists(decision.ownershipEvidenceRef) ||
                 (snapshot.state.execution?.owner &&
                     snapshot.state.execution.owner !== "harness"))
                 throw new Error("需原账号执行权核验和完整动作队列；不接管已有执行者");
@@ -37,7 +57,7 @@ export function createPlannedRound(dependencies) {
             };
             if (decision.attemptsCoverage) {
                 if (!decision.attemptsCoverage.complete ||
-                    !evidenceExists(decision.attemptsCoverage.evidenceRef))
+                    !this.#evidenceExists(decision.attemptsCoverage.evidenceRef))
                     throw new Error("共享历史须完整取证；不能默认为零");
                 next.attemptsCoverage = structuredClone(decision.attemptsCoverage);
             }
@@ -49,7 +69,7 @@ export function createPlannedRound(dependencies) {
                     ...structuredClone(decision.sharedAttempts),
                 ];
             }
-            snapshot = await save(snapshot, next);
+            snapshot = await this.#save(snapshot, next);
         }
         else if (decision) {
             const action = snapshot.state.actions?.find((a) => a.id === decision.actionId);
@@ -58,7 +78,7 @@ export function createPlannedRound(dependencies) {
             if (!action ||
                 action.status !== "prepared" ||
                 typeof decision.approved !== "boolean" ||
-                !evidenceExists(decision.evidenceRef))
+                !this.#evidenceExists(decision.evidenceRef))
                 throw new Error("决策仅能绑定原prepared动作及真实审查证据");
             const next = structuredClone(snapshot.state), target = next.actions.find((a) => a.id === action.id);
             if (!decision.approved)
@@ -80,25 +100,25 @@ export function createPlannedRound(dependencies) {
                                 : {}),
                         }),
                 };
-            snapshot = await save(snapshot, next);
+            snapshot = await this.#save(snapshot, next);
         }
         return snapshot;
     }
-    async function round({ taskId, decision, selector, requestedKind, } = {}) {
+    async handleRound({ taskId, decision, selector, requestedKind, } = {}) {
         try {
-            return await store.withLock(async () => {
-                let snapshot = await load(taskId);
+            return await this.#store.withLock(async () => {
+                let snapshot = await this.#load(taskId);
                 const activeKinds = snapshot.state.scopeKinds ?? kinds;
                 if (requestedKind && !activeKinds.includes(requestedKind))
                     return {
-                        ...result(snapshot),
+                        ...this.#result(snapshot),
                         status: "needsDecision",
                         mayEnd: false,
                         decision: [
                             { kind: requestedKind, reason: "kind-outside-round-scope" },
                         ],
                     };
-                snapshot = await applyRoundDecision(snapshot, decision, activeKinds);
+                snapshot = await this.applyRoundDecision(snapshot, decision, activeKinds);
                 const needs = [];
                 for (const kind of activeKinds) {
                     const queue = (snapshot.state.actions ?? [])
@@ -123,7 +143,7 @@ export function createPlannedRound(dependencies) {
                             continue;
                         if (item.verified >= item.planned && action.status === "prepared")
                             continue;
-                        const outcome = await execute(snapshot, action);
+                        const outcome = await this.#execute(snapshot, action);
                         snapshot = outcome.snapshot;
                         if (outcome.need) {
                             needs.push(outcome.need);
@@ -136,7 +156,7 @@ export function createPlannedRound(dependencies) {
                     .every((i) => i.verified === i.planned && i.unknown === 0)) {
                     const next = structuredClone(snapshot.state);
                     next.status = "COMPLETE";
-                    snapshot = await save(snapshot, next);
+                    snapshot = await this.#save(snapshot, next);
                 }
                 else {
                     const pending = snapshot.state.items.filter((i) => activeKinds.includes(i.kind) &&
@@ -150,13 +170,13 @@ export function createPlannedRound(dependencies) {
                         (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()) {
+                        waits.every((w) => w && Date.parse(w.resumeAt) > this.#clock()) &&
+                        Date.parse(scheduled) > this.#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(),
+                            const proof = await this.#store.recordProof({
+                                observedAt: this.#stamp(),
                                 reason: wait.reason,
                                 resumeAt: wait.resumeAt,
                                 attempts: next.attempts,
@@ -175,7 +195,7 @@ export function createPlannedRound(dependencies) {
                             nextScheduledCheckAt: scheduled,
                             nextEligibleCheckAt: waits.map((w) => w.resumeAt).sort()[0],
                         };
-                        snapshot = await save(snapshot, next);
+                        snapshot = await this.#save(snapshot, next);
                     }
                     else if (!needs.length)
                         needs.push({
@@ -183,7 +203,7 @@ export function createPlannedRound(dependencies) {
                             reason: "prepared-queue-does-not-cover-original-targets",
                         });
                 }
-                return result(snapshot, needs);
+                return this.#result(snapshot, needs);
             });
         }
         catch (error) {
@@ -191,7 +211,7 @@ export function createPlannedRound(dependencies) {
                 status: "needsDecision",
                 mayEnd: false,
                 taskId,
-                evidenceRef: store.path,
+                evidenceRef: this.#store.path,
                 decision: [
                     {
                         reason: error.code === "CONFLICT"
@@ -203,5 +223,7 @@ export function createPlannedRound(dependencies) {
             };
         }
     }
-    return { round };
+}
+export function createPlannedRound(...args) {
+    return new PlannedRound(...args);
 }

package/dist/growth-policy.d.ts

@@ -1,9 +1,18 @@
 import type { GrowthDependencies } from "./growth-dependencies.js";
-export declare function createGrowthPolicy(dependencies: Pick<GrowthDependencies, "executor" | "clock" | "evidenceExists" | "platform" | "store">): {
+export declare class GrowthPolicy {
+    #private;
     authorizedWindow: (state: any, kind: string) => boolean;
     scope: (state: any) => any;
     project: (state: any) => any;
     capability: (operation: any, input?: any) => any;
     waitBudget: (state: any) => any;
     guardInput: (state: any, action: any, independentExecution?: any) => any;
-};
+    constructor(dependencies: Pick<GrowthDependencies, "executor" | "clock" | "evidenceExists" | "platform" | "store">);
+    private handleCapability;
+    private handleWaitBudget;
+    private handleGuardInput;
+    private handleAuthorizedWindow;
+    private handleScope;
+    private handleProject;
+}
+export declare function createGrowthPolicy(...args: ConstructorParameters<typeof GrowthPolicy>): GrowthPolicy;