원클릭으로 Manus에서 모든 스킬 실행

park-thread

스타3

포크1

업데이트2026년 5월 13일 13:08

Pause or resume an active thread without archiving it. Park flips status from active to parked, preserves the current maturity, captures parked_at plus parked_by plus parked_reason (and optionally unpark_trigger), and moves the thread row from Active to Parked in thread-index.md. Unpark (via --unpark) reverses it, restoring the preserved maturity and clearing the park metadata. Thread stays at its original threads/<slug>/ path — no file move. Use when the user says "park this thread", "pause this", "shelve this for now", "resume <slug>", "unpark this", or "bring <slug> back active".

설치

Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.

Manus에서 실행

출처

ai-project-brain

ai-project-brain/project-brain

GitHub 저장소 열기 Creator 저장소 보기

다운로드

Manus에서 실행

관련 직업SOC

SOC 직업 분류 기준

파일 사무원사무 및 행정 지원직·SOC 43-4071

SKILL.md

readonly

이 저장소의 다른 Skills

같은 저장소

assign-thread

ai-project-brain/project-brain

Manage the assigned_to list on a thread. Supports --add (append handles), --remove (delete handles), --set (replace list), and --clear (remove field entirely). Appends an audit-trail line to the thread body recording who made the change, when, and why. Rebuilds thread-index.md and current-state.md. Use when the user says "assign this thread to <handles>", "add <name> to assigned_to", "unassign from <name>", "clear all assignments", or when managing thread ownership.

2026-05-133

discard-promotion

ai-project-brain/project-brain

Revert a promote PR back to active so the thread becomes editable again. Handles both cases — PR was closed by reviewers (rejected/abandoned), or the user wants to cancel a still-OPEN PR mid-review to keep editing the thread. For OPEN PRs, the skill runs `gh pr close --delete-branch` itself before reverting; for already-closed PRs it just verifies state and reverts. Reverts thread on main from in-review back to active/refining without touching tree_prs (the closed URL stays as audit per CONVENTIONS section 4.1). Does NOT flip any leaf status since leaves never reached main. Use when the user says "discard this promotion", "cancel the promotion", "I want to edit the in-review thread", or after observing a promote PR close without a merge commit.

2026-05-133

discard-thread

ai-project-brain/project-brain

Kill an active or parked thread before it was ever promoted. Flips status to archived, writes archived_at plus archived_by plus discard_reason, git mv's the thread directory from threads/ to archive/, removes the thread's row from Active or Parked sections of thread-index.md and adds it to Archived, and commits. Refuses if tree_prs is non-empty (route to discard-promotion or finalize-promotion instead) or if the thread is in-review. Use when the user says "discard this thread", "drop this idea", "kill this thread", "abandon <slug>", or "archive this — it was never promoted".

2026-05-133

finalize-promotion

ai-project-brain/project-brain

Close out a merged promotion PR. Verifies the PR is merged via gh, flips each landed leaf from in-review to decided on main, appends one entry to promoted_to plus one to promoted_at per leaf, and either returns the thread to active/refining for further work or archives it to project-brain/archive/. Updates thread-index.md and current-state.md to reflect the new state. Use when the user says "finalize the promotion", "close out the PR", "the promotion merged", "archive this thread", or after observing a promote PR go green.

2026-05-133

init-project-brain

ai-project-brain/project-brain

One-time scaffold of the project-brain skeleton into the host environment's project directory. Default invocation runs with **zero interactive questions in the common case** — the skill detects the host project root (Cowork workspace folder, Codex project root, Claude Code cwd, or the nearest git repo root) and scaffolds `project-brain/` inside it. A confirmation is printed showing which source the root came from. The skill only prompts if detection falls all the way through to raw cwd with no git signal, OR if an existing brain is already scaffolded at the target (overwrite vs cancel). Alias and title are derived from the detected home's last-path-component. Owner is written as the literal placeholder `TODO@example.com` with a TODO marker in CONVENTIONS.md § 10 — the user replaces it on their first commit, or leaves it until promote-time. If an existing `project-brain/` is already scaffolded, the skill prompts "overwrite (backup and replace) or cancel?" — it never silently clobbers. Creates project-brain/ wi

2026-05-133

multi-agent-debate

ai-project-brain/project-brain

