@senpi/runtime 3.0.59 → 3.0.63

package/dist/deploy/proof-gate.js

@@ -0,0 +1,269 @@
+/**
+ * Deploy's half of the proof contract.
+ *
+ * `verifyProof` owns the fact; this module owns turning it into a refusal deploy can render.
+ * The instances argument is the whole reason this file exists: VerifyOptions.instances is
+ * documented as directory names relative to the package root and consumed as
+ * `join(packageRoot, instance)`, while a DeployInstance carries a MANIFEST name. Passing the
+ * name verifies a directory that may not exist and reports `no_proof` for a proven package.
+ *
+ * ## What a proof actually attests, and what it does not
+ *
+ * A proof records that a full, unscoped `senpi validate` at live depth PASSED over exactly these
+ * bytes under exactly this runtime. It does NOT assert that every check that depth offers actually
+ * produced a verdict: the live-instrument check warns (`W_VALIDATE_UNIVERSE_UNAVAILABLE`) when the
+ * exchange list cannot be read, the verdict stays `PASS`, and `PASS` at live depth is what makes a
+ * run proof-eligible (`validate/run.ts`). So a proof can attest a run in which the universe check
+ * never ran.
+ *
+ * That is not a money leak, and it is deliberately not repaired here: `runDeploy` re-checks the
+ * universe itself, pre-money, from a live read on every deploy (`universe/package-universe.ts`), so
+ * no dead instrument reaches funding either way. What it means for THIS module is a rule about
+ * language: the refusals below say what a proof is a claim about — "this content ran under this
+ * runtime" — and never that the package was "fully validated" or "everything was checked". Recording
+ * the skipped checks INTO the proof was considered and rejected: deploy would then be enforcing on a
+ * stale record of an ops fault (an unreachable MCP server), refusing packages whose instruments it
+ * had just read as live, and routing an environment problem to the author.
+ */
+import { isAbsolute, join, relative } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { verifyProof, VALIDATE_CODE } from "../validate/index.js";
+import { VERSION } from "../version.js";
+import { readRuntimeYaml } from "./package.js";
+import { validateCommand } from "./recheck-commands.js";
+export function checkPackageProof(pkg) {
+    const instances = pkg.instances.map((inst) => relative(pkg.dir, inst.runtimeYamlDir));
+    return verifyProof(pkg.dir, { instances });
+}
+/**
+ * The one package shape a proof cannot answer for, which therefore has to be refused rather than
+ * verified.
+ *
+ * A proof is one file per DIRECTORY — `writeProof` writes `dirname(recipePath)/.senpi-proof.json` —
+ * and it records the recipe it was made for, which `verifyProofInner` re-fingerprints. Nothing in
+ * `loadDeployPackage` requires instances to live in different directories: a manifest naming
+ * `aggressive.yaml` and `calm.yaml` at the package root is legal and gives both instances the same
+ * `runtimeYamlDir`. Verifying that package asks the same directory twice and gets the same answer
+ * twice, so a proof recorded for ONE recipe passes the other — a recipe nobody watched run reaches
+ * funding, which is the precise harm this gate exists to prevent.
+ *
+ * Fixing it inside `verifyProof` would mean teaching the proof format about instances; the deploy
+ * layer is the one that HAS the manifest and can see the collision, so it refuses here. Fail-closed
+ * on principle and free in practice: of the 103 packages in the shipped catalog, 21 are
+ * multi-instance and none shares a runtime directory.
+ */
+export function collidingInstanceDirs(pkg) {
+    const byDir = new Map();
+    for (const inst of pkg.instances) {
+        byDir.set(inst.runtimeYamlDir, [...(byDir.get(inst.runtimeYamlDir) ?? []), inst]);
+    }
+    return [...byDir.entries()]
+        .filter(([, instances]) => instances.length > 1)
+        .map(([dir, instances]) => ({ dir, instances }));
+}
+/**
+ * The relative `scanners[].path` values in one instance's recipe — the things that silently
+ * re-point if the recipe moves without them.
+ *
+ * `runtimeYamlDir` is documented as "the base relative scanner paths resolve against"
+ * (`package.ts`), so a recipe moved into a new directory takes every relative path with it and
+ * lands them somewhere that does not exist. Never throws: this feeds a refusal, and a gate that
+ * can fail to render is a gate that sometimes does nothing. (`runDeploy` has already parsed these
+ * same files twice by the time it gets here, so a parse error is not reachable on that path.)
+ */
+function relativeScannerPaths(inst) {
+    try {
+        const parsed = parseYaml(readRuntimeYaml(inst));
+        const scanners = Array.isArray(parsed?.scanners) ? parsed.scanners : [];
+        const paths = scanners
+            .map((scanner) => scanner !== null && typeof scanner === "object"
+            ? scanner.path
+            : undefined)
+            .filter((path) => typeof path === "string" && path.length > 0 && !isAbsolute(path));
+        return [...new Set(paths)];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * The collision as an instruction — deliberately an END STATE, not a command.
+ *
+ * The obvious rendering ("mv the recipe into its own directory") produces a package that does not
+ * validate: a relative `path:` resolves against the recipe's own directory, so moving the recipe
+ * alone re-points `./scanners` at a directory that does not exist and the very next validation
+ * fails on an unresolvable scanner path. Nor can the right move be computed here — two recipes that
+ * share a directory may well be sharing what is in it, and whether the tree moves, is copied, or is
+ * referenced from both is a decision about this package that this gate does not have the standing
+ * to make. So it names what will break (computed from each recipe, not templated), describes the
+ * state to reach, and emits no command whose preconditions it cannot check — the same rule
+ * `buildBudgetEscape` follows when a report cannot support a teardown.
+ *
+ * It also emits no post-move `senpi validate` path. Those directories do not exist yet, and a
+ * non-colliding sleeve's directory is not its manifest name — the exact trap this module exists to
+ * prevent, which is easy to walk back into while writing helpful-looking text. Re-running the
+ * deploy is the loop: it names any instance still unproven and carries the exact command for it.
+ */
+export function buildInstanceDirCollisionRefusal(collisions, pkg) {
+    const relatives = new Set();
+    const groups = collisions.map((collision) => {
+        const rows = collision.instances.map((inst) => {
+            const paths = relativeScannerPaths(inst);
+            paths.forEach((path) => relatives.add(path));
+            const carries = paths.length > 0 ? ` — relative paths inside it: ${paths.join(", ")}` : "";
+            return `      "${inst.name}" → ${inst.runtimeYamlPath}${carries}`;
+        });
+        return `  - ${collision.dir} is shared by:\n${rows.join("\n")}`;
+    });
+    const movingCaveat = relatives.size > 0
+        ? `Moving a recipe is not enough on its own: a relative path in it (${[...relatives].join(", ")} ` +
+            `above) resolves against the directory the RECIPE is in, so a recipe that moves alone points ` +
+            `every one of them at a directory that does not exist, and the next validation fails on an ` +
+            `unresolvable scanner path. Whether the tree it names moves with the recipe, is copied, or is ` +
+            `referenced from both is a decision about this package — these sleeves share a directory ` +
+            `today, so they may be sharing what is in it. `
+        : "";
+    return (`[INVALID_REQUEST] ${collisions.length} directory(ies) in this package hold more than one ` +
+        `instance's recipe, and no proof can speak for either of them:\n${groups.join("\n")}\n\n` +
+        `Why: a proof lives BESIDE the recipe it is a claim about — one \`.senpi-proof.json\` per ` +
+        `directory, naming the one recipe it was recorded for. Two recipes in one directory therefore ` +
+        `share a single proof file, and whichever validation ran last is the only one it describes. ` +
+        `Deploy will not read that as evidence for both: it would fund and install a recipe nobody has ` +
+        `ever watched run, which is the one thing this gate exists to prevent.\n\n` +
+        `Nothing was created by this run — this gate reads the package's own files and nothing else, so ` +
+        `it stopped before any live read. Whatever this package already had is untouched, and this gate ` +
+        `cannot see it.\n\n` +
+        `Fix — each instance above needs its OWN directory, holding its recipe, with its \`runtime:\` in ` +
+        `${join(pkg.dir, "strategy.yaml")} updated to point there. ${movingCaveat}` +
+        `Once each one has its own directory and every relative path in its recipe still resolves from ` +
+        `there, re-run the deploy: it names any instance that is still unproven and carries the exact ` +
+        `\`openclaw senpi validate\` command for it.`);
+}
+/** How many changed files a single sentence names before it starts counting instead. */
+const MAX_NAMED_FILES = 5;
+/**
+ * The command that produces a proof, one per directory — from the shared producer, so the quoting
+ * these strings need (they are copied into a shell verbatim, and a real workspace path has spaces)
+ * is decided in one place for every surface that emits it.
+ *
+ * No python route here, deliberately: this gate is ABOUT the proof, and the skills validator does
+ * not write one. Naming it would be naming a command that cannot answer the refusal.
+ */
+function validateCommands(dirs) {
+    return dirs.map((dir) => `  ${validateCommand(dir)}`).join("\n");
+}
+/**
+ * Which directories the fix should send the reader to, and how to name the instance in prose.
+ *
+ * `verifyProof` reports the FIRST instance it could not verify and stops, carrying its name on the
+ * result. Using it keeps the fix to the sleeve that actually failed — listing every instance is not
+ * wrong (deploy requires them all proven) but costs a real live tick per sleeve to follow. When
+ * there is no instance identity — a flat package, whose one instance IS the package root — the
+ * package directory is the only honest target.
+ */
+function failingTarget(result, pkg) {
+    const failed = result.instance === undefined || result.instance === ""
+        ? undefined
+        : pkg.instances.find((inst) => relative(pkg.dir, inst.runtimeYamlDir) === result.instance);
+    if (failed === undefined) {
+        // Either a flat package, or a name this package no longer declares — in both cases the whole
+        // package is the target, which is never a wrong instruction, only a broader one.
+        const dirs = [...new Set(pkg.instances.map((inst) => inst.runtimeYamlDir))];
+        return { dirs, named: undefined };
+    }
+    return { dirs: [failed.runtimeYamlDir], named: failed.name };
+}
+/**
+ * The sentence that stops a second refusal from reading as "my fix did not work".
+ *
+ * Verification stops at the first unproven instance, so a package with two unproven sleeves refuses
+ * twice. Only said when there is more than one instance — on a flat package it would be noise.
+ */
+function everyInstanceNote(pkg) {
+    // Its OWN line. Appended to the last command line, an agent copying that line pastes the
+    // sentence into a shell along with it.
+    return pkg.instances.length > 1
+        ? `\nDeploy needs every instance of this package proven and stops at the first that is not, so ` +
+            `expect to be sent back here if another one is also unproven.`
+        : "";
+}
+/** `scan.py, scoring.py` — the first few, then a count. Never a bare "the package differs". */
+function nameChangedFiles(changed) {
+    const named = changed.slice(0, MAX_NAMED_FILES).join(", ");
+    return changed.length > MAX_NAMED_FILES ? `${named} and ${changed.length - MAX_NAMED_FILES} more` : named;
+}
+/**
+ * The three reasons, each with its own fix.
+ *
+ * A single generic "run senpi validate" would be a template hint rather than a computed one: the
+ * three states call for different reading. `no_proof` says nothing has ever been observed to run
+ * here; `content_changed` says the bytes moved and names which; `runtime_version_changed` says the
+ * package is unchanged and only the engine under it moved — the one case where editing the package
+ * would be exactly the wrong response.
+ */
+export function proofRefusalParts(result, pkg) {
+    const { dirs, named } = failingTarget(result, pkg);
+    const commands = validateCommands(dirs);
+    const scope = named === undefined ? "this package" : `instance "${named}" (${dirs[0]})`;
+    if (result.reason === "content_changed") {
+        const changed = result.changedFiles ?? [];
+        return {
+            code: VALIDATE_CODE.contentChanged,
+            what: changed.length > 0
+                ? `This package differs from the content that passed: ${nameChangedFiles(changed)}`
+                : "This package differs from the content that passed",
+            why: "A proof is a claim about exact bytes: these files are not the ones that ran, so nothing is " +
+                "known about how they behave. An edit is not required to be large to change what a scanner does.",
+            fix: `either restore the proven content, or prove what is there now — re-run the validation and ` +
+                `let it PASS, then re-run the deploy:\n${commands}${everyInstanceNote(pkg)}`,
+        };
+    }
+    if (result.reason === "runtime_version_changed") {
+        const proved = result.record?.runtime_version;
+        return {
+            code: VALIDATE_CODE.runtimeVersionChanged,
+            what: proved
+                ? `The proof was recorded under runtime ${proved}; this box runs ${VERSION}`
+                : `The proof was recorded under a runtime other than the ${VERSION} running here`,
+            why: "A pass is a claim about this package running under a specific runtime build. The proof " +
+                "predates the running runtime — the runtime self-updates in place — or, on a box that was " +
+                "rolled back, was made under a later one. Either way it no longer describes the code that " +
+                "would actually execute; the two versions above say which case this is.",
+            fix: `the package needs no editing: its content still matches its proof, and only the engine under ` +
+                `it moved. Re-prove it against the runtime running here, then re-run the deploy:` +
+                `\n${commands}${everyInstanceNote(pkg)}`,
+        };
+    }
+    return {
+        code: VALIDATE_CODE.noProof,
+        what: `No proof of a passing validation exists for ${scope}`,
+        why: "Deploy funds a wallet and installs code onto it. A proof is the record that this exact " +
+            "content ran: only a full, unscoped `openclaw senpi validate` at live depth that PASSES writes one — a " +
+            "scoped or shallow run deliberately does not. Without it, nothing here has been observed to " +
+            "execute at all.",
+        fix: `record one, and let it PASS, then re-run the deploy:\n${commands}${everyInstanceNote(pkg)}`,
+    };
+}
+/**
+ * The refusal as the step row's `detail`.
+ *
+ * The bracketed code leads, and is not decoration: `taxonomy.ts` extracts it and the CLI uses it to
+ * exit 2 (obey this) rather than 1 (state unknown).
+ *
+ * It emits NO re-run command of its own. The report's `next` already ends a refused report with
+ * `openclaw senpi deploy -p '<dir>' --budget <the real figure>`; a copy here would carry a `<usd>` placeholder
+ * instead, which is a second, worse command competing with the authoritative one.
+ */
+export function buildProofRefusal(result, pkg) {
+    const parts = proofRefusalParts(result, pkg);
+    return (`[${parts.code}] ${parts.what}.\n\n` +
+        `Why: ${parts.why}\n\n` +
+        // Scoped to THIS RUN, like the universe gate's refusal: the check runs before deploy reads any
+        // live state, so on a resume the package may already own a funded wallet this gate cannot see.
+        // Claiming "no wallet exists" there would invite funding a second one beside the live one.
+        `Nothing was created by this run — this gate reads the package's own files and nothing else, so ` +
+        `it stopped before any live read. Whatever this package already had is untouched, and this gate ` +
+        `cannot see it.\n\n` +
+        `Fix — ${parts.fix}`);
+}
+//# sourceMappingURL=proof-gate.js.map

package/dist/deploy/proof-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-gate.js","sourceRoot":"","sources":["../../src/deploy/proof-gate.ts"],"names":[],"mappings":"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"}

package/dist/deploy/python-float.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Read a YAML scalar the way Python's `float()` would — the ONE implementation of that question in
+ * the deploy module.
+ *
+ * Two places need it, for the same reason: the numbers they read are also read on the skills side
+ * by Python, and a disagreement means the discovery card and the verb compute different money.
+ * `min-budget.ts` uses it as the port of `min_budget.py`'s `_f`; `package.ts` uses it for
+ * `funding_share`, which additionally drives `planFunding`'s real allocation. They were briefly two
+ * near-copies that had already drifted (one had a boolean branch, the other did not) — which is the
+ * drift class this whole workstream exists to close, so they are one function now.
+ *
+ * SHAPE, NOT LETTER. A number, a bool, or a numeric string parses; everything else is null. Two
+ * classes of input where that is not exactly `float()`, both verified, both deliberately left:
+ *
+ *  - **A blank/whitespace string.** `float("")` raises, `Number("")` is `0`, so the explicit guard
+ *    aligns them. Defence in depth: it changes no output today, because every call site rejects `0`
+ *    downstream anyway — but that alignment then survives the next edit to any of those guards
+ *    instead of holding by accident.
+ *  - **Quoted exotic numeric strings**, the only real parity gap across ~450 adversarial inputs, and
+ *    reachable ONLY through a quoted YAML scalar (an unquoted `0x14` parses to `20` on both sides
+ *    before either implementation sees it). Python accepts more than `Number` in some places
+ *    (`"2_5"` → 25.0 under PEP 515, `"Infinity"`/`"inf"` → inf) and less in others (`"0x14"` raises
+ *    where `Number` gives 20). Deliberately NOT "fixed" with a numeric-literal regex: that closes
+ *    the `0x14` direction while leaving the underscore direction open, trading a documented, tested
+ *    divergence for a half-corrected one. Both directions are pinned as tests — in
+ *    `min-budget.test.ts` for the sizing path and `package.test.ts` for `funding_share` — so a
+ *    future "fix" cannot flip one silently.
+ *
+ * No shipped package is affected either way: across the 103 catalog packages, zero declare a quoted
+ * or non-numeric `funding_share` and zero declare a quoted sizing value.
+ */
+/** Python `float(x)`, returning null where it would raise. See the module header for the two gaps. */
+export declare function pythonFloat(value: unknown): number | null;
+//# sourceMappingURL=python-float.d.ts.map

package/dist/deploy/python-float.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python-float.d.ts","sourceRoot":"","sources":["../../src/deploy/python-float.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,sGAAsG;AACtG,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CASzD"}

package/dist/deploy/python-float.js

@@ -0,0 +1,46 @@
+/**
+ * Read a YAML scalar the way Python's `float()` would — the ONE implementation of that question in
+ * the deploy module.
+ *
+ * Two places need it, for the same reason: the numbers they read are also read on the skills side
+ * by Python, and a disagreement means the discovery card and the verb compute different money.
+ * `min-budget.ts` uses it as the port of `min_budget.py`'s `_f`; `package.ts` uses it for
+ * `funding_share`, which additionally drives `planFunding`'s real allocation. They were briefly two
+ * near-copies that had already drifted (one had a boolean branch, the other did not) — which is the
+ * drift class this whole workstream exists to close, so they are one function now.
+ *
+ * SHAPE, NOT LETTER. A number, a bool, or a numeric string parses; everything else is null. Two
+ * classes of input where that is not exactly `float()`, both verified, both deliberately left:
+ *
+ *  - **A blank/whitespace string.** `float("")` raises, `Number("")` is `0`, so the explicit guard
+ *    aligns them. Defence in depth: it changes no output today, because every call site rejects `0`
+ *    downstream anyway — but that alignment then survives the next edit to any of those guards
+ *    instead of holding by accident.
+ *  - **Quoted exotic numeric strings**, the only real parity gap across ~450 adversarial inputs, and
+ *    reachable ONLY through a quoted YAML scalar (an unquoted `0x14` parses to `20` on both sides
+ *    before either implementation sees it). Python accepts more than `Number` in some places
+ *    (`"2_5"` → 25.0 under PEP 515, `"Infinity"`/`"inf"` → inf) and less in others (`"0x14"` raises
+ *    where `Number` gives 20). Deliberately NOT "fixed" with a numeric-literal regex: that closes
+ *    the `0x14` direction while leaving the underscore direction open, trading a documented, tested
+ *    divergence for a half-corrected one. Both directions are pinned as tests — in
+ *    `min-budget.test.ts` for the sizing path and `package.test.ts` for `funding_share` — so a
+ *    future "fix" cannot flip one silently.
+ *
+ * No shipped package is affected either way: across the 103 catalog packages, zero declare a quoted
+ * or non-numeric `funding_share` and zero declare a quoted sizing value.
+ */
+/** Python `float(x)`, returning null where it would raise. See the module header for the two gaps. */
+export function pythonFloat(value) {
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : null;
+    if (typeof value === "boolean")
+        return value ? 1 : 0; // float(True) === 1.0
+    if (typeof value === "string") {
+        if (value.trim() === "")
+            return null;
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+//# sourceMappingURL=python-float.js.map

package/dist/deploy/python-float.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"python-float.js","sourceRoot":"","sources":["../../src/deploy/python-float.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,sGAAsG;AACtG,MAAM,UAAU,WAAW,CAAC,KAAc;IACxC,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;IAC5E,IAAI,OAAO,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,sBAAsB;IAC5E,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,IAAI,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE;YAAE,OAAO,IAAI,CAAC;QACrC,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC7B,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;IACjD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/deploy/recheck-commands.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The commands a deploy refusal sends a reader to when something has to be re-checked.
+ *
+ * TWO ROUTES, and both are named wherever either is. `python3 senpi-strategy-ops/scripts/…` is what
+ * the skills layer teaches today; `senpi validate` is what actually enforces, because a full,
+ * unscoped run at live depth that PASSES is the only thing that writes the `.senpi-proof.json` this
+ * verb now refuses a package without. A refusal naming only the python route sends an agent around
+ * a loop that cannot close: run the python validator, deploy, get refused for a missing proof,
+ * repeat — the python route cannot end it, and nothing in the refusal says so.
+ *
+ * ONE producer, for the same reason `resumeCommand` is one: every string here is pasted into a
+ * shell verbatim, so the quoting rule (a real workspace path has spaces in it) is decided once
+ * rather than per call site. Its own module because the callers span `deploy/` and `universe/`:
+ * `orchestrator.ts` imports `../universe/package-universe.ts`, so a producer living in either one
+ * would be imported back by the other — the same cycle constraint that gave `error-text.ts` a
+ * module of its own.
+ */
+/**
+ * `openclaw senpi validate '<dir>'` — the route that records a proof.
+ *
+ * The argument is always a DIRECTORY: an instance's `runtimeYamlDir`, a package root when no
+ * instance is known, or — where the package would not load at all — the directory the caller named,
+ * which is the only target left and the one validate diagnoses identically. Never a manifest
+ * instance NAME (validate resolves a path, and a name is not one — the exact confusion the proof
+ * gate exists to survive), and never a `<placeholder>`, which an agent pastes literally.
+ */
+export declare function validateCommand(dir: string): string;
+/** The skills package validator: the author-side checks over a package, and no proof. */
+export declare function deployPyValidateCommand(packageDir: string): string;
+/** The skills universe validator: the live-instrument half of the checks, and no proof. */
+export declare function validateUniversePyCommand(packageDir: string): string;
+/**
+ * Both routes as an indented block, one command per line — the form every refusal below the "fix"
+ * line uses.
+ *
+ * The validate directories are de-duplicated because two instances can legally share one, and the
+ * same line twice reads as two things to do. The runtime route leads: it is the one that ends the
+ * loop, and a reader who runs only the first command they see should be that reader.
+ */
+export declare function recheckBlock(validateDirs: readonly string[], pythonCommand: string): string;
+/**
+ * The sentence that stops "either" from reading as "either one finishes this".
+ *
+ * Named routes without it are a coin flip an agent loses half the time: the python route answers
+ * the question the refusal asked and still leaves the deploy refusing, with nothing in the text to
+ * explain why. It says which route ends the loop, and does not disparage the other — the skills
+ * validator is what the author-side skill teaches, and it catches these same faults.
+ */
+export declare const PROOF_ROUTE_NOTE = "Only `openclaw senpi validate` records the proof this deploy requires; the python route writes none.";
+//# sourceMappingURL=recheck-commands.d.ts.map

package/dist/deploy/recheck-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recheck-commands.d.ts","sourceRoot":"","sources":["../../src/deploy/recheck-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,yFAAyF;AACzF,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAElE;AAED,2FAA2F;AAC3F,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAG3F;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,yGAC2E,CAAC"}

package/dist/deploy/recheck-commands.js

@@ -0,0 +1,59 @@
+/**
+ * The commands a deploy refusal sends a reader to when something has to be re-checked.
+ *
+ * TWO ROUTES, and both are named wherever either is. `python3 senpi-strategy-ops/scripts/…` is what
+ * the skills layer teaches today; `senpi validate` is what actually enforces, because a full,
+ * unscoped run at live depth that PASSES is the only thing that writes the `.senpi-proof.json` this
+ * verb now refuses a package without. A refusal naming only the python route sends an agent around
+ * a loop that cannot close: run the python validator, deploy, get refused for a missing proof,
+ * repeat — the python route cannot end it, and nothing in the refusal says so.
+ *
+ * ONE producer, for the same reason `resumeCommand` is one: every string here is pasted into a
+ * shell verbatim, so the quoting rule (a real workspace path has spaces in it) is decided once
+ * rather than per call site. Its own module because the callers span `deploy/` and `universe/`:
+ * `orchestrator.ts` imports `../universe/package-universe.ts`, so a producer living in either one
+ * would be imported back by the other — the same cycle constraint that gave `error-text.ts` a
+ * module of its own.
+ */
+/**
+ * `openclaw senpi validate '<dir>'` — the route that records a proof.
+ *
+ * The argument is always a DIRECTORY: an instance's `runtimeYamlDir`, a package root when no
+ * instance is known, or — where the package would not load at all — the directory the caller named,
+ * which is the only target left and the one validate diagnoses identically. Never a manifest
+ * instance NAME (validate resolves a path, and a name is not one — the exact confusion the proof
+ * gate exists to survive), and never a `<placeholder>`, which an agent pastes literally.
+ */
+export function validateCommand(dir) {
+    return `openclaw senpi validate '${dir}'`;
+}
+/** The skills package validator: the author-side checks over a package, and no proof. */
+export function deployPyValidateCommand(packageDir) {
+    return `python3 senpi-strategy-ops/scripts/deploy.py validate '${packageDir}'`;
+}
+/** The skills universe validator: the live-instrument half of the checks, and no proof. */
+export function validateUniversePyCommand(packageDir) {
+    return `python3 senpi-strategy-ops/scripts/validate_universe.py '${packageDir}'`;
+}
+/**
+ * Both routes as an indented block, one command per line — the form every refusal below the "fix"
+ * line uses.
+ *
+ * The validate directories are de-duplicated because two instances can legally share one, and the
+ * same line twice reads as two things to do. The runtime route leads: it is the one that ends the
+ * loop, and a reader who runs only the first command they see should be that reader.
+ */
+export function recheckBlock(validateDirs, pythonCommand) {
+    const lines = [...new Set(validateDirs)].map(validateCommand);
+    return [...lines, pythonCommand].map((command) => `  ${command}`).join("\n");
+}
+/**
+ * The sentence that stops "either" from reading as "either one finishes this".
+ *
+ * Named routes without it are a coin flip an agent loses half the time: the python route answers
+ * the question the refusal asked and still leaves the deploy refusing, with nothing in the text to
+ * explain why. It says which route ends the loop, and does not disparage the other — the skills
+ * validator is what the author-side skill teaches, and it catches these same faults.
+ */
+export const PROOF_ROUTE_NOTE = "Only `openclaw senpi validate` records the proof this deploy requires; the python route writes none.";
+//# sourceMappingURL=recheck-commands.js.map

package/dist/deploy/recheck-commands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recheck-commands.js","sourceRoot":"","sources":["../../src/deploy/recheck-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAAC,GAAW;IACzC,OAAO,4BAA4B,GAAG,GAAG,CAAC;AAC5C,CAAC;AAED,yFAAyF;AACzF,MAAM,UAAU,uBAAuB,CAAC,UAAkB;IACxD,OAAO,0DAA0D,UAAU,GAAG,CAAC;AACjF,CAAC;AAED,2FAA2F;AAC3F,MAAM,UAAU,yBAAyB,CAAC,UAAkB;IAC1D,OAAO,4DAA4D,UAAU,GAAG,CAAC;AACnF,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAAC,YAA+B,EAAE,aAAqB;IACjF,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;IAC9D,OAAO,CAAC,GAAG,KAAK,EAAE,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,KAAK,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC/E,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAC3B,sGAAsG,CAAC"}

package/dist/deploy/register.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Gateway wiring for the deploy job: `senpi.deploy.start` / `.status`.
+ *
+ * These two methods are **internal transport** between the `senpi deploy` CLI
+ * verbs and the plugin. They are deliberately absent from the cheatsheet, the
+ * README's agent-facing sections and the skills: one teaching surface (the CLI)
+ * wins routing, and naming the RPCs too would invite raw-RPC calls that bypass
+ * the CLI-side validation.
+ *
+ * The module owns no logic of its own beyond adapting ctx → collaborators:
+ * everything it needs arrives in an explicit {@link DeployGatewayContext}, so it
+ * never reaches into the plugin's boot closure.
+ */
+import type { SenpiClient } from "../senpi/client.js";
+import { type RegistryEntryLite, type ScannerRowLite } from "./orchestrator.js";
+import { type DeployJobController } from "./job.js";
+/**
+ * Mirrors `installRuntimeCore`'s return shape (index.ts) without importing the boot closure.
+ *
+ * `payload.unwired` is the unwired phase — the install succeeded, but the runtime has NO live entry
+ * scanners. Deploy reads it as an install failure (it funded a wallet for a runtime that can never
+ * tick); direct gateway/CLI installs keep treating `ok` as ok.
+ */
+export type InstallGatewayResult = {
+    ok: true;
+    payload: {
+        id: string;
+        name: string;
+        wallet: string;
+        unwired?: string;
+    };
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+/** The slice of the plugin API this module uses. */
+export interface DeployPluginApi {
+    registerGatewayMethod(name: string, handler: (ctx: {
+        respond: (ok: boolean, value: unknown) => void;
+        params?: Record<string, unknown>;
+    }) => void | Promise<void>, opts?: {
+        scope?: "operator.write" | "operator.read";
+    }): void;
+}
+/**
+ * Everything the deploy gateway needs from the plugin boot closure, injected
+ * explicitly — register.ts never reaches into index.ts internals.
+ */
+export interface DeployGatewayContext {
+    controller: DeployJobController;
+    /**
+     * Runs fn with a fresh connected SenpiClient; always disconnects. One helper, reused per job.
+     *
+     * NOTE: a deploy holds this client for the whole job (up to `maxWait` + `tickWait` + install),
+     * unlike every other call site, which connects per operation. That is deliberate — the create
+     * poll must keep the same session — but it is the seam where an MCP idle/TTL bound would first
+     * surface, as a throw from the poll. That throw is now contained: the orchestrator records the
+     * step `failed` with the message quoted rather than losing the whole report.
+     */
+    withSenpiClient<T>(fn: (client: SenpiClient) => Promise<T>): Promise<T>;
+    /** = installRuntimeCore */
+    installRuntime(params: Record<string, unknown>): Promise<InstallGatewayResult>;
+    /** = deleteRuntimeCore — archival/launcher teardown is NOT reimplemented here. */
+    deleteRuntime(id: string): Promise<void>;
+    registryFindByWallet(wallet: string): Promise<RegistryEntryLite | undefined>;
+    registryFindById(id: string): Promise<RegistryEntryLite | undefined>;
+    getScannerRows(runtimeId: string): Promise<ScannerRowLite[] | null>;
+    /** H4: does this runtime id have a LIVE handle (not merely a registry row)? */
+    runtimeIsLive(id: string): Promise<boolean>;
+    logger: {
+        info(line: string): void;
+    };
+}
+export interface DeployLiveLayer {
+    strategies: Array<{
+        strategyName: string;
+        status: string;
+        strategyWalletAddress: string;
+        totalFunded?: number;
+    }>;
+    runtimes: Array<{
+        id: string;
+        wallet?: string;
+    }>;
+    /**
+     * Set when this layer could not be read at all — the package is gone (moved/deleted) or the
+     * strategy read failed closed (`listStrategies` throws rather than reporting zero). The layer is
+     * then EMPTY, not wrong: the renderer prints the reason instead of "none matching this package",
+     * which over a job that may have funded wallets would be the one claim this layer exists to
+     * prevent. Never set for a genuinely empty result.
+     */
+    unavailable?: string;
+}
+/** Register the internal deploy transport pair. */
+export declare function registerDeployGatewayMethods(api: DeployPluginApi, ctx: DeployGatewayContext): void;
+//# sourceMappingURL=register.d.ts.map

package/dist/deploy/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../src/deploy/register.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAmCtD,OAAO,EAA8B,KAAK,iBAAiB,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC5G,OAAO,EAAuB,KAAK,mBAAmB,EAAwC,MAAM,UAAU,CAAC;AAE/G;;;;;;GAMG;AACH,MAAM,MAAM,oBAAoB,GAC5B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GACrF;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC;AAE5D,oDAAoD;AACpD,MAAM,WAAW,eAAe;IAC9B,qBAAqB,CACnB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,GAAG,EAAE;QACb,OAAO,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;QAC/C,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAClC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC1B,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,gBAAgB,GAAG,eAAe,CAAA;KAAE,GACpD,IAAI,CAAC;CACT;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,mBAAmB,CAAC;IAChC;;;;;;;;OAQG;IACH,eAAe,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACxE,2BAA2B;IAC3B,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAC/E,kFAAkF;IAClF,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAAC;IAC7E,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAAC;IACrE,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,GAAG,IAAI,CAAC,CAAC;IACpE,+EAA+E;IAC/E,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5C,MAAM,EAAE;QAAE,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;CACtC;AAyaD,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,KAAK,CAAC;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,qBAAqB,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACjH,QAAQ,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACjD;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAoWD,mDAAmD;AACnD,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,oBAAoB,GAAG,IAAI,CAWlG"}