Intermediate

<!-- ~/.openclaw/workspace/skills/contract-review/SKILL.md -->
 
---
 
name: contract-review
description: "Review a contract document for standard clauses and flag potential issues."
triggers:
 
- "review contract"
- "check this agreement"
- "look at this contract"
- "contract review"
  version: 1.0.0
  author: your-name
 
---
 
## Instructions
 
When the user asks you to review a contract, follow this protocol exactly:
 
1. Ask for the contract file path if the user has not provided one.
   Call read_file with that path. If the file exceeds 50,000 bytes, read only the
   first 50,000 bytes and note this in your response.
 
2. Analyze the contract text for the following elements. For each, note whether it is
   present, absent, or ambiguous:
   - Governing law clause (which jurisdiction applies)
   - Termination clause (notice periods, for-cause vs. at-will)
   - Liability limitation (cap on damages)
   - Indemnification (who indemnifies whom and for what)
   - Intellectual property assignment (who owns work product)
   - Non-compete and non-solicitation provisions
   - Payment terms (amounts, schedules, late penalties)
   - Dispute resolution (arbitration vs. litigation, venue)
 
3. Flag any clause that is unusual, one-sided, or potentially problematic with a
   "[FLAG]" marker and a one-sentence explanation.
 
4. Format your output as:
   **Contract Review Summary**
   - Document: [filename]
   - Pages reviewed: [approximate based on character count]
 
   **Clause Checklist**
   [table with Clause | Status | Notes]
 
   **Flagged Issues**
   [numbered list of flagged items]
 
   **Recommendation**
   [1-2 sentence overall assessment]
 
Do not provide legal advice. Your output is a structural review only. Include a footer:
"This review is AI-assisted and does not constitute legal advice."
 
## Examples
 
User: "Can you review the contract at ~/Documents/vendor-agreement.pdf"
Agent: [calls read_file with path "~/Documents/vendor-agreement.pdf"]
[analyzes output for the 8 clause categories]
[produces formatted Contract Review Summary with checklist and flags]
 
User: "Check this agreement for red flags"
Agent: "I'll review the agreement for you. Could you share the file path or paste the
contract text?"
[if user provides path → calls read_file → produces summary]
[if user pastes text → analyzes inline text directly]
 
## Tools
 
tools:
 
- name: read_file
  description: "Read a file from the local filesystem and return its contents."
  parameters:
  type: object
  properties:
  path:
  type: string
  description: "Absolute or home-relative path to the file."
  maxBytes:
  type: integer
  default: 50000
  required: [path]
  permissions:
  - filesystem.read

// Skills System injection logic — simplified from @openclaw/core/src/skills/injector.ts
interface SkillInjectionConfig {
  tokenBudget: number; // => Max tokens allocated to skill context (default: 4000)
  semanticThreshold: number; // => Min similarity score for semantic injection (default: 0.65)
  maxSkillsPerTurn: number; // => Hard cap on simultaneous injections (default: 5)
}
 
