docks-kit 0.1.0

package/SoT/.claude/settings.json

@@ -0,0 +1,258 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "minimumVersion": "2.1.170",
+  "model": "opus",
+  "advisorModel": "fable",
+  "effortLevel": "xhigh",
+  "autoMemoryEnabled": true,
+  "skillListingMaxDescChars": 2048,
+  "respectGitignore": true,
+  "cleanupPeriodDays": 14,
+  "skillListingBudgetFraction": 0.05,
+  "env": {
+    "CLAUDE_CODE_MAX_OUTPUT_TOKENS": "64000",
+    "CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR": "1",
+    "CLAUDE_CODE_AUTO_COMPACT_WINDOW": "468000",
+    "CLAUDE_CODE_NO_FLICKER": "1"
+  },
+  "permissions": {
+    "defaultMode": "auto",
+    "allow": [
+      "Read",
+      "Glob",
+      "Grep",
+      "WebFetch",
+      "WebSearch",
+      "Edit(./)",
+      "Write(./)",
+      "Bash(git *)",
+      "Bash(git add *)",
+      "Bash(git commit *)",
+      "Bash(git status *)",
+      "Bash(git diff *)",
+      "Bash(git log *)",
+      "Bash(git branch *)",
+      "Bash(git checkout *)",
+      "Bash(git switch *)",
+      "Bash(git stash *)",
+      "Bash(git fetch *)",
+      "Bash(git pull *)",
+      "Bash(git tag *)",
+      "Bash(git show *)",
+      "Bash(git blame *)",
+      "Bash(git worktree *)",
+      "Bash(gh *)",
+      "Bash(pnpm *)",
+      "Bash(npm *)",
+      "Bash(npx *)",
+      "Bash(node *)",
+      "Bash(docker *)",
+      "Bash(docker-compose *)",
+      "Bash(rtk *)",
+      "Bash(ls *)",
+      "Bash(cat *)",
+      "Bash(find *)",
+      "Bash(grep *)",
+      "Bash(head *)",
+      "Bash(tail *)",
+      "Bash(wc *)",
+      "Bash(sort *)",
+      "Bash(uniq *)",
+      "Bash(diff *)",
+      "Bash(which *)",
+      "Bash(pwd *)",
+      "Bash(date *)",
+      "Bash(mkdir *)",
+      "Bash(basename *)",
+      "Bash(dirname *)",
+      "Bash(realpath *)",
+      "Bash(jq *)",
+      "Bash(curl *)",
+      "Bash(tree *)",
+      "Bash(sed *)",
+      "Bash(awk *)",
+      "Bash(cut *)",
+      "Bash(tr *)",
+      "Bash(tee *)",
+      "Bash(echo *)",
+      "Bash(printf *)",
+      "Bash(env *)",
+      "Bash(printenv *)",
+      "Bash(uname *)",
+      "Bash(file *)",
+      "Bash(stat *)",
+      "Bash(du *)",
+      "Bash(id *)",
+      "Bash(whoami *)",
+      "Bash(php *)",
+      "Bash(composer *)",
+      "Bash(python3 *)",
+      "Bash(python *)",
+      "Bash(pip *)",
+      "Bash(pip3 *)"
+    ],
+    "deny": [
+      "Read(**/.env)",
+      "Read(**/.env.local)",
+      "Read(**/secrets/**)",
+      "Read(**/*.key)",
+      "Read(**/*.pem)",
+      "Read(**/*.p12)",
+      "Read(**/.credentials*)",
+      "Edit(**/.env)",
+      "Edit(**/.env.local)",
+      "Edit(**/secrets/**)",
+      "Write(**/.env)",
+      "Write(**/.env.local)",
+      "Write(**/secrets/**)",
+      "Bash(sudo *)",
+      "Bash(rm -rf /)",
+      "Bash(rm -rf / *)",
+      "Bash(rm -rf ~)",
+      "Bash(rm -rf ~ *)",
+      "Bash(rm -rf $HOME)",
+      "Bash(rm -rf $HOME *)",
+      "Bash(> /dev *)",
+      "Bash(dd if= *)",
+      "Bash(mkfs *)",
+      "Bash(eval *)",
+      "Bash(chmod 777 *)",
+      "Bash(chmod -R 777 *)",
+      "Bash(git push --force origin main *)",
+      "Bash(git push --force origin master *)",
+      "Bash(git push -f origin main *)",
+      "Bash(git push -f origin master *)"
+    ],
+    "ask": [
+      "Bash(git push *)",
+      "Bash(git reset *)",
+      "Bash(git clean *)",
+      "Bash(git merge *)",
+      "Bash(git rebase *)",
+      "Bash(git checkout -- *)",
+      "Bash(git checkout . *)",
+      "Bash(rm *)",
+      "Bash(mv *)",
+      "Bash(chmod *)",
+      "Bash(chown *)",
+      "Bash(kill *)",
+      "Bash(pkill *)",
+      "Bash(docker run *)",
+      "Bash(docker rm *)",
+      "Bash(docker stop *)",
+      "Bash(docker volume rm *)",
+      "Bash(docker system prune *)",
+      "Bash(docker-compose down *)",
+      "Bash(docker-compose up *)",
+      "Bash(sed -i *)",
+      "Bash(xargs *)",
+      "Bash(pip install *)",
+      "Bash(pip uninstall *)",
+      "Bash(pip3 install *)",
+      "Bash(pip3 uninstall *)"
+    ]
+  },
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "echo \"[CONTEXT] Current date: $(date '+%A, %Y-%m-%d %H:%M:%S %Z')\"",
+            "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "echo \"[CONFIG] Context: $([ \\\"${CLAUDE_CODE_DISABLE_1M_CONTEXT:-0}\\\" = \\\"1\\\" ] && echo '200K' || echo '1M') | Compact-window: ${CLAUDE_CODE_AUTO_COMPACT_WINDOW:-full} | Effort: ${CLAUDE_CODE_EFFORT_LEVEL:-$(jq -r .effortLevel $HOME/.claude/settings.json 2>/dev/null || echo default)} | Thinking: adaptive | Subagent: ${CLAUDE_CODE_SUBAGENT_MODEL:-default}\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "Notification": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "[ -x \"$HOME/.claude/hooks/notify.sh\" ] && \"$HOME/.claude/hooks/notify.sh\" || true",
+            "timeout": 10,
+            "async": true
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "rtk hook claude"
+          }
+        ]
+      }
+    ],
+    "PostToolUseFailure": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "echo '{\"hookSpecificOutput\":{\"hookEventName\":\"PostToolUseFailure\",\"additionalContext\":\"Last bash command failed. Repository / file state may have shifted — re-read affected files before retrying. If the failure is a missing dependency or env mismatch, surface it to the user rather than retrying blindly.\"}}'",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash $HOME/.claude/fetch-usage.sh",
+            "timeout": 5,
+            "async": true
+          }
+        ]
+      }
+    ],
+    "SubagentStop": [
+      {
+        "hooks": [
+          {
+            "type": "prompt",
+            "prompt": "You are a quality gate for subagent outputs in a multi-agent code-analysis pipeline.\n\nEvaluate the subagent's `last_assistant_message` field (in the JSON below) against these requirements:\n\n1. ALLOW (return `{}`): Mode-selection or no-issues responses. Examples: \"Which mode do you prefer\", \"select an option\", \"no issues / problems / violations / blockers found\".\n\n2. ALLOW (return `{}`): Output contains at least one concrete file:line citation — e.g. `src/auth.ts:42`, `lib/db.ts:100-115`, or path references that include line numbers.\n\n3. BLOCK (return `{\"decision\":\"block\",\"reason\":\"<one-line explanation>\"}`): Output claims about code or findings WITHOUT concrete file:line citations. Vague references like \"the auth handler\" or \"near the database code\" are not acceptable as the only evidence.\n\nSubagent invocation JSON:\n$ARGUMENTS\n\nReturn ONLY the JSON decision (no commentary, no markdown fences).",
+            "timeout": 30
+          }
+        ]
+      }
+    ]
+  },
+  "statusLine": {
+    "type": "command",
+    "command": "~/.claude/statusline.sh",
+    "refreshInterval": 5
+  },
+  "enabledPlugins": {
+    "context7@claude-plugins-official": true,
+    "frontend-design@claude-plugins-official": true,
+    "php-lsp@claude-plugins-official": true,
+    "typescript-lsp@claude-plugins-official": true,
+    "docks@docks": true,
+    "session-relay@docks": true,
+    "effect-kit@docks": true
+  },
+  "extraKnownMarketplaces": {
+    "docks": {
+      "source": {
+        "source": "github",
+        "repo": "DocksDocks/docks"
+      }
+    }
+  },
+  "alwaysThinkingEnabled": true,
+  "showThinkingSummaries": true,
+  "viewMode": "default",
+  "theme": "dark-daltonized",
+  "skipDangerousModePermissionPrompt": true
+}

