chore: bump Cargo.toml to 0.7.4

CHANGELOG.md

@@ -1,3 +1,82 @@
+## v0.7.4 (2026-07-02)
+
+### Feat
+
+- Pin specific usql version to sbx kit
+- recursively take ownership over the copied in coyote config for the sbx
+- explicitly specify the COYOTE_CONFIG_DIR in the sbx kit
+- --tail-logs can track log rollovers and incoporates a sleep timer to minimize idle CPU cycles
+- Added support for log rolling so log files don't just blow up over time
+
+### Fix
+
+- Added back in --kit specification for the running of the sbx
+- sbx isn't copying base files in their respective directories
+- Update deprecated sbx kit config
+- Properly chown the coyote config recursively and password file in the sbx
+
+## v0.7.3 (2026-06-24)
+
+### Fix
+
+- apply bootstrapping of functions at startup to fix edge case
+
+## v0.7.2 (2026-06-19)
+
+### Fix
+
+- usql version upgrade
+
+## v0.7.1 (2026-06-19)
+
+### Fix
+
+- sbx mixins must be passed in directories, not as files and the files must be named spec.yaml per new sbx version
+
+## v0.7.0 (2026-06-18)
+
+### Feat
+
+- added configurable cache path via the COYOTE_CACHE_PATH environment variable
+- added a memory option to .set tab completions
+- Added a diagnostic .info tools subcommand to make it easier to see what tools are enabled in all contexts
+- Added additional info outputs for enabled skills and sbx directories
+- directly execute shell commands from within the REPL
+- created mixin kit for built-in functions and MCP servers
+- Added sbx mixins for the secrets providers so users can also bootstrap those as well.
+- added support for loading sbx mixins that are dynamically discovered in the users workspace and config directory
+- Added a --fresh flag to let users create a truly bare bones sandbox without bootstrapping their config
+- initial built-in sandboxing support powered by Docker sbx
+- Added the ability to auto-bootstrap workspace memory when in git repos
+- Added explicit guardrail handling for pending agents
+- auto-append memory to memory index and don't necessarily require the LLM to remember to do it after a write
+- Added an --init-memory [global|workspace] flag to easily and quickly enable memory
+- added memory global configuration settings to the output of --info and .info
+- added .set memory REPL commands to control memory injection and applied formatting
+- Create the built-in memory management tools
+- Append the memory system prompts (readonly or r/w) to the system prompt when applicable
+- Created the --no-memory CLI flag to disable memory for this invocation
+- Added the memory configuration properties and storage to the main app config, roles, sessions, and agents.
+- initial scaffolding of a memory system
+
+### Fix
+
+- rebuild the tool scope after dynamically updating the skills_enabled value in the REPL
+- properly resolve Windows-based local vault password file locations and bootstrap them into the sandbox when possible
+- auto-translation of user-prefixed Mac and Linux paths for the vault password file when running inside a sandbox
+- don't attempt to auto complete .vault list in the REPL; that's the end of the command
+- buffer tool stdout as well as stderr so that any tools that error to stdout are captured and included in the response to the model, enabling the model to see what went wrong and to reason about how to fix it.
+- auto-bootstrapped memory was accidentally putting the MEMORY.md directly in the repo root rather than .coyote/memory/MEMORY.md
+- improved the fs_patch script description and added improved error handling to it.
+- added in forgotten require_max_tokens to the fable model
+- append memory functions to non-graph based agents on init
+- when auto_continue is disabled via the .set auto_continue false command, it should strip the todo functions from the list of functions
+- use rawPredict for non-streaming Claude requests
+
+### Refactor
+
+- Migrated the .skills command completion to use StateFlags and updated the help messages
+
 ## v0.6.0 (2026-06-05)
 
 ### Feat

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "coyote-ai"
-version = "0.6.0"
+version = "0.7.4"
 edition = "2024"
 authors = ["Alex Clarke <alex.j.tusa@gmail.com>"]
 description = "An all-in-one, batteries included LLM CLI Tool"
@@ -49,7 +49,7 @@ textwrap = "0.16.0"
 ansi_colours = "1.2.2"
 eventsource-stream = "0.2.3"
 log = "0.4.28"
-log4rs = { version = "1.4.0", features = ["file_appender"] }
+log4rs = { version = "1.4.0", features = ["file_appender", "rolling_file_appender", "compound_policy", "fixed_window_roller", "size_trigger"] }
 shell-words = "1.1.0"
 sha2 = "0.10.8"
 unicode-width = "0.2.0"

README.md

@@ -98,7 +98,7 @@ You can use the following command to run a bash script that downloads and instal
 OS (Linux/MacOS) and architecture (x86_64/arm64):
 
 ```shell
-curl -fsSL https://raw.githubusercontent.com/Dark-Alex-17/coyote/main/install_coyote.sh | bash
+curl -fsSL https://raw.githubusercontent.com/Dark-Alex-17/coyote/refs/heads/main/scripts/install_coyote.sh | bash
 ```
 
 #### Windows/Linux/MacOS (`PowerShell`)
@@ -106,7 +106,7 @@ You can use the following command to run a PowerShell script that downloads and
 for your OS (Windows/Linux/MacOS) and architecture (x86_64/arm64):
 
 ```powershell
-powershell -NoProfile -ExecutionPolicy Bypass -Command "iwr -useb https://raw.githubusercontent.com/Dark-Alex-17/coyote/main/scripts/install_coyote.ps1 | iex"
+powershell -NoProfile -ExecutionPolicy Bypass -Command "iwr -useb https://raw.githubusercontent.com/Dark-Alex-17/coyote/refs/heads/main/scripts/install_coyote.ps1 | iex"
 ```
 
 ### Manual