async function selectSkillsToInject(
  message: ChannelMessage,
  skills: SkillDefinition[],
  config: SkillInjectionConfig,
): Promise<SkillDefinition[]> {
  const selected: SkillDefinition[] = [];
  let usedTokens = 0;
 
  // Pass 1: Trigger phrase matching (exact substring match, case-insensitive)
  const triggerMatches = skills.filter((skill) =>
    skill.triggers.some(
      (
        trigger, // => "review contract" in message text
      ) => message.text.toLowerCase().includes(trigger.toLowerCase()),
    ),
  ); // => => triggerMatches: [contract-review]
  // => These are injected first, highest priority
 
  // Pass 2: Semantic scoring for skills without trigger matches
  const unmatched = skills.filter((s) => !triggerMatches.includes(s));
  const messageEmbedding = await embedder.embed(message.text);
  // => 768-dim vector representing message meaning
  const semanticCandidates = unmatched
    .map((skill) => ({
      skill,
      score: cosineSimilarity(messageEmbedding, skill.descriptionEmbedding),
      // => skill.descriptionEmbedding pre-computed at install time from skill.description
    }))
    .filter((c) => c.score >= config.semanticThreshold) // => Only above threshold
    .sort((a, b) => b.score - a.score); // => Highest similarity first
 
  // Combine: trigger matches + semantic matches, apply token budget
  const candidates = [...triggerMatches, ...semanticCandidates.map((c) => c.skill)];
 
  for (const skill of candidates) {
    const skillTokens = estimateTokens(skill.content); // => Rough estimate: chars / 4
    if (usedTokens + skillTokens > config.tokenBudget) {
      break; // => Budget exhausted — stop injecting
      // => Skills sorted by priority, so important
      // => skills are not dropped in favor of
      // => semantically similar but less relevant ones
    }
    if (selected.length >= config.maxSkillsPerTurn) break;
    selected.push(skill);
    usedTokens += skillTokens;
  }
 
  return selected;
  // => For "review this contract at ~/Documents/vendor.pdf":
  // => => trigger match: contract-review (1847 tokens)
  // => => semantic match: core-memory (similarity 0.31 — below threshold, skipped)
  // => => semantic match: lead-research (similarity 0.42 — below threshold, skipped)
  // => => selected: [contract-review]
  // => => tokens used: 1847 of 4000 budget
}

// ~/.openclaw/workspace/gateway.config.ts — multi-channel routing
 
export const gatewayConfig = {
  routes: [
    {
      name: "personal-assistant",
      channels: ["telegram"], // => Messages from Telegram use this route
      workspace: "~/.openclaw/workspaces/personal/",
      // => ~personal/AGENTS.md: "You are a personal assistant for one person..."
      // => ~personal/SOUL.md: "Your name is Aria. Casual, direct tone."
      // => ~personal/TOOLS.md: calendar.read, email.read, filesystem.read
      // => ~personal/skills/: personal-scheduling, email-triage, note-taking
      rateLimiting: { messagesPerMinute: 20 }, // => Personal use: higher limit
    },
    {
      name: "team-devops-bot",
      channels: ["slack"], // => Slack messages use this route
      workspace: "~/.openclaw/workspaces/devops/",
      // => ~devops/AGENTS.md: "You are a DevOps assistant for the engineering team..."
      // => ~devops/SOUL.md: "Your name is Ops. Formal, information-dense."
      // => ~devops/TOOLS.md: run_shell (git, kubectl, docker), web_fetch
      // => ~devops/skills/: github-pr-review, kubernetes-status, incident-response
      rateLimiting: { messagesPerMinute: 60 }, // => Team use: higher throughput
      allowedUsers: ["U01AB2CD3EF", "U04GH5IJ6KL"], // => Slack user IDs — team members only
      // => Other Slack users get no response
    },
    {
      name: "customer-support",
      channels: ["discord"], // => Discord uses this route
      workspace: "~/.openclaw/workspaces/support/",
      // => ~support/AGENTS.md: "You are a customer support agent for Acme Corp..."
      // => ~support/skills/: faq-knowledge-base, ticket-creation, escalation
      rateLimiting: { messagesPerMinute: 10 },
    },
  ],
};
 
// Memory isolation is automatic: sessionId includes channelId
// => telegram:user123 and slack:user123 are different sessions, different memory stores
// => A user on both Telegram and Slack gets zero cross-channel memory bleed
// => (cross-channel memory sharing requires explicit shared memory pool config)

// Optional cross-channel identity map — only configure if you have a legitimate need
export const identityConfig = {
  crossChannelIdentities: [
    {
      canonicalId: "user-alice", // => Your internal identifier
      identities: [
        { channel: "telegram", userId: "123456789" },
        { channel: "slack", userId: "U01AB2CD3EF" },
      ],
      sharedMemory: true, // => Allow cross-channel memory access
      // => => Aria on Telegram and Ops on Slack
      // => => can both retrieve Alice's memories
      // => Only enable with user's informed consent
    },
  ],
};

// Isolation architecture — how the runtime enforces separation
 
