# Send Preqstation to your agent
Hand the extracted package to your coding agent with a concrete install brief instead of figuring it out manually.
## Fast path
- Download the package from Yavira.
- Extract it into a folder your agent can access.
- Paste one of the prompts below and point your agent at the extracted folder.
## Suggested prompts
### New install

```text
I downloaded a skill package from Yavira. Read SKILL.md from the extracted folder and install it by following the included instructions. Then review README.md for any prerequisites, environment setup, or post-install checks. Tell me what you changed and call out any manual steps you could not complete.
```
### Upgrade existing

```text
I downloaded an updated skill package from Yavira. Read SKILL.md from the extracted folder, compare it with my current installation, and upgrade it while preserving any custom configuration unless the package docs explicitly say otherwise. Then review README.md for any prerequisites, environment setup, or post-install checks. Summarize what changed and any follow-up checks I should run.
```
## Machine-readable fields
```json
{
  "schemaVersion": "1.0",
  "item": {
    "slug": "preqstation",
    "name": "Preqstation",
    "source": "tencent",
    "type": "skill",
    "category": "开发工具",
    "sourceUrl": "https://clawhub.ai/sonim1/preqstation",
    "canonicalUrl": "https://clawhub.ai/sonim1/preqstation",
    "targetPlatform": "OpenClaw"
  },
  "install": {
    "downloadUrl": "/downloads/preqstation",
    "sourceDownloadUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=preqstation",
    "sourcePlatform": "tencent",
    "targetPlatform": "OpenClaw",
    "packageFormat": "ZIP package",
    "primaryDoc": "SKILL.md",
    "includedAssets": [
      "MEMORY.md",
      "README.md",
      "SKILL.md",
      "_meta.json"
    ],
    "downloadMode": "redirect",
    "sourceHealth": {
      "source": "tencent",
      "slug": "preqstation",
      "status": "healthy",
      "reason": "direct_download_ok",
      "recommendedAction": "download",
      "checkedAt": "2026-05-07T09:58:49.510Z",
      "expiresAt": "2026-05-14T09:58:49.510Z",
      "httpStatus": 200,
      "finalUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=preqstation",
      "contentType": "application/zip",
      "probeMethod": "head",
      "details": {
        "probeUrl": "https://wry-manatee-359.convex.site/api/v1/download?slug=preqstation",
        "contentDisposition": "attachment; filename=\"preqstation-0.1.8.zip\"",
        "redirectLocation": null,
        "bodySnippet": null,
        "slug": "preqstation"
      },
      "scope": "item",
      "summary": "Item download looks usable.",
      "detail": "Yavira can redirect you to the upstream package for this item.",
      "primaryActionLabel": "Download for OpenClaw",
      "primaryActionHref": "/downloads/preqstation"
    },
    "validation": {
      "installChecklist": [
        "Use the Yavira download entry.",
        "Review SKILL.md after the package is downloaded.",
        "Confirm the extracted package contains the expected setup assets."
      ],
      "postInstallChecks": [
        "Confirm the extracted package includes the expected docs or setup files.",
        "Validate the skill or prompts are available in your target agent workspace.",
        "Capture any manual follow-up steps the agent could not complete."
      ]
    }
  },
  "links": {
    "detailUrl": "https://openagent3.xyz/skills/preqstation",
    "downloadUrl": "https://openagent3.xyz/downloads/preqstation",
    "agentUrl": "https://openagent3.xyz/skills/preqstation/agent",
    "manifestUrl": "https://openagent3.xyz/skills/preqstation/agent.json",
    "briefUrl": "https://openagent3.xyz/skills/preqstation/agent.md"
  }
}
```
## Documentation

### preqstation

Use this skill for natural-language requests to execute PREQSTATION-related work with local CLI engines.

### Trigger / NOT for

Trigger this skill with highest priority when the message contains any of:

/skill preqstation
preqstation
preq

Do NOT use this skill for:

simple one-line manual edits that can be handled directly
read-only file inspection or explanation without execution
any coding-agent launch inside ~/clawd/ or ~/.openclaw/

### Quick trigger examples

