Przejdź do treści
Biblioteka skilli
Nauka i badania · Planowanie

new-task

/new-task

Zakłada nowe zadanie w projekcie open science: ustala projekt z użytkownikiem, pisze plan.md z szablonu oraz tworzy kontekst, dziennik i podkontekst zadania.

Repozytorium
open-science ↗
Licencja
MIT
Ostatnia zmiana repozytorium
15.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 15.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

Zakłada nowe zadanie w projekcie open science: ustala projekt z użytkownikiem, pisze plan.md z szablonu oraz tworzy kontekst, dziennik i podkontekst zadania.

Wyzwalacze z opisu

brainstorm
Oryginalny opis (EN)

Start a new task in an open-science project - settle the design with the user, write tasks/<id>/plan.md from the plan template, and create the task's context, log and subcontext. Use when the user asks to start a task, plan a piece of work, start a campaign, or track a piece of work that will outlive one session. Also for small tasks and explorations that need no plan; without asking, when the user says "brainstorm" or asks to explore an idea or question in the project (a brainstorm task); and, without asking, when the user asks to audit, check, reproduce or adversely review work that is alrea

Jak działa

  1. Philosophy of a plan
  2. Procedure
  3. Privacy tier
  4. Brainstorm tasks
  5. Verification tasks
  6. Autonomy (plan header)
Sekcje z nagłówków SKILL.md, w oryginale · 147 linii, 1 362 słów
Podgląd SKILL.md
---
name: new-task
description: Start a new task in an open-science project - settle the design with the user, write tasks/<id>/plan.md from the plan template, and create the task's context, log and subcontext. Use when the user asks to start a task, plan a piece of work, start a campaign, or track a piece of work that will outlive one session. Also for small tasks and explorations that need no plan; without asking, when the user says "brainstorm" or asks to explore an idea or question in the project (a brainstorm task); and, without asking, when the user asks to audit, check, reproduce or adversely review work that is already done (a verification task).
---

# New task

A task is a directory, `tasks/<id>/`: node header and state in `context.md`, the plan in
`plan.md`, history in `log.md`, working documents in `subcontext/`. The id is short, lower
case, and starts with a sequence number (`t07-mode-fit-v2`).

## Philosophy of a plan

- The complete specification up front; then the executing agent runs. Each subtask section
  carries everything that subtask needs, with numbers and paths inline.
- No "verify each step", no self-review or second-agent review. A control case (an input
  that must fail) goes inside the subtask's own check.
- Gates only where a mistake is expensive or irreversible: deleting or overwriting data,
  large compute, a claim reaching the user or the public repo.
- No hedging and no numbered micro-steps for routine mechanics. A step states the outcome,
  the artifact and the acceptance criterion.
- Every subtask has a tier and a cost estimate with a ±2× band. Only parallel tracks are
  dispatched, at `med-effort` by default. Sequential work and open-ended debugging stay with
  the main agent.
- **Run to completion.** Once the user approves the plan, the main agent does not stop
  until it is done, except at a hold point or on something fatal (`contracts/main.md` §4).

## Procedure

1. **Settle the design.** Ask the user only the decisions that are theirs: goal, what counts
   as done, constraints, budget, autonomy level. Propose one recommended approach and name
   the alternatives in a line each. The design goes into the plan; there are no spec files.
   Settle the privacy tier too ("Privacy tier" below), and a short name: a few words, lower
   case and hyphens, at most 24 characters (`pp-real`, `noise-model`). Sessions driving the
   task show it after the project name, as `<project> · <short name>`.

2. **Create the task directory:**

   ```bash
   opsci task new <id> --title "<title>" --short-name <short> --plan \
       [--privacy public|soft-private|hard-private] \
       [--depends-on <id>...] [--related <id>...] [--supersedes <id>...] \
       [--autonomy autonomous|checkpoints|collaborative] [--hold-at S2 ...]
   ```

   It writes `context.md` with a validated node header, `map.md` (the task's graph, one node
   to start with), `results/README.md` (the task's results page, generated), `log.md`,
   `subcontext/`, and `plan.md` from the plan template (the header repeated, plus `autonomy`
   and `hold_at`). It refuses a bad or existing id and an edge to a node that does not
   exist. Without `--plan` you get a task with no plan: right for small work and
   explorations.

3. **Write the plan** into `plan.md`, keeping the template's sections in order: Goal (a
   falsifiable "done"), Design (with rejected alternatives, one line each), Constraints
   (conventions, environment, compute read from `config/site.local.yaml` and never written
   into the plan, frozen files, rule ids), Delegation, one section per subtask (output
   directory `tasks/<id>/<S>/`, delivers, steps, gate, **Fatal if**), Escalate only if
   fatal, Budget. No absolute paths and no submit lines in the plan.

4. **Fill `context.md`:** summary in the header, goal, the next step a fresh session would
   execute. Add the task to the project `context.md` task table. If the work changes shared
   code while other work runs, give it its own branch and worktree
   (`git worktree add ../<project>-<id> -b <id>`) and name it in the task context.

5. **Freshness test:** could a fresh session act from `AGENTS.md`, the project `context.md`
   and this task's `context.md` alone? Anything it would have to ask belongs in one of them.
   Run `opsci map build` and `opsci context check`.

6. **Switch the session to the new task**, right after `opsci task new`, for every kind of
   task (planned, no plan, brainstorm, verification), unless the user says to stay on the
   current one. With the `open-science-context` plugin installed, register the pane for the
   new task's `context.md` (`open-science-context:context-management`, "Pane registration"),
   so a jump or `/clear` resumes the new task. Say in one line that the session now drives
   the new task.