// Each route gets its own AgentContext at initialization
interface AgentContext {
  workspacePath: string; // => Path to the workspace directory for this route
  routeName: string; // => "personal-assistant" | "team-devops-bot" | etc.
  agentsMd: string; // => Loaded from workspacePath/AGENTS.md
  soulMd: string; // => Loaded from workspacePath/SOUL.md
  toolRegistry: ToolRegistry; // => Tools from workspacePath/TOOLS.md
  // => Tools from one route are not visible to another
  skillsDir: string; // => workspacePath/skills/ — separate per route
  memoryNamespace: string; // => Derived from routeName — used as vector DB prefix
  // => "personal-assistant:" prefix isolates from "devops:"
  permissionSet: PermissionGrant[]; // => Granted permissions for this workspace only
}
 
// Memory namespace enforcement — prevents cross-route retrieval
class MemoryStore {
  async retrieve(query: string, namespace: string): Promise<MemoryEntry[]> {
    // All DB queries are prefixed with the namespace
    return this.vectorDb.query({
      embedding: await embed(query),
      filter: { namespace }, // => "personal-assistant:" entries never returned for
      // => "team-devops-bot:" queries — namespace filter enforced
      // => at the database query level, not application level
      limit: 5,
    });
    // => If namespace = "team-devops-bot:" and query = "Aria's calendar preferences"
    // => => returns [] — Aria's memories are in namespace "personal-assistant:"
  }
}
 
// Tool registry isolation — Slack route cannot call tools from Telegram workspace
class ToolRegistry {
  constructor(
    private namespace: string,
    private permissionSet: PermissionGrant[],
  ) {}
 
  execute(toolName: string, params: unknown): Promise<ToolResult> {
    if (!this.tools.has(toolName)) {
      // => "run_shell" exists in devops workspace TOOLS.md but not in personal workspace
      // => If personal-assistant route somehow calls "run_shell", it fails here:
      throw new Error(`Tool ${toolName} not registered in workspace ${this.namespace}`);
      // => This is a hard failure, not a graceful fallback — by design
    }
    // ... execute the tool
  }
}

// Memory system configuration — ~/.openclaw/workspace/memory.config.ts
export const memoryConfig = {
  sessionHistory: {
    maxTurns: 20, // => How many recent turns to include in every context
    // => Higher values = more context but more tokens per call
    // => 20 turns ≈ 3000-8000 tokens depending on message length
    archiveOnTimeout: true, // => When session expires, archive history to long-term memory
  },
 
  longTermMemory: {
    embeddingModel: "text-embedding-3-small", // => OpenAI embedding model (768 dims, fast, cheap)
    // => Alternative: "text-embedding-3-large" (3072 dims)
    // => Local alternative: "nomic-embed-text" via Ollama
    storageBackend: "sqlite-vss", // => Local SQLite with vector search extension
    // => Alternative: "qdrant" (requires separate Qdrant process)
    autoStoreThreshold: 0.7, // => Store turns with importance score >= 0.7 automatically
    // => Importance score computed by LLM after each turn
    // => 0.7 stores notable turns; 0.0 stores everything (expensive)
    retentionDays: 365, // => Delete entries older than this many days
    maxEntries: 10000, // => Delete oldest entries when limit reached
  },
 
  knowledgeBase: {
    indexDir: "~/.openclaw/knowledge/", // => Directory to watch for documents to index
    supportedFormats: ["pdf", "md", "txt", "docx"],
    chunkSize: 512, // => Characters per chunk (indexed separately)
    // => Smaller chunks = more precise retrieval
    // => Larger chunks = more context per retrieved chunk
    chunkOverlap: 64, // => Characters of overlap between adjacent chunks
    // => Prevents concepts that span chunk boundaries from
    // => being split across two unrelated retrieval results
    retrievalLimit: 3, // => Max knowledge base chunks injected per turn
  },
};
 