assets/sbx-kit/spec.yaml

@@ -5,20 +5,19 @@
 #   sbx cp $HOME/.config/coyote/ testing:/home/agent/.config/
 #   sbx cp $HOME/.coyote_password testing:/home/agent/
 #   sbx run testing --kit ./sbx-kit/
-schemaVersion: "1"
-kind: agent
+schemaVersion: '1'
+kind: sandbox
 name: coyote
 displayName: Coyote
 description: >
   An all-in-one, batteries-included LLM CLI tool featuring Shell Assistant,
   CLI & REPL mode, RAG, AI tools & agents, MCP servers, skills, and macros.
 
-agent:
-  image: "docker/sandbox-templates:shell-docker"
+sandbox:
+  image: 'docker/sandbox-templates:shell-docker'
   aiFilename: COYOTE.md
-#  persistence: persistent
   entrypoint:
-    run: ["bash", "-lc", "exec /home/agent/.cargo/bin/coyote"]
+    run: ['bash', '-lc', 'exec /home/agent/.cargo/bin/coyote']
 
 network:
   # Proxy-managed LLM providers: the proxy substitutes `proxy-managed` for
@@ -51,96 +50,96 @@ network:
   serviceAuth:
     openai:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     anthropic:
       headerName: x-api-key
-      valueFormat: "%s"
+      valueFormat: '%s'
     gemini:
       headerName: x-goog-api-key
-      valueFormat: "%s"
+      valueFormat: '%s'
     cohere:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     groq:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     openrouter:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     ai21:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     cloudflare:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     deepinfra:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     deepseek:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     mistral:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     perplexity:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     voyageai:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     xai:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     jina:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     ernie:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     hunyuan:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     minimax:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     moonshot:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     qianwen:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
     zhipuai:
       headerName: Authorization
-      valueFormat: "Bearer %s"
+      valueFormat: 'Bearer %s'
   allowedDomains:
     # Coyote release + self-update + model-registry sync
-    - "github.com:443"
-    - "api.github.com:443"
-    - "raw.githubusercontent.com:443"
-    - "objects.githubusercontent.com:443"
-    - "*.githubusercontent.com:443"
+    - 'github.com:443'
+    - 'api.github.com:443'
+    - 'raw.githubusercontent.com:443'
+    - 'objects.githubusercontent.com:443'
+    - '*.githubusercontent.com:443'
     # Coyote install paths (cargo install + uv + rustup + Python tool deps at runtime)
-    - "crates.io:443"
-    - "static.crates.io:443"
-    - "pypi.org:443"
-    - "files.pythonhosted.org:443"
-    - "astral.sh:443"
-    - "sh.rustup.rs:443"
-    - "static.rust-lang.org:443"
+    - 'crates.io:443'
+    - 'static.crates.io:443'
+    - 'pypi.org:443'
+    - 'files.pythonhosted.org:443'
+    - 'astral.sh:443'
+    - 'sh.rustup.rs:443'
+    - 'static.rust-lang.org:443'
 
     # LLM model OAuth + API endpoints
-    - "claude.ai:443"
-    - "console.anthropic.com:443"
-    - "accounts.google.com:443"
+    - 'claude.ai:443'
+    - 'console.anthropic.com:443'
+    - 'accounts.google.com:443'
     # *.googleapis.com covers oauth2 + userinfo + VertexAI regional endpoints
     # (*-aiplatform.googleapis.com). Do not narrow without re-checking VertexAI.
-    - "*.googleapis.com:443"
+    - '*.googleapis.com:443'
 
     # Bedrock and GitHub Models use signed / GitHub-PAT auth that the proxy
     # cannot rewrite. Domains are allow-listed; credentials must be injected
     # separately (see README "Extending").
-    - "*.amazonaws.com:443"
-    - "models.inference.ai.azure.com:443"
+    - '*.amazonaws.com:443'
+    - 'models.inference.ai.azure.com:443'
 
 credentials:
   sources:
@@ -211,8 +210,9 @@ credentials:
 
 environment:
   variables:
-    IS_SANDBOX: "1"
+    IS_SANDBOX: '1'
     COYOTE_LOG_LEVEL: INFO
+    COYOTE_CONFIG_DIR: /home/agent/.config/coyote
   proxyManaged:
     - OPENAI_API_KEY
     - ANTHROPIC_API_KEY
@@ -250,25 +250,26 @@ commands:
           libssl-dev \
           pandoc \
           bzip2
-      user: "1000"
+      user: '1000'
       description: Install system prerequisites (including pandoc for fetch_url_via_curl)
-    - command: "curl -LsSf https://astral.sh/uv/install.sh | sh"
-      user: "1000"
+    - command: 'curl -LsSf https://astral.sh/uv/install.sh | sh'
+      user: '1000'
       description: Install uv (required for Python-based custom tools)
     - command: |
         set -euo pipefail
-        USQL_VERSION="0.19.20"
+        USQL_VERSION=0.21.4
         ARCH=$(uname -m)
         case "$ARCH" in
           x86_64) USQL_ARCH=amd64 ;;
           aarch64) USQL_ARCH=arm64 ;;
           *) echo "Unsupported arch for usql install: $ARCH" >&2; exit 1 ;;
         esac