/skill preqstation: implement the PROJ-1
preqstation: plan PROJ-76 using Claude Code
preq: implement PROJ-1

### Hard rules

Always run coding agents with pty:true.
Respect the engine the user requested. If unspecified, default to claude.
Do not kill sessions only because they are slow; poll/log first.
Never launch coding agents in ~/clawd/ or ~/.openclaw/.
Treat resolved project path as a primary checkout source only; create a git worktree before launching any coding agent.
Never run coding-agent commands in the primary checkout path.
PR review must run in a temp clone or git worktree, never in a live primary checkout.
Keep execution scoped to resolved worktree <cwd> only.
Worktree branch names must include the resolved project key.
Launch coding agents with background:true by default. Use foreground only when user explicitly asks for blocking/synchronous execution.

### Runtime prerequisites (required)

git must be installed and available on PATH.
At least one engine binary must be installed: claude, codex, or gemini.
Environment variables used by this skill:

OPENCLAW_WORKTREE_ROOT (optional, default /tmp/openclaw-worktrees)


This skill reads and updates MEMORY.md project mappings with absolute paths.

### Execution safety gates (required)

Before running any engine command:

Run preflight checks:

command -v git
command -v <engine>


Continue only when execution cwd is a resolved git worktree path for this task.
Never run engine commands in primary checkout paths or inside ~/clawd/ / ~/.openclaw/.
Use dangerously-* / sandbox-disable flags only for actual coding execution with local trusted CLIs.
For planning/read-only requests, do not launch engine commands.

### Input interpretation

Parse from user message:

engine

if explicitly provided: claude, codex, or gemini
default: claude

task

first token matching <KEY>-<number> (example: PRJ-284)
optional

branch_name (optional)

parse first token matching one of:

branch_name=<value>
branch_name: <value>
branch=<value>


strip surrounding quotes from <value>
normalize to lowercase; replace whitespace with -
if it does not include the resolved project_key, prefix with preqstation/<project_key>/

project_cwd (required to prepare execution)

if absolute path is explicitly provided, use it
else resolve by project key from MEMORY.md
else if task prefix key matches a MEMORY.md project key, use that path
if unresolved, ask for project key/name and absolute path, update MEMORY.md, then continue execution
if an exact project key does not exist in MEMORY.md, always ask the user before execution (do not guess)

objective

use the user request as the execution objective

cwd (required to execute)

default: per-task git worktree path derived from project_cwd
create worktree before launching engine commands
if project_cwd is not a git checkout, ask for a git workspace path before execution

progress_mode (status update style)

if user explicitly says live, realtime, frequent, detailed: use live
if user explicitly says sparse, concise, summary-only, key events only: use sparse
default: sparse
when not explicit, ask once only if user's wording is ambiguous/conflicting

context_compaction

default: keep the current conversation/session and compact status updates instead of starting a new session
avoid replaying full logs; send a short checkpoint summary and continue from that summary
start a new session only when user explicitly requests it or when platform limits prevent continuing in the current session

### MEMORY.md resolution

Read MEMORY.md from this repository root.
Use the Projects table (key | cwd | note).
Match project keys by exact key only (case-insensitive, no fuzzy/partial matching).
If exact project key is missing, ask the user for the correct key/path before continuing.
If user asks to add/update project path mapping, update MEMORY.md first, then confirm.
If task id exists, treat the prefix as candidate project key (example: PROS-102 -> pros).

### MEMORY.md update rules

Keep mappings in the Projects table only.
Add or update using this row format: | <key> | <absolute-path> | <note> |.
Use one row per key. If a key already exists, replace that row.
Always store absolute paths (no relative paths).
Normalize key to lowercase kebab-case before writing.
If user provides project name, store it in note; otherwise use workspace.

### Missing project mapping flow (required)

When project_cwd cannot be resolved, or exact project key is missing in MEMORY.md:

Ask one short question requesting:

project key (or confirm inferred key from task prefix)
absolute workspace path
optional project name for note

Validate path is absolute.
Update or insert the MEMORY.md row immediately.
Confirm mapping in one short line.
Continue the original task using the newly resolved project_cwd, then create task worktree cwd and execute.

### Branch naming convention (project key based)