// Retrieving from all three memory stores — what context assembly does
async function assembleMemoryContext(message: ChannelMessage, session: Session): Promise<MemoryContext> {
  const [sessionHistory, ltmResults, kbResults] = await Promise.all([
    Promise.resolve(session.recentHistory(20)), // => Instant — already in memory
    memory.retrieve(message.text, session.id, {
      // => Vector search ~10-50ms
      limit: 5,
      minSimilarity: 0.65,
    }),
    knowledgeBase.retrieve(message.text, {
      // => Chunk retrieval ~20-100ms
      limit: 3,
      namespace: session.routeName, // => Only docs indexed for this route
    }),
  ]);
 
  return {
    sessionHistory, // => => [{role:"user",content:"..."}, ...]
    longTermMemories: ltmResults, // => => [{content:"Acme deal closes June 15", similarity:0.94}]
    knowledgeChunks: kbResults, // => => [{source:"vendor-policy.pdf", chunk:"Section 3.2..."}]
  };
  // => All three results assembled into context before LLM call
  // => Total additional tokens: ~500-3000 depending on result counts and lengths
}

# Index documents from a directory (openclaw-cli command)
openclaw kb index ~/Documents/company-policies/   # => Watches directory recursively
# => Indexing: vendor-policy-2026.pdf (47 pages) ... chunked into 312 entries
# => Indexing: employee-handbook.pdf (89 pages) ... chunked into 587 entries
# => Indexing: sla-template.md ... chunked into 43 entries
# => Done. 942 entries indexed in ~/.openclaw/knowledge/
# => New documents added to this directory will be indexed automatically (file watcher active)
 
# Query the knowledge base directly (useful for testing retrieval quality)
openclaw kb query "termination notice period"
# => Top 3 results:
# => 1. vendor-policy-2026.pdf § 8.3 (similarity: 0.89)
# =>    "...either party may terminate with 30 days written notice..."
# => 2. employee-handbook.pdf § 12.1 (similarity: 0.81)
# =>    "...employment terminates immediately for cause, or with 2 weeks notice otherwise..."
# => 3. sla-template.md § Termination (similarity: 0.77)
# =>    "...Service may be terminated by either party upon 14 days written notice..."
 
# Check indexing status
openclaw kb status
# => Total documents: 3 files
# => Total chunks: 942
# => Index size: 14.2 MB
# => Last indexed: 2026-05-21 09:14:32
# => File watcher: active (watching ~/Documents/company-policies/)

// Knowledge base retrieval integration in a skill — policy-lookup skill example
 
// ~/.openclaw/workspace/skills/policy-lookup/SKILL.md (tools section)
// tools:
//   - name: kb_retrieve
//     description: "Retrieve relevant chunks from the company knowledge base."
 
// How kb_retrieve works internally (the tool implementation, not the skill):
async function kb_retrieve(params: { query: string; limit?: number }) {
  const queryEmbedding = await embedder.embed(params.query);
  // => 768-dimensional vector representing the query's meaning
 
  const results = await vectorDb.query({
    embedding: queryEmbedding,
    namespace: "knowledge-base", // => Separate namespace from conversation memory
    limit: params.limit ?? 3, // => Default: return top 3 chunks
    minSimilarity: 0.6, // => Lower threshold than memory — KB is broader
  });
  // => results: [{source: "vendor-policy-2026.pdf", chunk: "...", similarity: 0.89}, ...]
 
  return results.map((r) => ({
    source: r.source, // => Filename for citation
    section: r.metadata?.section ?? "", // => Section heading if extracted during indexing
    content: r.chunk, // => The retrieved text chunk (~512 chars)
    similarity: r.similarity, // => For debugging — not shown to user by default
  }));
  // => Tool result injected back into LLM context:
  // => "Relevant policy sections found:
  // =>  [vendor-policy-2026.pdf § 8.3]: either party may terminate with 30 days notice..."
}

# ~/.openclaw/workspace/TOOLS.md — custom CRM tool declaration
 
