@nextclaw/x-harness 0.1.1 → 0.2.1

package/dist/readers-cli.js

@@ -0,0 +1,79 @@
+import { axParserCode } from "./readers-ax-program.js";
+import { readPosts, changes } from "./readers-posts.js";
+import { readProfile, screenCandidates } from "./readers-profile.js";
+import { readAX } from "./readers-ax-parser.js";
+import { AXHarness, createAXHarness } from "./readers-ax-host.js";
+export function setupCode() {
+    return `var xReadPosts = ${readPosts.toString()};\nvar xReadChanges = ${changes.toString()};\nvar xReadProfile = ${readProfile.toString()};\nvar xScreenCandidates = ${screenCandidates.toString()};\nvar xReadAX = ${axParserCode};\nvar xCreateAXHarness = (function(readAX) { const AXHarness = ${AXHarness.toString()}; return ${createAXHarness.toString()}; })(xReadAX);\nvar xAXSessions = {};\nvar xReadCache = {};\n`;
+}
+export function profileCode({ tab = "xtab", handle } = {}) {
+    return profilesCode([{ tab, handle }]);
+}
+export function profilesCode(entries) {
+    if (!Array.isArray(entries) || !entries.length || entries.length > 5)
+        throw new Error("一次读取1～5位");
+    for (const { tab, handle } of entries) {
+        if (!/^[A-Za-z_$][\w$]*$/.test(tab ?? ""))
+            throw new Error("tab必须是已有Tab变量名");
+        if (!/^[A-Za-z0-9_]{1,15}$/.test(handle ?? ""))
+            throw new Error("需要已观察的X handle");
+    }
+    const inputs = entries
+        .map(({ tab, handle }) => `{tab:${tab},handle:${JSON.stringify(handle)}}`)
+        .join(",");
+    return `var xProfiles = [];\nfor (var entry of [${inputs}]) {\n  var page = new URL(await entry.tab.url());\n  if (page.origin !== 'https://x.com' || page.pathname.toLowerCase() !== '/' + entry.handle.toLowerCase()) { xProfiles.push({handle:entry.handle,blue:null,relationship:'unknown',alerts:['profile-url-mismatch']}); continue; }\n  xProfiles.push(await entry.tab.playwright.evaluate(xReadProfile, {handle:entry.handle}));\n}\nnodeRepl.write(xScreenCandidates(xProfiles));\n`;
+}
+export function browserCode({ handle = "xtab", offset = 0, limit = 5, targetId = "", fresh = false, } = {}) {
+    if (!/^[A-Za-z_$][\w$]*$/.test(handle))
+        throw new Error("handle必须是当前REPL已有Tab变量名");
+    if (targetId && !/^\d+$/.test(targetId))
+        throw new Error("targetId必须是已观察的数字公开ID");
+    if (!Number.isInteger(offset) ||
+        offset < 0 ||
+        !Number.isInteger(limit) ||
+        limit < 1 ||
+        limit > 5)
+        throw new Error("无效读取窗口");
+    return `var xReadResult = await ${handle}.playwright.evaluate(xReadPosts, ${JSON.stringify({ offset, limit, targetId })});\nnodeRepl.write(xReadChanges(xReadResult, xReadCache, await ${handle}.url(), ${fresh}));\n`;
+}
+export function axCode({ handle = "chrome", mode = "posts", offset = 0, limit = 1, targetId = "", targetHandle = "", fresh = false, } = {}) {
+    if (!/^[A-Za-z_$][\w$]*$/.test(handle))
+        throw new Error("handle必须是已有原生App/Tab变量名");
+    // Share validation with the pure parser, without requiring a browser.
+    readAX("", { mode, offset, limit, targetId, targetHandle });
+    return `if (xAXSessions.${handle}?.app !== ${handle}) xAXSessions.${handle} = {app:${handle}, harness:xCreateAXHarness(${handle})};\nvar xAXResult = await xAXSessions.${handle}.harness.observe(${JSON.stringify({ mode, offset, limit, targetId, targetHandle })});\nnodeRepl.write(xReadChanges(xAXResult, xReadCache, xAXResult.page ?? 'unknown', ${fresh}));\n`;
+}
+export function runReaderCLI() {
+    try {
+        const args = process.argv.slice(2);
+        const value = (flag, fallback) => args.includes(flag) ? args[args.indexOf(flag) + 1] : fallback;
+        process.stdout.write(args.includes("--setup")
+            ? setupCode()
+            : args.includes("--ax")
+                ? axCode({
+                    handle: value("--handle", "chrome"),
+                    mode: value("--mode", "posts"),
+                    offset: Number(value("--offset", 0)),
+                    limit: Number(value("--limit", 1)),
+                    targetId: value("--id", ""),
+                    targetHandle: value("--person", ""),
+                    fresh: args.includes("--fresh"),
+                })
+                : args.includes("--profile")
+                    ? profileCode({
+                        tab: value("--handle", "xtab"),
+                        handle: value("--profile", ""),
+                    })
+                    : browserCode({
+                        handle: value("--handle", "xtab"),
+                        offset: Number(value("--offset", 0)),
+                        limit: Number(value("--limit", 5)),
+                        targetId: value("--id", ""),
+                        fresh: args.includes("--fresh"),
+                    }));
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exitCode = 1;
+    }
+}

