@kortix/sandbox 0.4.1

package/opencode/commands/email.md

@@ -0,0 +1,36 @@
+---
+description: Check inbox, read, send, or manage email. Uses curl with IMAP/SMTP.
+agent: kortix-main
+---
+
+# Email
+
+The user wants to interact with email (by default the agent's own inbox).
+
+## Setup
+
+1. Load the `kortix-email` skill first
+2. Set up credential variables from env vars as shown in the skill
+
+## Parse the request
+
+Interpret what the user wants from their arguments:
+- No args or "check" or "inbox" → show recent inbox messages
+- "send [to] [subject]" → compose and send an email
+- "read [id]" → read a specific message
+- "reply [id]" → reply to a message
+- "search [query]" → search inbox
+- "count" → show unread count
+- Anything else → interpret intent and act
+
+## Execute
+
+Use `curl` directly against IMAP/SMTP as documented in the skill. No scripts needed.
+
+## Report
+
+Show results concisely. For inbox listings, show sender, subject, date, and read status. For sent mail, confirm delivery.
+
+## User request
+
+$ARGUMENTS

package/opencode/commands/init.md

@@ -0,0 +1,43 @@
+---
+description: Initialize project knowledge by scanning the workspace. Updates the Project section of MEMORY.md.
+agent: kortix-main
+---
+
+# Project Initialization
+
+Scan the current workspace and update the Project section of `workspace/.kortix/MEMORY.md`.
+
+## Exploration checklist
+
+Do ALL of these in parallel where possible:
+
+1. **Directory structure** — top-level layout, key directories
+2. **Project manifest** — package.json, Cargo.toml, pyproject.toml, go.mod, etc.
+3. **Git history** — `git log --oneline -30` for recent activity and commit style
+4. **README** — project description
+5. **Build/test/lint commands** — scripts in package.json, Makefile, CI configs
+6. **CI/CD** — .github/workflows/, .gitlab-ci.yml, etc.
+7. **Dependencies** — key libraries, frameworks, external services
+8. **Architecture** — entry points, module boundaries, data flow
+9. **Config files** — .env.example, tsconfig.json, eslint.config.*, etc.
+10. **Docker** — Dockerfile, docker-compose.yml
+
+## Update MEMORY.md
+
+Update the Project section with structured findings:
+
+```markdown
+## Project
+
+**Overview:** [One paragraph description]
+**Tech Stack:** [Languages, frameworks, key libraries]
+**Architecture:** [Key modules, entry points]
+**Commands:** [Build, test, lint, dev, deploy]
+**Conventions:** [Commit style, naming, patterns]
+```
+
+Keep it concise. If there's deep detail worth preserving, write it to `workspace/.kortix/memory/project-details.md`.
+
+Also update the Scratchpad to note the project was scanned.
+
+$ARGUMENTS

package/opencode/commands/journal.md

@@ -0,0 +1,44 @@
+---
+description: Write a session summary capturing what happened in this session.
+agent: kortix-main
+---
+
+# Write Session Summary
+
+Write a summary of this session to both the daily log and a session journal entry.
+
+## Steps
+
+1. Review what happened this session: tasks completed, decisions made, things learned, user feedback, unfinished work.
+
+2. **Write to today's daily log** — append to `workspace/.kortix/memory/YYYY-MM-DD.md` (use today's actual date):
+
+```markdown
+## HH:MM — Session Summary
+
+**What happened:** [2-3 sentence overview]
+- [Key task/decision 1]
+- [Key task/decision 2]
+- [Lessons learned]
+- **Open items:** [Unfinished work]
+```
+
+3. **Write a full journal entry** — append to `workspace/.kortix/journal/sessions.md` (most recent first):
+
+```markdown
+## [YYYY-MM-DD HH:MM] Session Summary
+
+**What happened:** [2-3 sentence overview]
+**Completed:** [List of tasks done]
+**Decisions:** [Key decisions with rationale]
+**Learned:** [What was learned — patterns, corrections, discoveries]
+**Open items:** [Unfinished work, handoff notes]
+```
+
+4. **Update MEMORY.md Scratchpad** — clear completed items, leave pending items for next session. Add handoff notes if needed.
+
+5. If anything from this session reveals lasting knowledge (user preferences, project conventions, architectural decisions), write it to the appropriate `memory/` topic file.
+
+6. Confirm to the user what was captured.
+
+$ARGUMENTS