7. Commit, and **report the plan to the user and stop.** Execution starts when the user
   approves it. Report it where the user reads: in a project mirrored to Notion (an
   `AGENTS.md` "Notion" section), run `opsci notion sync` and post
   `opsci notion post --kind question --task <id> --mention "<id>: plan ready for approval\n\n<goal, subtasks, cost in a few lines>"`;
   otherwise `opsci notify` it. Do this unasked.

## Privacy tier

A task is `public` by default (`--privacy` omitted); a brainstorm task is `soft-private`, and
so is a task whose goal is not science or code (the results website, infrastructure, tooling,
release preparation): set it and tell the user (`open-science-publish:publish`,
`reference/science-or-code.md`). Otherwise, if the task obviously looks private, ask first:

> This task looks like it may be private. Which tier should it have?
> - `public` (default): may be released; the task directory is exported.
> - `soft-private`: not released, but other documents may mention it by name, and the public
>   map names it without a link. For example private notes, brainstorm ideas, work too messy
>   to release.
> - `hard-private`: must not appear anywhere in the release, not even by name. For example
>   proprietary data, unpublished ideas, collaborators' unpublished work, private information
>   about people.

A soft- or hard-private task keeps its work inside `tasks/<id>/` (large data in
`data/<task-id>/` as usual), so that it is easy to keep out. A public task mentions
soft-private material at most in passing and never mentions hard-private material
(`AGENTS.md` §0, §6). A private task's header needs no rewording now: at publish time the
publish skill decides how the public map shows it, and flags any line of the published
project `context.md` and `log/` that names a hard-private task, for the user to decide
(`open-science-publish:publish`).

## Brainstorm tasks

An idea not yet ready to be project work goes under `brainstorm/` (its own context and
tasks; its nodes are part of the project graph). Same procedure, with `brainstorm` as the
root: `opsci task new b01-<slug> --title "<title>" --root brainstorm`, `opsci map build`,
`opsci context check brainstorm`. Ids start with `b`. Edges may join brainstorm and project
nodes in either direction: add one when the idea builds on project work or project work
comes from the idea. Give `--privacy public` only when the user asks for the idea to be
published, and `--privacy hard-private` for a hard-private idea.

A brainstorm task needs no plan and no approval. Make it as soon as the user says
"brainstorm" or starts exploring an idea: skip step 1's questions, create it without
`--plan`, record the question and what has been found so far in its `context.md` and in the
brainstorm `context.md` table, switch the session to it (step 6), commit, and carry on with
the conversation. Step 7's stop does not apply. Keep its `context.md` current as the
discussion goes on. A side question about existing work, not a new idea, is a private
investigation instead (`open-science-project:private-investigation`).

**Graduating an idea** is a new project task (no `--root`) whose `context.md` or `plan.md`
restates the idea (the question, what was found, the evidence), copied or rewritten so that
the task stands alone. It never links to `brainstorm/`; it may mention the idea in passing
(`AGENTS.md` §5). Then mark the brainstorm node `done`, naming the new task in its
`summary`.

## Verification tasks

A verification task audits, checks, reproduces or adversely reviews finished work (a task, a
result, a dataset). When the user asks for one, make it without asking; when it is unclear
whether the request checks finished work or asks for new work, propose one and ask. Never
start one to recheck your own work (`AGENTS.md` §2). Same procedure, with
`opsci task new v01-<slug> --title "<title>" --verifies <id>...`: it goes in
`tasks/<id>/verifications/` when every verified node lies in that task, else in
`verifications/`; its privacy is the strictest of the verified nodes (do not ask). Its
findings are results in its own `results/`; a confirmed node gets `verification: verified`
with `evidence:` there, a refuted one a new `status` (`tasks/README.md`).

## Autonomy (plan header)

| `autonomy` | the main agent |
|---|---|
| `autonomous` (default) | runs the whole plan and escalates only fatal problems |
| `checkpoints` | also stops at each point listed in `hold_at` |
| `collaborative` | also asks whenever two readings of the plan would lead to materially different work |

Fatal problems: `contracts/main.md` §4. A failed gate or an overrun is not fatal by itself.

Wersje

RepozytoriumWynikLicencja
Ta strona · mhycheung/open-science100MIT
sabbah13/cowork-tasks90MIT

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

  • 100brainstorm
    Planuje zadanie z użytkownikiem przed budową: bada projekt, zadaje rundy pytań, zapisuje specyfikację i wykonuje ją po zgodzie.
  • 90research-start
    Prowadzi przez start projektu badawczego lub badania danych i ML: plan, strukturę komponentów i potok, zanim powstanie kod.
  • 100context-files
    Utrzymuje aktualne pliki kontekstu projektu szablonowego w limitach linii: context.md projektu i zadań, podkontekst i logi, oraz przeprowadza cztery pytania na koniec podzadania.
  • 100update-from-template
    Przenosi ulepszenia szablonu projektu open science z historii frameworku, zachowuje celowe zmiany i wykonuje migracje układu według CHANGELOG.
  • 100work-start
    Rozpoczyna nowe zadanie: wczytuje kontekst i przygotowuje archiwum dla funkcji, poprawki lub projektu.
  • 100brainstorm
    Bada bazę kodu, ustala z użytkownikiem pomysł i tworzy mapę drogową oraz prompt do planowania, gdy trzeba sprawdzić wykonalność.

Uwagi i zgłoszenia

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