tools:
  - name: crm_get_contact
    description: "Look up a contact in the CRM by name or email address."
    parameters:
      type: object
      properties:
        query:
          type: string
          description: "Name or email address to search for."
        fields:
          type: array
          items:
            type: string
          description: "Contact fields to return. Default: [name, email, company, lastContact]."
          default: ["name", "email", "company", "lastContact"]
      required: [query]
    permissions:
      - network.http # => Requires HTTP access (CRM API call)
    timeout: 10000 # => Tool execution timeout in ms (default: 30000)
 
  - name: crm_create_note
    description: "Add a note to a contact's CRM record."
    parameters:
      type: object
      properties:
        contactId:
          type: string
          description: "The CRM contact ID to attach the note to."
        note:
          type: string
          description: "The note content to add."
        tags:
          type: array
          items:
            type: string
          description: "Optional tags for the note (e.g. ['follow-up', 'demo'])."
          default: []
      required: [contactId, note]
    permissions:
      - network.http
    requireConfirmation: true # => User approves before CRM is written

// ~/.openclaw/workspace/tools/crm-tools.ts — tool implementations
 
import { defineTool, ToolContext } from "@openclaw/tools";
 
export const crmGetContact = defineTool({
  name: "crm_get_contact", // => Must match TOOLS.md declaration name
  async execute(params: { query: string; fields: string[] }, ctx: ToolContext) {
    const apiKey = process.env.CRM_API_KEY; // => Never hardcode credentials
    if (!apiKey) {
      return { success: false, error: "CRM_API_KEY not configured" };
      // => => LLM sees this error and tells user the CRM is not configured
    }
 
    const response = await fetch(`https://api.yourcrm.com/contacts/search?q=${encodeURIComponent(params.query)}`, {
      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
    });
    // => HTTP GET to CRM search endpoint
    // => Timeout enforced by runtime at 10000ms (from TOOLS.md timeout field)
 
    if (!response.ok) {
      return { success: false, error: `CRM API error: ${response.status}` };
    }
 
    const data = await response.json();
    // => data: { contacts: [{id: "c_123", name: "Alice Smith", email: "...", ...}] }
 
    const contact = data.contacts[0]; // => Return first match
    if (!contact) {
      return { success: true, result: "No contact found matching that query." };
    }
 
    // Return only requested fields — avoid leaking unnecessary data to LLM context
    const filtered = params.fields.reduce(
      (acc, field) => {
        if (field in contact) acc[field] = contact[field]; // => Only return asked-for fields
        return acc;
      },
      {} as Record<string, unknown>,
    );
 
    return { success: true, result: filtered };
    // => => { success: true, result: { name: "Alice Smith", email: "alice@acme.com",
    // =>                               company: "Acme Corp", lastContact: "2026-03-15" } }
    // => Runtime injects this result into LLM context for next turn
  },
});

// ~/.openclaw/workspace/openclaw.config.ts — register custom tool implementations
export default {
  // ... llm, gateway, channels config ...
  tools: {
    implementations: [
      "~/workspace/tools/crm-tools.ts", // => Runtime imports this at startup
      // => Finds and registers crmGetContact and crmCreateNote
      // => Validates that each implementation matches a TOOLS.md entry
    ],
  },
};
// => On start: Loaded 2 custom tools: crm_get_contact, crm_create_note
// => On start: Permission check: network.http — granted
// => On start: crm_create_note: requireConfirmation = true (user approval required)

// Orchestrator's TOOLS.md declares agent_call as a tool
// The tool implementation calls a specialist agent's local HTTP API:
 
// ~/.openclaw/workspace/tools/agent-call.ts
export const agentCall = defineTool({
  name: "agent_call",
  async execute(params: { agentName: string; task: string; context?: string }) {
    const agentUrls: Record<string, string> = {
      research: "http://localhost:7433/api/v1/run", // => Research specialist agent
      writer: "http://localhost:7434/api/v1/run", // => Writer specialist agent
      crm: "http://localhost:7435/api/v1/run", // => CRM specialist agent
    };
 
    const url = agentUrls[params.agentName];
    if (!url) {
      return { success: false, error: `Unknown agent: ${params.agentName}` };
    }
 
    const response = await fetch(url, {
      method: "POST",
      headers: { "Content-Type": "application/json", Authorization: `Bearer ${process.env.LOCAL_AGENT_TOKEN}` },
      body: JSON.stringify({
        message: params.task, // => Task description for the specialist
        context: params.context ?? "", // => Optional context (e.g., user name, deal ID)
      }),
    });
    // => HTTP POST to specialist agent's local API
    // => Specialist agent runs its own full agentic loop
    // => May take 5-30 seconds for complex tasks
 
    const result = await response.json();
    return { success: true, result: result.response };
    // => => {success: true, result: "Research summary: Acme Corp (est. 2018), 450 employees..."}
    // => Orchestrator receives this and continues its own reasoning
  },
});
 