package/opencode/commands/memory-init.md

@@ -0,0 +1,81 @@
+---
+description: Bootstrap the agent's memory system. Creates MEMORY.md, directory structure, learns about the user, and scans the workspace.
+agent: kortix-main
+---
+
+# Memory Initialization
+
+You are bootstrapping your persistent memory. Follow these steps.
+
+## Step 1: Create directory structure
+
+Ensure all memory directories exist:
+```bash
+mkdir -p /workspace/.kortix/memory /workspace/.kortix/journal /workspace/.kortix/knowledge /workspace/.kortix/sessions
+```
+
+## Step 2: Create MEMORY.md
+
+If `workspace/.kortix/MEMORY.md` doesn't exist or is a default template, create it:
+
+```markdown
+# Memory
+
+## Identity
+Kortix — autonomous AI agent with persistent memory, full Linux access, and internet connectivity.
+[Check env for AGENT_EMAIL_ADDRESS, available tools and skills]
+
+## User
+Not yet known. Introduce yourself so I can remember you.
+
+## Project
+Not yet scanned. Scanning workspace...
+
+## Scratchpad
+Memory system initialized. Ready for tasks.
+```
+
+## Step 3: Populate Identity
+
+Read your environment to build the Identity section:
+- Check `env` for your email credentials (AGENT_EMAIL_ADDRESS)
+- Check what tools and skills are available
+- Write the Identity section of MEMORY.md
+
+## Step 4: Learn about the user
+
+Talk to the user:
+- Ask their name
+- Ask their role / what they do
+- Ask how they prefer to work with you (hands-off? collaborative? detailed reporting?)
+- Ask about any immediate projects or priorities
+
+Write everything to the User section of MEMORY.md.
+
+## Step 5: Scan the workspace
+
+Explore the current workspace and populate the Project section:
+- Directory structure, project manifests, git history
+- Tech stack, key dependencies, build/test commands
+- Architecture patterns, CI configs
+
+## Step 6: Initialize daily log
+
+Write today's first entry to `workspace/.kortix/memory/YYYY-MM-DD.md`:
+
+```markdown
+# YYYY-MM-DD
+
+## HH:MM — Memory system initialized
+- Created MEMORY.md with Identity, User, Project, Scratchpad sections
+- [Summary of what was learned about user and workspace]
+```
+
+## Step 7: Verify memory system
+
+- Confirm MEMORY.md exists and has real content
+- Confirm memory plugin is loading it (it should appear in your system prompt)
+- Test `memory_search` tool: `memory_search(query: "user preferences")`
+- Tell the user what you learned and that memory is active
+
+$ARGUMENTS

package/opencode/commands/memory-search.md

