@nextclaw/x-harness 0.1.0 → 0.2.0

package/dist/results.js

@@ -21,7 +21,7 @@ export function diagnostic(value) {
     if (typeof raw.code !== "string")
         return undefined;
     return {
-        ...pick(raw, ["operation", "category"]),
+        ...pick(raw, ["operation", "category", "next", "evidenceRef"]),
         code: stableReason(raw.code),
     };
 }

package/dist/round-state.js

@@ -109,8 +109,8 @@ export function checkRound(state, { now = Date.now(), evidenceExists = existsSyn
                         reply.unknown, "未提交欠量仍在；未知提交不能冻结新对象");
             if (exit.reason === "outside-window") {
                 const shanghaiHour = (new Date(now).getUTCHours() + 8) % 24;
-                require(shanghaiHour < 7 ||
-                    shanghaiHour >= 22, "仍在上海07至22点执行窗口，不能以时段截止结束");
+                require(shanghaiHour <
+                    7, "仍在上海07至24点评论执行窗口，不能以时段截止结束");
             }
             if (exit.reason === "user-stop")
                 require(typeof exit.instructionEvidenceRef === "string" &&
@@ -141,7 +141,24 @@ export function runRoundCLI() {
         const file = process.argv.slice(2).find((a) => !a.startsWith("--"));
         if (!file)
             throw new Error("用法：node scripts/x-round-state.mjs <原台账> [--check-end]");
-        const result = checkRound(readRound(readFileSync(file, "utf8")));
+        const state = readRound(readFileSync(file, "utf8"));
+        const executionId = process.argv
+            .find((a) => a.startsWith("--execution="))
+            ?.slice("--execution=".length);
+        let scoped = state;
+        if (executionId !== undefined) {
+            const execution = state.executions?.[executionId];
+            if (!execution?.scopeKinds?.length || !execution.evidenceRef)
+                throw new Error("原台账执行者或职责证据缺失");
+            scoped = {
+                ...state,
+                status: execution.status,
+                scopeKinds: execution.scopeKinds,
+                scopeEvidenceRef: execution.evidenceRef,
+                stop: execution.stop,
+            };
+        }
+        const result = checkRound(scoped);
         console.log(JSON.stringify(result));
         process.exitCode =
             result.valid && (!process.argv.includes("--check-end") || result.mayEnd)

package/dist/store.d.ts

@@ -24,7 +24,25 @@ export interface RoundStore {
     }>;
     recordProof(proof: unknown): Promise<string>;
 }
-export declare function createFileRoundStore({ ledgerPath, proofDirectory, }: {
-    ledgerPath: string;
-    proofDirectory: string;
-}): RoundStore;
+export declare class FileRoundStore implements RoundStore {
+    #private;
+    path: any;
+    evidenceExists: any;
+    processId: any;
+    constructor({ ledgerPath, proofDirectory, }: {
+        ledgerPath: string;
+        proofDirectory: string;
+    });
+    fingerprint(file: string): string;
+    ownerAlive(ownerPid: unknown): boolean;
+    transaction(fn: (snapshot: RoundSnapshot) => BoundaryRecord | undefined | Promise<BoundaryRecord | undefined>): Promise<RoundSnapshot>;
+    load(): Promise<RoundSnapshot>;
+    save(snapshot: RoundSnapshot, state: BoundaryRecord): Promise<RoundSnapshot>;
+    withLock<T>(fn: () => T | Promise<T>): Promise<T>;
+    recoverAbandonedLock(): Promise<{
+        recovered: boolean;
+        evidenceRef: string;
+    }>;
+    recordProof(proof: unknown): Promise<string>;
+}
+export declare function createFileRoundStore(...args: ConstructorParameters<typeof FileRoundStore>): RoundStore;

package/dist/store.js

@@ -11,165 +11,187 @@ export class HarnessConflict extends Error {
         this.code = "CONFLICT";
     }
 }
-export function createFileRoundStore({ ledgerPath, proofDirectory, }) {
-    const path = resolve(ledgerPath);
-    const lockPath = join(dirname(path), ".x-harness.lock");
-    const proofDir = resolve(proofDirectory);
-    let held = false;
-    return {
-        path,
-        evidenceExists: existsSync,
-        fingerprint: (file) => hash(readFileSync(resolve(file))),
-        processId: typeof process !== "undefined" ? process.pid : null,
-        ownerAlive(ownerPid) {
-            if (typeof ownerPid !== "number" ||
-                !Number.isInteger(ownerPid) ||
-                ownerPid < 1)
-                return true;
-            if (typeof process === "undefined" || typeof process.kill !== "function")
-                return true;
-            try {
-                process.kill(ownerPid, 0);
-                return true;
-            }
-            catch (error) {
-                if (error.code === "ESRCH")
-                    return false;
-                throw error;
-            }
-        },
-        // Only bounded local state work belongs here. Browser I/O never holds this lock.
-        async transaction(fn) {
-            const start = Date.now();
-            while (true) {
-                let entered = false;
-                try {
-                    return await this.withLock(async () => {
-                        entered = true;
-                        const snapshot = await this.load();
-                        const state = await fn(snapshot);
-                        return state ? this.save(snapshot, state) : snapshot;
-                    });
-                }
-                catch (error) {
-                    if (entered ||
-                        error.code !== "CONFLICT" ||
-                        Date.now() - start >= 2000)
-                        throw error;
-                    await new Promise((resolve) => setTimeout(resolve, 10));
-                }
-            }
-        },
-        async load() {
-            const text = readFileSync(path, "utf8");
-            return { state: readRound(text), revision: hash(text), path };
-        },
-        async save(snapshot, state) {
-            if (!held)
-                throw new HarnessConflict("保存原台账必须持有账号锁");
-            const text = readFileSync(path, "utf8");
-            if (snapshot.revision !== hash(text))
-                throw new HarnessConflict("原台账已变化：重新定向读取，禁止覆盖");
-            if (readRound(text).batchId !== state.batchId)
-                throw new HarnessConflict("禁止替换原批次ID");
-            const next = text.replace(block, () => "```x-round-state\n" + JSON.stringify(state, null, 2) + "\n```");
-            const temp = `${path}.harness-${randomUUID()}.tmp`;
+export class FileRoundStore {
+    #ledgerPath;
+    #proofDirectory;
+    #path;
+    #lockPath;
+    #proofDir;
+    #held;
+    path;
+    evidenceExists;
+    processId;
+    constructor({ ledgerPath, proofDirectory, }) {
+        this.recordProof = this.recordProof.bind(this);
+        this.recoverAbandonedLock = this.recoverAbandonedLock.bind(this);
+        this.withLock = this.withLock.bind(this);
+        this.save = this.save.bind(this);
+        this.load = this.load.bind(this);
+        this.transaction = this.transaction.bind(this);
+        this.ownerAlive = this.ownerAlive.bind(this);
+        this.fingerprint = this.fingerprint.bind(this);
+        this.#ledgerPath = ledgerPath;
+        this.#proofDirectory = proofDirectory;
+        this.#path = resolve(this.#ledgerPath);
+        this.#lockPath = join(dirname(this.#path), ".x-harness.lock");
+        this.#proofDir = resolve(this.#proofDirectory);
+        this.#held = false;
+        this.path = this.#path;
+        this.evidenceExists = existsSync;
+        this.processId = typeof process !== "undefined" ? process.pid : null;
+    }
+    fingerprint(file) {
+        return hash(readFileSync(resolve(file)));
+    }
+    ownerAlive(ownerPid) {
+        if (typeof ownerPid !== "number" ||
+            !Number.isInteger(ownerPid) ||
+            ownerPid < 1)
+            return true;
+        if (typeof process === "undefined" || typeof process.kill !== "function")
+            return true;
+        try {
+            process.kill(ownerPid, 0);
+            return true;
+        }
+        catch (error) {
+            if (error.code === "ESRCH")
+                return false;
+            throw error;
+        }
+    }
+    async transaction(fn) {
+        const start = Date.now();
+        while (true) {
+            let entered = false;
             try {
-                writeFileSync(temp, next, {
-                    flag: "wx",
-                    mode: statSync(path).mode & 0o777,
+                return await this.withLock(async () => {
+                    entered = true;
+                    const snapshot = await this.load();
+                    const state = await fn(snapshot);
+                    return state ? this.save(snapshot, state) : snapshot;
                 });
-                // Other writers must honor the same lock; CAS additionally detects observed external edits.
-                if (hash(readFileSync(path, "utf8")) !== snapshot.revision)
-                    throw new HarnessConflict("原台账在结算中变化");
-                renameSync(temp, path);
-            }
-            finally {
-                if (existsSync(temp))
-                    unlinkSync(temp);
-            }
-            return { state, revision: hash(next), path };
-        },
-        async withLock(fn) {
-            if (held)
-                throw new HarnessConflict("账号操作禁止重入");
-            if (existsSync(`${lockPath}.recovery`))
-                throw new HarnessConflict("原锁恢复核验进行中");
-            let fd;
-            try {
-                fd = openSync(lockPath, "wx", 0o600);
             }
             catch (error) {
-                if (error.code === "EEXIST")
-                    throw new HarnessConflict("账号锁占用：不并发写、不自动偷锁");
-                throw error;
-            }
-            try {
-                writeFileSync(fd, JSON.stringify({
-                    pid: typeof process !== "undefined" ? process.pid : null,
-                    acquiredAt: new Date().toISOString(),
-                    ledgerPath: path,
-                }));
-                held = true;
-                return await fn();
-            }
-            finally {
-                held = false;
-                closeSync(fd);
-                unlinkSync(lockPath);
+                if (entered ||
+                    error.code !== "CONFLICT" ||
+                    Date.now() - start >= 2000)
+                    throw error;
+                await new Promise((resolve) => setTimeout(resolve, 10));
             }
-        },
-        async recoverAbandonedLock() {
-            if (held)
-                throw new HarnessConflict("不能恢复当前正在持有的锁");
-            const recovery = `${lockPath}.recovery`;
-            let fd;
+        }
+    }
+    async load() {
+        const text = readFileSync(this.#path, "utf8");
+        return { state: readRound(text), revision: hash(text), path: this.#path };
+    }
+    async save(snapshot, state) {
+        if (!this.#held)
+            throw new HarnessConflict("保存原台账必须持有账号锁");
+        const text = readFileSync(this.#path, "utf8");
+        if (snapshot.revision !== hash(text))
+            throw new HarnessConflict("原台账已变化：重新定向读取，禁止覆盖");
+        if (readRound(text).batchId !== state.batchId)
+            throw new HarnessConflict("禁止替换原批次ID");
+        const next = text.replace(block, () => "```x-round-state\n" + JSON.stringify(state, null, 2) + "\n```");
+        const temp = `${this.#path}.harness-${randomUUID()}.tmp`;
+        try {
+            writeFileSync(temp, next, {
+                flag: "wx",
+                mode: statSync(this.#path).mode & 0o777,
+            });
+            // Other writers must honor the same lock; CAS additionally detects observed external edits.
+            if (hash(readFileSync(this.#path, "utf8")) !== snapshot.revision)
+                throw new HarnessConflict("原台账在结算中变化");
+            renameSync(temp, this.#path);
+        }
+        finally {
+            if (existsSync(temp))
+                unlinkSync(temp);
+        }
+        return { state, revision: hash(next), path: this.#path };
+    }
+    async withLock(fn) {
+        if (this.#held)
+            throw new HarnessConflict("账号操作禁止重入");
+        if (existsSync(`${this.#lockPath}.recovery`))
+            throw new HarnessConflict("原锁恢复核验进行中");
+        let fd;
+        try {
+            fd = openSync(this.#lockPath, "wx", 0o600);
+        }
+        catch (error) {
+            if (error.code === "EEXIST")
+                throw new HarnessConflict("账号锁占用：不并发写、不自动偷锁");
+            throw error;
+        }
+        try {
+            writeFileSync(fd, JSON.stringify({
+                pid: typeof process !== "undefined" ? process.pid : null,
+                acquiredAt: new Date().toISOString(),
+                ledgerPath: this.#path,
+            }));
+            this.#held = true;
+            return await fn();
+        }
+        finally {
+            this.#held = false;
+            closeSync(fd);
+            unlinkSync(this.#lockPath);
+        }
+    }
+    async recoverAbandonedLock() {
+        if (this.#held)
+            throw new HarnessConflict("不能恢复当前正在持有的锁");
+        const recovery = `${this.#lockPath}.recovery`;
+        let fd;
+        try {
+            fd = openSync(recovery, "wx", 0o600);
+        }
+        catch (error) {
+            if (error.code === "EEXIST")
+                throw new HarnessConflict("另一执行器正在核验原锁");
+            throw error;
+        }
+        try {
+            const original = readFileSync(this.#lockPath, "utf8"), owner = JSON.parse(original);
+            if (!Number.isInteger(owner.pid) || owner.pid < 1)
+                throw new HarnessConflict("锁owner缺失，不能自动移除");
+            if (typeof process === "undefined" || typeof process.kill !== "function")
+                throw new HarnessConflict("当前宿主无进程核验能力，禁止恢复原锁");
             try {
-                fd = openSync(recovery, "wx", 0o600);
+                process.kill(owner.pid, 0);
+                throw new HarnessConflict("原进程仍在：禁止抢占账号锁");
             }
             catch (error) {
-                if (error.code === "EEXIST")
-                    throw new HarnessConflict("另一执行器正在核验原锁");
-                throw error;
+                if (error.code !== "ESRCH")
+                    throw error;
             }
-            try {
-                const original = readFileSync(lockPath, "utf8"), owner = JSON.parse(original);
-                if (!Number.isInteger(owner.pid) || owner.pid < 1)
-                    throw new HarnessConflict("锁owner缺失，不能自动移除");
-                if (typeof process === "undefined" ||
-                    typeof process.kill !== "function")
-                    throw new HarnessConflict("当前宿主无进程核验能力，禁止恢复原锁");
-                try {
-                    process.kill(owner.pid, 0);
-                    throw new HarnessConflict("原进程仍在：禁止抢占账号锁");
-                }
-                catch (error) {
-                    if (error.code !== "ESRCH")
-                        throw error;
-                }
-                const proof = await this.recordProof({
-                    observedAt: new Date().toISOString(),
-                    recovery: "owner-process-confirmed-exited",
-                    owner,
-                });
-                if (readFileSync(lockPath, "utf8") !== original)
-                    throw new HarnessConflict("原锁已变化，禁止移除");
-                unlinkSync(lockPath);
-                return { recovered: true, evidenceRef: proof };
-            }
-            finally {
-                closeSync(fd);
-                unlinkSync(recovery);
-            }
-        },
-        async recordProof(proof) {
-            mkdirSync(proofDir, { recursive: true });
-            const file = join(proofDir, `${randomUUID()}.json`);
-            writeFileSync(file, JSON.stringify(proof, null, 2), {
-                flag: "wx",
-                mode: 0o600,
+            const proof = await this.recordProof({
+                observedAt: new Date().toISOString(),
+                recovery: "owner-process-confirmed-exited",
+                owner,
             });
-            return file;
-        },
-    };
+            if (readFileSync(this.#lockPath, "utf8") !== original)
+                throw new HarnessConflict("原锁已变化，禁止移除");
+            unlinkSync(this.#lockPath);
+            return { recovered: true, evidenceRef: proof };
+        }
+        finally {
+            closeSync(fd);
+            unlinkSync(recovery);
+        }
+    }
+    async recordProof(proof) {
+        mkdirSync(this.#proofDir, { recursive: true });
+        const file = join(this.#proofDir, `${randomUUID()}.json`);
+        writeFileSync(file, JSON.stringify(proof, null, 2), {
+            flag: "wx",
+            mode: 0o600,
+        });
+        return file;
+    }
+}
+export function createFileRoundStore(...args) {
+    return new FileRoundStore(...args);
 }

package/dist/types.d.ts

@@ -75,6 +75,8 @@ export interface Diagnostic {
     operation?: string;
     category?: string;
     code: string;
+    next?: "inspect-local-proof" | "restore-proof-store";
+    evidenceRef?: EvidenceRef;
 }
 export interface ReadResult {
     status: "observed" | "needsDecision" | "needsCapability";
@@ -196,6 +198,7 @@ export interface ActionResult {
     diagnostic?: Diagnostic;
 }
 export interface RoundResult {
+    diagnostic?: Diagnostic;
     status: string;
     taskId: string;
     mayEnd: boolean;
@@ -220,6 +223,7 @@ export interface RoundResult {
     };
 }
 export interface BatchResult {
+    diagnostic?: Diagnostic;
     status: string;
     taskId: string;
     batchId?: string;
@@ -265,6 +269,12 @@ export interface IndependentExecution {
     tabId: string;
     evidenceRef: EvidenceRef;
     scopeEvidenceRef: EvidenceRef;
+    windowAuthorization?: {
+        actionId: string;
+        userAuthorized: true;
+        expiresAt: string;
+        evidenceRef: EvidenceRef;
+    };
 }
 export interface PublishOptions {
     taskId: string;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/generated/observation.mjs

@@ -1,4 +1,4 @@
-// Generated by packages/x-harness/scripts/generate-observation.mjs; edit TS reader owners only.
+// Generated by scripts/generate-observation.mjs; edit TS reader owners only.
 export const readXObservation = (query) => {
   const readPosts = function readPosts({ offset = 0, limit = 5, targetId = "", } = {}) {
     if (!Number.isInteger(offset) ||
@@ -487,7 +487,8 @@ export const readXObservation = (query) => {
                             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/package.json

@@ -1,32 +1,46 @@
 {
   "name": "@nextclaw/x-harness",
-  "version": "0.1.0",
-  "description": "X tasks for browser-enabled AI agents: compact results, complete evidence and verified writes.",
-  "license": "SEE LICENSE IN LICENSE",
+  "version": "0.2.0",
   "type": "module",
+  "description": "Typed X task harness with compact business results and explicit diagnostics.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./diagnostics": {
+      "types": "./dist/diagnostics.d.ts",
+      "import": "./dist/diagnostics.js"
     }
   },
-  "bin": {
-    "x-harness": "./cli/main.js"
-  },
   "files": [
     "dist",
     "generated",
     "cli",
     "skill",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "SOURCE.md"
   ],
+  "license": "AGPL-3.0-only",
+  "homepage": "https://x-harness.gemigo.app/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Peiiii/x-harness.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Peiiii/x-harness/issues"
+  },
   "engines": {
     "node": ">=22"
   },
+  "bin": {
+    "x-harness": "./cli/main.js"
+  },
   "publishConfig": {
     "access": "public"
-  }
-}
+  },
+  "gitHead": "269a29c44c871bac51265653a4e559ffacbf2d84"
+}

package/skill/SKILL.md

@@ -1,52 +1,33 @@
 ---
 name: x-harness
-version: 0.1.0
-description: Use X through named task APIs with compact receipts, complete target evidence and verified writes. Requires a compatible CUA browser host and the user's own logged-in X account. Install and update with the npm-distributed X Harness runtime.
+version: 0.2.0
+description: Use X through task APIs with compact receipts, complete target evidence and verified writes; requires compatible CUA and the user's X login.
 ---
 
 # X Harness
 
-Use the installed runtime; normal tasks call its root business API. Do not recreate browser selectors, print full DOM/AX, or call lower layers for normal work. Keep observations local and only return the relevant complete evidence, receipt and actionable warnings.
+Use the root business API. Load only the current task reference; reuse unchanged instructions and a valid binding. Normal use needs no implementation source or type-file reading.
 
-## First use
+## Bind once
 
-Installed module: `{{MODULE_URL}}`
-CLI: `{{CLI_PATH}}`
+Read current host CUA documentation; bind a real logged-in `tab` or native `app`, exactly one. Preserve other tasks' tabs/editors.
 
-If these placeholders are unresolved, install first:
-`npx @nextclaw/x-harness@latest setup --target codex` (or `--target claude`).
-
-Requires Node 22+, a host that exposes compatible CUA `tab` or native `app` methods, and the user's own X login. Codex desktop CUA is validated. Installing this Skill into Claude only installs instructions; confirm that host's browser methods before claiming it can execute. If browser access/login is absent, report the actual missing condition; never fabricate execution or borrow the publisher's account.
-
-Read the host's CUA documentation before using its controls. Bind/create a task tab through the host's documented API, preserving the user's session. A compatible tab has `url()`, `playwright.evaluate()`, locator methods and optional navigation/AX/screenshot methods; native apps have `getAXState()`, click/key/paste methods. Use the provided connection; do not launch an unrelated automation driver.
-
-Initialize the user's own workspace once with `node <CLI> init --directory <user workspace> --account <user handle>`. It returns `ledgerPath`, `proofDirectory`, `taskId` and account. Existing project configurations and ledgers remain the owner; reuse those instead of creating duplicate state. Never import the publisher's operations directories, policies or credentials.
-
-In the host's Node-capable REPL:
+Installed module: `{{MODULE_URL}}`; CLI: `{{CLI_PATH}}`.
+In this repository use the absolute file URL of `<harness-repository>/dist/index.js` with original ledger/proof paths. Unresolved placeholders do not require reinstalling an existing repository runtime. Only absent runtime/workspace or an update needs [setup](references/setup.md).
 
 ```js
-const { createXGrowthHarness } = await import("MODULE_URL_FROM_SETUP");
-const x = createXGrowthHarness({ tab, ledgerPath, proofDirectory });
-const result = await x.readCreator({
-  handle: "USER_HANDLE",
-  target: 5,
-  mode: "decision",
-});
-// Print only the needed result; keep the full browser observation in the REPL.
+var { createXGrowthHarness } = await import(moduleURL);
+var x = createXGrowthHarness({ tab, ledgerPath, proofDirectory });
 ```
 
-Substitute the stable installed URL and initialized paths. Never assume an old imported module hot-reloads after updating. Read `references/api.md` only for the next operation's arguments and the installed `.d.ts` for detailed types.
-
-## Execution
-
-Choose the single named task: readCreator/readBookmarks/searchSources/readPost/readPerson/readFeedback/inspectAccount; publishPost/replyToPost/followOne/followBatch; inspectRound/runGrowthRound; verifySubmission/verifyPublishedPost/verifyFollow. `receipt` is the default compact result; `decision` includes full relevant evidence; `delta` rereads and returns changed complete evidence plus unchanged IDs. Do not trim the target's body to save tokens.
-
-Writing needs explicit authorization from the current user, verified identity, their own ledger plan, reviewed prepared actions and existing evidence files. Initialization plans zero writes. Set the authorized planned count in the original ledger before execution; never expand an authorized scope yourself. Check the installed types for action, quality and executor fields; retain one owner for the ledger, do not invent approvals or evidence. The current runtime writes only 07:00–22:00 Asia/Shanghai and follow candidate gates require reviewed Chinese-language, blue-check candidates; disclose these conditions when relevant.
-
-Interpret returned status literally: `verified` requires public proof; `unknown` is not success. For an unknown submission, call verifySubmission on the same action before any new submission. `needsCapability`, `needsDecision`, `waiting` and partial windows must be reported, with the next required condition. Capture visual media before making claims about its contents.
+## Load by task
 
-## Updates
+| Current need | Read only |
+| --- | --- |
+| Creator/bookmarks/search/post/person/feedback/account | [reads](references/reads.md) |
+| Publish/reply/follow or a round | [writes](references/writes.md), preamble + common review + matching operation heading |
+| Unknown submission, missing capability or connection failure | [recovery](references/recovery.md) |
 
-Run `npx @nextclaw/x-harness@latest update --target codex` (or claude). It stages the exact fetched release, replaces only managed runtime/Skill directories, saves the previous version and retains user workspaces/configurations. It refuses unfamiliar directories. Start a fresh module binding afterward and verify the next real read operation. A release's distributed Skill and runtime use the same version.
+Default `receipt` is for status; use `decision` on the first call needing content, `delta` for changed evidence with valid prior context. Keep observations in REPL/proof; return complete relevant evidence and actionable warnings. Never truncate target text or print full DOM/AX. Root calls own capability checks, intent, submission, verification and settlement; verified results need no extra preflight/reload/verify.
 
-Free use under the bundled proprietary license; the distributed JS is readable, the TS source repository remains private. Website: https://x-harness.gemigo.app/
+Writes require user authorization, verified identity, reviewed evidence and the original ledger plan; project rules own policy. Unknown submission: verify the same action before any new submission. Follow recovery for other failures; read source only to repair a concrete defect/unsupported capability, verify, then return to root calls.