// Example orchestrator turn for: "Research Acme Corp and add a note to their CRM record"
// Orchestrator LLM reasoning (internal):
// => Step 1: Call research agent with "Research Acme Corp background for CRM entry"
// => Step 2: Call crm agent with "Look up Acme Corp in CRM, then add note: [research results]"
// => Step 3: Compose final response confirming both actions

# Start specialist agents on separate ports
openclaw start --config ~/.openclaw/workspaces/research/openclaw.config.ts --port 7433
openclaw start --config ~/.openclaw/workspaces/crm/openclaw.config.ts --port 7434
 
# Start orchestrator (default port 7432, connects to user-facing Telegram channel)
openclaw start --config ~/.openclaw/workspaces/orchestrator/openclaw.config.ts
# => Orchestrator ready. Specialist agents: research@7433, crm@7434
# => User sends: "Research Acme Corp and add a CRM note"
# => Orchestrator delegates → research result received → CRM note added → response sent

// Voice mode configuration — ~/.openclaw/workspace/voice.config.ts
export const voiceConfig = {
  enabled: true, // => Enable voice mode for companion apps
 
  wakeWord: {
    phrase: "Hey Aria", // => Wake word to activate listening
    // => Processed entirely on-device (no cloud)
    // => Change to match your agent's name in SOUL.md
    sensitivity: 0.7, // => 0.0 = rarely triggers, 1.0 = very sensitive
    // => 0.7 is a good default for quiet environments
    platform: ["macos", "ios"], // => Which platforms enable wake word detection
  },
 
  speechToText: {
    provider: "apple-native", // => Apple Speech framework (on-device, free)
    // => Alternative: "openai-whisper" (cloud, higher quality)
    // => Alternative: "whisper-local" (Whisper model via Ollama)
    language: "en-US",
    silenceTimeout: 1500, // => ms of silence before recording stops
  },
 
  textToSpeech: {
    provider: "apple-native", // => Apple AVSpeechSynthesizer (on-device)
    // => Alternative: "elevenlabs" (cloud, much more natural)
    // => Alternative: "openai-tts" (cloud, good quality)
    voice: "Samantha", // => macOS system voice name
    rate: 0.52, // => 0.0 = slowest, 1.0 = fastest; 0.52 ≈ natural pace
    volume: 0.9,
  },
 
  responseFilter: {
    stripMarkdown: true, // => Remove **, ##, bullet markers before TTS
    // => LLMs often include markdown in responses;
    // => it sounds odd when read aloud
    maxResponseLength: 500, // => Truncate long responses for voice output
    // => Full text still shown in companion app log
  },
};

// A2UI payload — returned by agent instead of plain text when canvas is active
 
// Example: Agent returns a kanban board for project tasks
const kanbanPayload: A2UIPayload = {
  type: "canvas", // => Renders in Live Canvas panel
  version: "1.0",
  components: [
    {
      type: "kanban",
      id: "project-tasks",
      columns: [
        {
          id: "todo",
          label: "To Do",
          cards: [
            { id: "t1", content: "Research Acme Corp", tags: ["research"] },
            { id: "t2", content: "Draft proposal", tags: ["writing"] },
          ],
        },
        {
          id: "in-progress",
          label: "In Progress",
          cards: [{ id: "t3", content: "Review vendor contract", tags: ["legal"] }],
        },
        {
          id: "done",
          label: "Done",
          cards: [],
        },
      ],
      interactions: {
        onCardMove: {
          action: "agent_event", // => When user drags a card to a new column:
          eventType: "card_moved", // => Sends {cardId, fromColumn, toColumn}
          // => back to the agent runtime as a new message
          // => Agent can then update CRM, Jira, or other systems based on the move
        },
        onCardClick: {
          action: "agent_event",
          eventType: "card_detail_requested",
        },
      },
    },
  ],
};
 
