@prktsol/prkt 1.0.0 → 1.0.1

package/.env.devnet.all-protocols.example

@@ -7,6 +7,11 @@ ENABLE_LIVE_SWAP_PATH=true
 ENABLE_LIVE_RAYDIUM_LP=true
 ENABLE_LIVE_KAMINO=true
 ENABLE_LIVE_MARINADE=true
+# Optional Light / zk-compression endpoints for real compressed commitment anchors on devnet.
+# ZK_COMPRESSION_API_URL=https://your-compression-api.example.com
+# ZK_PROVER_URL=https://your-prover.example.com
+# Optional override for the deployed onchain policy/verifier program on devnet.
+# ONCHAIN_POLICY_GUARD_PROGRAM_ID=3sUkfLW4jtwSQFgdtWyEj8FPedtvKfXSB1J16PMUZhMG
 RAYDIUM_LP_CONFIG_PATH=raydium_lp.devnet.json
 KAMINO_LIVE_CONFIG_PATH=kamino_live.json
 UNIVERSAL_DEFI_LIVE_FIRST=true

package/.env.example

@@ -9,6 +9,13 @@ ENABLE_LIVE_RAYDIUM_LP=false
 ENABLE_LIVE_KAMINO=false
 # Set true for the autonomous agent wallet bounty demo and direct Marinade staking demo.
 ENABLE_LIVE_MARINADE=false
+# Optional Light / zk-compression endpoints for real compressed commitment anchors on devnet.
+# ZK_COMPRESSION_API_URL=https://your-compression-api.example.com
+# ZK_PROVER_URL=https://your-prover.example.com
+# IMPLEMENTATION_PATH=defensible_devnet_demo
+# NEON_BROADCAST_ENABLED=false
+# Optional override for the deployed onchain policy/verifier program on devnet.
+# ONCHAIN_POLICY_GUARD_PROGRAM_ID=3sUkfLW4jtwSQFgdtWyEj8FPedtvKfXSB1J16PMUZhMG
 # KAMINO_LIVE_CONFIG_PATH=kamino_live.json
 UNIVERSAL_DEFI_LIVE_FIRST=true
 # Preferred production path: remote transaction signer with bearer auth.

package/CLI.md

@@ -6,6 +6,7 @@ For the full end-to-end product guide, see:
 - [FULL_DOCUMENTATION.md](./FULL_DOCUMENTATION.md)
 
 - Published binary entrypoint: `prkt ...`
+- Published devnet verifier: `prkt-devnet-matrix`
 - Source entrypoint: `npm run cli -- ...`
 - CLI name in help output: `prkt`
 - Global machine-readable output mode: `--json`
@@ -35,6 +36,7 @@ npm install
 ```bash
 prkt --help
 prkt init
+prkt-devnet-matrix
 ```
 3. Create a wallet:
 ```bash
@@ -54,6 +56,28 @@ Example:
 prkt --json wallet list
 ```
 
+## 3.2) Devnet Tryability Runner
+Run the end-to-end devnet feature matrix. This is the fastest way to exercise the wallet stack and emit reviewable artifacts.
+
+Published install:
+```bash
+prkt-devnet-matrix
+```
+
+From source:
+```bash
+npm run demo:feature-matrix:devnet
+```
+
+Artifacts:
+- `artifacts/devnet-feature-matrix.json`
+- `artifacts/devnet-feature-matrix.md`
+
+Optional env flags:
+- `PRKT_DEVNET_MATRIX_INCLUDE_PROTOCOL_LIVE=1`
+- `PRKT_DEVNET_MATRIX_INCLUDE_STRESS=1`
+- `PRKT_DEVNET_MATRIX_INCLUDE_EXPORTS=1`
+
 ## 3.1) init
 Bootstrap local PRKT state for the current user install.
 

package/CLI_QUICKSTART.md

@@ -19,6 +19,7 @@ Published CLI:
 npm install -g @prktsol/prkt
 prkt --help
 prkt init
