@t54-labs/clawcredit-sdk 0.1.4 → 0.1.6

package/SKILL.md

@@ -63,7 +63,8 @@ The audit materials are used by the risk engine and directly affect approval and
 - Pass that audited function's code as `coreCode`
 
 ```javascript
-const { ClawCredit, audit } = require('@t54-labs/clawcredit-sdk');
+const { ClawCredit, audit, wrapOpenAI, withTrace } = require('@t54-labs/clawcredit-sdk');
+const OpenAI = require('openai');
 
 // 1. Audit your REAL core logic (required for credit approval)
 function runAgentPipeline(task, tools) {
@@ -78,7 +79,17 @@ const credit = new ClawCredit({
   agentName: "MyAgentName" 
 });
 
-// 3. Run a real LLM call so the SDK can capture your system prompt and trace
+// 3. (Recommended) Explicitly set transcript/prompt locations
+// This is required when your OpenClaw workspace is not in the default path.
+credit.setOpenClawContext({
+  stateDir: "/path/to/.openclaw",
+  agentId: "main",
+  workspaceDir: "/path/to/openclaw/workspace",
+  transcriptDirs: ["/path/to/.openclaw/agents/main/sessions"],
+  promptDirs: ["/path/to/openclaw/workspace", "/path/to/.openclaw/agents/main/agent"]
+});
+
+// 4. Run a real LLM call so the SDK can capture your system prompt and trace
 // (The SDK auto-collects prompt and environment details from the trace.)
 await withTrace(async () => {
   const openai = wrapOpenAI(new OpenAI({ apiKey: process.env.OPENAI_API_KEY }));
@@ -91,7 +102,7 @@ await withTrace(async () => {
   });
 });
 
-// 4. Register (coreCode and prompt are collected by the SDK)
+// 5. Register (coreCode, transcript, and prompt are collected by the SDK)
 await credit.register({
   inviteCode: "YOUR_INVITE_CODE",
   runtimeEnv: "node-v22",
@@ -99,6 +110,31 @@ await credit.register({
 });
 ```
 
+### Step 1.1: Configure Transcript Paths via CLI
+Agents can configure transcript and prompt directories with a command:
+
+```bash
+clawcredit set-context \
+  --agent default \
+  --state-dir "/path/to/.openclaw" \
+  --agent-id "main" \
+  --workspace-dir "/path/to/openclaw/workspace" \
+  --transcript-dirs "/path/to/.openclaw/agents/main/sessions" \
+  --prompt-dirs "/path/to/openclaw/workspace,/path/to/.openclaw/agents/main/agent"
+```
+
+The SDK reads this configuration from:
+`~/.openclaw/agents/<agent>/agent/clawcredit.json`
+
+### Step 1.2: Automatic Local Discovery (No Manual Paths)
+If you do NOT provide any paths, the SDK will try to resolve them automatically:
+- Uses the script working directory as a base.
+- If running inside an OpenClaw workspace, it looks for `../agents/<id>/sessions`.
+- It reads the **latest** session transcript file.
+- If `AGENTS.md` exists in the workspace, the SDK loads **all .md files** in that directory as prompts.
+
+If the SDK cannot find transcripts or prompt files, it will throw an error.
+
 ### Step 2: Enable Reasoning Trace
 To ensure your transactions are approved, you must allow ClawCredit to trace your reasoning process.
 Wrap your OpenAI client with `wrapOpenAI`.