@@ -0,0 +1,50 @@
+---
+description: Search across all memory files for a keyword or topic.
+agent: kortix-main
+---
+
+# Memory Search
+
+Search the entire memory system for relevant information using the native `memory_search` tool.
+
+## Search strategy
+
+Use the `memory_search` tool for structured hybrid search (semantic + keyword):
+
+```
+memory_search(query: "$ARGUMENTS", scope: "all")
+```
+
+This runs BOTH LSS (BM25 + embeddings) and grep in parallel, merges and deduplicates results.
+
+### If you need broader search
+
+Also search Desktop files if memory results are insufficient:
+
+```bash
+lss "$ARGUMENTS" -p /workspace --json -k 10
+```
+
+## Output
+
+For each match, show:
+- Source file (relative path under .kortix/)
+- The matching content or snippet
+- Relevance score (for semantic results)
+- Source type (semantic vs keyword)
+
+Group results by tier:
+1. **Core memory** — from MEMORY.md
+2. **Episodic memory** — from memory/*.md
+3. **Journal** — from journal/*.md
+4. **Knowledge** — from knowledge/*.md
+5. **Sessions** — from sessions/*.md
+
+If no results found, suggest:
+- Related terms to try
+- Whether to search Desktop files too
+- Whether to export past sessions: `python3 ~/.opencode/skills/KORTIX-memory/scripts/export-sessions.py`
+
+## Search query
+
+$ARGUMENTS

package/opencode/commands/memory-status.md

@@ -0,0 +1,56 @@
+---
+description: Show the current state of the agent's memory system including all tiers, tools, and plugin status.
+agent: kortix-main
+---
+
+# Memory Status
+
+Read and report on the full memory system at `workspace/.kortix/`.
+
+## Core Memory (Tier 1)
+
+Read `workspace/.kortix/MEMORY.md` via `memory_get(path: "MEMORY.md")` and show a summary of each section (Identity, User, Project, Scratchpad).
+
+## Episodic Memory (Tier 2)
+
+List all files in `workspace/.kortix/memory/` and show:
+- Total number of files
+- Most recent daily log date
+- One-line summary of each topic file
+
+## Journal (Tier 3)
+
+List all files in `workspace/.kortix/journal/` and show count + latest entry date.
+
+## Knowledge (Tier 4)
+
+List all files in `workspace/.kortix/knowledge/` and show count + one-line summary of each.
+
+## Session Transcripts
+
+List all files in `workspace/.kortix/sessions/` and show count.
+If empty, suggest: `python3 ~/.opencode/skills/KORTIX-memory/scripts/export-sessions.py`
+
+## Health Check
+
+Report:
+- Whether MEMORY.md exists and has real content (not default template)
+- Approximate token count of MEMORY.md (target: under ~3000 tokens)
+- Number of files per tier
+- Whether the memory plugin is active (check if MEMORY.md appears in system prompt)
+- Whether `memory_search` tool is available (test a simple query)
+- Whether LSS is running (`lss status`)
+- Any issues (empty sections, stale scratchpad, missing directories)
+
+## System Components
+
+| Component | Status | Description |
+|---|---|---|
+| Memory Plugin | Check if `plugin/memory.ts` is registered in opencode.jsonc | Auto-loads MEMORY.md + daily logs, pre-compaction flush |
+| memory_search tool | Test with a simple query | Hybrid semantic + keyword search |
+| memory_get tool | Test by reading MEMORY.md | Secure memory file reader |
+| LSS daemon | Run `lss status` | Real-time file indexing for semantic search |
+
+Present as a clean, concise summary.
+
+$ARGUMENTS

package/opencode/commands/research.md

@@ -0,0 +1,36 @@
+---
+description: Kick off a deep research task on any topic. Delegates to the research subagent.
+agent: kortix-main
+---
+
+# Deep Research
+
+The user wants deep, comprehensive research on a topic. This is Tier 3 -- a full investigation with cited sources and a structured report. For quick lookups or moderate exploration, handle it yourself (see Web Information Needs tiers).
+
+Delegate this to `@kortix-research`.
+
+## Before delegating
+
+1. Check `workspace/.kortix/memory/` and `research/` — has this topic been researched before? If so, read the existing report and ask the user if they want a fresh investigation or an update.
+
+2. Check `workspace/.kortix/MEMORY.md` User section — are there any preferences about research format, depth, or style?
+
+## Delegation prompt
+
+Send `@kortix-research` a detailed, self-contained prompt that includes:
+- The research topic/question from the user
+- Any existing knowledge you found (summarized)
+- User preferences if relevant
+- Instruction to create a research working directory at `research/{topic-slug}/`
+- Instruction to save the final report to `workspace/.kortix/memory/research-{topic-slug}.md`
+- Instruction to load the `kortix-deep-research` skill first
+
+## After research completes
+
+1. Read the report from `research/{topic-slug}/report.md`
+2. Present a concise summary to the user with the full report path
+3. Update MEMORY.md Scratchpad to note research was completed
+
+## Research topic
+
+$ARGUMENTS

package/opencode/commands/search.md

@@ -0,0 +1,38 @@
+---
+description: Semantic search across all files and memory.
+agent: kortix-main
+---
+
+# Semantic Search
+
+Search everything semantically using lss (BM25 + OpenAI embeddings).
+
+## Strategy
+
+Run searches across all indexed sources in parallel:
+
+```bash
+# Search Desktop files (projects, documents, etc.)
+lss "$ARGUMENTS" -p /workspace --json -k 10
+
+# Search agent memory + knowledge
+lss "$ARGUMENTS" -p /workspace/.kortix/ --json -k 5
+```
+
+## Output
+
+Present results grouped by source, ranked by score:
+
+1. **Best matches** — Top results across all sources, with file path and snippet
+2. **Memory matches** — Relevant stored knowledge
+
+For each result, show:
+- File path
+- Relevance score
+- Snippet preview
+
+If results reference a specific file, offer to read it for full context.
+
+## Search query
+
+$ARGUMENTS

package/opencode/commands/slides.md

@@ -0,0 +1,32 @@
+---
+description: Create a presentation / slide deck. Delegates to the slides subagent.
+agent: kortix-main
+---
+
+# Create Presentation
+
+The user wants a slide deck. Delegate to `@kortix-slides`.
+
+## Before delegating
+
+1. Check `workspace/.kortix/MEMORY.md` User section for brand/style preferences
+2. Check `workspace/.kortix/memory/` for relevant research that could inform the content
+3. Ask the user for any details not provided: topic, audience, tone, slide count, style
+
+## Delegation prompt
+
+Send `@kortix-slides` a detailed prompt including:
+- The presentation topic and requirements
+- User style preferences from memory
+- Any relevant research content
+- Instruction to load the `kortix-presentations` skill first
+- Where to save the output
+
+## After completion
+
+1. Update MEMORY.md Scratchpad to note presentation was created
+2. Tell the user where to find the slides and how to view them (presentation viewer at port 3210)
+
+## Presentation request
+
+$ARGUMENTS

package/opencode/commands/spreadsheet.md

@@ -0,0 +1,30 @@
+---
+description: Create or edit a spreadsheet. Delegates to the sheets subagent.
+agent: kortix-main
+---
+
+# Spreadsheet
+
+The user wants to create or edit a spreadsheet. Delegate to `@kortix-sheets`.
+
+## Before delegating
+
+1. Check `workspace/.kortix/MEMORY.md` User section for formatting preferences
+2. Check `workspace/.kortix/memory/` for relevant data or research
+
+## Delegation prompt
+
+Send `@kortix-sheets` a detailed prompt including:
+- What spreadsheet to create/edit and the requirements
+- User formatting preferences from memory
+- Any relevant data sources
+- Instruction to load the `kortix-xlsx` skill first
+
+## After completion
+
+1. Update MEMORY.md Scratchpad
+2. Tell the user where the file is
+
+## Spreadsheet request
+
+$ARGUMENTS

package/opencode/memory.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "Memory configuration for Kortix agent memory system",
+  "enabled": true,
+  "basePath": "/workspace/.kortix",
+  "corePath": "MEMORY.md",
+  "memoryDir": "memory",
+  "journalDir": "journal",
+  "knowledgeDir": "knowledge",
+  "sessionsDir": "sessions",
+  "search": {
+    "maxResults": 6,
+    "minScore": 0.35,
+    "maxSnippetLength": 700,
+    "sources": ["memory", "sessions"]
+  },
+  "flush": {
+    "enabled": true,
+    "softThresholdTokens": 4000,
+    "systemPrompt": "Session is nearing context compaction. Before context is lost, write any durable memories that should persist across sessions.",
+    "prompt": "Review what you have learned in this session. Write any lasting notes, decisions, lessons, or user preferences to workspace/.kortix/memory/{date}.md. Update workspace/.kortix/MEMORY.md Scratchpad with current state and pending items. Reply with NO_REPLY if there is nothing worth remembering."
+  },
+  "inject": {
+    "coreMemory": true,
+    "dailyLogs": true,
+    "dailyLogDays": 2
+  },
+  "dailyLog": {
+    "filePattern": "YYYY-MM-DD.md",
+    "appendOnly": true
+  },
+  "sessionExport": {
+    "enabled": true,
+    "deltaMessages": 50,
+    "filterRoles": ["user", "assistant"],
+    "excludeToolCalls": true
+  }
+}

package/opencode/ocx.jsonc

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://ocx.kdco.dev/schemas/ocx.json",
+  "registries": {
+    "kdco": {
+      "url": "https://registry.kdco.dev"
+    }
+  },
+  "lockRegistries": false,
+  "skipCompatCheck": false
+}

package/opencode/opencode.jsonc

@@ -0,0 +1,103 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": "allow",
+  "plugin": ["opencode-pty", "./plugin/worktree.ts", "./plugin/memory.ts"], // ["@tarquinen/opencode-dcp@latest"],
+  "autoupdate": true,
+  "default_agent": "kortix-main",
+  // "model": "anthropic/claude-sonnet-4-20250514",
+  "provider": {
+    "kortix": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "Kortix",
+      "options": {
+        "baseURL": "{env:KORTIX_API_URL}/v1",
+        "apiKey": "{env:KORTIX_TOKEN}"
+      },
+      "models": {
+        "kortix/basic": {
+          "name": "Kortix Basic",
+          "limit": {
+            "context": 200000,
+            "output": 8192
+          }
+        },
+        "kortix/power": {
+          "name": "Kortix Power",
+          "limit": {
+            "context": 200000,
+            "output": 8192
+          }
+        },
+        "claude-sonnet-4": {
+          "name": "Claude Sonnet 4",
+          "limit": {
+            "context": 200000,
+            "output": 8192
+          }
+        },
+        "claude-3-5-sonnet": {
+          "name": "Claude 3.5 Sonnet",
+          "limit": {
+            "context": 200000,
+            "output": 8192
+          }
+        },
+        "claude-3-haiku": {
+          "name": "Claude 3 Haiku",
+          "limit": {
+            "context": 200000,
+            "output": 8192
+          }
+        },
+        "gpt-4o": {
+          "name": "GPT-4o",
+          "limit": {
+            "context": 128000,
+            "output": 16384
+          }
+        },
+        "gpt-4o-mini": {
+          "name": "GPT-4o Mini",
+          "limit": {
+            "context": 128000,
+            "output": 16384
+          }
+        },
+        "grok-2": {
+          "name": "Grok 2",
+          "limit": {
+            "context": 131072,
+            "output": 8192
+          }
+        },
+        "llama-3.3-70b": {
+          "name": "Llama 3.3 70B",
+          "limit": {
+            "context": 128000,
+            "output": 8192
+          }
+        },
+        "llama-3.1-8b": {
+          "name": "Llama 3.1 8B",
+          "limit": {
+            "context": 128000,
+            "output": 8192
+          }
+        }
+      }
+    },
+    "anthropic": {
+      "name": "Anthropic"
+    }
+  },
+  "mcp": {
+    "context7": {
+      "type": "remote",
+      "url": "https://mcp.context7.com/mcp",
+      "headers": {
+        "CONTEXT7_API_KEY": "{env:CONTEXT7_API_KEY}"
+      },
+      "enabled": true
+    }
+  }
+}

package/opencode/package.json

@@ -0,0 +1,25 @@
+{
+  "name": ".opencode",
+  "module": "index.ts",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "postinstall": "bash patches/apply.sh"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@mendable/firecrawl-js": "^4.12.0",
+    "@opencode-ai/plugin": "1.1.65",
+    "@kortix/opencode-sdk": "^0.3.0",
+    "@tavily/core": "^0.7.1",
+    "agent-browser": "^0.9.1",
+    "jsonc-parser": "^3.3.1",
+    "opencode-pty": "^0.2.1",
+    "replicate": "^1.4.0"
+  }
+}

package/opencode/patches/apply.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# Postinstall patch: applies local overrides to plugin files in node_modules.
+# Run automatically via "postinstall" in package.json after every `bun install`.
+# Each patch is a full replacement of the target file.
+
+set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+ROOT_DIR="$(dirname "$SCRIPT_DIR")"
+
+# Patch opencode-pty spawn.txt tool description (adds anti-pattern guidance)
+TARGET="$ROOT_DIR/node_modules/opencode-pty/src/plugin/pty/tools/spawn.txt"
+PATCH="$SCRIPT_DIR/opencode-pty-spawn.txt"
+
+if [ -f "$TARGET" ] && [ -f "$PATCH" ]; then
+  cp "$PATCH" "$TARGET"
+  echo "[patches] Applied opencode-pty spawn.txt patch"
+else
+  echo "[patches] Skipped opencode-pty spawn.txt patch (target or patch not found)"
+fi