+prkt-devnet-matrix
 ```
 
 From source:
@@ -27,6 +28,21 @@ From source:
 npm install
 npm run cli -- --help
 npm run cli -- init
+npm run demo:feature-matrix:devnet
+```
+
+## 1a) One-command devnet proof
+
+Use the feature matrix when you need the fastest end-to-end devnet verification run.
+
+```bash
+npm run demo:feature-matrix:devnet
+```
+
+Published install:
+
+```bash
+prkt-devnet-matrix
 ```
 
 ## 2) Create wallets

package/README.md

@@ -15,6 +15,13 @@ Published CLI:
 npm install -g @prktsol/prkt
 prkt --help
 prkt init
+prkt-devnet-matrix
+```
+
+Typed Node SDK surface:
+
+```js
+const { WalletManager, PolicyEngine, SessionAnchor } = require("@prktsol/prkt");
 ```
 
 From source:
@@ -24,6 +31,7 @@ git clone <repo-url> && cd PRKT
 npm install
 npm run cli -- --help
 npm run cli -- init
+npm run demo:feature-matrix:devnet
 ```
 
 ### 2. Configure environment
@@ -50,18 +58,26 @@ Edit `.env`:
 | `AGENT_PRIVATE_KEY` | Optional | `[]` | Only for operator-funded wallet demos; the autonomous devnet demo generates its own wallet |
 | `DEVNET_TREASURY_PRIVATE_KEY` | No | `[]` | Optional funded devnet treasury used as an internal faucet for generated agent wallets |
 | `USDC_MINT` | No | devnet USDC | Override only if using a custom mint |
-| `KORA_MOCK_MODE` | No | `true` | Set `false` for live Kora gasless signing |
+| `KORA_MOCK_MODE` | No | `true` | Set `false` for live Kora gasless signing; demo scripts fall back to mock if Kora is unavailable |
 | `ENABLE_LIVE_SWAP_PATH` | No | `false` | Set `true` for live Jupiter swaps |
 | `ENABLE_LIVE_RAYDIUM_LP` | No | `false` | Set `true` for live Raydium LP |
 | `ENABLE_LIVE_KAMINO` | No | `false` | Set `true` for live Kamino lending / borrowing |
 | `ENABLE_LIVE_MARINADE` | No | `false` | Set `true` for live Marinade staking |
 | `KAMINO_LIVE_CONFIG_PATH` | No | `kamino_live.json` | Path to Kamino live config copied from `kamino_live.example.json` |
+| `ZK_COMPRESSION_API_URL` | No | none | Light / ZK Compression API endpoint for memo-free compressed account storage on devnet |
+| `ZK_PROVER_URL` | No | none | Optional Light prover endpoint; defaults to `ZK_COMPRESSION_API_URL` when omitted |
+| `IMPLEMENTATION_PATH` | No | `strict_live` | Set `defensible_devnet_demo` to allow commitment-backed fallback storage when full Light data-account writes are unavailable on devnet |
+| `NEON_BROADCAST_ENABLED` | No | `false` | Set `true` only when you want PRKT to broadcast Neon EVM transactions instead of failing closed |
+| `ONCHAIN_POLICY_GUARD_PROGRAM_ID` | No | `3sUkfLW4jtwSQFgdtWyEj8FPedtvKfXSB1J16PMUZhMG` | Override for the deployed devnet onchain policy/verifier program |
 | `POLICY_SESSION_TTL_MINUTES` | No | `60` | Session TTL in minutes (1–1440) |
 
 > **Production**: Use `REMOTE_SIGNER_URL`, `REMOTE_SIGNER_BEARER_TOKEN`, and `REMOTE_SIGNER_PUBKEY` instead of `AGENT_PRIVATE_KEY`. All three must be set together.
 
 For the autonomous bounty demo, set `ENABLE_LIVE_MARINADE=true`. No pre-existing wallet is required, but setting `DEVNET_TREASURY_PRIVATE_KEY` lets generated wallets fund from your own devnet treasury instead of the public faucet.
 
