Przejdź do treści
Biblioteka skilli
Programowanie · Integracja z narzędziem

setup

/setup

Instaluje, konfiguruje, aktualizuje lub usuwa t3-orchestration w projekcie w T3 Code, gdy użytkownik o to prosi.

Licencja
MIT
Ostatnia zmiana repozytorium
28.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 28.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Instaluje, konfiguruje, aktualizuje lub usuwa t3-orchestration w projekcie w T3 Code, gdy użytkownik o to prosi.

Oryginalny opis (EN)

In T3 Code only, install, configure, update or remove t3-orchestration for a project. Use when the user asks to set up orchestration on a project, add another project, update the plugin, or uninstall it.

Jak działa

  1. 1. Load the plugin in T3
  2. 2. Collect the decisions
  3. 3. Create the coordinator
  4. 4. Write the files
  5. 5. Create the memory thread (optional)
  6. 6. Check it end to end
  7. Update
  8. Uninstall
Sekcje z nagłówków SKILL.md, w oryginale · 118 linii, 904 słów
Podgląd SKILL.md
---
name: setup
description: In T3 Code only, install, configure, update or remove t3-orchestration for a project. Use when the user asks to set up orchestration on a project, add another project, update the plugin, or uninstall it.
---

# Set up t3-orchestration

Run this from a Claude thread in T3 Code, inside the project to orchestrate. Show the user each
change before making it, and ask only for the decisions listed below. The plugin directory is
`${CLAUDE_PLUGIN_ROOT}`. If that text was not replaced by a path, you were asked to read this file
directly: use the directory that contains `skills/setup/SKILL.md` instead.

Requirements: T3 Code with its `t3-code` MCP server exposing `t3_thread_configure`,
`t3_thread_read`, `t3_thread_launch`, `t3_thread_send`, `t3_project_list` and `schedule_task`;
Claude Code with mods (tested on 2.1.312); Python 3.9+ for memory. If a tool is missing, stop and
report it instead of working around it.

All user state lives in `~/.t3-orchestration/`, never in the plugin directory, so updates never
touch it:

```text
~/.t3-orchestration/
├── config.json                  # every orchestrated project
└── projects/<name>/
    ├── coordinator.md           # injected into the coordinator's prompts
    ├── worker.md                # injected into its workers' prompts
    └── library/                 # optional long-term memory
```

## 1. Load the plugin in T3

Skip this step when this skill was invoked as `/t3-orchestration:setup`: the plugin is loaded.

Otherwise the T3 Claude provider must start Claude Code with `--plugin-dir <plugin directory>`.
Prefer letting the user add it to the launch arguments of their Claude provider instance in T3
Code's settings. If they ask you to do it: T3 stores it in `~/.t3/userdata/settings.json`, under
`providerInstances.<id>.config.launchArgs` of an instance whose `driver` is `claudeAgent`. Back up
the file, append the flag to the existing arguments without changing anything else, and show the
diff. Only threads started afterwards load the plugin: ask the user to open a new Claude thread in
the project and run `/t3-orchestration:setup` there.

The plugin is inert in threads it does not recognise, so loading it on a provider used by other
projects is safe.

## 2. Collect the decisions

1. Identify this thread with `t3_thread_configure`, then its project with `t3_thread_read`.
   Confirm the T3 project with the user (`t3_project_list` if it is not this one).
2. Ask for:
   - a project `name`: lowercase letters, digits and dashes;
   - the project rules both roles must follow: repositories, guardrails (production, secrets,
     personal data), delivery process, review policy, language of replies. Keep them short: they
     are injected into every prompt;
   - whether to enable long-term memory, and how often it runs (default every 10 minutes).
3. If `~/.t3-orchestration/config.json` already lists this `projectId` or `name`, stop and ask
   whether to replace it, instead of creating a second coordinator.

## 3. Create the coordinator

Create it idle, without a first message, so that its first turn already receives its reminder:
`t3_thread_launch` with the `projectId`, the title `Orchestration` and no `message`. Keep the
returned `threadId` and `link`. Suggest the user pins it.

## 4. Write the files

1. Create `~/.t3-orchestration/projects/<name>/`.
2. Fill `${CLAUDE_PLUGIN_ROOT}/templates/coordinator.md` and `worker.md`: replace
   `{{PROJECT_NAME}}`, `{{COORDINATOR_THREAD_ID}}`, `{{PLUGIN_ROOT}}` (the plugin directory) and `{{PROJECT_RULES}}` (a short bullet list).
   Write them as `coordinator.md` and `worker.md` in that directory.