package/SoT/.claude/statusline.sh

@@ -0,0 +1,175 @@
+#!/bin/bash
+# Claude Code status line — single-line display inspired by claude-watch.
+# Layout: model | folder • branch | ctx X% (Xk/Xk) | 5h X% (Xh Xm) • 7d X% (Xd Xh)
+# Cross-platform: works on both macOS and Linux.
+
+input=$(cat)
+
+# --- platform-aware file age ---
+file_mtime() {
+  if [ "$(uname)" = "Darwin" ]; then
+    stat -f %m "$1" 2>/dev/null || echo 0
+  else
+    stat -c %Y "$1" 2>/dev/null || echo 0
+  fi
+}
+
+# --- platform-aware ISO date parsing ---
+parse_epoch() {
+  # GNU date (Linux)
+  date -d "$1" +%s 2>/dev/null && return
+  # BSD date (macOS): strip fractional seconds and timezone suffix
+  local clean
+  clean=$(echo "$1" | sed 's/\.[0-9]*//' | sed 's/[+-][0-9][0-9]:[0-9][0-9]$//' | sed 's/Z$//')
+  date -j -f "%Y-%m-%dT%H:%M:%S" "$clean" "+%s" 2>/dev/null
+}
+
+# --- model ---
+model=$(echo "$input" | jq -r '.model.display_name // ""')
+model="${model%% (*}"  # strip parenthetical suffix: "Opus 4.7 (1M context)" → "Opus 4.7"
+
+# --- folder ---
+dir=$(echo "$input" | jq -r '.workspace.current_dir // .cwd // ""')
+dir_name=$(basename "$dir")
+
+# --- git branch (per-invocation, no cache) ---
+# Previously cached to /tmp/statusline-git-cache with a 5s TTL, but that
+# leaked branches across concurrent sessions in different worktrees: any
+# session reading the cache within 5s of another saw the other's branch.
+# `git -C "$dir" symbolic-ref` is sub-5ms; not worth caching.
+branch=""
+if [ -d "${dir}/.git" ] || git -C "$dir" rev-parse --git-dir > /dev/null 2>&1; then
+  branch=$(git -C "$dir" symbolic-ref --short HEAD 2>/dev/null || git -C "$dir" rev-parse --short HEAD 2>/dev/null)
+fi
+
+# --- usage stats from cache ---
+USAGE_CACHE="/tmp/.claude_usage_cache"
+CREDS_FILE="$HOME/.claude/.credentials.json"
+FETCH_MARKER="/tmp/.claude_usage_fetching"
+
+# At most one spawn per 5s window: redraws come ~every 300ms but the fetch
+# takes up to 3s, so an unthrottled spawn here piles up overlapping curls.
+spawn_usage_fetch() {
+  if [ $(( $(date +%s) - $(file_mtime "$FETCH_MARKER") )) -ge 5 ]; then
+    touch "$FETCH_MARKER"
+    bash ~/.claude/fetch-usage.sh > /dev/null 2>&1 &
+  fi
+}
+
+# Credentials newer than the cache => account switch; the cached numbers
+# belong to the previous account. Treat as missing rather than display them.
+five_h="" seven_d="" five_h_reset="" seven_d_reset=""
+if [ -f "$USAGE_CACHE" ] \
+   && { [ ! -f "$CREDS_FILE" ] || [ "$(file_mtime "$CREDS_FILE")" -lt "$(file_mtime "$USAGE_CACHE")" ]; }; then
+  five_h=$(sed -n '1p' "$USAGE_CACHE")
+  seven_d=$(sed -n '2p' "$USAGE_CACHE")
+  five_h_reset=$(sed -n '3p' "$USAGE_CACHE")
+  seven_d_reset=$(sed -n '4p' "$USAGE_CACHE")
+else
+  spawn_usage_fetch
+fi
+
+# --- format token count in thousands → "Xk" under 1000, "XM"/"X.XM" at/above ---
+format_tokens_k() {
+  local k=$1
+  if [ "$k" -ge 1000 ]; then
+    if [ $((k % 1000)) -eq 0 ]; then
+      echo "$((k / 1000))M"
+    else
+      awk -v k="$k" 'BEGIN { printf "%.1fM", k/1000 }'
+    fi
+  else
+    echo "${k}k"
+  fi
+}
+
+# --- time delta: ISO timestamp → human-readable countdown ---
+compute_delta() {
+  local ts="$1"
+  [ -z "$ts" ] && return
+  local reset_epoch now_epoch diff days hours minutes
+  reset_epoch=$(parse_epoch "$ts")
+  [ -z "$reset_epoch" ] && return
+  now_epoch=$(date -u +%s)
+  diff=$(( reset_epoch - now_epoch ))
+  [ "$diff" -le 0 ] && echo "now" && return
+  days=$(( diff / 86400 ))
+  hours=$(( (diff % 86400) / 3600 ))
+  minutes=$(( (diff % 3600) / 60 ))
+  # Show only the largest non-zero unit; truncate smaller (2h 13m → 2h).
+  if [ "$days" -gt 0 ]; then
+    echo "${days}d"
+  elif [ "$hours" -gt 0 ]; then
+    echo "${hours}h"
+  else
+    echo "${minutes}m"
+  fi
+}
+
+# --- context window ---
+# Anthropic's used_percentage is always vs the model's full context window
+# (per env-vars docs). When CLAUDE_CODE_AUTO_COMPACT_WINDOW caps the effective
+# window (e.g. 400K on a 1M model), recompute the bar against that cap so
+# `ctx 95%` actually means "autocompact imminent".
+used=$(echo "$input" | jq -r '.context_window.used_percentage // empty')
+ctx_str="" ctx_tokens_str=""
+if [ -n "$used" ]; then
+  ctx_total=$(echo "$input" | jq -r '.context_window.context_window_size // empty' 2>/dev/null)
+  if [ -n "$ctx_total" ]; then
+    ctx_used_k=$(awk -v p="$used" -v t="$ctx_total" 'BEGIN { printf "%.0f", (p/100) * (t/1000) }')
+
+    effective_total=$ctx_total
+    if [ -n "$CLAUDE_CODE_AUTO_COMPACT_WINDOW" ] \
+       && [ "$CLAUDE_CODE_AUTO_COMPACT_WINDOW" -lt "$ctx_total" ]; then
+      effective_total=$CLAUDE_CODE_AUTO_COMPACT_WINDOW
+    fi
+    effective_total_k=$(( effective_total / 1000 ))
+
+    if [ "$effective_total_k" -gt 0 ]; then
+      effective_pct=$(awk -v u="$ctx_used_k" -v t="$effective_total_k" 'BEGIN { printf "%.0f", (u/t) * 100 }')
+      ctx_str="${effective_pct}%"
+    fi
+    ctx_tokens_str="$(format_tokens_k "$ctx_used_k")/$(format_tokens_k "$effective_total_k")"
+  else
+    ctx_str="$(printf '%.0f%%' "$used")"
+  fi
+fi
+
+# --- assemble output ---
+SEP="\033[90m • \033[0m"
+
+# Line 1: model | folder • branch
+printf "\033[38;5;208m\033[1m%s\033[22m\033[0m" "$model"
+printf "\033[90m | \033[0m"
+printf "\033[1m\033[38;2;76;208;222m%s\033[22m\033[0m" "$dir_name"
+if [ -n "$branch" ]; then
+  printf "%b" "$SEP"
+  printf "\033[1m\033[38;2;192;103;222m%s\033[22m\033[0m" "$branch"
+fi
+
+# Usage groups in order: ctx | 5h • 7d. Each group opens with `|`; the 5h/7d
+# pair share a soft-dot separator.
+if [ -n "$ctx_str" ]; then
+  printf "\033[90m | \033[0m"
+  printf "\033[38;2;130;160;230mctx %s\033[0m" "$ctx_str"
+  [ -n "$ctx_tokens_str" ] && printf " \033[2m\033[38;2;156;162;175m(%s)\033[0m" "$ctx_tokens_str"
+fi
+if [ -n "$five_h" ] || [ -n "$seven_d" ]; then
+  printf "\033[90m | \033[0m"
+fi
+if [ -n "$five_h" ]; then
+  printf "\033[38;2;100;200;200m5h %s%%\033[0m" "$five_h"
+  if [ -n "$five_h_reset" ]; then
+    delta=$(compute_delta "$five_h_reset")
+    [ -n "$delta" ] && printf " \033[2m\033[38;2;156;162;175m(%s)\033[0m" "$delta"
+  fi
+fi
+if [ -n "$seven_d" ]; then
+  [ -n "$five_h" ] && printf "%b" "$SEP"
+  printf "\033[38;2;230;180;90m7d %s%%\033[0m" "$seven_d"
+  if [ -n "$seven_d_reset" ]; then
+    delta=$(compute_delta "$seven_d_reset")
+    [ -n "$delta" ] && printf " \033[2m\033[38;2;156;162;175m(%s)\033[0m" "$delta"
+  fi
+fi
+printf "\n"