Run a structured multi-agent review round against either a leaf (hardening) or a thread (refinement). Creates debate/round-NN/ under the artifact per § 7, writes feedback-in.md, spawns per-persona reviewer subagents in parallel (count controlled by --reviewers=N; personas from § 10.2 or ad-hoc via --persona=name:charter), runs a defender that issues CONCEDE / CONCEDE-IN-PART / DEFER / REJECT verdicts, optionally runs a synthesizer, and emits proposed-patches.md plus open-issues.md. Supports --review-mode=full (default) or --review-mode=delta (review only changes since the prior round). On leaf scope, flips status decided|specified ↔ hardening. On thread scope, updates last_debate_round but leaves status/maturity unchanged, enabling multiple review rounds during thread refinement. Use when the user says "run multi-agent review", "review this thread", "harden this leaf", "open a debate round", "close the debate", "round-NN results", or "finish the review cycle".

2026-05-133

name	park-thread
description	Pause or resume an active thread without archiving it. Park flips status from active to parked, preserves the current maturity, captures parked_at plus parked_by plus parked_reason (and optionally unpark_trigger), and moves the thread row from Active to Parked in thread-index.md. Unpark (via --unpark) reverses it, restoring the preserved maturity and clearing the park metadata. Thread stays at its original threads/<slug>/ path — no file move. Use when the user says "park this thread", "pause this", "shelve this for now", "resume <slug>", "unpark this", or "bring <slug> back active".
version	1.0.0-rc4
pack	project-brain
requires	["git","read:~/.config/project-brain/projects.yaml","write:[brain-root]"]

park-thread

Parking is the "alive but paused" state. A thread gets parked when work is blocked on something external (a missing dependency, a decision elsewhere, a quarter-boundary wait), or when the author realizes the thread is not the right shape yet but does not want to discard it. Parked threads stay at their original path and keep every byte of their content — only status and a small set of park metadata fields change.

Unparking is the symmetric reverse: clear the park metadata, restore status: active, and restore the maturity value held at park time. The skill treats the two directions as one operation with a --unpark flag because they share every non-trivial step (resolve, validate, flip, re-sync index, commit) and the divergence is narrow.

When to invoke

"Park this thread" / "pause this" / "shelve this for now"
"I need to stop thinking about until "
"Unpark " / "resume this thread" / "pick this back up"
When current-state.md is cluttered with threads the user isn't actively working, and they want to hide them without killing them
Before switching contexts for a long stretch and wanting to document why the thread was left

Inputs

Name	Source	Required	Description
`thread_slug`	user prompt or cwd inference	yes	Slug of the thread. Defaults to the thread whose directory contains cwd.
`mode`	flag (`--unpark`) or inferred	yes	`park` or `unpark`. If flag is absent, infer from current thread status: `active → park`, `parked → unpark`. Mismatch is a refuse.
`reason`	user prompt	cond.	Short "why paused". Required for `park`. 1–3 sentences; verbatim into `parked_reason`.
`unpark_trigger`	user prompt	no	Optional for `park`. Free-form description of what would cause resumption (e.g. "after Q3 planning", "when ADP spec lands").
`note`	user prompt	no	Optional for `unpark`. A brief note appended to `thread.md` under a `## Park log` heading to record the round-trip.
`--brain=<path>`	user prompt or cwd inference	no	Absolute path to the brain root. Defaults to the nearest ancestor `project-brain/` directory.
`--dry-run`	boolean	no	Print the plan (status flip, park metadata, commit message) without performing any file writes, git mutations, or audit-log writes. See Process § Dry-run semantics.

Prompt strategy: resolve thread_slug from cwd. Infer mode from current status; if ambiguous (e.g. skill invoked without context), ask the user to pick park-vs-unpark. For park, always prompt for reason even if the user supplied an inline reason in their original message — parked threads are often re-read weeks later and a one-word reason is rarely enough.

Preconditions

The skill refuses if any of these are not met.

