{"id":45904440,"url":"https://github.com/dtormoen/tsk-tsk","last_synced_at":"2026-02-28T01:29:39.271Z","repository":{"id":300857007,"uuid":"993887001","full_name":"dtormoen/tsk-tsk","owner":"dtormoen","description":"Keeping your agents out of trouble with sandboxed coding agent automation","archived":false,"fork":false,"pushed_at":"2026-02-26T16:49:18.000Z","size":6959,"stargazers_count":140,"open_issues_count":1,"forks_count":15,"subscribers_count":3,"default_branch":"main","last_synced_at":"2026-02-26T22:52:21.363Z","etag":null,"topics":["agentic-coding","agents","ai","ai-agents","ai-agents-automation","claude-code","codex","rust","sandbox"],"latest_commit_sha":null,"homepage":"","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/dtormoen.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-05-31T18:27:41.000Z","updated_at":"2026-02-26T16:47:41.000Z","dependencies_parsed_at":"2025-07-18T07:14:57.104Z","dependency_job_id":"3e6e17d9-157f-4c22-a7da-c96c13c7c23f","html_url":"https://github.com/dtormoen/tsk-tsk","commit_stats":null,"previous_names":["dtormoen/tsk","dtormoen/tsk-tsk"],"tags_count":31,"template":false,"template_full_name":null,"purl":"pkg:github/dtormoen/tsk-tsk","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dtormoen%2Ftsk-tsk","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dtormoen%2Ftsk-tsk/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dtormoen%2Ftsk-tsk/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dtormoen%2Ftsk-tsk/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/dtormoen","download_url":"https://codeload.github.com/dtormoen/tsk-tsk/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dtormoen%2Ftsk-tsk/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":29918972,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-02-27T19:37:42.220Z","status":"ssl_error","status_checked_at":"2026-02-27T19:37:41.463Z","response_time":57,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["agentic-coding","agents","ai","ai-agents","ai-agents-automation","claude-code","codex","rust","sandbox"],"created_at":"2026-02-28T01:29:38.710Z","updated_at":"2026-02-28T01:29:39.255Z","avatar_url":"https://github.com/dtormoen.png","language":"Rust","funding_links":[],"categories":["Rust","AI Coding Agents"],"sub_categories":["Claude Code"],"readme":"# tsk-tsk: keeping your agents out of trouble\n\nDelegate 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.\n\n1. **Assign tasks** using templates that automate prompt boilerplate\n2. **`tsk` copies your repo** and builds containers with your toolchain automatically\n3. **Agents work in YOLO mode** in parallel filesystem and network isolated containers\n4. **`tsk` fetches branches** back to your repo for review\n5. **Review and merge** on your own schedule\n\nEach agent gets what it needs and nothing more:\n- Agent configuration (e.g. `~/.claude` or `~/.codex`)\n- A copy of your repo excluding gitignored files (no accidental API key sharing)\n- An isolated filesystem (no accidental `rm -rf .git`)\n- A configurable domain allowlist (Agents can't share your code on MoltBook)\n\nEach 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.\n\nSupports Claude Code and Codex coding agents. Docker and Podman container runtimes.\n\n![tsk demo](./docs/images/tsk-demo.gif)\n\n## Installation\n\n### Requirements\n\n- [Rust](https://rustup.rs/) - Rust toolchain and Cargo\n- [Docker](https://docs.docker.com/get-docker/) or [Podman](https://podman.io/) - Container runtime\n- [Git](https://git-scm.com/downloads) - Version control system\n- One of the supported coding agents:\n  - [Claude Code](https://docs.anthropic.com/en/docs/claude-code)\n  - [Codex](https://openai.com/codex/)\n  - Help us support more!\n\n### Install `tsk`\n\n```bash\n# Install using cargo\ncargo install tsk-ai\n# Or build from source!\ngh repo clone dtormoen/tsk-tsk\ncd tsk-tsk\ncargo install --path .\n```\n\n**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`:\n\n```bash\n/plugin marketplace add dtormoen/tsk-tsk\n/plugin install tsk-help@dtormoen/tsk-tsk\n/plugin install tsk-config@dtormoen/tsk-tsk\n/plugin install tsk-add@dtormoen/tsk-tsk\n```\n\nSee [Claude Code Skills Marketplace](#claude-code-skills-marketplace) for more details.\n\n## Quick Start Guide\n\n`tsk` can be used in multiple ways. Here are some of the main workflows to get started. Try testing these in the `tsk` repository!\n\n### Interactive Sandboxes\n\nStart 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`.\n\n```bash\ntsk shell\n```\n\nThe `tsk shell` command will:\n- Make a copy of your repo\n- Create a new git branch for you to work on\n- Start a proxy to limit internet access\n- Build and start a container with your stack (go, python, rust, etc.) and agent (default: claude) installed\n- Drop you into an interactive shell\n\nAfter 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.\n\nThis 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.\n\n### One-off Fully Autonomous Agent Sandboxes\n\n`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:\n\n```bash\ntsk run --type feat --name greeting --prompt \"Add a greeting to all tsk commands.\"\n```\n\nSome important parts of the command:\n- `--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.\n- `--name` will be used in the final git branch to help you remember what task the branch contains.\n- `--prompt` is used to fill in the `{{PROMPT}}` placeholder in [feat.md](./templates/feat.md).\n\nSimilar 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.\n\nAfter you try this command out, try out these next steps:\n- Add the `--edit` flag to edit the full prompt that is sent to the agent.\n- Add a custom task type. Use `tsk template list` to see existing task templates and where you can add your own custom tasks.\n  - See the [custom templates used by `tsk`](./.tsk/templates) for inspiration.\n\n### Queuing Tasks for Parallel Execution\n\nThe `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:\n\n```bash\ntsk server start --workers 4\n```\n\nNow, in another terminal window, we can quickly queue up multiple tasks:\n\n```bash\n# Add a task. Notice the similarity to the `tsk run` command\ntsk add --type doc --name tsk-architecture --prompt \"Tell me how tsk works\"\n\n# Look at the task queue. Your task `tsk-architecture` should be present in the list\ntsk list\n\n# Add another task. Notice the short flag names\ntsk add -t feat -n greeting -p \"Add a silly robot greeting to every tsk command\"\n\n# Now there should be two running tasks\ntsk list\n\n# Wait for the tasks to finish. After they complete, look at the two new branches\ngit branch --format=\"%(refname:short) - %(subject) (%(committerdate:relative))\"\n```\n\nAfter you try this command out, try these next steps:\n- Add tasks from multiple repositories in parallel\n- Start up multiple agents at once\n  - Adding `--agent codex` will use `codex` to perform the task\n  - 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\n  - Adding `--agent claude,claude` will have `claude` do the task twice. This can be useful for exploratory changes to get ideas quickly\n\n### Task Chaining\n\nChain tasks together with `--parent` so a child task starts from where its parent left off:\n\n```bash\n# First task: set up the foundation\ntsk add -t feat -n add-api -p \"Add a REST API endpoint for users\"\n\n# Check the task list to get the task ID\ntsk list\n\n# Second task: chain it to the first (replace \u003ctaskid\u003e with the parent's ID)\ntsk add -t feat -n add-tests -p \"Add integration tests for the users API\" --parent \u003ctaskid\u003e\n```\n\nChild 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.\n\n### Create a Simple Task Template\n\nLet's create a very basic way to automate working on GitHub issues:\n\n```bash\n# First create the tsk template configuration directory\nmkdir -p ~/.config/tsk/templates\n\n# Create a very simple template. Notice the use of the \"{{PROMPT}}\" placeholder\ncat \u003e ~/.config/tsk/templates/issue-bot.md \u003c\u003c 'EOF'\nSolve the GitHub issue below. Make sure it is tested and write a descriptive commit\nmessage describing the changes after you are done.\n\n{{PROMPT}}\nEOF\n\n# Make sure tsk sees the new `issue-bot` task template\ntsk template list\n\n# Pipe in some input to start the task\n# Piped input automatically replaces the {{PROMPT}} placeholder\ngh issue view \u003cissue-number\u003e | tsk add -t issue-bot -n fix-my-issue\n```\n\nNow it's easy to solve GitHub issues with a simple task template. Try this with code reviews as well to easily respond to feedback.\n\n## Commands\n\n### Task Commands\n\nCreate, manage, and monitor tasks assigned to AI agents.\n\n- `tsk run` - Execute a task immediately (Ctrl+C marks task as CANCELLED)\n- `tsk shell` - Start a sandbox container with an interactive shell\n- `tsk add` - Queue a task (supports `--parent \u003ctaskid\u003e` for task chaining)\n- `tsk list` - View task status and branches\n- `tsk cancel \u003ctask-id\u003e...` - Cancel one or more running or queued tasks\n- `tsk clean` - Clean up completed tasks\n- `tsk delete \u003ctask-id\u003e...` - Delete one or more tasks\n- `tsk retry \u003ctask-id\u003e...` - Retry one or more tasks\n\n### Server Commands\n\nManage the `tsk` server daemon for parallel task execution. The server automatically cleans up completed, failed, and cancelled tasks older than 7 days.\n\n- `tsk server start` - Start the `tsk` server daemon\n- `tsk server stop` - Stop the running `tsk` server\n\nGraceful shutdown (via `q`, Ctrl+C, or `tsk server stop`) marks any in-progress tasks as CANCELLED.\n\nWhen 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.\n\n**TUI Controls:**\n- `Left` / `h`: Focus the task list panel\n- `Right` / `l`: Focus the log viewer panel\n- `Up` / `k`, `Down` / `j`: Navigate tasks or scroll logs (depends on focused panel)\n- `Page Up` / `Page Down`: Jump scroll in log viewer\n- Click: Select a task or focus a panel\n- Mouse scroll: scroll tasks or logs\n- Scrollbar click/drag: Jump or scrub through the task list\n- `Shift+click` / `Shift+drag`: Select text (bypasses mouse capture for clipboard use)\n- `c`: Cancel the selected task (when task panel is focused, only RUNNING/QUEUED tasks)\n- `d`: Delete the selected task (when task panel is focused, only terminal-state tasks)\n- `q`: Quit the server (graceful shutdown)\n\n### Configuration Commands\n\nBuild container images and manage task templates.\n\n- `tsk docker build` - Build required container images\n- `tsk template list` - View available task type templates and where they are installed\n- `tsk template show \u003ctemplate\u003e` - Display the contents of a template\n- `tsk template edit \u003ctemplate\u003e` - Open a template in your editor for customization\n\nRun `tsk help` or `tsk help \u003ccommand\u003e` for detailed options.\n\n## Configuring `tsk`\n\n`tsk` has 3 levels of configuration in priority order:\n- Project level in the `.tsk` folder local to your project\n- User level in `~/.config/tsk`\n- Built-in configurations\n\nEach configuration directory can contain:\n- `templates`: A folder of task template markdown files which can be used via the `-t/--type` flag\n\n### Configuration File\n\n`tsk` can be configured at two levels:\n\n1. **User-level**: `~/.config/tsk/tsk.toml` — global settings, defaults, and per-project overrides\n2. **Project-level**: `.tsk/tsk.toml` in your project root — shared project defaults (checked into version control)\n\nBoth levels use the same shared config shape. The project-level config only contains shared settings (no `container_engine`, `[server]`, or `[project.\u003cname\u003e]` sections).\n\n**User-level config** (`~/.config/tsk/tsk.toml`):\n\n```toml\n# Container engine (top-level setting, user-only)\ncontainer_engine = \"docker\"  # \"docker\" (default) or \"podman\"\n\n# Server daemon configuration (user-only)\n[server]\nauto_clean_enabled = true   # Automatically clean old tasks (default: true)\nauto_clean_age_days = 7.0   # Minimum age in days before cleanup (default: 7.0)\n\n# Default settings for all projects (showing built-in defaults)\n[defaults]\nagent = \"claude\"             # AI agent: \"claude\" or \"codex\"\nstack = \"default\"            # Tech stack (auto-detected from project files)\nmemory_gb = 12.0             # Container memory limit in GB\ncpu = 8                      # Number of CPUs\ndind = false                 # Enable Docker-in-Docker support\ngit_town = false             # Enable git-town parent branch tracking\n\n# Project-specific overrides (matches directory name)\n[project.my-go-service]\nstack = \"go\"\nmemory_gb = 24.0\ncpu = 16\nsetup = '''\nUSER root\nRUN apt-get update \u0026\u0026 apt-get install -y libssl-dev pkg-config\nUSER agent\n'''\nhost_ports = [5432, 6379]    # Forward host ports to containers\nvolumes = [\n    # Bind mount: share host directories with containers (supports ~ expansion)\n    { host = \"~/.cache/go-mod\", container = \"/go/pkg/mod\" },\n    # Named volume: container-managed persistent storage (prefixed with tsk-)\n    { name = \"go-build-cache\", container = \"/home/agent/.cache/go-build\" },\n    # Read-only mount: provide artifacts without modification risk\n    { host = \"~/debug-logs\", container = \"/debug-logs\", readonly = true }\n]\nenv = [\n    { name = \"DB_PORT\", value = \"5432\" },\n    { name = \"REDIS_PORT\", value = \"6379\" },\n]\n```\n\n**Project-level config** (`.tsk/tsk.toml` in project root):\n\n```toml\n# Project defaults shared via version control\nstack = \"rust\"\nmemory_gb = 16.0\nhost_ports = [5432]\nsetup = '''\nUSER root\nRUN apt-get update \u0026\u0026 apt-get install -y cmake\nUSER agent\n'''\n\n[stack_config.rust]\nsetup = '''\nRUN cargo install cargo-nextest\n'''\n```\n\nThe `setup` field injects Dockerfile commands at the project layer position in the Docker image build. Use it for project-specific build dependencies. `stack_config.\u003cname\u003e.setup` and `agent_config.\u003cname\u003e.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.\n\nVolume mounts are particularly useful for:\n- **Build caches**: Share Go module cache (`/go/pkg/mod`) or Rust target directories to speed up builds\n- **Persistent state**: Use named volumes for build caches that persist across tasks\n- **Read-only artifacts**: Mount debugging artifacts, config files, or other resources without risk of modification\n\nEnvironment 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.\n\nThe container engine can also be set per-command with the `--container-engine` flag (available on `run`, `shell`, `retry`, `cancel`, `server start`, and `docker build`).\n\nHost ports (`host_ports`) expose host services to task containers. Agents connect to `$TSK_PROXY_HOST:\u003cport\u003e` 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.\n\nWhen `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.\n\nConfiguration priority: CLI flags \u003e user `[project.\u003cname\u003e]` \u003e project `.tsk/tsk.toml` \u003e user `[defaults]` \u003e auto-detection \u003e built-in defaults\n\nSettings in `[defaults]`, `[project.\u003cname\u003e]`, 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.\n\n### Customizing the `tsk` Sandbox Environment\n\nEach `tsk` sandbox container image has 4 main parts:\n- A [base dockerfile](./dockerfiles/base/default.dockerfile) that includes the OS and a set of basic development tools e.g. `git`\n- A `stack` snippet that defines language specific build steps. See:\n  - [default](./dockerfiles/stack/default.dockerfile) - minimal fallback stack\n  - [go](./dockerfiles/stack/go.dockerfile)\n  - [java](./dockerfiles/stack/java.dockerfile)\n  - [lua](./dockerfiles/stack/lua.dockerfile)\n  - [node](./dockerfiles/stack/node.dockerfile)\n  - [python](./dockerfiles/stack/python.dockerfile)\n  - [rust](./dockerfiles/stack/rust.dockerfile)\n- An `agent` snippet that installs an agent, e.g. `claude` or `codex`.\n- 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.\n\nIt 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).\n\nSee [dockerfiles](./dockerfiles) for the built-in dockerfiles.\n\nYou can run `tsk docker build --dry-run` to see the dockerfile that `tsk` will dynamically generate for your repository.\n\nSee 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.\n\nI'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!\n\n### Creating Templates\n\nTemplates 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 \u003cpath\u003e` to read from a file. The legacy `{{DESCRIPTION}}` placeholder is still supported but deprecated.\n\nTo inspect an existing template, run `tsk template show \u003ctemplate\u003e`. To customize a built-in template, run `tsk template edit \u003ctemplate\u003e` — `tsk` will copy it to `~/.config/tsk/templates/` and open it in your `$EDITOR`.\n\nTo 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.\n\n### Custom Proxy Configuration\n\n`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.\n\n**Inline configuration** in tsk.toml (recommended):\n```toml\n[defaults]\nsquid_conf = '''\nhttp_port 3128\nacl allowed_domains dstdomain .example.com .myapi.dev\nhttp_access allow allowed_domains\nhttp_access deny all\n'''\n```\n\n**File-based configuration** (path reference):\n```toml\n[defaults]\nsquid_conf_path = \"~/.config/tsk/squid.conf\"\n\n# Or in project-level .tsk/tsk.toml (path relative to project root):\n# squid_conf_path = \".tsk/squid.conf\"\n```\n\nInline `squid_conf` takes priority over `squid_conf_path`. See the default [`tsk` squid.conf](./dockerfiles/tsk-proxy/squid.conf) as a starting point.\n\n**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.\n\n## `tsk` Data Directory\n\n`tsk` uses the following directories for storing data while running tasks:\n- **~/.local/share/tsk/tasks.db**: SQLite database for task queue and task definitions\n- **~/.local/share/tsk/tasks/**: Task directories that get mounted into sandboxes when the agent runs. They contain:\n  - **\u003ctaskid\u003e/repo**: The repo copy that the agent operates on\n  - **\u003ctaskid\u003e/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\n  - **\u003ctaskid\u003e/instructions.md**: The instructions that were passed to an agent\n\nThese 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:\n- `TSK_DATA_HOME` - overrides `XDG_DATA_HOME` for `tsk` (default: `~/.local/share`)\n- `TSK_RUNTIME_DIR` - overrides `XDG_RUNTIME_DIR` for `tsk` (default: `/tmp`)\n- `TSK_CONFIG_HOME` - overrides `XDG_CONFIG_HOME` for `tsk` (default: `~/.config`)\n\n## Claude Code Skills Marketplace\n\nThis repository includes a Claude Code skills marketplace with `tsk`-specific skills that teach Claude how to use `tsk` commands. To install:\n\n```bash\n# Add the marketplace in Claude Code\n/plugin marketplace add dtormoen/tsk-tsk\n\n# Install a skill (e.g. tsk-help, tsk-config, tsk-add)\n/plugin install tsk-help@dtormoen/tsk-tsk\n```\n\nSkills 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.\n\n## Contributing\n\nThis project uses:\n- `cargo test` for running tests\n- `just precommit` for full CI checks\n- `just integration-test` for stack layer integration tests (requires Docker/Podman)\n- See [CLAUDE.md](CLAUDE.md) for development guidelines\n\n## License\n\nMIT License - see [LICENSE](LICENSE) file for details.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdtormoen%2Ftsk-tsk","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fdtormoen%2Ftsk-tsk","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdtormoen%2Ftsk-tsk/lists"}