package/SoT/.codex/AGENTS.md

@@ -0,0 +1,75 @@
+# AGENTS.md
+
+## Research Before Implementation
+
+Before writing or modifying code that uses an API, hook, method, or config surface you have not verified in this session, research current documentation first.
+
+Research workflow:
+1. Prefer official documentation and primary sources for the specific library, framework, or API.
+2. If a local docs or MCP tool is available, use it before broad web search.
+3. Only then proceed to implementation.
+
+Research when:
+- Installing or configuring a dependency.
+- Using an API, hook, method, or pattern not verified in this session.
+- Upgrading or migrating between versions.
+- Any task where relying on memory could cause stale syntax or behavior.
+
+Do not:
+- Assume API signatures, method names, or config options from memory.
+- Generate framework code without checking current docs first.
+- Skip research because the library seems familiar.
+
+<constraint>
+Research the codebase before editing. Never change code you have not read.
+</constraint>
+
+## Agentic Harness Heuristics
+
+Model-agnostic operating rules for coding-agent work.
+
+1. Persistence. Keep going until the user's request is actually handled. Only yield when the problem is solved or a concrete blocker is identified. Resolve in the fewest useful tool loops — once you can answer the core request with evidence, answer. Before ending a turn, check the last paragraph: if it is a plan, a question you can answer yourself, or a promise of work not done, do that work now.
+2. Default to parallel. When multiple reads, searches, inspections, or independent checks can run without depending on each other, run them together.
+3. Multi-pass search. First-pass search often misses — vary the wording before concluding something does not exist.
+4. Trace symbols. Before modifying a symbol, trace its definition and usages. Do not infer behavior from one call site.
+5. Linter-loop 3-strike rule. Do not loop more than 3 times fixing the same lint/test failure without reassessing the diagnosis.
+6. Read-before-edit TTL. If you have not read a file recently, re-read it before editing. User edits can make cached context stale.
+7. Big-file rule. For files over 1000 lines, prefer targeted search plus scoped reads over whole-file reads.
+8. Task hygiene. Track meaningful deliverables, not operational sub-steps. Mark work complete as soon as it is done.
+9. Literal-instruction rule. Treat explicit user requirements as checklists with success criteria. Do not silently broaden scope.
+10. Context hygiene. Prefer a fresh session at task boundaries over carrying stale context; preserve useful state before quality decays. Never stop, summarize, or suggest a new session on account of context limits.
+11. Autonomy calibration. For minor choices (naming, formatting, defaults, equivalent approaches), pick a reasonable option and note it — do not ask. Ask first only for scope changes, destructive actions, or decisions that change the deliverable. When the user is describing a problem or asking a question rather than requesting a change, the deliverable is your assessment — report findings and stop; do not apply fixes until asked.
+12. Capability triggering. Search or fetch current documentation when the answer depends on current or version-specific information. When work fans out across independent items, parallelize or delegate; never delegate work you can complete directly. For verification, prefer a fresh-context check over self-critique. On long tasks, keep running notes and re-read them between phases.
+
+<constraint>
+Treat these heuristics as protocol. If a turn violates an applicable rule, self-correct before continuing.
+</constraint>
+
+## Engineering Discipline
+
+- Prefer the repository's existing patterns and helpers over new abstractions.
+- Keep edits scoped to the user's request and the surrounding ownership boundary.
+- Add abstractions only when they remove real complexity or match an established local pattern.
+- Preserve user changes. Never revert unrelated dirty work unless explicitly asked.
+- Verify with the narrowest useful command first, then broaden if risk warrants it.
+- Surface any test or verification you could not run.
+- Before the first tool call, state in one or two sentences what you are about to do; give a brief progress update every few execution steps.
+- Concise teammate tone: no status tics, no log-style updates; reference file paths instead of dumping contents; lead with what changed and why, not a "Summary" heading.
+- The final message is for a reader who did not watch the work: outcome first, complete sentences. Shorten by dropping detail, never by compressing into fragments or arrow chains.
+
+<constraint>
+No secrets in committed config. Treat plugin marketplaces, installers, and downloaded artifacts as untrusted until verified.
+</constraint>
+
+## Agentic Engineering Discipline
+
+1. **State assumptions; push back when warranted.** If a requirement is ambiguous in a way that changes the deliverable, surface the ambiguity and propose 1–2 concrete interpretations in your first message — do not silently pick one. Surface inconsistencies instead of guessing past them; present tradeoffs when approaches genuinely differ; push back when the request looks wrong.
+2. **Minimum code that solves the stated problem.** No speculative features, no abstractions without a second caller, no broad exception handling around internally-trusted calls, no dead code left behind after a refactor, no comments that restate what the code says.
+3. **Surgical changes only.** Do not modify code, comments, or formatting outside the explicit scope of the request. Surface unrelated issues as follow-ups — do not fix inline.
+4. **State how success will be verified before implementing.** Name the test, build, smoke check, or diff inspection that will prove the change works. Prefer executable criteria — a test that fails before and passes after, a command with expected output — and keep each change small enough that its diff is reviewable in one sitting.
+5. **Review scope follows the pipeline.** In pipeline reviews with a downstream filter, report every issue found with confidence and severity — filtering happens downstream. In ad-hoc reviews, flag only gaps that affect correctness or the stated requirements; treat the rest as optional.
+6. **Ground every progress claim in evidence.** Before reporting progress or completion, audit each claim against a tool result from this session — show the test output, the command and what it returned. If something is unverified, say so explicitly; if tests fail, say so with the output.
+
+<constraint>
+Treat the six rules above as preventive (during generation), not remedial (after the fact). Self-correct if a turn drifts.
+</constraint>