+Reviewer-demo note: set `SOLANA_RPC_FALLBACK_URL` and `DEVNET_TREASURY_PRIVATE_KEY` before recording or sharing a live demo. The proof/session/policy path prefers real Light compressed storage on devnet, so also set `ZK_COMPRESSION_API_URL` and optionally `ZK_PROVER_URL`. In `IMPLEMENTATION_PATH=defensible_devnet_demo`, PRKT will fall back to on-chain commitment anchors plus a local payload registry if full Light data-account writes are unavailable.
+The deployed devnet onchain policy/verifier program in this repo is `3sUkfLW4jtwSQFgdtWyEj8FPedtvKfXSB1J16PMUZhMG`.
+
 ### 3. Run the autonomous agent wallet demo
 
 ```bash
@@ -70,6 +86,29 @@ npm run demo:autonomous-agent-wallet:devnet
 
 Expected output: generated wallet address, devnet funding signature, live Marinade staking signature, and an owner emergency-lock block message.
 
+### 3a. Run the full devnet feature matrix
+
+This is the fastest one-command proof that the wallet stack is tryable on devnet. It exercises the CLI, managed wallets, SPL flows, policy controls, agent runtime, monitor/audit views, gasless memo path, security simulation, and the proof/session/policy anchoring path. With `ZK_COMPRESSION_API_URL` configured, the proof/session/policy path prefers Light compressed account storage on devnet and can fall back to commitment anchors in `defensible_devnet_demo` mode.
+
+```bash
+npm run demo:feature-matrix:devnet
+```
+
+Published install:
+
+```bash
+prkt-devnet-matrix
+```
+
+Artifacts:
+- `artifacts/devnet-feature-matrix.json`
+- `artifacts/devnet-feature-matrix.md`
+
+Optional live-expansion flags:
+- `PRKT_DEVNET_MATRIX_INCLUDE_PROTOCOL_LIVE=1`
+- `PRKT_DEVNET_MATRIX_INCLUDE_STRESS=1`
+- `PRKT_DEVNET_MATRIX_INCLUDE_EXPORTS=1`
+
 ### 4. Run the autonomous portfolio demo
 
 ```bash
@@ -139,6 +178,10 @@ flowchart TD
 | `npm run release:check` | — | Preflight readiness check |
 | `npm run cli -- --help` | — | CLI help |
 
+| `npm run wallet:status` | — | Local wallet status smoke check |
+| `npm run demo:feature-matrix:devnet` | `LIVE` / `SIMULATED` | One-command devnet tryability run with JSON and Markdown artifacts |
+| `npm run onchain:policy-guard:devnet` | `LIVE` | Fresh operator wallet, onchain policy init, program-vault funding, session open, onchain proof verification, managed transfer, session close |
+
 ### Live Devnet
 
 | Command | Mode | Description |
@@ -149,13 +192,14 @@ flowchart TD
 | `npm run defi:stake:devnet -- 0.15` | `LIVE` | Marinade stake on devnet |
 | `npm run defi:orca:devnet -- 0.05` | `LIVE` | Orca Whirlpool LP position on devnet |
 | `npm run defi:lp:devnet` | `LIVE` | Raydium LP on devnet |
-| `npm run defi:kamino:devnet -- deposit` | `LIVE` | Kamino deposit on devnet |
-| `npm run defi:kamino:devnet -- borrow` | `LIVE` | Kamino borrow on devnet |
+| `npm run defi:kamino:devnet -- deposit` | `LIVE` / `SIMULATED` | Kamino deposit on devnet, with simulated fallback when the selected devnet market cannot execute live |
+| `npm run defi:kamino:devnet -- borrow` | `LIVE` / `SIMULATED` | Kamino borrow on devnet, with simulated fallback when the selected devnet market cannot execute live |
 | `npm run demo:multi-agent:devnet` | `LIVE` | Multi-agent devnet demo |
 | `npm run simulate-attack` | `LIVE` | Security guardrail demo |
 | `npm run stress:agents` | `LIVE` | Rate limit + circuit breaker demo |
 
 Set `PRKT_AGENT_NAME=<agent-id>` to pin these autonomous/live scripts to a specific persistent agent wallet across reruns.
