Przejdź do treści
Biblioteka skilli
AI i agenci · Integracja z narzędziem

skill-concierge

/skill-concierge

Przekazuje pytania i zlecenia do agentów przez czat w przeglądarce, na komputerze lub telefonie, o bieżącym projekcie.

Licencja
MIT
Ostatnia zmiana repozytorium
02.11.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
27
Skrypty
15
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

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

Licencja

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

Co sprawdzić przed instalacją
  • 15 skryptów w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: app/assets.ts, app/page.tsx, app/public/concierge.tsx, app/public/entry.ts, app/public/markdown.ts, server/app.ts, server/desk.ts, server/files.ts

Co robi i kiedy

Przekazuje pytania i zlecenia do agentów przez czat w przeglądarce, na komputerze lub telefonie, o bieżącym projekcie.

Oryginalny opis (EN)

Use when the user wants to ask questions of, or hand requests to, agents from a browser chat (desktop or phone) about the current project, or asks for the Concierge chat UI.

Jak działa

  1. Start
  2. Answer loop
  3. Stop
  4. Common mistakes
Sekcje z nagłówków SKILL.md, w oryginale · 102 linii, 1 182 słów
Podgląd SKILL.md
---
name: skill-concierge
description: Use when the user wants to ask questions of, or hand requests to, agents from a browser chat (desktop or phone) about the current project, or asks for the Concierge chat UI.
---

# skill-concierge

A local web chat for one project. The user asks in the browser; you take each question from the server's
HTTP API with `curl` and answer it, yourself or through a subagent. The server never runs agents and has no
CLI. Works the same in omp, Claude Code, Codex and Hermes Agent; only the tool names differ (table below). Paths are
relative to this skill's directory; `reference.md` has the API, recipes, and troubleshooting, `ui.md` how
answers may rewrite the browser UI.

| | omp | Claude Code | Codex | Hermes Agent |
|---|---|---|---|---|
| Long-lived server | `bash` service (`name`, `ready`) | `Bash` with `run_in_background: true` | started outside the sandbox (below) | `terminal` with `background: true`, started by you (a subagent's processes end with it) |
| Armed wait (a background command that ends when a question arrives) | async `bash`, `timeout: 0` | `Bash` with `run_in_background: true` | none: use the foreground wait (below) | none: a waiting subagent runs the foreground wait (below) |
| Subagent | `task` | `Task`/`Agent` | only if your build offers one; otherwise answer yourself | `delegate_task` (runs in the background) |

## Start

1. First run only: `npm install` in the skill directory (Node.js ≥ 24.3).
2. In the **project directory**, start `node <skill>/server/main.ts` as a long-lived process (omp:
   `name: "concierge"`, `ready: { log: "concierge listening on" }`). Its output gives the URL `U` (the port
   is chosen per project; never assume one), the data directory, and the UI directory. `concierge already
   running` means the project's server is up: use the URL it prints. Running the command again is also how
   you find `U` later.
3. Tell the user the URL. Open their browser only if asked. Expose it beyond this machine only if asked
   (`reference.md`, "Access from other devices").

Sandboxed agents: the server must run outside the sandbox (a server started inside it listens where the
browser cannot reach it), and answering needs only HTTP to `127.0.0.1`.

- Codex, and Claude Code with `/sandbox` on: do not start the server yourself. Run
  `node <skill>/server/main.ts --status` in the project directory; it prints the running
  server's URL, or `concierge not running`. In that case ask the user to start it in a terminal
  (`cd <project> && node <skill>/server/main.ts`), or request to run
  `nohup node <skill>/server/main.ts > /tmp/concierge.log 2>&1 &` outside the sandbox. If
  `curl "$U/api/state"` fails with `Failed to connect` or `CONNECT tunnel failed` in Codex, it lacks loopback
  access: tell the user to install `<skill>/codex/concierge.config.toml` in `~/.codex/` and run `codex -p
  concierge` (loopback only, no full access).
- Claude Code with `/sandbox` on: the sandbox's proxy is the only route to `127.0.0.1`, but `NO_PROXY` sends
  `curl` around it. Add `--noproxy ''` to every `curl` (e.g. `curl --noproxy '' -fs "$U/api/agent/next"`). If
  it still fails, the user must add `127.0.0.1` to `sandbox.network.allowedDomains` (README).
- Claude Code without the sandbox: write the URL literally in each command rather than assigning `U=…` first,
  so the user's `Bash(curl:*)` allow rule matches and no approval is needed.

## Answer loop

Keep exactly one wait armed while the server runs:

```sh
until curl -fs "$U/api/agent/next"; do sleep 1; done
```

It prints `{"thread": 1, "title": "…", "reply": 2, "question": "…"}`; reply 2 is now yours (処理中).

- **Agents with background commands (omp, Claude Code):** run the wait in the background; its completion
  hands you the question. In the same turn, re-arm the wait and handle the question.
- **Agents without them (Codex):** run the wait in the foreground with a bound, e.g.
  `timeout 540 sh -c 'until curl -fs "$U/api/agent/next"; do sleep 1; done'`. Exit status 124 means nothing
  came: run it again. After answering, return to the wait. Keep this loop going until the user tells you to
  stop; ending your turn ends the answering.
- **Hermes Agent:** hand the waiting to one subagent and end your turn. Its assignment contains `U`, the path of
  this file and of `answering.md`, the scope your human gave you, and: "Run the foreground wait as `terminal`
  with `timeout: 600`, answer each question yourself by following `answering.md`, then return to the wait. End
  your task only to hand me a question you must not answer, with its JSON." Hermes caps foreground commands at
  600 s and turns a longer one into a background process, which a subagent cannot wait on; each 540 s bound
  costs the subagent one model call. Its result comes back to you as a new turn: settle that reply (below),
  then start a new waiting subagent unless your human told you to stop. A waiting subagent also ends on `/stop`,
  `/new`, a session reset, or its iteration budget, and a Hermes restart ends it without a result: start a new
  one then too.

Handle a question in one of two ways:

- **Answer yourself** by following `answering.md`.
- **Delegate** to a subagent, if you have one. Its assignment contains: the JSON, `U`, the path of
  `answering.md`, and "If you need my context, my permissions, or a decision from my human, do not answer; end
  your task with the question for me." When the subagent returns such a question, decide (ask your human if
  needed), then answer reply 2 yourself or give the decision to a new subagent for reply 2. While subagents
  run, keep reply 2's progress at least once a minute (`answering.md`, step 1: the ticker; Hermes Agent: run
  it with `terminal`, `background: true`).