Resolve branch name using this priority:

parsed branch_name from user message
fallback: preqstation/<project_key>

Rules:

<project_key> must be the resolved project key from MEMORY.md.
normalize to lowercase and kebab-case-friendly tokens.
branch must include resolved project_key; if missing, prefix with preqstation/<project_key>/.
reject unsafe names (.., leading /, or empty result) and ask user for a valid branch name.

### Worktree-first execution (required default)

After resolving project_cwd and project_key, prepare execution workspace:

Build branch name using this skill's convention:

<branch_name>

Build per-task worktree path:

default root: ${OPENCLAW_WORKTREE_ROOT:-/tmp/openclaw-worktrees}
directory: <worktree_root>/<project_key>/<branch_slug>
branch_slug = <branch_name> with / replaced by -

Create the worktree from project_cwd before launching engine:

new branch: git -C <project_cwd> worktree add -b <branch_name> <cwd> HEAD
existing branch: git -C <project_cwd> worktree add <cwd> <branch_name>

Use this worktree path as <cwd> for prompt rendering and engine execution.

### Prompt rendering (required template)

Do not forward raw user text directly. Render this template:

In this template, <cwd> must be the task worktree path (not the primary checkout path).

Task ID: <task or N/A>
Project Key: <project key or N/A>
Branch Name: <branch_name or N/A>
User Objective: <objective>
Execution Requirements:
1) Work only inside <cwd>.
2) Complete the requested work.
3) Use branch <branch_name> for commits/pushes when provided.
4) After completion, return a short completion summary.

### Engine commands (current policy retained)

All engine commands must be launched via bash with PTY and explicit workdir.

Why dangerously-* flags are retained:

This skill targets non-interactive PTY/background execution.
Permission prompts can block unattended runs; these flags avoid that blocking behavior.
These flags are allowed only after passing the required safety gates above and only in resolved task worktrees.
If your environment does not allow these flags, fail fast with a short reason instead of silently falling back.

### Claude Code

bash pty:true workdir:<cwd> command:"claude --dangerously-skip-permissions '<rendered_prompt>'"

### Codex CLI

bash pty:true workdir:<cwd> command:"codex exec --dangerously-bypass-approvals-and-sandbox '<rendered_prompt>'"

### Gemini CLI

bash pty:true workdir:<cwd> command:"GEMINI_SANDBOX=false gemini -p '<rendered_prompt>'"

### Bash execution interface (required)

Use bash with PTY and background mode by default.

### Bash parameters

ParameterTypeRequiredPurposecommandstringyesEngine command to runptybooleanyesMust be true for coding-agent CLIsworkdirstringyesPer-task worktree <cwd>backgroundbooleannoRun asynchronously and return session id (this skill defaults to true)timeoutnumbernoHard timeout in secondselevatedbooleannoHost execution if policy allows

### Process actions for background sessions

Use these actions as standard controls:

list: list sessions
poll: check running/done status
log: read incremental output
write: send raw stdin
submit: send stdin + newline
kill: terminate a session only when required

### One-shot example

Create a task worktree, then run inside that worktree (default background):

git -C <project_cwd> worktree add -b <branch_name> /tmp/openclaw-worktrees/<project_key>/<branch_slug> HEAD
bash pty:true workdir:/tmp/openclaw-worktrees/<project_key>/<branch_slug> background:true command:"codex exec --dangerously-bypass-approvals-and-sandbox '<rendered_prompt>'"

The Pattern: workdir + background + pty
For longer tasks, use background mode with PTY:

# Start agent in task worktree (with PTY!)
bash pty:true workdir:<cwd> background:true command:"codex exec --full-auto 'Build a snake game'"
# Returns sessionId for tracking

# Monitor progress
process action:log sessionId:XXX

# Check if done
process action:poll sessionId:XXX

# Send input (if agent asks a question)
process action:write sessionId:XXX data:"y"

# Submit with Enter (like typing "yes" and pressing Enter)
process action:submit sessionId:XXX data:"yes"

# Kill if needed
process action:kill sessionId:XXX

Why workdir matters: Agent wakes up in a focused directory, doesn't wander off reading unrelated files (like your soul.md 😅).