package/dist/readers.js

@@ -0,0 +1,9 @@
+/** Compatibility exports only. Implementation owners are task-specific modules. */
+export { readPosts, changes } from "./readers-posts.js";
+export { readAX } from "./readers-ax-parser.js";
+export { createAXTabHarness, createAXHarness } from "./readers-ax-host.js";
+export { readProfile, readPeople, screenCandidates, } from "./readers-profile.js";
+export { readComposer, readMediaEditor } from "./readers-composer.js";
+export { readMenu, readNavigation } from "./readers-navigation.js";
+export { attachImage, openReply } from "./readers-actions.js";
+export { setupCode, profileCode, profilesCode, browserCode, axCode, runReaderCLI, } from "./readers-cli.js";

package/dist/round-state.js

@@ -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.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) ||

package/package.json

@@ -1,32 +1,46 @@
 {
   "name": "@nextclaw/x-harness",
-  "version": "0.1.1",
-  "description": "X tasks for browser-enabled AI agents: compact results, complete evidence and verified writes.",
-  "license": "SEE LICENSE IN LICENSE",
+  "version": "0.2.1",
   "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": "66d1ce5637601897d7d769f74d56eacffc2e865e"
+}

package/skill/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: x-harness
-version: 0.1.1
+version: 0.2.1
 description: Use X through task APIs with compact receipts, complete target evidence and verified writes; requires compatible CUA and the user's X login.
 ---
 
@@ -13,7 +13,7 @@ Use the root business API. Load only the current task reference; reuse unchanged
 Read current host CUA documentation; bind a real logged-in `tab` or native `app`, exactly one. Preserve other tasks' tabs/editors.
 
 Installed module: `{{MODULE_URL}}`; CLI: `{{CLI_PATH}}`.
-In this repository use the absolute file URL of `<repository>/packages/x-harness/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).
+In a development checkout use the absolute file URL of `<harness-repository>/dist/index.js` with existing ledger/proof paths. Keep an existing repository runtime when placeholders remain unresolved. Only absent runtime/workspace or an update needs [setup](references/setup.md).
 
 ```js
 var { createXGrowthHarness } = await import(moduleURL);

package/skill/references/reads.md

