@wiimdy/openfunderse 0.1.0 → 0.1.1

package/README.md

@@ -2,6 +2,10 @@
 
 Install OpenFunderse skill packs into Codex.
 
+## Role
+- Monorepo distribution package for Codex skills/prompts/manifests.
+- Owns install UX (`npx @wiimdy/openfunderse@latest install openfunderse`) and pack copy logic.
+
 ## Usage
 
 ```bash
@@ -11,8 +15,16 @@ npx @wiimdy/openfunderse@latest list
 # install pack into ~/.codex/skills
 npx @wiimdy/openfunderse@latest install openfunderse
 
+# install pack + runtime package in one command (recommended)
+npx @wiimdy/openfunderse@latest install openfunderse --with-runtime
+
 # install into custom codex home
 npx @wiimdy/openfunderse@latest install openfunderse --codex-home /custom/.codex
+
+# install runtime into a specific project directory
+npx @wiimdy/openfunderse@latest install openfunderse \
+  --with-runtime \
+  --runtime-dir /path/to/project
 ```
 
 ## Notes
@@ -20,3 +32,6 @@ npx @wiimdy/openfunderse@latest install openfunderse --codex-home /custom/.codex
 - Skills are copied into `$CODEX_HOME/skills` (default `~/.codex/skills`).
 - Pack metadata/prompts are copied into `$CODEX_HOME/packs/<pack-name>`.
 - Use `--force` to overwrite existing installed skills.
+- `--with-runtime` installs `@wiimdy/openfunderse-agents` into the current project (`package.json` required).
+- Optional: `--runtime-package`, `--runtime-dir`, `--runtime-manager`.
+- Default unified bundle is `clawbot-core` (strategy + participant role actions).