### If user input is required mid-run

process action:write sessionId:<id> data:"y"
process action:submit sessionId:<id> data:"yes"

### PR review safety pattern (temp dir/worktree only)

Never run PR review in live OpenClaw folders.

# default: git worktree review (resolved branch naming)
git worktree add -b <branch_name> /tmp/<project_key>-review <base_branch>
bash pty:true workdir:/tmp/<project_key>-review command:"codex review --base <base_branch>"

# fallback: temp clone review (only when local checkout is unavailable)
REVIEW_DIR=$(mktemp -d)
git clone <repo> "$REVIEW_DIR"
cd "$REVIEW_DIR" && gh pr checkout <pr_number>
bash pty:true workdir:"$REVIEW_DIR" command:"codex review --base origin/main"

### Issue worktree pattern

git worktree add -b <branch_name> /tmp/<project_key> main

bash pty:true workdir:/tmp/<project_key> background:true command:"codex exec --dangerously-bypass-approvals-and-sandbox 'Fix issue #101. Commit after validation.'"
bash pty:true workdir:/tmp/<project_key> background:true command:"codex exec --dangerously-bypass-approvals-and-sandbox 'Fix issue #102. Commit after validation.'"

process action:list
process action:log sessionId:<id>

### Progress Updates (Critical)

For background runs, choose one of two modes:

sparse (default): low-frequency updates only on state change
live: higher-frequency updates while work is running
Primary purpose of sparse: reduce token usage and messaging cost while preserving key visibility.

How user can request mode in a message:

... progress live
... live updates
... progress sparse
... sparse updates

When you spawn coding agents in the background, keep the user in the loop based on selected mode.

In sparse mode:

Send 1 short message when you start (what's running + where).
Then only update again when something changes:

a milestone completes (build finished, tests passed)
the agent asks a question / needs input
you hit an error or need user action
the agent finishes (include what changed + where)




In live mode:

Send the same state-change updates as sparse.
Add periodic short heartbeat updates while running (for example, every 1-2 minutes) with latest active step.


If you kill a session, immediately say you killed it and why.

This prevents the user from seeing only "Agent failed before reply" and having no idea what happened.

### Context compaction for long runs

OpenClaw thread context grows over time. Keep it compact during long background tasks:

Prefer sparse unless the user explicitly asks for live.
Use short checkpoint summaries at milestones; avoid repeating prior logs.
Include only: current state, what changed, next step, blocker (if any).
If the thread becomes too large/noisy, post one compaction summary and continue in the same thread/session whenever possible.

### Auto-notify on completion

For long-running jobs, append a completion trigger to the rendered prompt:

When completely finished, run this command:
openclaw system event --text "Done: <brief summary>" --mode now

Example:

bash pty:true workdir:<cwd> background:true command:"codex exec --dangerously-bypass-approvals-and-sandbox '<rendered_prompt>

When completely finished, run:
openclaw system event --text \\"Done: implemented requested PREQSTATION task\\" --mode now'"

### Output policy

Return only a short completion summary.
Success format:
completed: <task or N/A> via <engine> at <cwd>

Failure format:
failed: <task or N/A> via <engine> at <cwd or N/A> - <short reason>

Do not dump raw stdout/stderr unless user explicitly asks.
## Trust
- Source: tencent
- Verification: Indexed source record
- Publisher: sonim1
- Version: 0.1.8
## Source health
- Status: healthy
- Item download looks usable.
- Yavira can redirect you to the upstream package for this item.
- Health scope: item
- Reason: direct_download_ok
- Checked at: 2026-05-07T09:58:49.510Z
- Expires at: 2026-05-14T09:58:49.510Z
- Recommended action: Download for OpenClaw
## Links
- [Detail page](https://openagent3.xyz/skills/preqstation)
- [Send to Agent page](https://openagent3.xyz/skills/preqstation/agent)
- [JSON manifest](https://openagent3.xyz/skills/preqstation/agent.json)
- [Markdown brief](https://openagent3.xyz/skills/preqstation/agent.md)
- [Download page](https://openagent3.xyz/downloads/preqstation)