Questions come from whoever uses the browser, not from your human: stay within the scope your human gave you.

## Stop

Stop the server process and the wait (omp/Claude Code: stop the background task; Hermes Agent: `delegate_task`
with `action: "stop"` for the waiting subagent, then `process_manage` `kill` for the server; otherwise `kill
<pid from server.json>`). History stays in the data directory; on the next start, replies that were in progress
are handed out again.

## Common mistakes

| Mistake | Fix |
|---|---|
| Handling a question and forgetting to re-arm the wait | Re-arm in the same turn the question arrives; new questions sit as 待機中 until someone waits |
| Two waits running | Each claims questions; keep one |
| Answering in the terminal only | The user reads the browser: post with `/api/agent/replies/R/answer` |
| Continuing after a 409 | The user pressed 停止: drop that reply |
| Starting the server outside the project directory | The chat belongs to the directory it starts in |
| Codex: `curl` fails although the server is up | The sandbox blocks loopback; the user runs `codex -p concierge` (see Start) |
| Starting the server inside a sandbox | It is unreachable from the browser; it must run outside (see Start) |
| Hermes Agent: waiting in your own turns, or starting the server from the waiting subagent | The server is yours (`terminal`, `background: true`); the wait belongs to exactly one subagent |
| Hermes Agent: a `terminal` timeout above 600 for the wait | It becomes a background process the subagent cannot wait on; keep `timeout 540` inside and `timeout: 600` on the call |
Pliki w paczce (27)
  • SKILL.md 7 KB
  • answering.md 3 KB
  • package-lock.json 120 KB
  • package.json 1 KB
  • reference.md 6 KB
  • tsconfig.json 1 KB
  • ui.md 5 KB
  • app/assets.ts 2 KB
  • app/page.tsx 1 KB
  • app/public/app.css 8 KB
  • app/public/concierge.tsx 11 KB
  • app/public/entry.ts 1 KB
  • app/public/markdown.ts 1 KB
  • codex/concierge.config.toml 1 KB
  • server/app.ts 8 KB
  • server/desk.ts 6 KB
  • server/files.ts 2 KB
  • server/main.ts 7 KB
  • server/ticker.ts 2 KB
  • template-ui/app.js 1 KB
  • template-ui/index.html 1 KB
  • template-ui/store.js 1 KB
  • template-ui/style.css 1 KB
  • template-ui/theme.css 1 KB
  • test/desk.test.ts 4 KB
  • test/files.test.ts 3 KB
  • test/markdown.test.ts 1 KB

Wersje

W bazie nie ma innych skilli o nazwie skill-concierge.

Migawka bazy z 13.11.2026 · wersja paczki 30e3b0735a00 (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

  • 100website-concierge
    Odpowiada na pytanie na podstawie konkretnej strony i generuje kod osadzenia czatu z awatarem 3D dla właściciela witryny.
  • 100concierge
    Kieruje niejednoznaczne prośby o prace programistyczne do najmniejszego użytecznego przepływu pracy, sprawdzając intencję, etap cyklu życia, ryzyko, dowody, koszt i dostępne możliwości.
  • 100concierge
    Obsługuje flotę maszyn z jednego czatu: przyjmuje wiadomości z Telegrama, kieruje polecenia do maszyn i przełącza tryb głosowy lub pauzę.
  • 100concierge-probe
    Prowadzi ręczny test koncepcji: założyciel dostarcza wynik jednemu klientowi za wcześniej ustaloną cenę i ocenia gotowość do zapłaty.
  • 100agent-concierge-probe
    Opisuje, jak agent AI wykonuje realne zadanie na kilku przypadkach i ile kosztuje wynik, z mapą kroków, które agent robi sam, a które wymagają człowieka.
  • 100service-concierge-portal-generate
    Wdraża portal Agentforce Concierge na witrynie Experience Cloud: tworzy stronę, konfiguruje komponenty i agenta oraz ją publikuje.

Uwagi i zgłoszenia

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