// How a skill instructs the agent to return A2UI instead of plain text:
// (In SKILL.md instructions section)
// "When the user asks to see tasks as a board, respond with an A2UI kanban payload.
//  Format: JSON wrapped in ```a2ui ... ``` code block.
//  The companion app will render it visually."

// Handling a user interaction event from the canvas
// (When user drags "Review vendor contract" from "In Progress" to "Done")
const interactionEvent: CanvasEvent = {
  type: "card_moved",
  payload: {
    cardId: "t3",
    fromColumn: "in-progress",
    toColumn: "done",
    timestamp: "2026-05-21T09:45:00Z",
  },
};
// => Gateway receives this as a structured message (not free text)
// => Runtime processes it like any other turn: LLM decides what action to take
// => Agent might call crm_create_note("t3 task completed") or send Slack notification

# Enable trace mode for a single turn (without restarting the agent)
openclaw trace send "Review the contract at ~/Documents/test.pdf"
 
# => === TURN TRACE ===
# => Message: "Review the contract at ~/Documents/test.pdf"
# => Session: telegram:123456789 (14 previous turns)
# =>
# => [SKILL INJECTION]
# => Evaluating 4 installed skills...
# => contract-review: trigger match "review" + "contract" → INJECT (1847 tokens)
# => lead-research: no trigger match, semantic score 0.31 < 0.65 → SKIP
# => core-memory: no trigger match, semantic score 0.58 < 0.65 → SKIP
# => core-datetime: no trigger match, semantic score 0.22 < 0.65 → SKIP
# => Injected: [contract-review]
# =>
# => [CONTEXT ASSEMBLY]
# => AGENTS.md: 287 tokens
# => SOUL.md: 143 tokens
# => Injected skills: 1847 tokens (contract-review)
# => Long-term memories retrieved: 2 entries (421 tokens)
# => Session history: 12 turns (3891 tokens)
# => Current message: 12 tokens
# => Total context: 6601 tokens
# =>
# => [LLM CALL 1/10]
# => Provider: claude claude-sonnet-4-6
# => Input tokens: 6601
# => Output: tool_call → read_file({"path": "~/Documents/test.pdf", "maxBytes": 50000})
# =>
# => [TOOL EXECUTION]
# => Tool: read_file
# => Params: {path: "~/Documents/test.pdf", maxBytes: 50000}
# => Permission check: filesystem.read → granted
# => Result: success (43821 bytes, 10956 tokens)
# =>
# => [LLM CALL 2/10]
# => Input tokens: 17557 (6601 + 10956)
# => Output: final response (no tool calls)
# =>
# => [RESPONSE]
# => Length: 847 tokens
# => Delivered via: telegram
# => === END TRACE ===

# Enable persistent trace logging (writes all turns to a log file)
openclaw start --trace --trace-output ~/.openclaw/traces/
# => Trace mode: ON
# => Writing traces to: ~/.openclaw/traces/ (one file per turn)
 
# View the most recent trace
openclaw trace tail                    # => Streams most recent trace file in real time
 
# Filter traces for a specific session
openclaw trace list --session "telegram:123456789" --since "2026-05-21"
# => 14 traces found
# => 2026-05-21 09:14 — contract review (6 LLM calls, 2 tool calls)
# => 2026-05-21 10:02 — research request (3 LLM calls, 5 tool calls)

<!-- Skill composition example: two skills that must coexist on a research turn -->
 
<!-- ~/.openclaw/workspace/skills/lead-research/SKILL.md (excerpt) -->
 
## Instructions
 