Current working directory is inside a brain root (a project-brain/ directory containing CONVENTIONS.md) or an explicit --brain=<path> was given.
project-brain/threads/[thread_slug]/thread.md exists.
For park mode:
- Thread status is active. Parking from in-review is refused (close or merge the PR first); parking from parked is a no-op refuse; parking from archived is refused.
- reason is non-empty.
For unpark mode:
- Thread status is parked.
- parked_at, parked_by, parked_reason are present in frontmatter (any missing means the thread was hand-edited into a bad state; refuse and route to manual fix or verify-tree).
- The preserved maturity value is one of exploring | refining | locking.
Working tree has no uncommitted changes to project-brain/thread-index.md, project-brain/current-state.md, or the thread's thread.md.
parked_by is resolvable. If --by <email> is supplied, use it. Otherwise write the literal placeholder TODO@example.com into the parked_by frontmatter field and append a TODO note to the thread body reminding the user to fix it. No git invocation and no env-var read — rc4 keeps park-thread shell-free. Precondition always succeeds (placeholder is always available); it never refuses.

Process

⛔️ HARD CONSTRAINT — ONE TOOL CALL

Call ${PROJECT_BRAIN_PACK_ROOT}/scripts/park-thread.sh ONCE. No Read of thread.md, no pre-flight status check. The script reads frontmatter, determines park vs unpark (from the thread's current status or --unpark flag), validates, mutates, rebuilds indexes.

Derive mode + reason/trigger from language. "Park this for now, waiting on X" → --reason='waiting on X'. "Pick this back up — X just landed" → --unpark --trigger='X landed'. Don't ask.

One call:

"${PROJECT_BRAIN_PACK_ROOT}/scripts/park-thread.sh" \
  --brain=<absolute brain path> \
  --slug=<thread_slug>          \
  --reason='<reason>'           \    # park mode
  [--unpark]                    \    # unpark mode (alternative)
  [--trigger='<trigger>']       \    # optional unpark trigger description
  [--by=<email>]

Infer --slug from cwd. After success, echo the script's stdout in your response message verbatim — don't rely on the Bash tool's result card to display it; the user should see the script's output as part of your reply.

Dry-run semantics

When --dry-run is set:

Run all preconditions (steps 1–2 above), including brain-root existence, thread existence, status checks. Exit 1 if any fail.
Compute the full plan: print the mode (park or unpark), the frontmatter changes, any body append for unpark note, and the rebuild step.
Invoke verify-tree --rebuild-index --dry-run to surface any index-rebuild failures. If that fails, print the error and exit 1.
Write NOTHING to disk: neither frontmatter edits, nor body appends, nor the transcript.
Exit 0 if the plan would succeed end-to-end, exit 1 if any check failed, exit 2 on unexpected error.

Print the plan to stdout as a numbered list. When exiting 1, also print the failing precondition or rebuild error.

Side effects

Files written or modified

Path (relative to brain root)	Operation	Mode	Notes
`threads/[slug]/thread.md`	edit (frontmatter + optional body append)	both	Frontmatter flip; `unpark` optionally appends a `## Park log` entry
`threads/[slug]/transcript.md`	append	both	If `transcript_logging=on` (default)
`thread-index.md`	regenerate	both	By `verify-tree --rebuild-index` from per-thread frontmatter
`current-state.md`	regenerate	both	By `verify-tree --rebuild-index` from per-thread frontmatter

No file moves. The thread directory stays at threads/[slug]/ in both directions. This is deliberate — parking is not archiving.

Git operations

None. This skill performs file operations only. The user runs git add and git commit themselves (§ Git deferred).

When --dry-run is set: NO side effects. Stdout output only.

External calls

None.

Outputs

User-facing summary. A short message with:

The commit SHA.
The new status (parked or active) and the preserved (park) or restored (unpark) maturity.
For park: the reason and unpark trigger, plus the suggestion "Run park-thread --unpark [slug] when you're ready to resume."
For unpark: a pointer to the ## Park log entry (if written) and the suggestion "Continue with update-thread or promote-thread-to-tree."

State passed forward.

thread_slug — unchanged.
mode — park or unpark (the one that ran).
thread_status — resulting status (parked or active).
preserved_maturity — the maturity value carried through (always present in both directions).
parked_reason — present if mode == park.

Verbosity contract

Reads verbosity from <brain>/config.yaml (env override: PROJECT_BRAIN_VERBOSITY). Defaults to terse.

terse (default): one acknowledgement line naming the operation + thread, then Done.
- Example output: Parking project-brain/threads/alpha/ (reason: blocked on ADP). Done.
normal: structured summary of frontmatter changes (status flip, metadata added/removed).
verbose: full narration (pre-rc4 default). Use for debugging.

Frontmatter flips

File	Field	Before	After	Mode
`threads/[slug]/thread.md`	`status`	`active`	`parked`	park
`threads/[slug]/thread.md`	`parked_at`	(absent)	`<ISO-8601>`	park
`threads/[slug]/thread.md`	`parked_by`	(absent)	`<email>`	park
`threads/[slug]/thread.md`	`parked_reason`	(absent)	`<string>`	park
`threads/[slug]/thread.md`	`unpark_trigger`	(absent)	`<string>` (only if given)	park
`threads/[slug]/thread.md`	`status`	`parked`	`active`	unpark
`threads/[slug]/thread.md`	`parked_at`	`<ISO-8601>`	(removed)	unpark
`threads/[slug]/thread.md`	`parked_by`	`<email>`	(removed)	unpark
`threads/[slug]/thread.md`	`parked_reason`	`<string>`	(removed)	unpark
`threads/[slug]/thread.md`	`unpark_trigger`	`<string>` or absent	(removed)	unpark

maturity is never flipped by this skill in either direction. It is preserved across the park/unpark round-trip by design.

When --dry-run is set: no files are written; the frontmatter changes and any body appends are described in the plan output instead.

Postconditions

Thread directory unchanged at threads/[slug]/. Nothing moved, no content deleted.
On park: status == parked, the four park metadata fields are populated, and the thread is visible under ## Parked in thread-index.md (autogenerated).
On unpark: status == active, no park metadata present, and the thread is visible under ## Active in thread-index.md (autogenerated).
maturity equals whatever it was pre-skill (park direction) or pre-park (unpark direction). The round-trip is lossless.
thread-index.md and current-state.md reflect the post-operation state of all threads (autogenerated).
Exactly one commit was added.
verify-tree passes on the thread.

Failure modes

Failure	Cause	Response
Brain root not found	No `project-brain/CONVENTIONS.md` up the tree; no `--brain` given	refuse — prompt user to `init-project-brain`
Thread slug does not resolve	Typo; wrong cwd	refuse — list nearby slugs
`park` on already-`parked` thread	Mode mismatch	refuse — suggest `--unpark` instead
`park` on `in-review` thread	PR is live	refuse — tell user to close, merge, or discard the PR first
`park` on `archived` thread	Terminal state	refuse — no action
`unpark` on non-`parked` thread	Mode mismatch	refuse — report current status
Missing park metadata on `unpark`	Hand-edited thread; frontmatter broken	refuse — suggest `verify-tree` and manual repair
Empty `reason` on `park`	Slipped past prompt	re-prompt — reason is not optional
(retired in rc4 — `parked_by` defaults to `TODO@example.com` when `--by` not supplied)	Git not configured	refuse — ask user to configure git
Uncommitted edits to unrelated paths	Conflict risk	refuse — ask user to stash or commit
Rebuild source-validation failure	Thread frontmatter schema violations	refuse — report violating thread; user must repair before retrying
Rebuild write failure	Filesystem / permissions issue	refuse — live index files unchanged (atomic); report error
`--dry-run` plan shows a precondition failure	Any precondition failed during dry-run	skill exits 1 after printing the plan and the failing precondition. The plan is still useful: the user sees both what was intended and why it wouldn't work.

Related skills

Coordinates with: update-thread, discard-thread — the three pre-promotion thread operations; mutually exclusive per invocation.
Blocks: promote-thread-to-tree — will refuse on a parked thread; unpark first.
Compatible with: verify-tree — run after unpark to confirm the round-trip restored a clean state.
Mutually exclusive with: itself — cannot be re-invoked in the same mode without an interleaving flip (no-op refuse).

Asset dependencies

None. The skill edits existing frontmatter and index files; it does not create files from templates. The ## Park log heading in thread.md is created on-demand by unpark when a note is supplied.

Versioning

0.2.2 — Added --dry-run flag specification with full semantics contract, including exit codes 0/1/2 (2 reserved for unexpected errors).

0.2.0 — Stage 2 of v0.9.0: index-file updates moved to centralized verify-tree --rebuild-index final step; previous inline edits removed.

0.1.0 — initial draft. Minor bump if a pin/snooze variant is added (e.g. a "park until " that auto-unparks). Major bump if the preservation semantics around maturity change (e.g. a rule that parking always resets maturity to refining on unpark).