-        curl -sSL "https://github.com/xo/usql/releases/download/v${USQL_VERSION}/usql_static-${USQL_VERSION}-linux-${USQL_ARCH}.tar.bz2" -o /tmp/usql.tar.bz2
-        sudo tar -xjf /tmp/usql.tar.bz2 -C /usr/local/bin
-        sudo chmod +x /usr/local/bin/usql
-        rm -f /tmp/usql.tar.bz2
-      user: "1000"
+        TMPDIR=$(mktemp -d)
+        trap 'rm -rf "$TMPDIR"' EXIT
+        curl -fsSL --retry 3 "https://github.com/xo/usql/releases/download/v${USQL_VERSION}/usql_static-${USQL_VERSION}-linux-${USQL_ARCH}.tar.bz2" -o "$TMPDIR/usql.tar.bz2"
+        tar -xjf "$TMPDIR/usql.tar.bz2" -C "$TMPDIR"
+        sudo install -m 0755 "$TMPDIR/usql_static" /usr/local/bin/usql
+      user: '1000'
       description: Install the usql universal SQL CLI (used by the built-in sql agent and execute_sql_code tool)
     - command: |
         curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \
@@ -278,16 +279,21 @@ commands:
           --target x86_64-unknown-linux-musl
         . "$HOME/.cargo/env"
         cargo install --locked coyote-ai
-      user: "1000"
+      user: '1000'
       description: Install Coyote AI CLI via Rust's Cargo
 
   startup:
-    - command: ["sh", "-c", "test -f \"$HOME/.config/coyote/config.yaml\" || coyote --info >/dev/null 2>&1 || true"]
-      user: "1000"
+    - command:
+        [
+          'sh',
+          '-c',
+          'test -f "$HOME/.config/coyote/config.yaml" || coyote --info >/dev/null 2>&1 || true',
+        ]
+      user: '1000'
       background: false
       description: Bootstrap Coyote config directory on first sandbox start
 
-memory: |
+agentContext: |
   ## Sandbox environment
 
   You are running inside a Docker sandbox launched via `sbx run coyote`. The

models.yaml

@@ -377,6 +377,14 @@
           thinking:
             type: enabled
             budget_tokens: 16000
+    - name: claude-sonnet-5
+      max_input_tokens: 1000000
+      max_output_tokens: 128000
+      require_max_tokens: true
+      input_price: 3
+      output_price: 15
+      supports_vision: true
+      supports_function_calling: true
     - name: claude-sonnet-4-6
       max_input_tokens: 200000
       max_output_tokens: 8192
@@ -922,6 +930,14 @@
           thinking:
             type: enabled
             budget_tokens: 16000
+    - name: claude-sonnet-5
+      max_input_tokens: 1000000
+      max_output_tokens: 128000
+      require_max_tokens: true
+      input_price: 3
+      output_price: 15
+      supports_vision: true
+      supports_function_calling: true
     - name: claude-sonnet-4-6
       max_input_tokens: 200000
       max_output_tokens: 8192
@@ -1103,6 +1119,14 @@
             thinking:
               type: enabled
               budget_tokens: 16000
+    - name: us.anthropic.claude-sonnet-5
+      max_input_tokens: 1000000
+      max_output_tokens: 128000
+      require_max_tokens: true
+      input_price: 3
+      output_price: 15
+      supports_vision: true
+      supports_function_calling: true
     - name: us.anthropic.claude-sonnet-4-6
       max_input_tokens: 200000
       max_output_tokens: 8192
@@ -1785,6 +1809,14 @@
       output_price: 25
       supports_vision: true
       supports_function_calling: true
+    - name: anthropic/claude-sonnet-5
+      max_input_tokens: 1000000
+      max_output_tokens: 128000
+      require_max_tokens: true
+      input_price: 3
+      output_price: 15
+      supports_vision: true
+      supports_function_calling: true
     - name: anthropic/claude-sonnet-4.6
       max_input_tokens: 200000
       max_output_tokens: 8192

scripts/install_coyote.ps1