When researching a company, always end your output with a "Research confidence: HIGH/MEDIUM/LOW"
indicator based on source quality. HIGH = multiple corroborating sources. MEDIUM = single
reliable source. LOW = limited public information available.
 
<!-- ~/.openclaw/workspace/skills/crm-formatter/SKILL.md (excerpt) -->
 
## Instructions
 
When producing output intended for CRM entry, format the final section as:
---CRM-ENTRY---
[structured data here]
---END-CRM-ENTRY---
This delimiter allows our CRM integration script to parse the response.

<!-- In crm-formatter/SKILL.md, handle the potential conflict explicitly -->
 
## Instructions
 
...
If the lead-research skill is also active (you will see a "Research confidence:" section in
your instructions), use the CRM delimiter to wrap the research output rather than replacing
the research format. The research format and CRM delimiter are compatible — produce the
research in its natural format, then wrap the entire output in the CRM delimiters.

// Controlling skill injection order via priority configuration
// ~/.openclaw/workspace/skills.config.ts
 
export const skillsConfig = {
  injectionOrder: "priority-then-semantic", // => "priority-then-semantic" (default) or
  // => "semantic-only" (no explicit priority)
  priorities: {
    "crm-formatter": 100, // => Higher priority = injected first = appears earlier
    "lead-research": 80, // => in context window = LLM reads it first
    "contract-review": 90,
    // => Unspecified skills default to priority 50
    // => Injection order in context: crm-formatter → contract-review → lead-research → others
  },
};
// => When multiple skills inject on the same turn, higher-priority skills appear earlier
// => in the context window. LLMs attend more strongly to earlier context, so the
// => highest-priority skill's instructions tend to dominate in conflict situations.

# Prepare a skill for ClawHub publishing
cd ~/.openclaw/workspace/skills/contract-review/
 
# Required: verify SKILL.md has all required ClawHub metadata fields
cat SKILL.md
# => ---
# => name: contract-review
# => description: "Review a contract document for standard clauses and flag issues."
# => version: 1.0.0
# => author: your-clawhub-username          # => ClawHub account required to publish
# => license: MIT                           # => Must be an OSI-approved license
# => triggers: [...]
# => minOpenClawVersion: "1.3.0"           # => Minimum version your skill requires
# => ---
 
# Run ClawHub quality check (validates metadata, tests trigger matching, checks size)
openclaw skill validate --clawhub
# => Checking SKILL.md metadata... OK
# => Checking trigger phrases (5 found)... OK
# => Checking tool declarations... WARNING: crm_get_contact is not a standard tool
# =>   Consider adding a note in description that users must define this tool themselves
# => Checking size: 4.2KB (limit: 50KB)... OK
# => Checking examples section (2 examples)... OK (minimum: 2)
# => Quality score: 87/100
# => Warnings: 1 (non-blocking)
# => Ready to publish
 
# Publish to ClawHub
openclaw skill publish
# => Authenticating with ClawHub...
# => Publishing contract-review v1.0.0...
# => Published: https://clawhub.dev/skills/your-username/contract-review
# => Your skill is live. It will appear in search results within 5 minutes.

# Version management — publishing updates to an existing skill
# After improving your skill's instructions or adding examples:
 
# Bump version in SKILL.md (follows semantic versioning)
# 1.0.0 → 1.1.0 for new functionality, 1.0.0 → 1.0.1 for bug fixes
 
openclaw skill publish --changelog "Added 3 more clause types: IP assignment, NDA, arbitration"
# => Publishing contract-review v1.1.0...
# => Changelog recorded: "Added 3 more clause types..."
# => Users who have this skill installed will see an update available via `openclaw skill update`
 
# Check your skill's download stats and ratings
openclaw skill stats contract-review
# => contract-review v1.1.0
# => Downloads: 234 (last 30 days)
# => Rating: 4.6/5.0 (18 ratings)
# => Issues reported: 1 open ("Does not handle PDFs larger than 100 pages")
# => Latest reviews:
# => "Works exactly as described for standard commercial agreements" ★★★★★
# => "Missed the arbitration clause in our tech services agreement" ★★★