3. Multiple Claude accounts (optional): each account is its own T3 Claude instance with its own
   `homePath` (a separate `CLAUDE_CONFIG_DIR`, logged in with
   `CLAUDE_CONFIG_DIR=<dir> claude auth login`) and the same `--plugin-dir`. Run
   `npm install --prefix "${CLAUDE_PLUGIN_ROOT}"` once, then check
   `node "${CLAUDE_PLUGIN_ROOT}/scripts/accounts.mjs"` lists every account.
4. With memory: copy `${CLAUDE_PLUGIN_ROOT}/templates/library/` to `library/`, replacing
   `{{PROJECT_NAME}}`, then run
   `python3 "${CLAUDE_PLUGIN_ROOT}/scripts/memory.py" --library "<library path>" status`.
5. Back up `config.json` if it exists, then add this project to `projects`, keeping the others
   (see `${CLAUDE_PLUGIN_ROOT}/config.example.json`). `excludedThreadIds` holds this setup thread's
   id; `memoryThreadId` stays `null` until step 5; `libraryPath` is absolute, or `null`.

## 5. Create the memory thread (optional)

A schedule runs in the thread that creates it, so the memory thread creates its own. Launch it
with `t3_thread_launch` in the same project, titled `Memory`, with this first message, filled in:

> You are the memory thread of `<name>`. Create your own schedule with `schedule_task`:
> `schedule: {type: "interval", everyMs: <interval in ms>}`, `bindToCurrentThread: true`, title
> `<name> memory pass`, prompt `Run one incremental pass with the t3-orchestration:memory skill.`
> Report the schedule id and next run time, then stop. Do not run a pass yet.

Then set `memoryThreadId` in `config.json` to the returned `threadId`. Read the memory thread to
confirm the schedule exists; report its id or the failure exactly.

## 6. Check it end to end

Give the user this check and the links:

1. In the coordinator, send any request. Its context contains `[T3O_COORDINATOR_V1]`.
2. Ask the coordinator to open a small worker thread. The worker's context contains
   `[T3O_WORKER_V1]`, and when its turn ends the coordinator receives `[T3O_SIGNAL_V1]`.
3. In a thread the user creates manually, neither marker appears and no signal is sent.

Report what was created, with the exact links, and what remains unverified.

## Update

1. Note the current commit (`git -C "${CLAUDE_PLUGIN_ROOT}" rev-parse HEAD`), then
   `git -C "${CLAUDE_PLUGIN_ROOT}" pull --ff-only`. Stop on any conflict or local change.
2. Show `git log` and the diff of `templates/` between the two commits. The user's reminder files
   are theirs: propose the template changes, never overwrite them.
3. Run `npm install --prefix "${CLAUDE_PLUGIN_ROOT}"` if `package.json` changed.
4. New threads load the new version; ask the user to restart the threads already running.

## Uninstall

On the user's explicit request only: delete the project's memory schedule
(`list_scheduled_tasks`, then `delete_scheduled_task`) and remove the project from `config.json`.
Remove `--plugin-dir` from the T3 launch arguments only when no project is left: it serves every
configured project. Ask before deleting `~/.t3-orchestration/projects/<name>/`: it holds
the memory library. Threads are kept; archiving them is the user's choice.

Wersje

RepozytoriumWynikLicencja
Ta strona · sanztheo/t3-orchestration100MIT
HwangSlater/harness-fit100MIT
nesquikm/dev-process-toolkit100MIT
userKael/rastro100MIT
als-apg/osprey100BSD-3-Clause
dedujeong/gemba100Apache-2.0
eigenwise/eigenwise-toolshed100MIT
awrshift/agent-memory-kit100MIT
lifecycle-innovations-limited/claude-ops100MIT

Migawka bazy z 13.11.2026 · wersja paczki be7d4ea5f517 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100setting-up-software-writer-extension
    Instaluje, konfiguruje lub migruje rozszerzenie wtyczki software-writer dla bieżącego projektu, tylko gdy użytkownik o to prosi.
  • 100cc-spex-init
    Instaluje lub odświeża przepływy Spex oparte na specyfikacji w bieżącym projekcie ze źródła dołączonego do wtyczki cc-spex oraz konfiguruje rozszerzenia i ustawienia bezpieczeństwa.
  • 100manage-skills
    Instaluje, usuwa i sprawdza skille z klona repozytorium kapo-skills i aktualizuje wspólny zestaw.
  • 90framework
    Prowadzi rekord instalacji i wszystkie zmiany w projekcie: manifest oraz przepływy setup, instalacji, przywracania, odinstalowania i diagnostyki.
  • 100openspec-init
    Konfiguruje OpenSpec w projekcie, gdy użytkownik prosi o inicjalizację lub chce dodać ten framework do repozytorium.
  • 90update
    Aktualizuje wersję frontendowego harnessu w projekcie do najnowszej wersji wtyczki.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.