Skip to content
Back to search

tsk

MarketplaceWorks with Claude CodeGitHub

Keeping your agents out of trouble with sandboxed coding agent automation

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/dtormoen--tsk-tsk/badge.svg)](/listings/dtormoen--tsk-tsk)

HTML

<a href="/listings/dtormoen--tsk-tsk"><img src="/api/listings/dtormoen--tsk-tsk/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Requirements

- [Rust](https://rustup.rs/) - Rust toolchain and Cargo - [Docker](https://docs.docker.com/get-docker/) or [Podman](https://podman.io/) - Container runtime - [Git](https://git-scm.com/downloads) - Version control system - One of the supported coding agents: - [Claude Code](https://docs.anthropic.com/en/docs/claude-code) - [Codex](https://openai.com/codex/) - Help us support more!

Install `tsk`

# Install using cargo
cargo install tsk-ai
# Or build from source!
gh repo clone dtormoen/tsk-tsk
cd tsk-tsk
cargo install --path .

**Claude Code users:** Install `tsk` skills to teach Claude how to use `tsk` commands directly in your conversations and help you configure your projects for use with `tsk`:

/plugin marketplace add dtormoen/tsk-tsk
/plugin install tsk-help@dtormoen/tsk-tsk
/plugin install tsk-config@dtormoen/tsk-tsk
/plugin install tsk-add@dtormoen/tsk-tsk

See [Claude Code Skills Marketplace](#claude-code-skills-marketplace) for more details.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 26 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "tsk",
  3. "owner": {
  4. "name": "tsk-tsk contributors"
  5. },
  6. "metadata": {
  7. "description": "Claude Code skills for tsk-tsk: sandboxed AI agent task delegation"
  8. },
  9. "plugins": [
  10. {
  11. "name": "tsk-help",
  12. "description": "Teaches Claude core tsk commands for delegating tasks to AI agents in sandboxed containers.",
  13. "source": "./skills/tsk-help"
  14. },
  15. {
  16. "name": "tsk-config",
  17. "description": "Guides users through configuring tsk Docker container images for their project.",
  18. "source": "./skills/tsk-config"
  19. },
  20. {
  21. "name": "tsk-add",
  22. "description": "Helps queue a development task from the current conversation using tsk add.",
  23. "source": "./skills/tsk-add"
  24. }
  25. ]
  26. }
README.md · README · 438 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # tsk-tsk: keeping your agents out of trouble
  2. Delegate development `tsk` tasks to YOLO mode AI agents running in sandbox containers. `tsk` auto-detects your toolchain and builds container images for you, so most projects require very little setup. Agents work asynchronously and in parallel so you can review their work on your own schedule, respecting your time and attention.
  3. 1. **Assign tasks** using templates that automate prompt boilerplate
  4. 2. **`tsk` copies your repo** and builds containers with your toolchain automatically
  5. 3. **Agents work in YOLO mode** in parallel filesystem and network isolated containers
  6. 4. **`tsk` fetches branches** back to your repo for review
  7. 5. **Review and merge** on your own schedule
  8. Each agent gets what it needs and nothing more:
  9. - Agent configuration (e.g. `~/.claude` or `~/.codex`)
  10. - A copy of your repo excluding gitignored files (no accidental API key sharing)
  11. - An isolated filesystem (no accidental `rm -rf .git`)
  12. - A configurable domain allowlist (Agents can't share your code on MoltBook)
  13. Each agent runs in an isolated network where all traffic routes through a proxy sidecar, enforcing the domain allowlist. Beyond network restrictions, agents have full control within their container.
  14. Supports Claude Code and Codex coding agents. Docker and Podman container runtimes.
  15. ![tsk demo](./docs/images/tsk-demo.gif)
  16. ## Installation
  17. ### Requirements
  18. - [Rust](https://rustup.rs/) - Rust toolchain and Cargo
  19. - [Docker](https://docs.docker.com/get-docker/) or [Podman](https://podman.io/) - Container runtime
  20. - [Git](https://git-scm.com/downloads) - Version control system
  21. - One of the supported coding agents:
  22. - [Claude Code](https://docs.anthropic.com/en/docs/claude-code)
  23. - [Codex](https://openai.com/codex/)
  24. - Help us support more!
  25. ### Install `tsk`
  26. ```bash
  27. # Install using cargo
  28. cargo install tsk-ai
  29. # Or build from source!
  30. gh repo clone dtormoen/tsk-tsk
  31. cd tsk-tsk
  32. cargo install --path .
  33. ```
  34. **Claude Code users:** Install `tsk` skills to teach Claude how to use `tsk` commands directly in your conversations and help you configure your projects for use with `tsk`:
  35. ```bash
  36. /plugin marketplace add dtormoen/tsk-tsk
  37. /plugin install tsk-help@dtormoen/tsk-tsk
  38. /plugin install tsk-config@dtormoen/tsk-tsk
  39. /plugin install tsk-add@dtormoen/tsk-tsk
  40. ```
  41. See [Claude Code Skills Marketplace](#claude-code-skills-marketplace) for more details.
  42. ## Quick Start Guide
  43. `tsk` can be used in multiple ways. Here are some of the main workflows to get started. Try testing these in the `tsk` repository!
  44. ### Interactive Sandboxes
  45. Start up sandbox with an interactive shell so you can work interactively with a coding agent. This is similar to a git worktrees workflow, but provides stronger isolation. `claude` is the default coding agent, but you can also specify `--agent codex` to use `codex`.
  46. ```bash
  47. tsk shell
  48. ```
  49. The `tsk shell` command will:
  50. - Make a copy of your repo
  51. - Create a new git branch for you to work on
  52. - Start a proxy to limit internet access
  53. - Build and start a container with your stack (go, python, rust, etc.) and agent (default: claude) installed
  54. - Drop you into an interactive shell
  55. After you exit the interactive shell (ctrl-d or `exit`), `tsk` will save any work you've done as a new branch in your original repo.
  56. This workflow is really powerful when used with terminal multiplexers like `tmux` or `zellij`. It allows you to start multiple agents that are working on completely isolated copies of your repository with no opportunity to interfere with each other or access resources outside of the container.
  57. ### One-off Fully Autonomous Agent Sandboxes
  58. `tsk` has flags that help you avoid repetitive instructions like "make sure unit tests pass", "update documentation", or "write a descriptive commit message". Consider this command which immediately kicks off an autonomous agent in a sandbox to implement a new feature:
  59. ```bash
  60. tsk run --type feat --name greeting --prompt "Add a greeting to all tsk commands."
  61. ```
  62. Some important parts of the command:
  63. - `--type` specifies the type of task the agent is working on. Using `tsk` built-in tasks or writing your own can save a lot of boilerplate. Check out [feat.md](./templates/feat.md) for the `feat` type and [templates](./templates) for all task types.
  64. - `--name` will be used in the final git branch to help you remember what task the branch contains.
  65. - `--prompt` is used to fill in the `{{PROMPT}}` placeholder in [feat.md](./templates/feat.md).
  66. Similar to `tsk shell`, the agent will run in a sandbox so it will not interfere with any ongoing work and will create a new branch in your repository in the background once it is done working.
  67. Add `--branch main` to start from a specific branch's committed state instead of your current working tree. This is useful when you want to launch a task from a different branch without switching to it.
  68. After you try this command out, try out these next steps:
  69. - Add the `--edit` flag to edit the full prompt that is sent to the agent.
  70. - Add a custom task type. Use `tsk template list` to see existing task templates and where you can add your own custom tasks.
  71. - See the [custom templates used by `tsk`](./.tsk/templates) for inspiration.
  72. ### Queuing Tasks for Parallel Execution
  73. The `tsk` server allows you to have a single process that manages parallel task execution so you can easily background agents working. First, we start the server set up to handle up to 4 tasks in parallel:
  74. ```bash
  75. tsk server start --workers 4
  76. ```
  77. Now, in another terminal window, we can quickly queue up multiple tasks:
  78. ```bash
  79. # Add a task. Notice the similarity to the `tsk run` command
  80. tsk add --type doc --name tsk-architecture --prompt "Tell me how tsk works"
  81. # Look at the task queue. Your task `tsk-architecture` should be present in the list
  82. tsk list
  83. # Add another task. Notice the short flag names
  84. tsk add -t feat -n greeting -p "Add a silly robot greeting to every tsk command"
  85. # Now there should be two running tasks
  86. tsk list
  87. # Wait for a specific task to finish (blocks until complete)
  88. tsk wait <taskid>
  89. # Or look at all the branches after tasks complete
  90. git branch --format="%(refname:short) - %(subject) (%(committerdate:relative))"
  91. ```
  92. After you try this command out, try these next steps:
  93. - Use `tsk add --wait` to queue a task and block until it completes (useful in scripts and CI)
  94. - Add tasks from multiple repositories in parallel
  95. - Start up multiple agents at once
  96. - Adding `--agent codex` will use `codex` to perform the task
  97. - Adding `--agent codex,claude` will have `codex` and `claude` do the task in parallel with the same environment and instructions so you can compare agent performance
  98. - Adding `--agent claude,claude` will have `claude` do the task twice. This can be useful for exploratory changes to get ideas quickly
  99. ### Task Chaining
  100. Chain tasks together with `--parent` so a child task starts from where its parent left off:
  101. ```bash
  102. # First task: set up the foundation
  103. tsk add -t feat -n add-api -p "Add a REST API endpoint for users"
  104. # Check the task list to get the task ID
  105. tsk list
  106. # Second task: chain it to the first (replace <taskid> with the parent's ID)
  107. tsk add -t feat -n add-tests -p "Add integration tests for the users API" --parent <taskid>
  108. ```
  109. Child tasks wait for their parent to complete, then start from the parent's final commit. `tsk list` shows these tasks as `WAITING`. If a parent fails, its children are automatically marked as `FAILED`; if a parent is cancelled, its children are marked as `CANCELLED`. Chains of any length (A → B → C) are supported.
  110. ### Create a Simple Task Template
  111. Let's create a very basic way to automate working on GitHub issues:
  112. ```bash
  113. # First create the tsk template configuration directory
  114. mkdir -p ~/.config/tsk/templates
  115. # Create a very simple template. Notice the use of the "{{PROMPT}}" placeholder
  116. cat > ~/.config/tsk/templates/issue-bot.md << 'EOF'
  117. Solve the GitHub issue below. Make sure it is tested and write a descriptive commit
  118. message describing the changes after you are done.
  119. {{PROMPT}}
  120. EOF
  121. # Make sure tsk sees the new `issue-bot` task template
  122. tsk template list
  123. # Pipe in some input to start the task
  124. # Piped input automatically replaces the {{PROMPT}} placeholder
  125. gh issue view <issue-number> | tsk add -t issue-bot -n fix-my-issue
  126. ```
  127. Now it's easy to solve GitHub issues with a simple task template. Try this with code reviews as well to easily respond to feedback.
  128. ## Commands
  129. ### Task Commands
  130. Create, manage, and monitor tasks assigned to AI agents.
  131. - `tsk run` - Execute a task immediately (supports `--branch <branch>` to start from a specific branch's HEAD; Ctrl+C marks task as CANCELLED)
  132. - `tsk shell` - Start a sandbox container with an interactive shell (supports `--branch <branch>` to start from a specific branch's HEAD)
  133. - `tsk add` - Queue a task (supports `--parent <taskid>` for task chaining, `--wait` to block until completion, `--branch <branch>` to start from a specific branch's HEAD)
  134. - `tsk list` - View task status and branches
  135. - `tsk wait <task-id>...` - Block until one or more tasks complete (exits non-zero if any task failed, was cancelled, or is blocked by a warmup error)
  136. - `tsk cancel <task-id>...` - Cancel one or more running or queued tasks
  137. - `tsk clean` - Clean up completed tasks
  138. - `tsk delete <task-id>...` - Delete one or more tasks
  139. - `tsk retry <task-id>...` - Retry one or more tasks
  140. ### Server Commands
  141. Manage the `tsk` server daemon for parallel task execution. The server automatically cleans up completed, failed, and cancelled tasks older than 7 days.
  142. - `tsk server start` - Start the `tsk` server daemon
  143. - `tsk server stop` - Stop the running `tsk` server
  144. Graceful shutdown (via `q`, Ctrl+C, or `tsk server stop`) marks any in-progress tasks as CANCELLED.
  145. When running in an interactive terminal, `tsk server start` shows a TUI dashboard with a split-pane view: task list on the left, log viewer on the right. In the task list, active tasks (Running, Queued, Waiting) appear above completed or failed tasks. The log viewer starts at the bottom of the selected task's output and auto-follows new content. Scrolling up pauses follow mode; scrolling back to the bottom resumes it. When stdout is piped or non-interactive (e.g. `tsk server start | cat`), plain text output is used instead.
  146. **TUI Controls:**
  147. - `Left` / `h`: Focus the task list panel
  148. - `Right` / `l`: Focus the log viewer panel
  149. - `Up` / `k`, `Down` / `j`: Navigate tasks or scroll logs (depends on focused panel)
  150. - `Page Up` / `Page Down`: Jump scroll in log viewer
  151. - Click: Select a task or focus a panel
  152. - Mouse scroll: scroll tasks or logs
  153. - Scrollbar click/drag: Jump or scrub through the task list
  154. - `Shift+click` / `Shift+drag`: Select text (bypasses mouse capture for clipboard use)
  155. - `c`: Cancel the selected task (when task panel is focused, only RUNNING/QUEUED tasks)
  156. - `d`: Delete the selected task (when task panel is focused, only terminal-state tasks)
  157. - `q`: Quit the server (graceful shutdown)
  158. ### Configuration Commands
  159. Build container images and manage task templates.
  160. - `tsk docker build` - Build required container images
  161. - `tsk template list` - View available task type templates and where they are installed
  162. - `tsk template show <template>` - Display the contents of a template
  163. - `tsk template edit <template>` - Open a template in your editor for customization
  164. Run `tsk help` or `tsk help <command>` for detailed options.
  165. ## Configuring `tsk`
  166. `tsk` has 3 levels of configuration in priority order:
  167. - Project level in the `.tsk` folder local to your project
  168. - User level in `~/.config/tsk`
  169. - Built-in configurations
  170. Each configuration directory can contain:
  171. - `templates`: A folder of task template markdown files which can be used via the `-t/--type` flag
  172. ### Configuration File
  173. `tsk` can be configured at two levels:
  174. 1. **User-level**: `~/.config/tsk/tsk.toml` — global settings, defaults, and per-project overrides
  175. 2. **Project-level**: `.tsk/tsk.toml` in your project root — shared project defaults (checked into version control)
  176. Both levels use the same shared config shape. The project-level config only contains shared settings (no `container_engine`, `[server]`, or `[project.<name>]` sections).
  177. **User-level config** (`~/.config/tsk/tsk.toml`):
  178. ```toml
  179. # Container engine (top-level setting, user-only)
  180. container_engine = "docker" # "docker" (default) or "podman"
  181. # Server daemon configuration (user-only)
  182. [server]
  183. auto_clean_enabled = true # Automatically clean old tasks (default: true)
  184. auto_clean_age_days = 7.0 # Minimum age in days before cleanup (default: 7.0)
  185. # Default settings for all projects (showing built-in defaults)
  186. [defaults]
  187. agent = "claude" # AI agent: "claude" or "codex"
  188. stack = "default" # Tech stack (auto-detected from project files)
  189. memory_gb = 12.0 # Container memory limit in GB
  190. cpu = 8 # Number of CPUs
  191. dind = false # Enable Docker-in-Docker support
  192. privileged = false # Run containers in privileged mode (disables security restrictions)
  193. sudo = false # Enable passwordless sudo inside containers
  194. devices = [] # Device paths to expose (e.g., ["/dev/video0"])
  195. git_town = false # Enable git-town parent branch tracking
  196. # Project-specific overrides (matches directory name)
  197. [project.my-go-service]
  198. stack = "go"
  199. memory_gb = 24.0
  200. cpu = 16
  201. setup = '''
  202. USER root
  203. RUN apt-get update && apt-get install -y libssl-dev pkg-config
  204. USER agent
  205. '''
  206. host_ports = [5432, 6379] # Forward host ports to containers
  207. volumes = [
  208. # Bind mount: share host directories with containers (supports ~ expansion)
  209. { host = "~/.cache/go-mod", container = "/go/pkg/mod" },
  210. # Named volume: container-managed persistent storage (prefixed with tsk-)
  211. { name = "go-build-cache", container = "/home/agent/.cache/go-build" },
  212. # Read-only mount: provide artifacts without modification risk
  213. { host = "~/debug-logs", container = "/debug-logs", readonly = true }
  214. ]
  215. env = [
  216. { name = "DB_PORT", value = "5432" },
  217. { name = "REDIS_PORT", value = "6379" },
  218. ]
  219. ```
  220. **Project-level config** (`.tsk/tsk.toml` in project root):
  221. ```toml
  222. # Project defaults shared via version control
  223. stack = "rust"
  224. memory_gb = 16.0
  225. host_ports = [5432]
  226. setup = '''
  227. USER root
  228. RUN apt-get update && apt-get install -y cmake
  229. USER agent
  230. '''
  231. [stack_config.rust]
  232. setup = '''
  233. RUN cargo install cargo-nextest
  234. '''
  235. ```
  236. The `setup` field injects Dockerfile commands at the project layer position in the Docker image build. Use it for project-specific build dependencies. `stack_config.<name>.setup` and `agent_config.<name>.setup` similarly inject content at the stack and agent layer positions, and can define entirely new stacks or agents (e.g., `stack_config.scala.setup` lets you use `stack = "scala"`). Config-defined layers take priority over embedded Docker layers. Setup commands run as the `agent` user by default — use `USER root` for operations that require elevated privileges (e.g., `apt-get install`) and always switch back to `USER agent` afterwards.
  237. Volume mounts are particularly useful for:
  238. - **Build caches**: Share Go module cache (`/go/pkg/mod`) or Rust target directories to speed up builds
  239. - **Persistent state**: Use named volumes for build caches that persist across tasks
  240. - **Read-only artifacts**: Mount debugging artifacts, config files, or other resources without risk of modification
  241. Environment variables (`env`) let you pass configuration to task containers, such as database URLs or API keys. To connect to host services forwarded through the proxy, use the `TSK_PROXY_HOST` environment variable (set automatically by `tsk`) as the hostname.
  242. The container engine can also be set per-command with the `--container-engine` flag (available on `run`, `shell`, `retry`, `cancel`, `server start`, and `docker build`).
  243. Host ports (`host_ports`) expose host services to task containers. Agents connect to `$TSK_PROXY_HOST:<port>` to reach services running on your host machine (e.g., local databases or dev servers). The `TSK_PROXY_HOST` environment variable is automatically set by `tsk` to the correct proxy container hostname.
  244. When `git_town` is enabled, `tsk` integrates with [git-town](https://www.git-town.com/) by setting the parent branch metadata on task branches, allowing git-town commands like `git town sync` to work correctly with `tsk`-created branches.
  245. Configuration priority: CLI flags > user `[project.<name>]` > project `.tsk/tsk.toml` > user `[defaults]` > auto-detection > built-in defaults
  246. Settings in `[defaults]`, `[project.<name>]`, and `.tsk/tsk.toml` share the same shape. Scalars use first-set in priority order. Lists (`volumes`, `env`, `host_ports`) combine across layers, with higher-priority winning on conflicts (same container path, same env var name, same port). `stack_config`/`agent_config` maps combine all names; for the same name, higher-priority replaces the entire config.
  247. ### Customizing the `tsk` Sandbox Environment
  248. Each `tsk` sandbox container image has 4 main parts:
  249. - A [base dockerfile](./dockerfiles/base/default.dockerfile) that includes the OS and a set of basic development tools e.g. `git`, `git-lfs`
  250. - A `stack` snippet that defines language specific build steps. See:
  251. - [default](./dockerfiles/stack/default.dockerfile) - minimal fallback stack
  252. - [go](./dockerfiles/stack/go.dockerfile)
  253. - [java](./dockerfiles/stack/java.dockerfile)
  254. - [lua](./dockerfiles/stack/lua.dockerfile)
  255. - [node](./dockerfiles/stack/node.dockerfile)
  256. - [python](./dockerfiles/stack/python.dockerfile)
  257. - [rust](./dockerfiles/stack/rust.dockerfile)
  258. - An `agent` snippet that installs an agent, e.g. `claude` or `codex`.
  259. - A `project` snippet that defines project specific build steps (applied last for project-specific customizations). This does nothing by default, but can be used to add extra build steps for your project.
  260. It is very difficult to make these images general purpose enough to cover all repositories. You may need some special customization. If you use Claude Code, the `tsk-config` skill can walk you through configuring `tsk`'s Docker layers for your project (see [Claude Code Skills Marketplace](#claude-code-skills-marketplace) for installation). Otherwise, the recommended approach is to use `setup`, `stack_config`, and `agent_config` fields in your `tsk.toml` to inject custom Dockerfile commands (see [Configuration File](#configuration-file) above).
  261. See [dockerfiles](./dockerfiles) for the built-in dockerfiles.
  262. You can run `tsk docker build --dry-run` to see the dockerfile that `tsk` will dynamically generate for your repository.
  263. See the [Docker Builds Guide](docs/docker-builds.md) for a more in-depth walk through, and the [Network Isolation Guide](docs/network-isolation.md) for details on how `tsk` secures agent network access.
  264. I'm working on improving this part of `tsk` to be as seamless and easy to set up as possible, but it's still a work in progress. I welcome all feedback on how to make this easier and more intuitive!
  265. ### Creating Templates
  266. Templates are simply markdown files that get passed to agents. `tsk` additionally adds a convenience `{{PROMPT}}` placeholder that will get replaced by anything you pipe into tsk or pass in via the `-p/--prompt` flag, or by using `--prompt-file <path>` to read from a file. The legacy `{{DESCRIPTION}}` placeholder is still supported but deprecated.
  267. To inspect an existing template, run `tsk template show <template>`. To customize a built-in template, run `tsk template edit <template>` — `tsk` will copy it to `~/.config/tsk/templates/` and open it in your `$EDITOR`.
  268. To create good templates, I would recommend thinking about repetitive tasks that you need agents to do within your codebase like "make sure the unit tests pass", "write a commit message", etc. and encode those in a template file. There are many great prompting guides out there so I'll spare the details here.
  269. ### Custom Proxy Configuration
  270. `tsk` uses Squid as a forward proxy to control network access from task containers. You can customize the proxy configuration to allow access to specific services or URLs needed by your project.
  271. **Inline configuration** in tsk.toml (recommended):
  272. ```toml
  273. [defaults]
  274. squid_conf = '''
  275. http_port 3128
  276. acl allowed_domains dstdomain .example.com .myapi.dev
  277. http_access allow allowed_domains
  278. http_access deny all
  279. '''
  280. ```
  281. **File-based configuration** (path reference):
  282. ```toml
  283. [defaults]
  284. squid_conf_path = "~/.config/tsk/squid.conf"
  285. # Or in project-level .tsk/tsk.toml (path relative to project root):
  286. # squid_conf_path = ".tsk/squid.conf"
  287. ```
  288. Inline `squid_conf` takes priority over `squid_conf_path`. See the default [`tsk` squid.conf](./dockerfiles/tsk-proxy/squid.conf) as a starting point.
  289. **Per-configuration proxy instances:** Tasks with different proxy configurations (different `host_ports` or `squid_conf`) automatically get separate proxy containers. Tasks with identical proxy config share the same proxy. Proxy containers are named `tsk-proxy-{fingerprint}` where the fingerprint is derived from the proxy configuration.
  290. ## `tsk` Data Directory
  291. `tsk` uses the following directories for storing data while running tasks:
  292. - **~/.local/share/tsk/tasks.db**: SQLite database for task queue and task definitions
  293. - **~/.local/share/tsk/tasks/**: Task directories that get mounted into sandboxes when the agent runs. They contain:
  294. - **<taskid>/repo**: The repo copy that the agent operates on
  295. - **<taskid>/output**: Directory containing `agent.log` with structured JSON-lines output including infrastructure phases (image build, agent launch, saving changes, branch result) and processed agent output
  296. - **<taskid>/instructions.md**: The instructions that were passed to an agent
  297. These default paths follow XDG conventions. You can override them with `tsk`-specific environment variables without affecting other XDG-aware software. Like XDG variables, these specify the base directory; `tsk` appends `/tsk` automatically:
  298. - `TSK_DATA_HOME` - overrides `XDG_DATA_HOME` for `tsk` (default: `~/.local/share`)
  299. - `TSK_RUNTIME_DIR` - overrides `XDG_RUNTIME_DIR` for `tsk` (default: `/tmp`)
  300. - `TSK_CONFIG_HOME` - overrides `XDG_CONFIG_HOME` for `tsk` (default: `~/.config`)
  301. ## Claude Code Skills Marketplace
  302. This repository includes a Claude Code skills marketplace with `tsk`-specific skills that teach Claude how to use `tsk` commands. To install:
  303. ```bash
  304. # Add the marketplace in Claude Code
  305. /plugin marketplace add dtormoen/tsk-tsk
  306. # Install a skill (e.g. tsk-help, tsk-config, tsk-add)
  307. /plugin install tsk-help@dtormoen/tsk-tsk
  308. ```
  309. Skills follow the [Agent Skills](https://agentskills.io) open standard. See the [Skills Marketplace Guide](docs/skill-marketplace.md) for details on available skills, manual installation, and contributing new skills.
  310. ## Contributing
  311. This project uses:
  312. - `cargo test` for running tests
  313. - `just precommit` for full CI checks
  314. - `just integration-test` for stack layer integration tests (requires Docker/Podman)
  315. - See [CLAUDE.md](CLAUDE.md) for development guidelines
  316. ## License
  317. MIT License - see [LICENSE](LICENSE) file for details.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.