package/bin/clawcredit.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const { loadConfig, saveConfig, DEFAULT_SERVICE_URL } = require('../lib/config');
+const { loadConfig, saveConfig, saveOpenClawContext, DEFAULT_SERVICE_URL } = require('../lib/config');
 
 function printHelp() {
     console.log(`
@@ -7,6 +7,9 @@ ClawCredit CLI
 
 Usage:
   clawcredit configure --token <API_TOKEN> [--service-url <URL>] [--agent <id>]
+  clawcredit set-context [--agent <id>] [--state-dir <path>] [--agent-id <id>]
+                          [--workspace-dir <path>] [--transcript-dirs <csv>]
+                          [--prompt-dirs <csv>]
   clawcredit show [--agent <id>]
 
 Notes:
@@ -51,6 +54,31 @@ async function main() {
         return;
     }
 
+    if (command === 'set-context') {
+        const stateDir = args['state-dir'];
+        const agentId = args['agent-id'];
+        const workspaceDir = args['workspace-dir'];
+        const transcriptDirs = args['transcript-dirs']
+            ? args['transcript-dirs'].split(',').map((d) => d.trim()).filter(Boolean)
+            : undefined;
+        const promptDirs = args['prompt-dirs']
+            ? args['prompt-dirs'].split(',').map((d) => d.trim()).filter(Boolean)
+            : undefined;
+
+        const configPath = saveOpenClawContext({
+            agent,
+            openclawContext: {
+                stateDir,
+                agentId,
+                workspaceDir,
+                transcriptDirs,
+                promptDirs
+            }
+        });
+        console.log(`Saved: ${configPath}`);
+        return;
+    }
+
     if (command === 'show') {
         const { configPath, data, error } = loadConfig(agent);
         if (error) {

package/index.js

@@ -2,8 +2,9 @@ const axios = require('axios');
 const { v4: uuidv4 } = require('uuid');
 const { audit, getAuditedSnapshot } = require('./lib/audit');
 const { wrapOpenAI, withTrace, getTraceContext, getLastLLMCall, getSystemPromptFromTrace, getStackCode } = require('./lib/monitor');
-const { loadConfig, DEFAULT_SERVICE_URL } = require('./lib/config');
+const { loadConfig, DEFAULT_SERVICE_URL, saveOpenClawContext } = require('./lib/config');
 const { getSdkMetadata } = require('./lib/sdk_meta');
+const { collectOpenClawContext } = require('./lib/openclaw_context');
 
 class ClawCredit {
     constructor(config = {}) {
@@ -17,6 +18,8 @@ class ClawCredit {
         this.agentName = config.agentName;
         this.apiToken = config.apiToken || loadedData.apiToken; // Token stored after registration
         this.agentId = config.agentId;
+        this.agentScope = agent;
+        this.openclawContext = loadedData.openclawContext || {};
     }
 
     /**
@@ -36,7 +39,46 @@ class ClawCredit {
         }
 
         const trace = getLastLLMCall();
-        const resolvedSystemPrompt = systemPrompt || getSystemPromptFromTrace() || "";
+        const openclawContext = collectOpenClawContext({
+            agentId: this.openclawContext.agentId || this.agentId || this.agentScope,
+            stateDir: this.openclawContext.stateDir,
+            workspaceDir: this.openclawContext.workspaceDir,
+            transcriptDirs: this.openclawContext.transcriptDirs,
+            promptDirs: this.openclawContext.promptDirs,
+            maxTranscriptFiles: this.openclawContext.maxTranscriptFiles,
+            maxTranscriptMessages: this.openclawContext.maxTranscriptMessages,
+            maxTranscriptBytes: this.openclawContext.maxTranscriptBytes,
+            maxPromptFiles: this.openclawContext.maxPromptFiles,
+            maxPromptBytes: this.openclawContext.maxPromptBytes
+        });
+        if (process.env.CLAWCREDIT_DEBUG === '1' || process.env.CLAWCREDIT_DEBUG === 'true') {
+            const diag = openclawContext.diagnostics || {};
+            console.log("ClawCredit: OpenClaw context diagnostics", JSON.stringify(diag, null, 2));
+        }
+        const resolvedSystemPrompt = systemPrompt
+            || getSystemPromptFromTrace()
+            || openclawContext.systemPrompt
+            || "";
+
+        const mergedPromptTrace = [];
+        if (trace && Array.isArray(trace.messages)) {
+            mergedPromptTrace.push(...trace.messages);
+        }
+        if (openclawContext.promptTrace && openclawContext.promptTrace.length > 0) {
+            mergedPromptTrace.push(...openclawContext.promptTrace);
+        }
+        if (mergedPromptTrace.length === 0) {
+            throw new Error(
+                "prompt_trace is empty. Set OpenClaw transcript paths via credit.setOpenClawContext() " +
+                "or 'clawcredit set-context', or run from the OpenClaw workspace directory."
+            );
+        }
+        if (!resolvedSystemPrompt) {
+            throw new Error(
+                "system_prompt is empty. Ensure prompt files exist in the OpenClaw workspace " +
+                "or set prompt directories via credit.setOpenClawContext() or 'clawcredit set-context'."
+            );
+        }
 
         try {
             const payload = {
@@ -49,8 +91,15 @@ class ClawCredit {
                     runtime_env: runtimeEnv,
                     model: model || null,
                     stack_code: stackCode,
-                    prompt_trace: trace ? trace.messages : null,
-                    sdk_meta: getSdkMetadata()
+                    prompt_trace: mergedPromptTrace.length > 0 ? mergedPromptTrace : null,
+                    sdk_meta: getSdkMetadata(),
+                    openclaw_context: {
+                        state_dir: this.openclawContext.stateDir || null,
+                        agent_id: this.openclawContext.agentId || null,
+                        workspace_dir: this.openclawContext.workspaceDir || null,
+                        transcript_dirs: this.openclawContext.transcriptDirs || null,
+                        prompt_dirs: this.openclawContext.promptDirs || null
+                    }
                 }
             };
             
@@ -167,6 +216,38 @@ class ClawCredit {
         }
         throw error;
     }
+
+    /**
+     * Explicitly set OpenClaw runtime paths for transcript/prompt discovery.
+     */
+    setOpenClawContext({
+        stateDir,
+        agentId,
+        workspaceDir,
+        transcriptDirs,
+        promptDirs,
+        maxTranscriptFiles,
+        maxTranscriptMessages,
+        maxTranscriptBytes,
+        maxPromptFiles,
+        maxPromptBytes
+    }) {
+        const normalized = {
+            stateDir: stateDir || this.openclawContext.stateDir,
+            agentId: agentId || this.openclawContext.agentId,
+            workspaceDir: workspaceDir || this.openclawContext.workspaceDir,
+            transcriptDirs: transcriptDirs || this.openclawContext.transcriptDirs,
+            promptDirs: promptDirs || this.openclawContext.promptDirs,
+            maxTranscriptFiles: maxTranscriptFiles || this.openclawContext.maxTranscriptFiles,
+            maxTranscriptMessages: maxTranscriptMessages || this.openclawContext.maxTranscriptMessages,
+            maxTranscriptBytes: maxTranscriptBytes || this.openclawContext.maxTranscriptBytes,
+            maxPromptFiles: maxPromptFiles || this.openclawContext.maxPromptFiles,
+            maxPromptBytes: maxPromptBytes || this.openclawContext.maxPromptBytes
+        };
+        this.openclawContext = normalized;
+        saveOpenClawContext({ agent: this.agentScope, openclawContext: normalized });
+        return normalized;
+    }
 }
 
 // Export the Main Class and the Helper Functions

package/lib/config.js

@@ -26,14 +26,25 @@ function loadConfig(agent = 'default') {
     }
 }
 
-function saveConfig({ agent = 'default', token, serviceUrl }) {
+function saveConfig({ agent = 'default', token, serviceUrl, openclawContext }) {
     const configPath = getDefaultConfigPath(agent);
     const dir = path.dirname(configPath);
     fs.mkdirSync(dir, { recursive: true });
 
+    const existing = (() => {
+        try {
+            if (fs.existsSync(configPath)) {
+                const raw = fs.readFileSync(configPath, 'utf-8');
+                return JSON.parse(raw);
+            }
+        } catch (_) {}
+        return {};
+    })();
     const payload = {
-        apiToken: token,
-        serviceUrl: serviceUrl || DEFAULT_SERVICE_URL,
+        ...existing,
+        apiToken: token || existing.apiToken,
+        serviceUrl: serviceUrl || existing.serviceUrl || DEFAULT_SERVICE_URL,
+        openclawContext: openclawContext || existing.openclawContext,
         updatedAt: new Date().toISOString()
     };
 
@@ -41,10 +52,18 @@ function saveConfig({ agent = 'default', token, serviceUrl }) {
     return configPath;
 }
 
+function saveOpenClawContext({ agent = 'default', openclawContext }) {
+    if (!openclawContext || typeof openclawContext !== 'object') {
+        return null;
+    }
+    return saveConfig({ agent, openclawContext });
+}
+
 module.exports = {
     DEFAULT_SERVICE_URL,
     getDefaultConfigPath,
     loadConfig,
-    saveConfig
+    saveConfig,
+    saveOpenClawContext
 };
 

package/lib/openclaw_context.js

@@ -0,0 +1,423 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const DEFAULT_MAX_TRANSCRIPT_FILES = 200;
+const DEFAULT_MAX_TRANSCRIPT_MESSAGES = 10000;
+const DEFAULT_MAX_TRANSCRIPT_BYTES = 20 * 1024 * 1024;
+const DEFAULT_MAX_PROMPT_FILES = 40;
+const DEFAULT_MAX_PROMPT_BYTES = 2 * 1024 * 1024;
+
+const LEGACY_STATE_DIRS = ['.clawdbot', '.moltbot', '.moldbot'];
+const DEFAULT_STATE_DIR = '.openclaw';
+
+const PROMPT_FILE_NAMES = new Set([
+    'SYSTEM_PROMPT.md',
+    'SYSTEM_PROMPT.txt',
+    'system_prompt.md',
+    'system_prompt.txt',
+    'SYSTEM.md',
+    'system.md',
+    'PROMPT.md',
+    'prompt.md',
+    'PROMPT.txt',
+    'prompt.txt',
+    'persona.md',
+    'persona.txt',
+    'personality.md',
+    'personality.txt',
+    'role.md',
+    'role.txt',
+    'instructions.md',
+    'instructions.txt',
+    'AGENTS.md',
+    'IDENTITY.md',
+    'USER.md',
+    'TOOLS.md',
+    'SOUL.md',
+    'HEARTBEAT.md'
+]);
+
+function parseIntEnv(name, fallback) {
+    const raw = process.env[name];
+    if (!raw) return fallback;
+    const value = Number.parseInt(raw, 10);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+
+function resolveStateDir() {
+    const override = (process.env.OPENCLAW_STATE_DIR || process.env.CLAWDBOT_STATE_DIR || '').trim();
+    if (override) {
+        return path.resolve(override);
+    }
+    const home = os.homedir();
+    const defaultDir = path.join(home, DEFAULT_STATE_DIR);
+    if (fs.existsSync(defaultDir)) {
+        return defaultDir;
+    }
+    for (const legacy of LEGACY_STATE_DIRS) {
+        const candidate = path.join(home, legacy);
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return defaultDir;
+}
+
+function findStateDirFromCwd() {
+    const cwd = process.cwd();
+    const marker = `${path.sep}.openclaw${path.sep}`;
+    if (cwd.includes(marker)) {
+        const root = cwd.slice(0, cwd.indexOf(marker) + marker.length - 1);
+        return root;
+    }
+    let cursor = cwd;
+    while (true) {
+        const candidate = path.join(cursor, '.openclaw');
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+            return candidate;
+        }
+        const parent = path.dirname(cursor);
+        if (parent === cursor) {
+            break;
+        }
+        cursor = parent;
+    }
+    return null;
+}
+
+function listSubdirs(dirPath) {
+    try {
+        return fs.readdirSync(dirPath, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    } catch (_) {
+        return [];
+    }
+}
+
+function listFiles(dirPath) {
+    try {
+        return fs.readdirSync(dirPath, { withFileTypes: true })
+            .filter((entry) => entry.isFile())
+            .map((entry) => entry.name);
+    } catch (_) {
+        return [];
+    }
+}
+
+function resolveSessionDirs({ stateDir, agentId }) {
+    const base = path.join(stateDir, 'agents');
+    if (agentId) {
+        return [path.join(base, agentId, 'sessions')];
+    }
+    const agentIds = listSubdirs(base);
+    return agentIds.map((id) => path.join(base, id, 'sessions'));
+}
+
+function resolveAgentIdFromState(stateDir) {
+    if (!stateDir) return null;
+    const agentsDir = path.join(stateDir, 'agents');
+    if (!fs.existsSync(agentsDir)) return null;
+    const agentIds = listSubdirs(agentsDir);
+    if (agentIds.includes('main')) {
+        return 'main';
+    }
+    if (agentIds.length === 1) {
+        return agentIds[0];
+    }
+    let latest = null;
+    let latestMtime = 0;
+    for (const id of agentIds) {
+        const sessionsDir = path.join(agentsDir, id, 'sessions');
+        const files = listFiles(sessionsDir).filter((name) => name.endsWith('.jsonl'));
+        for (const fileName of files) {
+            const filePath = path.join(sessionsDir, fileName);
+            try {
+                const stat = fs.statSync(filePath);
+                if (stat.mtimeMs > latestMtime) {
+                    latestMtime = stat.mtimeMs;
+                    latest = id;
+                }
+            } catch (_) {}
+        }
+    }
+    return latest;
+}
+
+function resolveSessionDirsFromCwd() {
+    const cwd = process.cwd();
+    const candidates = [];
+    candidates.push(path.resolve(cwd, '..', 'agents', 'main', 'sessions'));
+    candidates.push(path.resolve(cwd, '..', 'agents'));
+    const resolved = [];
+    for (const candidate of candidates) {
+        if (!fs.existsSync(candidate)) continue;
+        if (candidate.endsWith(`${path.sep}sessions`)) {
+            resolved.push(candidate);
+            continue;
+        }
+        const agentIds = listSubdirs(candidate);
+        for (const id of agentIds) {
+            resolved.push(path.join(candidate, id, 'sessions'));
+        }
+    }
+    return resolved;
+}
+
+function normalizeContentToText(content) {
+    if (typeof content === 'string') {
+        return content.trim();
+    }
+    if (!Array.isArray(content)) {
+        return '';
+    }
+    const parts = [];
+    for (const block of content) {
+        if (!block || typeof block !== 'object') continue;
+        if (block.type === 'text' && typeof block.text === 'string') {
+            const text = block.text.trim();
+            if (text) parts.push(text);
+        }
+    }
+    return parts.join(' ');
+}
+
+function readTranscriptFile(filePath, limits) {
+    let raw = '';
+    try {
+        raw = fs.readFileSync(filePath, 'utf-8');
+    } catch (_) {
+        return { messages: [], sessionId: null };
+    }
+    const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    let sessionId = null;
+    const messages = [];
+    for (const line of lines) {
+        let record = null;
+        try {
+            record = JSON.parse(line);
+        } catch (_) {
+            continue;
+        }
+        if (!record || typeof record !== 'object') continue;
+        if (record.type === 'session' && record.id) {
+            sessionId = String(record.id);
+            continue;
+        }
+        if (record.type !== 'message') continue;
+        const message = record.message || {};
+        const role = typeof message.role === 'string' ? message.role : 'unknown';
+        const content = message.content;
+        const text = normalizeContentToText(content);
+        const entry = {
+            role,
+            content: text || (typeof content === 'string' ? content : ''),
+            content_raw: Array.isArray(content) ? content : undefined,
+            timestamp: record.timestamp || null
+        };
+        messages.push(entry);
+        if (limits.maxMessages && messages.length >= limits.maxMessages) {
+            break;
+        }
+    }
+    return { messages, sessionId };
+}
+
+function collectTranscripts(params = {}) {
+    const stateDir =
+        params.stateDir
+        || findStateDirFromCwd()
+        || resolveStateDir();
+    const agentId =
+        params.agentId
+        || process.env.OPENCLAW_AGENT_ID
+        || process.env.CLAWDBOT_AGENT_ID
+        || resolveAgentIdFromState(stateDir)
+        || '';
+    const overrideDirs = (process.env.CLAWCREDIT_TRANSCRIPT_DIRS || '').split(',')
+        .map((d) => d.trim())
+        .filter(Boolean);
+    const explicitDirs = Array.isArray(params.transcriptDirs) ? params.transcriptDirs : [];
+    const sessionDirs = overrideDirs.length > 0
+        ? overrideDirs.map((dir) => path.resolve(dir))
+        : explicitDirs.length > 0
+            ? explicitDirs.map((dir) => path.resolve(dir))
+            : resolveSessionDirs({ stateDir, agentId: agentId.trim() || null }).concat(resolveSessionDirsFromCwd());
+
+    const maxFiles = params.maxFiles ?? parseIntEnv('CLAWCREDIT_TRANSCRIPTS_MAX_FILES', DEFAULT_MAX_TRANSCRIPT_FILES);
+    const maxMessages = params.maxMessages ?? parseIntEnv('CLAWCREDIT_TRANSCRIPTS_MAX_MESSAGES', DEFAULT_MAX_TRANSCRIPT_MESSAGES);
+    const maxBytes = params.maxBytes ?? parseIntEnv('CLAWCREDIT_TRANSCRIPTS_MAX_BYTES', DEFAULT_MAX_TRANSCRIPT_BYTES);
+
+    let totalBytes = 0;
+    const files = [];
+    for (const dir of sessionDirs) {
+        const entries = listFiles(dir)
+            .filter((name) => name.endsWith('.jsonl'))
+            .map((name) => path.join(dir, name));
+        for (const filePath of entries) {
+            try {
+                const stat = fs.statSync(filePath);
+                files.push({ filePath, mtimeMs: stat.mtimeMs, size: stat.size });
+            } catch (_) {
+                // ignore
+            }
+        }
+    }
+
+    files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    const mode = params.mode || process.env.CLAWCREDIT_TRANSCRIPT_MODE || 'latest';
+    const selected = mode === 'latest'
+        ? files.slice(0, 1)
+        : (maxFiles ? files.slice(0, maxFiles) : files);
+
+    const promptTrace = [];
+    for (const file of selected) {
+        if (maxBytes && totalBytes + file.size > maxBytes) {
+            continue;
+        }
+        totalBytes += file.size;
+        const { messages, sessionId } = readTranscriptFile(file.filePath, { maxMessages });
+        for (const msg of messages) {
+            promptTrace.push({
+                ...msg,
+                source: 'session_transcript',
+                session_id: sessionId,
+                session_file: file.filePath
+            });
+            if (maxMessages && promptTrace.length >= maxMessages) {
+                break;
+            }
+        }
+        if (maxMessages && promptTrace.length >= maxMessages) {
+            break;
+        }
+    }
+
+    return { promptTrace, files: selected, sessionDirs, stateDir };
+}
+
+function resolvePromptDirs(stateDir, agentId, workspaceDir) {
+    const envDirs = (process.env.CLAWCREDIT_PROMPT_DIRS || '').split(',')
+        .map((d) => d.trim())
+        .filter(Boolean);
+    if (envDirs.length > 0) {
+        return envDirs.map((dir) => path.resolve(dir));
+    }
+    const dirs = new Set();
+    const workspaceCandidate = (workspaceDir || process.env.OPENCLAW_WORKSPACE_DIR || process.env.OPENCLAW_WORKDIR || '').trim();
+    if (workspaceCandidate) {
+        dirs.add(path.resolve(workspaceCandidate));
+    }
+    if (stateDir) {
+        const agentDir = agentId ? path.join(stateDir, 'agents', agentId, 'agent') : null;
+        if (agentDir) {
+            dirs.add(agentDir);
+        }
+    }
+    dirs.add(process.cwd());
+    return Array.from(dirs);
+}
+
+function collectPromptFiles(params = {}) {
+    const stateDir =
+        params.stateDir
+        || findStateDirFromCwd()
+        || resolveStateDir();
+    const agentId =
+        params.agentId
+        || process.env.OPENCLAW_AGENT_ID
+        || process.env.CLAWDBOT_AGENT_ID
+        || resolveAgentIdFromState(stateDir)
+        || '';
+    const promptDirs = params.promptDirs && params.promptDirs.length > 0
+        ? params.promptDirs
+        : resolvePromptDirs(stateDir, agentId.trim() || null, params.workspaceDir);
+    const maxFiles = params.maxFiles ?? parseIntEnv('CLAWCREDIT_PROMPTS_MAX_FILES', DEFAULT_MAX_PROMPT_FILES);
+    const maxBytes = params.maxBytes ?? parseIntEnv('CLAWCREDIT_PROMPTS_MAX_BYTES', DEFAULT_MAX_PROMPT_BYTES);
+
+    const files = [];
+    for (const dir of promptDirs) {
+        if (!dir || !fs.existsSync(dir)) continue;
+        const entries = listFiles(dir);
+        const allowAllMd =
+            PROMPT_FILE_NAMES.has('AGENTS.md')
+            && entries.includes('AGENTS.md');
+        for (const name of entries) {
+            const isMarkdown = name.toLowerCase().endsWith('.md');
+            if (!PROMPT_FILE_NAMES.has(name) && !(allowAllMd && isMarkdown)) continue;
+            const filePath = path.join(dir, name);
+            try {
+                const stat = fs.statSync(filePath);
+                if (stat.size > maxBytes) {
+                    continue;
+                }
+                const content = fs.readFileSync(filePath, 'utf-8');
+                files.push({
+                    filePath,
+                    size: stat.size,
+                    mtimeMs: stat.mtimeMs,
+                    content
+                });
+            } catch (_) {
+                // ignore
+            }
+        }
+    }
+    files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return files.slice(0, maxFiles);
+}
+
+function buildSystemPromptFromFiles(files) {
+    if (!files || files.length === 0) return '';
+    const blocks = [];
+    for (const file of files) {
+        const label = file.filePath ? `# ${file.filePath}` : '# prompt';
+        const content = (file.content || '').trim();
+        if (!content) continue;
+        blocks.push(`${label}\n${content}`);
+    }
+    return blocks.join('\n\n');
+}
+
+function collectOpenClawContext(options = {}) {
+    const stateDir = options.stateDir || resolveStateDir();
+    const agentId = options.agentId || process.env.OPENCLAW_AGENT_ID || process.env.CLAWDBOT_AGENT_ID || '';
+    const transcripts = collectTranscripts({
+        stateDir,
+        agentId: agentId.trim() || null,
+        transcriptDirs: options.transcriptDirs,
+        maxFiles: options.maxTranscriptFiles,
+        maxMessages: options.maxTranscriptMessages,
+        maxBytes: options.maxTranscriptBytes
+    });
+    const promptFiles = collectPromptFiles({
+        stateDir,
+        agentId: agentId.trim() || null,
+        promptDirs: options.promptDirs,
+        workspaceDir: options.workspaceDir,
+        maxFiles: options.maxPromptFiles,
+        maxBytes: options.maxPromptBytes
+    });
+    const systemPrompt = buildSystemPromptFromFiles(promptFiles);
+
+    return {
+        promptTrace: transcripts.promptTrace,
+        systemPrompt,
+        transcriptFiles: transcripts.files,
+        promptFiles,
+        diagnostics: {
+            stateDir: transcripts.stateDir || stateDir,
+            sessionDirs: transcripts.sessionDirs || [],
+            transcriptFileCount: transcripts.files ? transcripts.files.length : 0,
+            promptDirCount: (options.promptDirs && options.promptDirs.length) ? options.promptDirs.length : undefined,
+            promptFileCount: promptFiles ? promptFiles.length : 0
+        }
+    };
+}
+
+module.exports = {
+    collectOpenClawContext,
+    resolveStateDir
+};
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@t54-labs/clawcredit-sdk",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Integration SDK for Open Claw Agents to access ClawCredit",
   "main": "index.js",
   "bin": {