+Set `PRKT_DEVNET_MATRIX_INCLUDE_PROTOCOL_LIVE=1` to make the feature matrix attempt the full live protocol tranche as well.
 
 ### Simulated
 
@@ -288,34 +332,37 @@ npm run release:check
 # 2. Rehearsal (generates demo-session.json)
 npm run demo:rehearsal
 
-# 3. Autonomous agent wallet demo (LIVE)
+# 3. Full devnet feature matrix
+npm run demo:feature-matrix:devnet
+
+# 4. Autonomous agent wallet demo (LIVE)
 npm run demo:autonomous-agent-wallet:devnet
 
-# 4. Autonomous portfolio demo (LIVE)
+# 5. Autonomous portfolio demo (LIVE)
 npm run demo:autonomous-portfolio:devnet
 
-# 5. Wallet demo (LIVE)
+# 6. Wallet demo (LIVE)
 npm run wallet:devnet
 
 # 6. Raydium LP (LIVE) — requires raydium_lp.devnet.json
 npm run defi:lp:devnet
 
-# 7. Marinade stake (LIVE)
+# 8. Marinade stake (LIVE)
 npm run defi:stake:devnet -- 0.15
 
-# 8. Orca Whirlpool LP (LIVE)
+# 9. Orca Whirlpool LP (LIVE)
 npm run defi:orca:devnet -- 0.05
 
-# 9. Kamino deposit (LIVE attempt on devnet; current portfolio demo falls back to simulated if reserve refresh is broken)
+# 10. Kamino deposit (LIVE attempt on devnet; current portfolio demo falls back to simulated if reserve refresh is broken)
 npm run defi:kamino:devnet -- deposit
 
-# 9. Security guardrails
+# 11. Security guardrails
 npm run simulate-attack
 
-# 10. Multi-agent stress test
+# 12. Multi-agent stress test
 npm run stress:agents
 