@@ -39,7 +39,7 @@ switch ([System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture) {
 
 if (-not $BinDir) {
   if ($isWin) { $BinDir = Join-Path $env:LOCALAPPDATA 'coyote\bin' }
-  else { $home = $env:HOME; if (-not $home) { $home = (Get-Item -Path ~).FullName }; $BinDir = Join-Path $home '.local/bin' }
+  else { $userHome = $env:HOME; if (-not $userHome) { $userHome = (Get-Item -Path ~).FullName }; $BinDir = Join-Path $userHome '.local/bin' }
 }
 New-Item -ItemType Directory -Force -Path $BinDir | Out-Null
 
@@ -95,13 +95,13 @@ if ($asset.name -match '\.zip$') {
   [System.IO.Compression.ZipFile]::ExtractToDirectory($archive, $extractDir)
 } elseif ($asset.name -match '\.tar\.gz$' -or $asset.name -match '\.tgz$') {
   $tar = Get-Command tar -ErrorAction SilentlyContinue
-  if ($tar) { & $tar.FullName -xzf $archive -C $extractDir }
+  if ($tar) { & $tar.Source -xzf $archive -C $extractDir }
   else { Fail "Asset is tar archive but 'tar' is not available." }
 } else {
   try { Add-Type -AssemblyName System.IO.Compression.FileSystem; [System.IO.Compression.ZipFile]::ExtractToDirectory($archive, $extractDir) }
   catch {
     $tar = Get-Command tar -ErrorAction SilentlyContinue
-    if ($tar) { & $tar.FullName -xf $archive -C $extractDir } else { Fail "Unknown archive format; neither zip nor tar workable." }
+    if ($tar) { & $tar.Source -xf $archive -C $extractDir } else { Fail "Unknown archive format; neither zip nor tar workable." }
   }
 }
 

scripts/install_coyote.sh

@@ -133,30 +133,21 @@ else
   echo "Error: unsupported OS for this installer: $OS" >&2; exit 1
 fi
 
+DL_URLS=$(grep -oE '"browser_download_url":[[:space:]]*"[^"]+"' "$JSON" \
+  | sed -E 's/.*"browser_download_url":[[:space:]]*"//; s/"$//' \
+  || true)
+
 ASSET_NAME=""; ASSET_URL=""
 for candidate in "${ASSET_CANDIDATES[@]}"; do
-  NAME=$(grep -oE '"name":\s*"[^"]+"' "$JSON" | sed 's/"name":\s*"//; s/"$//' | grep -Fx "$candidate" || true)
-  if [[ -n "$NAME" ]]; then
-    ASSET_NAME="$NAME"
-    ASSET_URL=$(awk -v pat="$NAME" '
-      BEGIN{ FS=":"; want=0 }
-      /"name"/ {
-        line=$0;
-        gsub(/^\s+|\s+$/,"",line);
-        gsub(/"name"\s*:\s*"|"/ ,"", line);
-        want = (line==pat) ? 1 : 0;
-        next
-      }
-      want==1 && /"browser_download_url"/ {
-        u=$0;
-        gsub(/^\s+|\s+$/,"",u);
-        gsub(/.*"browser_download_url"\s*:\s*"|".*/ ,"", u);
-        print u;
-        exit
-      }
-    ' "$JSON")
-    if [[ -n "$ASSET_URL" ]]; then break; fi
+  while IFS= read -r url; do
+    [[ -z "$url" ]] && continue
+    if [[ "$url" == */"$candidate" ]]; then
+      ASSET_NAME="$candidate"
+      ASSET_URL="$url"
+      break
     fi
+  done <<< "$DL_URLS"
+  [[ -n "$ASSET_URL" ]] && break
 done
 
 if [[ -z "$ASSET_URL" ]]; then

src/config/mod.rs

@@ -147,6 +147,7 @@ const SBX_KIT_DIR_NAME: &str = "sbx-kit";
 const SBX_KIT_HASH_FILE: &str = "kit.sha256";
 const SBX_MIXIN_FILE_NAME: &str = "sbx-mixin.yaml";
 const SBX_VAULT_MIXINS_DIR_NAME: &str = "sbx-vault-mixins";
+const SBX_MIXIN_KITS_DIR_NAME: &str = "sbx-mixin-kits";
 const GIT_DIR_NAME: &str = ".git";
 const GITIGNORE_FILE_NAME: &str = ".gitignore";
 const DEFAULT_VISIBLE_TOOLS: [&str; 18] = [

src/config/paths.rs

@@ -4,8 +4,8 @@ use super::{
     ENV_FILE_NAME, FUNCTIONS_BIN_DIR_NAME, FUNCTIONS_DIR_NAME, GLOBAL_TOOLS_DIR_NAME,
     GLOBAL_TOOLS_UTILS_DIR_NAME, MACROS_DIR_NAME, MCP_FILE_NAME, MEMORY_DIR_NAME,
     MEMORY_INDEX_FILE_NAME, ModelsOverride, RAGS_DIR_NAME, ROLES_DIR_NAME, SBX_KIT_DIR_NAME,
-    SBX_KIT_HASH_FILE, SBX_MIXIN_FILE_NAME, SBX_VAULT_MIXINS_DIR_NAME, SKILLS_DIR_NAME,
-    WORKSPACE_MEMORY_DIR_NAME,
+    SBX_KIT_HASH_FILE, SBX_MIXIN_FILE_NAME, SBX_MIXIN_KITS_DIR_NAME, SBX_VAULT_MIXINS_DIR_NAME,
+    SKILLS_DIR_NAME, WORKSPACE_MEMORY_DIR_NAME,
 };
 use crate::client::ProviderModels;
 use crate::utils::{get_env_name, list_file_names, normalize_env_name};
@@ -33,9 +33,15 @@ pub fn local_path(name: &str) -> PathBuf {
 }
 
 pub fn cache_path() -> PathBuf {
+    if let Ok(v) = env::var(get_env_name("cache_dir")) {
+        PathBuf::from(v)
+    } else if let Ok(v) = env::var("XDG_CACHE_HOME") {
+        PathBuf::from(v).join(env!("CARGO_CRATE_NAME"))
+    } else {
         let base_dir = dirs::cache_dir().unwrap_or_else(env::temp_dir);
         base_dir.join(env!("CARGO_CRATE_NAME"))
     }
+}
 
 pub fn sandbox_kit_override() -> Option<PathBuf> {
     env::var_os(get_env_name("sandbox_kit")).map(PathBuf::from)
@@ -148,6 +154,10 @@ pub fn sbx_vault_mixins_hash_file() -> PathBuf {
     sbx_vault_mixins_dir().join(SBX_KIT_HASH_FILE)
 }
 
+pub fn sbx_mixin_kits_dir() -> PathBuf {
+    cache_path().join(SBX_MIXIN_KITS_DIR_NAME)
+}
+
 pub fn config_file() -> PathBuf {
     match env::var(get_env_name("config_file")) {
         Ok(value) => PathBuf::from(value),

src/main.rs

@@ -39,7 +39,10 @@ use client::ClientConfig;
 use inquire::{Select, Text, set_global_render_config};
 use log::{LevelFilter, warn};
 use log4rs::append::console::ConsoleAppender;
-use log4rs::append::file::FileAppender;
+use log4rs::append::rolling_file::RollingFileAppender;
+use log4rs::append::rolling_file::policy::compound::CompoundPolicy;
+use log4rs::append::rolling_file::policy::compound::roll::fixed_window::FixedWindowRoller;
+use log4rs::append::rolling_file::policy::compound::trigger::size::SizeTrigger;
 use log4rs::config::{Appender, Logger, Root};
 use log4rs::encode::pattern::PatternEncoder;
 use oauth::OAuthProvider;
@@ -137,7 +140,10 @@ async fn main() -> Result<()> {
         )
         .await?,
     );
-    let ctx = RequestContext::bootstrap(app_state, working_mode, info_flag)?;
+    let mut ctx = RequestContext::bootstrap(app_state, working_mode, info_flag)?;
+    let app_config = Arc::clone(&ctx.app.config);
+    ctx.bootstrap_tools(&app_config, start_mcp_servers, abort_signal.clone())
+        .await?;
 
     {
         let app = &*ctx.app.config;
@@ -582,7 +588,20 @@ fn setup_logger() -> Result<Option<PathBuf>> {
         }
         Some(path) => {
             ensure_parent_exists(&path)?;
-            let file_appender = FileAppender::builder().encoder(encoder.clone()).build(path);
+
+            let archive_pattern = path
+                .with_extension("archived.{}.log")
+                .to_string_lossy()
+                .into_owned();
+            let trigger = SizeTrigger::new(10 * 1024 * 1024);
+            let roller = FixedWindowRoller::builder()
+                .build(&archive_pattern, 5)
+                .unwrap();
+            let policy = CompoundPolicy::new(Box::new(trigger), Box::new(roller));
+
+            let file_appender = RollingFileAppender::builder()
+                .encoder(encoder.clone())
+                .build(path, Box::new(policy));
 
             match file_appender {
                 Ok(appender) => {
@@ -605,7 +624,7 @@ fn setup_logger() -> Result<Option<PathBuf>> {
 fn init_file_logger(
     log_level: LevelFilter,
     log_filter: Option<String>,
-    file_appender: FileAppender,
+    file_appender: RollingFileAppender,
 ) -> log4rs::Config {
     let root_log_level = if log_filter.is_some() {
         LevelFilter::Off

src/sandbox/mixins.rs

@@ -1,13 +1,16 @@
 use std::env;
+use std::fs;
 use std::fs::{read_dir, read_to_string};
 use std::path::{Path, PathBuf};
 
 use anyhow::{Context, Result};
 use serde_yaml::Value;
+use sha2::{Digest, Sha256};
 
 use crate::config::paths;
 
 const SBX_MIXIN_FILE_NAME: &str = "sbx-mixin.yaml";
+const KIT_SPEC_FILE_NAME: &str = "spec.yaml";
 
 #[derive(Debug, Clone)]
 pub struct DiscoveredMixin {
@@ -17,6 +20,46 @@ pub struct DiscoveredMixin {
     pub domain_count: usize,
 }
 
+impl DiscoveredMixin {
+    pub fn kit_path(&self) -> Result<PathBuf> {
+        if self.path.is_dir() {
+            return Ok(self.path.clone());
+        }
+
+        wrap_mixin_as_kit(&self.path)
+    }
+}
+
+pub fn wrap_mixin_as_kit(mixin_path: &Path) -> Result<PathBuf> {
+    let bytes = fs::read(mixin_path)
+        .with_context(|| format!("Failed to read sbx mixin {}", mixin_path.display()))?;
+    let mut hasher = Sha256::new();
+    hasher.update(&bytes);
+    let hash = format!("{:x}", hasher.finalize());
+
+    let kit_dir = paths::sbx_mixin_kits_dir().join(&hash);
+    let spec_path = kit_dir.join(KIT_SPEC_FILE_NAME);
+
+    if let Ok(existing) = fs::read(&spec_path)
+        && existing == bytes
+    {
+        return Ok(kit_dir);
+    }
+
+    fs::create_dir_all(&kit_dir)
+        .with_context(|| format!("Failed to create mixin kit dir {}", kit_dir.display()))?;
+    fs::write(&spec_path, &bytes)
+        .with_context(|| format!("Failed to write {}", spec_path.display()))?;
+
+    debug!(
+        "Wrapped mixin {} as kit at {}",
+        mixin_path.display(),
+        kit_dir.display()
+    );
+
+    Ok(kit_dir)
+}
+
 pub fn discover() -> Result<Vec<DiscoveredMixin>> {
     let mut out = Vec::new();
 
@@ -234,4 +277,166 @@ network:
         let found = collect_subdir_mixins(&absent);
         assert!(found.is_empty());
     }
+
+    mod wrap_as_kit {
+        use super::*;
+        use serial_test::serial;
+        use std::ffi::OsString;
+
+        struct TestCacheDirGuard {
+            key: String,
+            previous: Option<OsString>,
+            path: PathBuf,
+        }
+
+        impl TestCacheDirGuard {
+            fn new() -> Self {
+                let key = crate::utils::get_env_name("cache_dir");
+                let previous = env::var_os(&key);
+                let nanos = time::SystemTime::now()
+                    .duration_since(time::UNIX_EPOCH)
+                    .unwrap()
+                    .as_nanos();
+                let path = env::temp_dir().join(format!("coyote-mixin-wrap-cache-{nanos}"));
+                fs::create_dir_all(&path).unwrap();
+                unsafe {
+                    env::set_var(&key, &path);
+                }
+                Self {
+                    key,
+                    previous,
+                    path,
+                }
+            }
+        }
+
+        impl Drop for TestCacheDirGuard {
+            fn drop(&mut self) {
+                unsafe {
+                    match &self.previous {
+                        Some(v) => env::set_var(&self.key, v),
+                        None => env::remove_var(&self.key),
+                    }
+                }
+                let _ = fs::remove_dir_all(&self.path);
+            }
+        }
+
+        fn write_mixin(name: &str, content: &str) -> PathBuf {
+            let root = unique_root(&format!("wrap-src-{name}"));
+            let path = root.join("sbx-mixin.yaml");
+            fs::write(&path, content).unwrap();
+            path
+        }
+
+        #[test]
+        #[serial]
+        fn wrap_mixin_as_kit_creates_spec_yaml_with_original_content() {
+            let _guard = TestCacheDirGuard::new();
+            let content = "schemaVersion: \"1\"\nkind: mixin\nname: probe\n";
+            let mixin = write_mixin("content", content);
+
+            let kit_dir = wrap_mixin_as_kit(&mixin).unwrap();
+            let spec = kit_dir.join("spec.yaml");
+
+            assert!(spec.exists(), "spec.yaml must exist in wrapped kit dir");
+            assert_eq!(fs::read_to_string(&spec).unwrap(), content);
+        }
+
+        #[test]
+        #[serial]
+        fn wrap_mixin_as_kit_is_deterministic_for_identical_content() {
+            let _guard = TestCacheDirGuard::new();
+            let content = "schemaVersion: \"1\"\nkind: mixin\nname: probe\n";
+            let mixin_one = write_mixin("dedup-1", content);
+            let mixin_two = write_mixin("dedup-2", content);
+
+            let kit_a = wrap_mixin_as_kit(&mixin_one).unwrap();
+            let kit_b = wrap_mixin_as_kit(&mixin_two).unwrap();
+
+            assert_eq!(
+                kit_a, kit_b,
+                "same content should share the same content-addressed kit dir"
+            );
+        }
+
+        #[test]
+        #[serial]
+        fn wrap_mixin_as_kit_different_content_yields_different_dirs() {
+            let _guard = TestCacheDirGuard::new();
+            let mixin_a = write_mixin("diff-a", "kind: mixin\nname: a\n");
+            let mixin_b = write_mixin("diff-b", "kind: mixin\nname: b\n");
+
+            let kit_a = wrap_mixin_as_kit(&mixin_a).unwrap();
+            let kit_b = wrap_mixin_as_kit(&mixin_b).unwrap();
+
+            assert_ne!(
+                kit_a, kit_b,
+                "different content must hash to different kit dirs"
+            );
+        }
+
+        #[test]
+        #[serial]
+        fn wrap_mixin_as_kit_is_idempotent_on_cache_hit() {
+            let _guard = TestCacheDirGuard::new();
+            let mixin = write_mixin("idempotent", "kind: mixin\nname: probe\n");
+
+            let kit_first = wrap_mixin_as_kit(&mixin).unwrap();
+            let spec = kit_first.join("spec.yaml");
+            let mtime_first = fs::metadata(&spec).unwrap().modified().unwrap();
+
+            std::thread::sleep(std::time::Duration::from_millis(10));
+
+            let kit_second = wrap_mixin_as_kit(&mixin).unwrap();
+            let mtime_second = fs::metadata(kit_second.join("spec.yaml"))
+                .unwrap()
+                .modified()
+                .unwrap();
+
+            assert_eq!(kit_first, kit_second);
+            assert_eq!(
+                mtime_first, mtime_second,
+                "cache hit must not rewrite spec.yaml"
+            );
+        }
+
+        #[test]
+        #[serial]
+        fn kit_path_passes_through_existing_directory() {
+            let _guard = TestCacheDirGuard::new();
+            let dir = unique_root("kit-path-dir-passthrough");
+
+            let m = DiscoveredMixin {
+                path: dir.clone(),
+                label: "vault".into(),
+                install_count: 1,
+                domain_count: 1,
+            };
+
+            assert_eq!(m.kit_path().unwrap(), dir);
+        }
+
+        #[test]
+        #[serial]
+        fn kit_path_wraps_file_into_kit_dir() {
+            let _guard = TestCacheDirGuard::new();
+            let mixin = write_mixin("kit-path-wrap", "kind: mixin\nname: probe\n");
+
+            let m = DiscoveredMixin {
+                path: mixin.clone(),
+                label: mixin.display().to_string(),
+                install_count: 0,
+                domain_count: 0,
+            };
+
+            let wrapped = m.kit_path().unwrap();
+            assert!(wrapped.is_dir(), "kit_path of a file should be a directory");
+            assert!(wrapped.join("spec.yaml").exists());
+            assert_ne!(
+                wrapped, mixin,
+                "kit_path should not return the original file path"
+            );
+        }
+    }
 }

src/sandbox/mod.rs

@@ -316,6 +316,7 @@ fn sandbox_exists(name: &str) -> Result<bool> {
 fn create_sandbox(name: &str, kit_path: &Path, mixins: &[DiscoveredMixin]) -> Result<()> {
     info!("Creating sandbox '{name}'");
     let args = build_create_args(name, kit_path, mixins)?;
+    debug!("sbx {}", args.join(" "));
     let status = Command::new(SBX_BINARY)
         .args(&args)
         .stdin(Stdio::inherit())
@@ -342,22 +343,23 @@ fn build_create_args(
 
     let mut args = vec![
         "create".to_string(),
+        "--name".to_string(),
+        name.to_string(),
         "--kit".to_string(),
         kit_str.to_string(),
     ];
 
     for mixin in mixins {
-        let mixin_str = mixin
-            .path
+        let mixin_kit = mixin.kit_path()?;
+        let mixin_str = mixin_kit
             .to_str()
-            .ok_or_else(|| anyhow!("Mixin path is not valid UTF-8: {}", mixin.path.display()))?;
+            .ok_or_else(|| anyhow!("Mixin kit path is not valid UTF-8: {}", mixin_kit.display()))?
+            .to_string();
         args.push("--kit".to_string());
-        args.push(mixin_str.to_string());
+        args.push(mixin_str);
     }
 
     args.push(SANDBOX_AGENT.to_string());
-    args.push("--name".to_string());
-    args.push(name.to_string());
     args.push(".".to_string());
 
     Ok(args)
@@ -368,10 +370,17 @@ fn copy_host_files(name: &str) -> Result<()> {
     let home_dir = dirs::home_dir().context("Could not determine home directory")?;
 
     if config_dir.exists() {
-        ensure_sandbox_dir(name, "/home/agent/.config")?;
-        let src = format!("{}/", config_dir.display());
-        let dest = format!("{name}:/home/agent/.config/");
-        sbx_cp(&src, &dest)?;
+        let sandbox_config_dir = "/home/agent/.config/coyote";
+        ensure_sandbox_dir(name, sandbox_config_dir)?;
+        let dest = format!("{name}:{sandbox_config_dir}/");
+        for entry in fs::read_dir(&config_dir)
+            .with_context(|| format!("Failed to read {}", config_dir.display()))?
+        {
+            let entry = entry?;
+            let path = entry.path();
+            sbx_cp(&path.display().to_string(), &dest)?;
+        }
+        chown_agent_recursive(name, sandbox_config_dir)?;
     } else {
         debug!(
             "Skipping config copy: {} does not exist",
@@ -389,6 +398,7 @@ fn copy_host_files(name: &str) -> Result<()> {
             }
             let dest = format!("{name}:{dest_path}");
             sbx_cp(&password_file.display().to_string(), &dest)?;
+            chown_agent_recursive(name, &dest_path)?;
         }
         Some(password_file) => {
             debug!(
@@ -504,8 +514,9 @@ fn exec_run(name: &str, kit_path: &Path) -> Result<()> {
     let kit_str = kit_path
         .to_str()
         .ok_or_else(|| anyhow!("Kit path is not valid UTF-8: {}", kit_path.display()))?;
+    debug!("sbx run --name {name} --kit {kit_str}");
     let status = Command::new(SBX_BINARY)
-        .args(["run", name, "--kit", kit_str])
+        .args(["run", "--name", name, "--kit", kit_str])
         .stdin(Stdio::inherit())
         .stdout(Stdio::inherit())
         .stderr(Stdio::inherit())
@@ -519,6 +530,27 @@ fn exec_run(name: &str, kit_path: &Path) -> Result<()> {
     Ok(())
 }
 
+fn chown_agent_recursive(sandbox: &str, path: &str) -> Result<()> {
+    let path_q = shell_words::quote(path);
+    let cmd = format!("sudo chown -R agent:agent {path_q}");
+
+    debug!("sbx exec {sandbox}: {cmd}");
+
+    let status = Command::new(SBX_BINARY)
+        .args(["exec", sandbox, "sh", "-c", &cmd])
+        .stdin(Stdio::inherit())
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .status()
+        .context("Failed to spawn `sbx exec` to chown copied files")?;
+
+    if !status.success() {
+        bail!("Chowning '{path}' in sandbox failed: sbx exec exited with {status}");
+    }
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -590,15 +622,24 @@ mod tests {
     #[test]
     fn build_create_args_emits_base_kit_before_mixins() {
         let kit = PathBuf::from("/cache/sbx-kit");
+        let unique = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let dir_a = env::temp_dir().join(format!("coyote-mixin-a-{unique}"));
+        let dir_b = env::temp_dir().join(format!("coyote-mixin-b-{unique}"));
+        fs::create_dir_all(&dir_a).unwrap();
+        fs::create_dir_all(&dir_b).unwrap();
+
         let mixins = vec![
             DiscoveredMixin {
-                path: PathBuf::from("/cfg/sbx-mixin.yaml"),
+                path: dir_a.clone(),
                 label: "user".into(),
                 install_count: 0,
                 domain_count: 0,
             },
             DiscoveredMixin {
-                path: PathBuf::from("/cfg/agents/sql/sbx-mixin.yaml"),
+                path: dir_b.clone(),
                 label: "sql".into(),
                 install_count: 0,
                 domain_count: 0,
@@ -611,18 +652,21 @@ mod tests {
             args,
             vec![
                 "create".to_string(),
+                "--name".to_string(),
+                "my-box".to_string(),
                 "--kit".to_string(),
                 "/cache/sbx-kit".to_string(),
                 "--kit".to_string(),
-                "/cfg/sbx-mixin.yaml".to_string(),
+                dir_a.display().to_string(),
                 "--kit".to_string(),
-                "/cfg/agents/sql/sbx-mixin.yaml".to_string(),
+                dir_b.display().to_string(),
                 "coyote".to_string(),
-                "--name".to_string(),
-                "my-box".to_string(),
                 ".".to_string(),
             ]
         );
+
+        let _ = fs::remove_dir_all(&dir_a);
+        let _ = fs::remove_dir_all(&dir_b);
     }
 
     #[test]
@@ -633,11 +677,11 @@ mod tests {
             args,
             vec![
                 "create".to_string(),
+                "--name".to_string(),
+                "box".to_string(),
                 "--kit".to_string(),
                 "/cache/sbx-kit".to_string(),
                 "coyote".to_string(),
-                "--name".to_string(),
-                "box".to_string(),
                 ".".to_string(),
             ]
         );
@@ -645,6 +689,7 @@ mod tests {
 
     mod vault_mixins {
         use super::*;
+        use crate::utils::get_env_name;
         use gman::providers::aws_secrets_manager::AwsSecretsManagerProvider;
         use gman::providers::azure_key_vault::AzureKeyVaultProvider;
         use gman::providers::gcp_secret_manager::GcpSecretManagerProvider;
@@ -652,6 +697,46 @@ mod tests {
         use gman::providers::local::LocalProvider;
         use gman::providers::one_password::OnePasswordProvider;
         use serial_test::serial;
+        use std::time::{SystemTime, UNIX_EPOCH};
+
+        struct TestCacheDirGuard {
+            key: String,
+            previous: Option<std::ffi::OsString>,
+            path: PathBuf,
+        }
+
+        impl TestCacheDirGuard {
+            fn new() -> Self {
+                let key = get_env_name("cache_dir");
+                let previous = env::var_os(&key);
+                let unique = SystemTime::now()
+                    .duration_since(UNIX_EPOCH)
+                    .unwrap()
+                    .as_nanos();
+                let path = env::temp_dir().join(format!("coyote-sandbox-vault-tests-{unique}"));
+                fs::create_dir_all(&path).unwrap();
+                unsafe {
+                    env::set_var(&key, &path);
+                }
+                Self {
+                    key,
+                    previous,
+                    path,
+                }
+            }
+        }
+
+        impl Drop for TestCacheDirGuard {
+            fn drop(&mut self) {
+                unsafe {
+                    match &self.previous {
+                        Some(v) => env::set_var(&self.key, v),
+                        None => env::remove_var(&self.key),
+                    }
+                }
+                let _ = fs::remove_dir_all(&self.path);
+            }
+        }
 
         #[test]
         fn returns_none_for_local() {
@@ -664,6 +749,7 @@ mod tests {
         #[test]
         #[serial]
         fn returns_some_for_aws() {
+            let _guard = TestCacheDirGuard::new();
             let p = SupportedProvider::AwsSecretsManager {
                 provider_def: AwsSecretsManagerProvider {
                     aws_profile: None,
@@ -680,6 +766,7 @@ mod tests {
         #[test]
         #[serial]
         fn returns_some_for_gcp() {
+            let _guard = TestCacheDirGuard::new();
             let p = SupportedProvider::GcpSecretManager {
                 provider_def: GcpSecretManagerProvider {
                     gcp_project_id: None,
@@ -695,6 +782,7 @@ mod tests {
         #[test]
         #[serial]
         fn returns_some_for_one_password() {
+            let _guard = TestCacheDirGuard::new();
             let p = SupportedProvider::OnePassword {
                 provider_def: OnePasswordProvider {
                     vault: None,
@@ -711,6 +799,7 @@ mod tests {
         #[test]
         #[serial]
         fn returns_some_for_azure() {
+            let _guard = TestCacheDirGuard::new();
             let p = SupportedProvider::AzureKeyVault {
                 provider_def: AzureKeyVaultProvider { vault_name: None },
             };
@@ -724,6 +813,7 @@ mod tests {
         #[test]
         #[serial]
         fn returns_some_for_gopass() {
+            let _guard = TestCacheDirGuard::new();
             let p = SupportedProvider::Gopass {
                 provider_def: GopassProvider { store: None },
             };

src/utils/logs.rs

@@ -1,9 +1,11 @@
 use crate::config::paths;
 use colored::Colorize;
 use fancy_regex::Regex;
-use std::fs::File;
+use std::fs::{self, File};
 use std::io::{BufRead, BufReader, Seek, SeekFrom};
 use std::process;
+use std::time::Duration;
+use tokio::time::sleep;
 
 pub async fn tail_logs(no_color: bool) {
     let re = Regex::new(r"^(?P<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3})\s+<(?P<opid>[^\s>]+)>\s+\[(?P<level>[A-Z]+)\]\s+(?P<logger>[^:]+):(?P<line>\d+)\s+-\s+(?P<message>.*)$").unwrap();
@@ -16,17 +18,40 @@ pub async fn tail_logs(no_color: bool) {
         process::exit(1);
     };
 
-    let mut lines = reader.lines();
+    let mut line_buf = String::new();
 
     loop {
-        if let Some(Ok(line)) = lines.next() {
+        match reader.read_line(&mut line_buf) {
+            Ok(0) => {
+                if file_was_rotated(&file_path, &mut reader) {
+                    let file = File::open(&file_path).expect("Cannot open file");
+                    reader = BufReader::new(file);
+                }
+                sleep(Duration::from_millis(100)).await;
+            }
+            Ok(_) => {
+                let line = line_buf.trim_end();
                 if no_color {
                     println!("{line}");
                 } else {
-                let colored_line = colorize_log_line(&line, &re);
+                    let colored_line = colorize_log_line(line, &re);
                     println!("{colored_line}");
                 }
+                line_buf.clear();
             }
+            Err(_) => {
+                line_buf.clear();
+                sleep(Duration::from_millis(100)).await;
+            }
+        }
+    }
+}
+
+fn file_was_rotated(path: &std::path::Path, reader: &mut BufReader<File>) -> bool {
+    let current_pos = reader.stream_position().unwrap_or(0);
+    match fs::metadata(path) {
+        Ok(metadata) => metadata.len() < current_pos,
+        Err(_) => true,
     }
 }