@@ -18,6 +18,6 @@ var result = await x.readCreator({ handle: selectedHandle, target: 5, mode: 'dec
 var postResult = await x.readPost({ target: observedPost, mode: 'decision' });
 ```
 
-Targets/proof come from actual observations, never guessed URLs or made-up references. API owns navigation/expansion and bounded collection. Native creator collection may return `needsCapability`; inspect that signal before changing adapter.
+Targets/proof come from actual observations, never guessed URLs or made-up references. API owns navigation/expansion and bounded collection. Native creator collection supports an already selected profile with `navigate:false`; it keeps relative times unknown and stops with partial evidence if the active page changes. Native automatic creator navigation remains `needsCapability`; inspect that signal before changing adapter.
 
 Results include status/evidenceRef/missing/IDs/completeness. In `decision`, creator/bookmark/search use `sources`, post `post`, person `person`, feedback `feedback`; account includes accountHandle/accountURL. `observed` alone does not prove every requested field exists. `pageComplete:false` is a collection boundary, not proof of truncated target text. View media before describing it. Return complete chosen evidence; keep other observations local. Only on failure load recovery.

package/skill/references/recovery.md

@@ -1,6 +1,6 @@
 # Recovery by signal
 
-Load on failure/unknown only. Keep operation/status/missing/code/proof/error; never infer success or repeat identical failures.
+Load on failure/unknown only. Keep operation/status/missing/code/proof/error; do not infer success or repeat failures.
 
 | Signal | Next action and exit condition |
 | --- | --- |
@@ -16,10 +16,10 @@ Load on failure/unknown only. Keep operation/status/missing/code/proof/error; ne
 
 ## Host connection or native focus
 
-Failure to list/bind Chrome is a host-connection failure before reaching X, not proof of logged-out X. Per current host documentation rediscover the task tab once; validate navigation plus a necessary visible read. Native focus rejection instead needs latest AX URL/window confirmation and one supported focus correction. Do not repeat discovery or restart editors blindly.
+Naming failure is not tab failure or X logout. Once, try a host-supported alternative: real Chrome → owned tab → root read. Preserve editors; no policy bypass/unchanged retries. Success proves current reading, not stable transport/writes. Reuse bindings; after real reset rediscover Chrome identity, not old numeric IDs. Native rejection needs fresh URL/window and one supported correction. App fallback keeps root calls; do not change network settings.
 
-Lost tab: reuse a live owned tab or create a task tab in the same actual browser; preserve other editors. Native fallback changes binding to app, not business calls; unsupported native tasks remain gaps. Network/TUN observations do not authorize setting changes.
+`tab-busy`: inspect proof/claim. Age/null PID is not termination. Only evidenced own-runtime termination permits CAS release matching executor/runtime/token, preserving intent/unknown and others. Verify same ID, never resubmit. Do not reset a working runtime to diagnose another error.
 
 ## Repair boundary
 
-Normal use/known recovery need no source. Unresolved runtime defect/unsupported capability permits diagnostics: maintainers repair the owner, verify the failed boundary and return to root; consumers report gap/update/support, without private TS. Never scan adapters for arguments, add parsers, bypass refusal or resubmit unknown.
+Source is only for unresolved defects/capability gaps: maintainers repair the owner, verify the failed boundary and return to root; consumers report gap/update/support, without source. Never scan adapters for arguments, add parsers, bypass refusal or resubmit unknown.

package/skill/references/setup.md

@@ -4,7 +4,7 @@ Load only when runtime/workspace is absent, binding needs refreshing after updat
 
 ## Repository runtime
 
-Use `<repository>/packages/x-harness/dist/index.js` as an absolute file URL; if absent run `pnpm --filter @ai-content-studio/x-harness build`. Reuse original ledger/proofs and runtime-context entry; do not initialize a second ledger or download another runtime. Global Skill links to this repository owner.
+Use `<repository>/dist/index.js` as an absolute file URL; if absent run `npm run build`. Reuse original ledger/proofs and private parent runtime-context entry; do not initialize a second ledger or download another runtime. Use this repository’s skill/ as the development Skill owner.
 
 ## Independent installation