-# 11. Fill artifacts/bounty-evidence.md with signatures
+# 13. Fill artifacts/bounty-evidence.md with signatures
 ```
 
 ---

package/dist/agent/AgentManager.d.ts

@@ -0,0 +1,61 @@
+import { PolicyGuard } from "../policy/PolicyGuard";
+import type { PolicyConstraints } from "../types/policy";
+import { WalletManager } from "../wallet/WalletManager";
+import { MockPriceFeed } from "./MockPriceFeed";
+import { KoraSigner } from "../kora/KoraSigner";
+import { type TradeSimulationResult } from "./AgentRuntime";
+import { SwapExecutor } from "../dex/SwapExecutor";
+export type ManagedAgent = {
+    id: string;
+    policy: PolicyConstraints;
+    policyGuard: PolicyGuard;
+    walletManager: WalletManager;
+};
+export type AgentSafetyControls = {
+    cooldownMs: number;
+    maxActionsPerWindow: number;
+    maxConsecutiveFailures: number;
+    windowMs: number;
+};
+export type ManagedSimulationEvent = {
+    agentId: string;
+    iteration: number;
+    result: TradeSimulationResult;
+    status: "executed";
+} | {
+    agentId: string;
+    iteration: number;
+    reason: string;
+    status: "blocked" | "failed";
+};
+export declare class AgentManager {
+    static spawnAgents(count: number): ManagedAgent[];
+    static runConcurrentTradeSimulation(input: {
+        amountSol: number;
+        koraSigner: KoraSigner;
+        liveSwapConfig?: {
+            enabled: boolean;
+            outputMint: string;
+            swapExecutor: SwapExecutor | null;
+        };
+        logger?: (message: string) => void;
+        priceFeed: MockPriceFeed;
+    }): Promise<Array<{
+        agentId: string;
+        result: TradeSimulationResult;
+    }>>;
+    static runManagedTradeSimulation(input: {
+        amountSol: number;
+        koraSigner: KoraSigner;
+        liveSwapConfig?: {
+            enabled: boolean;
+            outputMint: string;
+            swapExecutor: SwapExecutor | null;
+        };
+        logger?: (message: string) => void;
+        priceFeed: MockPriceFeed;
+        rounds: number;
+        safetyControls?: Partial<AgentSafetyControls>;
+        simulateAction?: (agent: ManagedAgent) => Promise<TradeSimulationResult>;
+    }): Promise<ManagedSimulationEvent[]>;
+}

package/dist/agent/AgentRuntime.d.ts

@@ -0,0 +1,28 @@
+import { PolicyGuard } from "../policy/PolicyGuard";
+import { KoraSigner, type GaslessExecutionResult } from "../kora/KoraSigner";
+import { WalletManager } from "../wallet/WalletManager";
+import { MockPriceFeed, type MarketSnapshot } from "./MockPriceFeed";
+import { SwapExecutor, type LiveSwapResult } from "../dex/SwapExecutor";
+import type { GuardedPreparedTransactionExecutor } from "../defi/universal";
+export type TradeSimulationResult = {
+    action: "execute_swap" | "hold";
+    execution: GaslessExecutionResult | null;
+    liveSwap: LiveSwapResult | null;
+    market: MarketSnapshot;
+    memo: string | null;
+};
+export type RuntimeLogger = (message: string) => void;
+export declare function simulateMarketAction(input: {
+    amountSol: number;
+    koraSigner: KoraSigner;
+    liveSwapConfig?: {
+        guardedExecutor?: GuardedPreparedTransactionExecutor;
+        enabled: boolean;
+        outputMint: string;
+        swapExecutor: SwapExecutor | null;
+    };
+    logger?: RuntimeLogger;
+    policyGuard: PolicyGuard;
+    priceFeed: MockPriceFeed;
+    walletManager: WalletManager;
+}): Promise<TradeSimulationResult>;

package/dist/agent/DecisionEngine.d.ts

@@ -0,0 +1,51 @@
+import type { AccountInfo, Commitment, PublicKey, SendOptions, SignatureResult, TransactionConfirmationStrategy, VersionedTransaction } from "@solana/web3.js";
+import { WalletManager } from "../wallet/WalletManager";
+export type DecisionEngineConnection = {
+    confirmTransaction(strategy: TransactionConfirmationStrategy, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
+    getAccountInfo(publicKey: PublicKey, commitment?: Commitment): Promise<AccountInfo<Buffer> | null>;
+    getBalance(publicKey: PublicKey, commitment?: Commitment): Promise<number>;
+    getLatestBlockhash(commitment?: Commitment): Promise<{
+        blockhash: string;
+        lastValidBlockHeight: number;
+    }>;
+    getTokenAccountBalance(publicKey: PublicKey, commitment?: Commitment): Promise<RpcResponseAndContext<TokenAccountBalanceValue>>;
+    sendTransaction(transaction: VersionedTransaction, options?: SendOptions): Promise<string>;
+};
+type RpcResponseAndContext<T> = {
+    context: {
+        apiVersion?: string;
+        slot: number;
+    };
+    value: T;
+};
+type TokenAccountBalanceValue = {
+    amount: string;
+    decimals: number;
+    uiAmount: number | null;
+    uiAmountString?: string;
+};
+export type DecisionResult = {
+    action: "hold";
+    associatedTokenAddress: string;
+    reason: string;
+    solBalance: number;
+    wsolBalance: number;
+} | {
+    action: "wrap";
+    associatedTokenAddress: string;
+    createdAssociatedTokenAccount: boolean;
+    reason: string;
+    signature: string;
+    solBalance: number;
+    wrapAmount: number;
+    wsolBalance: number;
+};
+export declare class DecisionEngine {
+    private readonly connection;
+    private readonly walletManager;
+    private readonly logger;
+    constructor(connection: DecisionEngineConnection, walletManager: WalletManager, logger?: (message: string) => void);
+    think(): Promise<DecisionResult>;
+    private getWsolBalance;
+}
+export {};

package/dist/agent/MockPriceFeed.d.ts

@@ -0,0 +1,10 @@
+export type MarketSnapshot = {
+    buyThresholdUsd: number;
+    solPriceUsd: number;
+    usdcPriceUsd: number;
+};
+export declare class MockPriceFeed {
+    private readonly snapshot;
+    constructor(snapshot: MarketSnapshot);
+    read(): MarketSnapshot;
+}

package/dist/agent/intents/types.d.ts

@@ -0,0 +1,35 @@
+import type { SupportedProtocol } from "../../types/policy";
+import type { MarketSnapshot } from "../../defi/types";
+export type TransferSolIntent = {
+    type: "transfer-sol";
+    to: string;
+    lamports: number;
+};
+export type TransferSplIntent = {
+    type: "transfer-spl";
+    mint: string;
+    toOwner: string;
+    amountRaw: bigint;
+};
+export type CreateAtaIntent = {
+    type: "create-ata";
+    mint: string;
+    owner: string;
+};
+export type MintTokenIntent = {
+    type: "mint-token";
+    mint: string;
+    toOwner: string;
+    amountRaw: bigint;
+};
+export type WriteMemoIntent = {
+    type: "write-memo";
+    memo: string;
+};
+export type DeFiCapabilityIntent = {
+    type: "defi-capability";
+    capability: "trade" | "lp" | "lending" | "borrowing" | "yield" | "staking";
+    protocol?: SupportedProtocol;
+    snapshot: MarketSnapshot;
+};
+export type AgentIntent = TransferSolIntent | TransferSplIntent | CreateAtaIntent | MintTokenIntent | WriteMemoIntent | DeFiCapabilityIntent;

package/dist/agent/new-index.d.ts

@@ -0,0 +1,9 @@
+export { AgentRunner } from "./runner/AgentRunner";
+export { AgentRegistry } from "./registry/AgentRegistry";
+export type { AgentContext, AgentLogger, Strategy } from "./types/AgentContext";
+export type { AgentIntent, CreateAtaIntent, MintTokenIntent, TransferSolIntent, TransferSplIntent, WriteMemoIntent } from "./intents/types";
+export { MemoHeartbeatStrategy } from "./strategies/MemoHeartbeatStrategy";
+export { SimpleScriptedTransferStrategy } from "./strategies/SimpleScriptedTransferStrategy";
+export { TokenRebalancerStrategy } from "./strategies/TokenRebalancerStrategy";
+export { TreasuryDistributorStrategy } from "./strategies/TreasuryDistributorStrategy";
+export { UniversalDeFiStrategy } from "./strategies/UniversalDeFiStrategy";

package/dist/agent/policyFactory.d.ts

@@ -0,0 +1,2 @@
+import type { PolicyConstraints } from "../types/policy";
+export declare function createDefaultAgentPolicy(overrides?: Partial<PolicyConstraints>): PolicyConstraints;

package/dist/agent/registry/AgentRegistry.d.ts

@@ -0,0 +1,11 @@
+import type { AgentContext, Strategy } from "../types/AgentContext";
+export type RegisteredAgent = {
+    context: AgentContext;
+    strategy: Strategy;
+};
+export declare class AgentRegistry {
+    private readonly agents;
+    register(agent: RegisteredAgent): void;
+    get(agentId: string): RegisteredAgent | undefined;
+    list(): RegisteredAgent[];
+}

package/dist/agent/runner/AgentRunner.d.ts

@@ -0,0 +1,51 @@
+import { type ApprovalCallback, type PolicyConfig } from "../../policy";
+import type { AgentIntent } from "../intents/types";
+import type { AgentContext, Strategy } from "../types/AgentContext";
+export type IntentExecutionOutcome = {
+    intent: AgentIntent;
+    allowed: boolean;
+    signature: string | null;
+    reasons: string[];
+};
+export type AgentRunResult = {
+    agentId: string;
+    strategy: string;
+    outcomes: IntentExecutionOutcome[];
+};
+export declare class AgentRunner {
+    private readonly registry;
+    private readonly runtimes;
+    private readonly policyAccountManager;
+    private readonly auditLogManager;
+    private readonly sessionAnchor;
+    constructor();
+    registerCompressedAgent(input: {
+        context: AgentContext;
+        strategy: Strategy;
+        approvalMode?: "sandbox" | "live";
+        approvalCallback?: ApprovalCallback;
+    }): Promise<void>;
+    registerAgent(input: {
+        context: AgentContext;
+        strategy: Strategy;
+        policyConfig?: PolicyConfig;
+        approvalMode?: "sandbox" | "live";
+        approvalCallback?: ApprovalCallback;
+    }): Promise<void>;
+    closeAgentSession(agentId: string): Promise<{
+        commitment: string;
+        ledgerSlot: number;
+    } | null>;
+    listAgents(): Array<{
+        id: string;
+        strategy: string;
+    }>;
+    runOnceParallel(): Promise<AgentRunResult[]>;
+    runRounds(rounds: number): Promise<AgentRunResult[]>;
+    private executeIntents;
+    private buildIntentTransaction;
+    private executePreparedTransaction;
+    private createSandboxExecutor;
+    private mergePolicyConfig;
+    private mergeUnique;
+}

package/dist/agent/runner/AgentRunner.js

@@ -4,16 +4,62 @@ exports.AgentRunner = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const policy_1 = require("../../policy");
 const AgentRegistry_1 = require("../registry/AgentRegistry");
+const PolicyAccountManager_1 = require("../../compression/PolicyAccountManager");
+const AuditLogManager_1 = require("../../compression/AuditLogManager");
+const SessionAnchor_1 = require("../../anchoring/SessionAnchor");
+const PRKTConfig_1 = require("../../config/PRKTConfig");
 class AgentRunner {
     registry = new AgentRegistry_1.AgentRegistry();
     runtimes = new Map();
-    registerAgent(input) {
+    policyAccountManager;
+    auditLogManager;
+    sessionAnchor;
+    constructor() {
+        this.policyAccountManager = new PolicyAccountManager_1.PolicyAccountManager(PRKTConfig_1.defaultPRKTConfig.zkCompression.rpcEndpoint);
+        this.auditLogManager = new AuditLogManager_1.AuditLogManager(PRKTConfig_1.defaultPRKTConfig.zkCompression.rpcEndpoint);
+        this.sessionAnchor = new SessionAnchor_1.SessionAnchor(PRKTConfig_1.defaultPRKTConfig.zkCompression.rpcEndpoint);
+    }
+    async registerCompressedAgent(input) {
+        if (!PRKTConfig_1.defaultPRKTConfig.zkCompression.enabled) {
+            return this.registerAgent(input);
+        }
+        // Wire policy READ through compressed account
+        const compressed = await this.policyAccountManager.fetchCompressedPolicyAccount(input.context.id);
+        const policyConfig = {
+            agentId: compressed.agentId,
+            approvalMode: input.approvalMode ?? "sandbox",
+            limits: {
+                maxTransactionsPerDay: 100, // Derived or default
+                maxTransactionsPerSession: 50,
+                maxSolPerTxLamports: Number(compressed.dailySpendLimit.toString()), // Approximated
+                maxSplPerTxRawAmount: BigInt(compressed.dailySpendLimit.toString())
+            },
+            rules: {
+                allowedMintAddresses: [],
+                allowedProgramIds: compressed.programAllowlist.map((pk) => pk.toBase58()),
+                allowOpaqueProgramIds: [],
+                denyUnknownInstructionsByDefault: true,
+                rejectSuspiciousBalanceDeltas: true,
+                requireSimulationSuccess: true
+            },
+            sessionExpiresAtIso8601: new Date(Date.now() + compressed.sessionTTL * 60000).toISOString()
+        };
+        this.registerAgent({
+            ...input,
+            policyConfig
+        });
+    }
+    async registerAgent(input) {
         const policyConfig = input.policyConfig ?? input.context.policyConfig;
         const policyEngine = new policy_1.PolicyEngine({
             ...policyConfig,
             approvalMode: input.approvalMode ?? policyConfig.approvalMode
         });
         const sandboxExecutor = new policy_1.SandboxExecutor(policyEngine, input.context.transactionService, input.approvalMode ?? policyConfig.approvalMode, input.approvalCallback);
+        let sessionId;
+        if (PRKTConfig_1.defaultPRKTConfig.dataAnchoring.enabled) {
+            sessionId = (await this.sessionAnchor.startSession(input.context.id)).sessionId;
+        }
         this.registry.register({
             context: {
                 ...input.context,
@@ -30,9 +76,20 @@ class AgentRunner {
             approvalMode: input.approvalMode ?? policyConfig.approvalMode,
             strategy: input.strategy,
             policyEngine,
-            sandboxExecutor
+            sandboxExecutor,
+            sessionId
         });
     }
+    async closeAgentSession(agentId) {
+        const runtime = this.runtimes.get(agentId);
+        if (!runtime || !runtime.sessionId) {
+            return null;
+        }
+        const logs = await this.auditLogManager.fetchAuditLog(agentId);
+        const result = await this.sessionAnchor.closeSession(runtime.sessionId, logs);
+        runtime.sessionId = undefined; // clear
+        return result;
+    }
     listAgents() {
         return this.registry.list().map((entry) => ({
             id: entry.context.id,

package/dist/agent/strategies/MemoHeartbeatStrategy.d.ts

@@ -0,0 +1,6 @@
+import type { AgentIntent } from "../intents/types";
+import type { AgentContext, Strategy } from "../types/AgentContext";
+export declare class MemoHeartbeatStrategy implements Strategy {
+    readonly name = "memo-heartbeat";
+    nextIntents(context: AgentContext): Promise<AgentIntent[]>;
+}

package/dist/agent/strategies/SimpleScriptedTransferStrategy.d.ts

@@ -0,0 +1,12 @@
+import type { AgentIntent } from "../intents/types";
+import type { AgentContext, Strategy } from "../types/AgentContext";
+export declare class SimpleScriptedTransferStrategy implements Strategy {
+    private readonly plan;
+    readonly name = "simple-scripted-transfer";
+    constructor(plan: {
+        to: string;
+        lamports: number;
+        memo?: string;
+    });
+    nextIntents(_context: AgentContext): Promise<AgentIntent[]>;
+}

package/dist/agent/strategies/TokenRebalancerStrategy.d.ts

@@ -0,0 +1,13 @@
+import type { AgentIntent } from "../intents/types";
+import type { AgentContext, Strategy } from "../types/AgentContext";
+export declare class TokenRebalancerStrategy implements Strategy {
+    private readonly config;
+    readonly name = "token-rebalancer";
+    constructor(config: {
+        mint: string;
+        targetOwner: string;
+        minBalanceUi: number;
+        topUpRawAmount: bigint;
+    });
+    nextIntents(context: AgentContext): Promise<AgentIntent[]>;
+}

package/dist/agent/strategies/TreasuryDistributorStrategy.d.ts

@@ -0,0 +1,12 @@
+import type { AgentIntent } from "../intents/types";
+import type { AgentContext, Strategy } from "../types/AgentContext";
+export declare class TreasuryDistributorStrategy implements Strategy {
+    private readonly config;
+    readonly name = "treasury-distributor";
+    constructor(config: {
+        mint: string;
+        recipients: string[];
+        amountRawPerRecipient: bigint;
+    });
+    nextIntents(_context: AgentContext): Promise<AgentIntent[]>;
+}