package/SoT/.codex/agents/.gitkeep

@@ -0,0 +1 @@
+

package/SoT/.codex/config.toml

@@ -0,0 +1,45 @@
+model = "gpt-5.5"
+model_reasoning_effort = "xhigh"
+plan_mode_reasoning_effort = "xhigh"
+model_reasoning_summary = "detailed"
+model_verbosity = "medium"
+personality = "pragmatic"
+web_search = "live"
+project_doc_max_bytes = 131072
+approval_policy = "on-request"
+sandbox_mode = "workspace-write"
+approvals_reviewer = "auto_review"
+
+[sandbox_workspace_write]
+network_access = true
+
+[features]
+memories = true
+
+[memories]
+dedicated_tools = true
+max_rollout_age_days = 30
+
+[agents]
+max_threads = 12
+max_depth = 2
+
+[tui]
+status_line_use_colors = true
+status_line = [
+  "model-with-reasoning",
+  "current-dir",
+  "git-branch",
+  "context-used",
+  "five-hour-limit",
+  "weekly-limit",
+]
+
+[plugins."docks@docks"]
+enabled = true
+
+[plugins."session-relay@docks"]
+enabled = true
+
+[plugins."effect-kit@docks"]
+enabled = true

package/SoT/.codex/plugins/marketplace.json

@@ -0,0 +1,50 @@
+{
+  "name": "docks",
+  "interface": {
+    "displayName": "DocksDocks"
+  },
+  "plugins": [
+    {
+      "name": "docks",
+      "source": {
+        "source": "git-subdir",
+        "url": "https://github.com/DocksDocks/docks.git",
+        "path": "./plugins/docks",
+        "ref": "main"
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_INSTALL"
+      },
+      "category": "Productivity"
+    },
+    {
+      "name": "session-relay",
+      "source": {
+        "source": "git-subdir",
+        "url": "https://github.com/DocksDocks/docks.git",
+        "path": "./plugins/session-relay",
+        "ref": "main"
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_INSTALL"
+      },
+      "category": "Productivity"
+    },
+    {
+      "name": "effect-kit",
+      "source": {
+        "source": "git-subdir",
+        "url": "https://github.com/DocksDocks/docks.git",
+        "path": "./plugins/effect-kit",
+        "ref": "main"
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_INSTALL"
+      },
+      "category": "Productivity"
+    }
+  ]
+}