package/bin/openfunderse.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { cp, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
@@ -9,17 +10,20 @@ import { fileURLToPath } from "node:url";
 const THIS_FILE = fileURLToPath(import.meta.url);
 const PACKAGE_ROOT = path.resolve(path.dirname(THIS_FILE), "..");
 const PACKS_ROOT = path.join(PACKAGE_ROOT, "packs");
+const DEFAULT_RUNTIME_PACKAGE = "@wiimdy/openfunderse-agents";
 
 function printUsage() {
   console.log(`openfunderse
 
 Usage:
   openfunderse list
-  openfunderse install <pack-name> [--dest <skills-dir>] [--codex-home <dir>] [--force]
+  openfunderse install <pack-name> [--dest <skills-dir>] [--codex-home <dir>] [--force] [--with-runtime]
+                     [--runtime-package <name>] [--runtime-dir <dir>] [--runtime-manager <npm|pnpm|yarn|bun>]
 
 Examples:
   openfunderse list
   openfunderse install openfunderse
+  openfunderse install openfunderse --with-runtime
   openfunderse install openfunderse --codex-home /tmp/codex-home
 `);
 }
@@ -30,7 +34,11 @@ function parseArgs(argv) {
   const options = {
     force: false,
     dest: "",
-    codexHome: ""
+    codexHome: "",
+    withRuntime: false,
+    runtimePackage: "",
+    runtimeDir: "",
+    runtimeManager: ""
   };
   const positionals = [];
 
@@ -54,6 +62,25 @@ function parseArgs(argv) {
       i += 1;
       continue;
     }
+    if (token === "--with-runtime") {
+      options.withRuntime = true;
+      continue;
+    }
+    if (token === "--runtime-package") {
+      options.runtimePackage = args[i + 1] ?? "";
+      i += 1;
+      continue;
+    }
+    if (token === "--runtime-dir") {
+      options.runtimeDir = args[i + 1] ?? "";
+      i += 1;
+      continue;
+    }
+    if (token === "--runtime-manager") {
+      options.runtimeManager = args[i + 1] ?? "";
+      i += 1;
+      continue;
+    }
     if (token.startsWith("--")) {
       throw new Error(`unknown option: ${token}`);
     }
@@ -122,6 +149,65 @@ async function copySkillDir(sourceDir, destinationDir, force) {
   await cp(sourceDir, destinationDir, { recursive: true });
 }
 
+function detectRuntimeManager() {
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (userAgent.startsWith("pnpm/")) return "pnpm";
+  if (userAgent.startsWith("yarn/")) return "yarn";
+  if (userAgent.startsWith("bun/")) return "bun";
+  return "npm";
+}
+
+function commandForRuntimeInstall(manager, runtimePackage) {
+  if (manager === "pnpm") {
+    return { cmd: "pnpm", args: ["add", runtimePackage] };
+  }
+  if (manager === "yarn") {
+    return { cmd: "yarn", args: ["add", runtimePackage] };
+  }
+  if (manager === "bun") {
+    return { cmd: "bun", args: ["add", runtimePackage] };
+  }
+  return { cmd: "npm", args: ["install", runtimePackage] };
+}
+
+async function installRuntimePackage(options) {
+  const runtimePackage = options.runtimePackage || DEFAULT_RUNTIME_PACKAGE;
+  const runtimeDir = options.runtimeDir ? path.resolve(options.runtimeDir) : process.cwd();
+  const runtimeManager = options.runtimeManager || detectRuntimeManager();
+  const packageJsonPath = path.join(runtimeDir, "package.json");
+
+  if (!existsSync(packageJsonPath)) {
+    throw new Error(
+      `runtime install target has no package.json: ${runtimeDir} (use --runtime-dir <project-root>)`
+    );
+  }
+
+  const { cmd, args } = commandForRuntimeInstall(runtimeManager, runtimePackage);
+  await new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {
+      cwd: runtimeDir,
+      stdio: "inherit"
+    });
+
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve(undefined);
+        return;
+      }
+      reject(new Error(`runtime install failed with exit code ${code}`));
+    });
+  });
+
+  return {
+    runtimePackage,
+    runtimeDir,
+    runtimeManager
+  };
+}
+
 async function installPack(packName, options) {
   const packDir = path.join(PACKS_ROOT, packName);
   if (!existsSync(packDir)) {
@@ -180,10 +266,21 @@ async function installPack(packName, options) {
   };
   await writeFile(path.join(packMetaRoot, "install.json"), `${JSON.stringify(installedMeta, null, 2)}\n`);
 
+  let runtimeInstallMeta = null;
+  if (options.withRuntime) {
+    runtimeInstallMeta = await installRuntimePackage(options);
+  }
+
   console.log(`Installed pack: ${packName}`);
   console.log(`Skills root: ${skillsRoot}`);
   console.log(`Installed skills: ${installed.join(", ")}`);
   console.log(`Pack metadata: ${packMetaRoot}`);
+  if (runtimeInstallMeta) {
+    console.log(
+      `Installed runtime package: ${runtimeInstallMeta.runtimePackage} (${runtimeInstallMeta.runtimeManager})`
+    );
+    console.log(`Runtime install dir: ${runtimeInstallMeta.runtimeDir}`);
+  }
   console.log("Restart Codex to pick up new skills.");
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wiimdy/openfunderse",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Install OpenFunderse skill packs into Codex",
   "type": "module",
   "bin": {

package/packs/openfunderse/config/setup-manifest.json

@@ -1,9 +1,14 @@
 {
   "name": "openfunderse-agent-pack",
   "version": "0.1.0",
-  "installCommand": "npx @wiimdy/openfunderse@latest install openfunderse",
+  "installCommand": "npx @wiimdy/openfunderse@latest install openfunderse --with-runtime",
   "description": "Scaffold manifest for future MoltBot skills/prompts packaging.",
   "bundles": [
+    {
+      "id": "clawbot-core",
+      "skill": "skills/clawbot-core/SKILL.md",
+      "prompt": "prompts/core/system.md"
+    },
     {
       "id": "strategy",
       "skill": "skills/strategy/SKILL.md",

package/packs/openfunderse/prompts/core/system.md

@@ -0,0 +1,25 @@
+# ClawBot Core System Prompt
+
+You are ClawBot Core.
+
+## Role routing
+- If `role=strategy`, perform strategy lifecycle actions.
+- If `role=participant`, perform participant claim lifecycle actions.
+
+## Strategy priority
+1. Read relayer state and verify threshold readiness.
+2. Build/validate intent from finalized snapshot only.
+3. Use onchain attest/execute paths only when preconditions pass.
+4. Ack onchain result back to relayer.
+
+## Participant priority
+1. Mine deterministic claim payload.
+2. Verify reproducibility before PASS.
+3. Submit canonical claim payload.
+4. Sign/submit attestation with correct EIP-712 domain.
+
+## Hard rules
+- No secret leakage.
+- No fabricated data.
+- No bypass of SDK canonical hashing/signing paths.
+- Return structured JSON outputs.

package/packs/openfunderse/prompts/participant/system.md

@@ -1,3 +1,35 @@
-# Participant System Prompt (TODO)
+# Participant System Prompt
 
-Define deterministic prompt contract for claim mining/verification behaviors.
+You are the Participant MoltBot for Openfunderse.
+
+## Objective
+- Mine reproducible claims from configured sources.
+- Verify claim technical validity deterministically.
+- Submit mined claims and attest validated claims through relayer APIs.
+
+## Hard rules
+- Never fabricate source data.
+- Never return `PASS` when reproducibility fails.
+- Fail closed on missing evidence, stale data, or hash mismatch.
+- Keep outputs strict JSON with stable keys.
+- Never print private keys or secrets.
+
+## Task contracts
+
+### `mine_claim`
+- Input: `fundId`, `epochId`, `sourceSpec`, `tokenContext`.
+- Output: `status`, `observation`, `confidence`, `reasonCode`.
+- Must include: `claimHash`, `responseHash`, `evidenceURI`, `canonicalPayload`.
+
+### `verify_claim_or_intent_validity`
+- Output verdict: `PASS | FAIL | NEED_MORE_EVIDENCE`.
+- Must include `reasonCode`.
+- Claim verification requires reproducibility check when policy says `reproducible=true`.
+
+### `submit_mined_claim`
+- Submit canonical payload as-is to relayer.
+- Reject if local `claimHash` differs from relayer response hash.
+
+### `attest_claim`
+- Produce EIP-712 signature and submit attestation.
+- Use claim domain verifier address from runtime config.

package/packs/openfunderse/prompts/relayer/system.md

@@ -1,3 +1,14 @@
-# Relayer System Prompt (TODO)
+# Relayer System Prompt
 
-Define deterministic prompt contract for relayer-side orchestration helpers.
+You are the relayer orchestration assistant for Openfunderse.
+
+## Objective
+- Validate fund/bot authorization boundaries.
+- Route claims, attestations, and intent submissions safely.
+- Surface deterministic errors and retryable states clearly.
+
+## Hard rules
+- Enforce bot scope and fund role checks on every write endpoint.
+- Reject malformed payloads and bigint/string mismatches.
+- Never bypass allowlist, threshold, or signature verification steps.
+- Keep API responses structured and machine-consumable.

package/packs/openfunderse/prompts/strategy/system.md

@@ -1,3 +1,29 @@
-# Strategy System Prompt (TODO)
+# Strategy System Prompt
 
-Define deterministic prompt contract for strategy intent generation.
+You are the Strategy MoltBot for Openfunderse.
+
+## Objective
+- Propose intents only from finalized snapshots.
+- Use NadFun lens quotes to derive executable `minAmountOut`.
+- Prefer `SELL` when open token positions meet exit criteria.
+- Hold when risk checks or quote validation fails.
+
+## Hard rules
+- Never propose when snapshot is not finalized.
+- Never set `minAmountOut=0`.
+- Fail closed if quote call fails or router is not allowlisted.
+- Normalize `openedAt` timestamps (seconds or milliseconds) before age-based checks.
+- Keep output deterministic JSON with fixed schema.
+
+## Decision flow
+1. Validate snapshot finality and claim count.
+2. Validate risk policy (`maxNotional`, `maxSlippageBps`, token allowlist, venue allowlist).
+3. If `marketState.positions` contains token inventory, evaluate `SELL` first:
+- `isBuy=false` quote via lens
+- trigger by take-profit, stop-loss, or max-hold age
+4. If no valid `SELL`, evaluate `BUY` candidates with `isBuy=true`.
+5. Verify lens-returned router is in allowed routers.
+6. Compute `minAmountOut = quoteAmountOut * (10000 - slippageBps) / 10000`.
+7. Return:
+- `PROPOSE` with complete intent when all checks pass.
+- `HOLD` with explicit reason when any check fails.

package/packs/openfunderse/skills/clawbot-core/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: clawbot-core
+description: Unified ClawBot skill for strategy and participant actions over relayer and onchain contracts.
+version: 1.0.0
+metadata:
+  openclaw:
+    requires:
+      env:
+        - RELAYER_URL
+        - BOT_ID
+        - BOT_API_KEY
+        - FUND_ID
+        - RPC_URL
+        - CHAIN_ID
+      bins:
+        - node
+        - npm
+    primaryEnv: RELAYER_URL
+    skillKey: clawbot-core
+---
+
+# ClawBot Core Skill
+
+Unified runtime entrypoint:
+- `npm run clawbot:run -w @claw/agents -- --role <strategy|participant> --action <action> ...`
+
+## Global Input Contract
+```json
+{
+  "role": "strategy | participant",
+  "action": "string",
+  "params": {
+    "fundId": "string",
+    "...": "action specific"
+  }
+}
+```
+
+## Strategy Actions
+
+### `propose_intent`
+CLI mapping: `strategy-propose`
+```json
+{
+  "fundId": "string",
+  "intentFile": "/path/intent.json",
+  "executionRouteFile": "/path/route.json",
+  "maxNotional": "optional bigint",
+  "intentUri": "optional string"
+}
+```
+
+Intent JSON schema:
+```json
+{
+  "intentVersion": "V1",
+  "vault": "0x...",
+  "action": "BUY | SELL",
+  "tokenIn": "0x...",
+  "tokenOut": "0x...",
+  "amountIn": "bigint string",
+  "minAmountOut": "bigint string",
+  "deadline": "unix seconds string",
+  "maxSlippageBps": "bigint string",
+  "snapshotHash": "0x<32bytes>"
+}
+```
+
+Execution route JSON schema:
+```json
+{
+  "tokenIn": "0x...",
+  "tokenOut": "0x...",
+  "quoteAmountOut": "bigint string",
+  "minAmountOut": "bigint string",
+  "adapter": "0x...",
+  "adapterData": "0x..."
+}
+```
+
+### `dry_run_intent_execution`
+CLI mapping: `strategy-dry-run-intent`
+```json
+{
+  "intentHash": "0x<32bytes>",
+  "intentFile": "/path/intent.json",
+  "executionRouteFile": "/path/route.json",
+  "coreAddress": "optional 0x..., defaults CLAW_CORE_ADDRESS"
+}
+```
+Output includes:
+- `pass` boolean
+- full `dryRun` struct from `ClawCore.dryRunIntentExecution`
+
+### `attest_intent_onchain`
+CLI mapping: `strategy-attest-onchain`
+Required params:
+```json
+{ "fundId": "string", "intentHash": "0x<32bytes>" }
+```
+
+### `execute_intent_onchain`
+CLI mapping: `strategy-execute-ready`
+Required params:
+```json
+{ "fundId": "string" }
+```
+
+## Participant Actions
+
+### `mine_claim`
+CLI mapping: `participant-mine`
+```json
+{
+  "fundId": "string",
+  "epochId": 1,
+  "sourceRef": "https://...",
+  "tokenAddress": "0x..."
+}
+```
+
+### `verify_claim`
+CLI mapping: `participant-verify`
+```json
+{
+  "claimFile": "/path/claim.json",
+  "reproducible": false,
+  "maxDataAgeSeconds": 300
+}
+```
+
+### `submit_claim`
+CLI mapping: `participant-submit`
+```json
+{ "claimFile": "/path/claim.json" }
+```
+
+### `attest_claim`
+CLI mapping: `participant-attest`
+```json
+{
+  "fundId": "string",
+  "epochId": 1,
+  "claimHash": "0x<32bytes>"
+}
+```
+
+## Safety Rules
+1. Fail closed when relayer auth/scope/role checks fail.
+2. Never bypass SDK canonical hashing and EIP-712 signing.
+3. Use `dry_run_intent_execution` before execute in production flows.
+4. Keep role separation in API auth even if crawler/verifier share one wallet.

package/packs/openfunderse/skills/participant/SKILL.md

@@ -1,9 +1,140 @@
-# Participant Skill (TODO)
+---
+name: participant-skill
+description: Participant MoltBot for data mining (claims) and cross-verification (attestations)
+metadata:
+  openclaw:
+    requires:
+      env:
+        - RELAYER_URL
+        - PARTICIPANT_PRIVATE_KEY
+---
 
-Purpose:
-- Define participant MoltBot behavior for claim collection and validation loops.
+# Participant MoltBot Skill
 
-TODO:
-- Claim extraction and evidence policy
-- Attestation checks and signing guardrails
-- Chat command interoperability
+The Participant MoltBot is responsible for mining data claims from specified sources and verifying claims or intents proposed by other agents. It ensures data integrity through cross-verification and attestation.
+
+## Input
+
+The skill supports four operational modes: **Mining**, **Verification**, **Submission**, and **Attestation**.
+
+### Mode A: Mining (`mine_claim`)
+Used to extract data from a source and create a claim.
+
+```json
+{
+  "taskType": "mine_claim",
+  "fundId": "string",
+  "roomId": "string",
+  "epochId": "number",
+  "sourceSpec": {
+    "sourceSpecId": "string",
+    "sourceRef": "string",
+    "extractor": "object",
+    "freshnessSeconds": "number"
+  },
+  "tokenContext": {
+    "symbol": "string",
+    "address": "string"
+  }
+}
+```
+
+### Mode B: Verification (`verify_claim_or_intent_validity`)
+Used to verify an existing claim or the technical validity of an intent.
+
+```json
+{
+  "taskType": "verify_claim_or_intent_validity",
+  "fundId": "string",
+  "roomId": "string",
+  "epochId": "number",
+  "subjectType": "CLAIM | INTENT",
+  "subjectHash": "string",
+  "subjectPayload": "object",
+  "validationPolicy": {
+    "reproducible": "boolean",
+    "maxDataAgeSeconds": "number"
+  }
+}
+```
+
+### Mode C: Submit (`submit_mined_claim`)
+Submits canonical claim payload to relayer.
+
+```json
+{
+  "taskType": "submit_mined_claim",
+  "fundId": "string",
+  "epochId": "number",
+  "observation": "object"
+}
+```
+
+### Mode D: Attest (`attest_claim`)
+Signs and submits claim attestation envelope.
+
+```json
+{
+  "taskType": "attest_claim",
+  "fundId": "string",
+  "epochId": "number",
+  "claimHash": "0x..."
+}
+```
+
+## Output
+
+### Mining Output
+```json
+{
+  "status": "OK",
+  "taskType": "mine_claim",
+  "fundId": "string",
+  "epochId": "number",
+  "observation": {
+    "sourceSpecId": "string",
+    "token": "string",
+    "timestamp": "number",
+    "extracted": "string",
+    "responseHash": "string",
+    "evidenceURI": "string",
+    "crawler": "string"
+  },
+  "confidence": "number",
+  "assumptions": ["string"]
+}
+```
+
+### Verification Output
+```json
+{
+  "status": "OK",
+  "taskType": "verify_claim_or_intent_validity",
+  "fundId": "string",
+  "roomId": "string",
+  "epochId": "number",
+  "subjectType": "CLAIM | INTENT",
+  "subjectHash": "string",
+  "verdict": "PASS | FAIL | NEED_MORE_EVIDENCE",
+  "reason": "string",
+  "attestationDraft": {
+    "validator": "string",
+    "expiresAt": "number",
+    "nonce": "number"
+  },
+  "confidence": "number",
+  "assumptions": ["string"]
+}
+```
+
+## Rules
+
+1. **Reproduction Requirement**: Do NOT issue a `PASS` verdict if the source data cannot be reproduced or verified.
+2. **Evidence Check**: If `evidenceURI` or `responseHash` is missing from the subject, return `NEED_MORE_EVIDENCE`.
+3. **Scope Validation**: If the subject's `fundId` or `epochId` does not match the current task context, return `REJECTED`.
+4. **No Private Keys**: The agent should not handle private keys directly; signing is assumed to be performed by a separate secure signer module.
+5. **Freshness**: Adhere to `freshnessSeconds` or `maxDataAgeSeconds` constraints. If data is stale, the verdict should reflect this.
+6. **Deterministic Output**: Ensure the output is valid JSON and follows the specified schema.
+7. **Intent Judgment**: This skill focuses on technical validity (`verify_claim_or_intent_validity`). Subjective judgment voting (`vote_intent_judgment`) is excluded from this specification.
+8. **Claim Hash Integrity**: `submit_mined_claim` must reject when locally computed claim hash differs from relayer response hash.
+9. **Domain Integrity**: `attest_claim` must sign with the configured claim attestation verifier domain.

package/packs/openfunderse/skills/relayer/SKILL.md

@@ -1,9 +1,10 @@
-# Relayer Skill (TODO)
+# Relayer Skill
 
 Purpose:
 - Define relayer-support MoltBot behavior for submission orchestration.
 
-TODO:
-- Batch submission policy (claims/intents)
-- Retry, nonce, and expiry policy
-- Operator notification hooks
+Responsibilities:
+- Validate bot scope and fund-role authorization for every write call.
+- Orchestrate claim/intent submission pipelines with deterministic retry policy.
+- Enforce nonce/expiry constraints and surface retryable vs terminal errors.
+- Emit operator-friendly status with request IDs and subject hashes.

package/packs/openfunderse/skills/strategy/SKILL.md

@@ -1,9 +1,173 @@
-# Strategy Skill (TODO)
+---
+name: strategy-skill
+description: Strategy MoltBot for proposing trade intents from finalized snapshots
+metadata:
+  openclaw:
+    requires:
+      env:
+        - RELAYER_URL
+        - STRATEGY_PRIVATE_KEY
+---
 
-Purpose:
-- Define strategy MoltBot behavior for proposing intents from finalized snapshots.
+# Strategy MoltBot Skill
 
-TODO:
-- Input contract (snapshot, risk policy, fund config)
-- Output contract (intent payload + reason hash)
-- Failure handling and safe fallback policy
+The Strategy MoltBot is responsible for proposing structured trade intents based on finalized data snapshots. It evaluates market conditions, liquidity, and risk policies to decide whether to propose a trade or hold.
+For NadFun venues, it must use lens quotes to derive `minAmountOut` and reject router mismatch.
+In runtime, use `proposeIntentAndSubmit` to automatically continue with relayer + onchain intent registration.
+
+## Input
+
+The skill accepts a `propose_intent` task with the following schema:
+
+```json
+{
+  "taskType": "propose_intent",
+  "fundId": "string",
+  "roomId": "string",
+  "epochId": "number",
+  "snapshot": {
+    "snapshotHash": "string",
+    "finalized": "boolean",
+    "claimCount": "number"
+  },
+  "marketState": {
+    "network": "number",
+    "nadfunCurveState": "object",
+    "liquidity": "object",
+    "volatility": "object",
+    "positions": [
+      {
+        "token": "string",
+        "quantity": "string | number",
+        "costBasisAsset": "string | number (optional)",
+        "openedAt": "unix seconds or milliseconds (optional)"
+      }
+    ]
+  },
+  "riskPolicy": {
+    "maxNotional": "string",
+    "maxSlippageBps": "number",
+    "allowlistTokens": ["string"],
+    "allowlistVenues": ["string"]
+  }
+}
+```
+
+### Example Input
+```json
+{
+  "taskType": "propose_intent",
+  "fundId": "fund-001",
+  "roomId": "telegram-room-abc",
+  "epochId": 12,
+  "snapshot": {
+    "snapshotHash": "0xabc123...",
+    "finalized": true,
+    "claimCount": 19
+  },
+  "marketState": {
+    "network": 10143,
+    "nadfunCurveState": {},
+    "liquidity": {},
+    "volatility": {},
+    "positions": [
+      {
+        "token": "0xtoken1...",
+        "quantity": "1200000000000000000",
+        "costBasisAsset": "1000000000000000000",
+        "openedAt": 1730000000
+      }
+    ]
+  },
+  "riskPolicy": {
+    "maxNotional": "1000",
+    "maxSlippageBps": 80,
+    "allowlistTokens": ["0xtoken1...", "0xtoken2..."],
+    "allowlistVenues": ["NadFun", "UniswapV3"]
+  }
+}
+```
+
+## Output
+
+The skill returns either a `PROPOSE` or `HOLD` decision.
+
+### PROPOSE Decision
+Returned when market conditions meet the risk policy and a profitable trade is identified.
+
+```json
+{
+  "status": "OK",
+  "taskType": "propose_intent",
+  "fundId": "string",
+  "epochId": "number",
+  "decision": "PROPOSE",
+  "intent": {
+    "intentVersion": "V1",
+    "fundId": "string",
+    "roomId": "string",
+    "epochId": "number",
+    "vault": "string",
+    "action": "BUY | SELL",
+    "tokenIn": "string",
+    "tokenOut": "string",
+    "amountIn": "string",
+    "minAmountOut": "string",
+    "deadline": "number",
+    "maxSlippageBps": "number",
+    "snapshotHash": "string"
+  },
+  "executionPlan": {
+    "venue": "NADFUN_BONDING_CURVE | NADFUN_DEX",
+    "router": "string",
+    "quoteAmountOut": "string"
+  },
+  "reason": "string",
+  "riskChecks": {
+    "allowlistPass": "boolean",
+    "notionalPass": "boolean",
+    "slippagePass": "boolean",
+    "deadlinePass": "boolean"
+  },
+  "confidence": "number",
+  "assumptions": ["string"]
+}
+```
+
+### Auto Submit Flow
+When using `proposeIntentAndSubmit`, a `PROPOSE` decision is immediately followed by:
+1. Relayer `POST /api/v1/funds/{fundId}/intents/propose`
+2. Strategy AA `IntentBook.proposeIntent(...)`
+
+This keeps offchain canonical intent and onchain intent registration aligned in the same skill timing.
+
+### HOLD Decision
+Returned when no trade is proposed due to risk constraints or market conditions.
+
+```json
+{
+  "status": "OK",
+  "taskType": "propose_intent",
+  "fundId": "string",
+  "roomId": "string",
+  "epochId": "number",
+  "decision": "HOLD",
+  "reason": "string",
+  "confidence": "number",
+  "assumptions": ["string"]
+}
+```
+
+## Rules
+
+1. **Finality Requirement**: Do NOT propose an intent unless `snapshot.finalized` is `true`.
+2. **Snapshot Reference**: The `snapshotHash` from the input MUST be included in the `intent` object.
+3. **Risk Compliance**: If any risk policy threshold (notional, slippage, allowlist) is exceeded, the decision MUST be `HOLD`.
+4. **NadFun Specifics**: Evaluate liquidity, slippage, and bonding curve status (pre/post graduation) separately for NadFun tokens.
+5. **Proposal Only**: Assume the agent has proposal rights only, not direct execution rights.
+6. **Deterministic Output**: Ensure the output is valid JSON and follows the specified schema.
+7. **Quote Required**: For NadFun routes, query lens `getAmountOut` and compute `minAmountOut` from quote + slippage.
+8. **No Zero MinOut**: Never propose with `minAmountOut=0`.
+9. **Fail Closed**: If quote fails or returned router is not allowlisted, return `HOLD`.
+10. **Sell First**: If a token position exists, evaluate `SELL` triggers first (`take-profit`, `stop-loss`, `time-exit`) before considering `BUY`.
+11. **Timestamp Normalization**: `openedAt` may be in seconds or milliseconds; normalize before age-based exits.