メニュー
ALU execution pattern for ephemeral autonomous work. Detects hooked work, enters GUPP autonomous mode, executes the assigned bead, commits and pushes results, then self-terminates. Never coordinates other agents.
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/Tibsfox/gsd-skill-creator --skill polecat-workerコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
Use the moment a request is underspecified and you are about to act on an ASSUMED goal. Enumerate the candidate goals the request could mean, project the action or artifact each one implies, and check whether they diverge: if two or more plausible goals lead to materially different actions or artifacts, ask exactly ONE targeted clarifying question; otherwise proceed on the most-likely goal and state the assumption in one line. Clarification is an evidence-producing action, not a delay — but one question, never an interrogation. Distinct from gsd-spec-phase (GSD-phase-bound, emits a heavy SPEC.md) and intent-router (fetch strategy, not goal disambiguation). Backed by agent goal-state inference (arxiv 2606.16813v1). Triggers on acting under an assumed goal when the request admits more than one materially different reading.
Use at write time to vector/embedding memory — Grove content-addressed insertion, chroma/pgvector upserts, memory-consolidation promoting session traces to MEMORY.md, or embedding externally-ingested content. Scores each candidate record against a fixed panel of sentinel queries and quarantines any record that would become the nearest neighbor of too many unrelated queries — a hub — whether from adversarial poisoning or accidental over-generality. This is the memory-record-side sibling of skill-injection-guardian (file-side) and the write-side complement of memory-use-warrant (read-side). Quarantine, never silently drop; a human reviews. Backed by the admission-time hubness gate (arxiv 2606.19692v1). Triggers on inserting into vector memory, consolidating memory, and embedding stranger content.
Run this appropriateness check the moment you are about to integrate a retrieved long-term memory — a Grove content-addressed hit, a chroma/pgvector neighbour, a memory-consolidation digest, or a MEMORY.md line — into a response, especially anything touching private origins, Fox Companies IP, credentials, or Center Camp / consent-governed content. It answers a question intent-router never asks: not WHAT to fetch or HOW, but WHETHER a correctly-retrieved item should reach output. Relevance is not appropriateness — a perfect similarity match can still be a boundary violation. Default is FAIL-CLOSED: if in-context authorization is uncertain, the memory may inform behaviour but must not be surfaced. Backed by RBI-Eval (arxiv 2606.06055v1). Triggers on surfacing recalled sensitive memory into a response.
SKILL.md を表示中
SOC 職業分類に基づく
| name | polecat-worker |
| description | ALU execution pattern for ephemeral autonomous work. Detects hooked work, enters GUPP autonomous mode, executes the assigned bead, commits and pushes results, then self-terminates. Never coordinates other agents. |
| type | skill |
| category | orchestration |
| status | stable |
| origin | tibsfox |
| modified | false |
| first_seen | "2026-03-06T00:00:00.000Z" |
| first_path | .claude/skills/polecat-worker/SKILL.md |
| superseded_by | null |
Ephemeral execution unit for single-bead autonomous work. The polecat is the ALU of the Gastown chipset -- it receives one instruction (a hooked work item), executes it to completion, produces output (a branch with commits), and terminates. Polecats do not persist between tasks. Identity lives in the bead (git-backed state); the session is disposable.
This skill activates when:
The Gas Town Universal Propulsion Principle defines the polecat's entire lifecycle. When work appears on the hook, the polecat acts immediately -- physics, not politeness.
The four-step cycle:
1. CHECK HOOK Is there a bead on my hook?
| |
no yes
| |
[idle] 2. ANNOUNCE
|
3. EXECUTE
|
4. DONE (terminate)
Step 1 -- Check Hook:
const state = new StateManager({ stateDir: '.chipset/state/' });
const hook = await state.getHook(myAgentId);
if (!hook || hook.status === 'empty') {
// No work assigned -- remain idle
return;
}
// Work found -- enter GUPP mode
const workItem = hook.workItem;
Step 2 -- Announce:
// Notify the mayor/convoy that work has started
await state.updateAgentStatus(myAgentId, 'active');
await state.updateWorkStatus(workItem., );
: = {
: myAgentId,
: ,
: ,
: ,
: ().(),
: ,
};
Step 3 -- Execute:
This is where the actual work happens. The polecat:
git checkout -b polecat/{beadId}The polecat works autonomously. It does not wait for approval between steps. It does not ask for permission. GUPP means: if the work is on your hook, you execute it.
Step 4 -- Done:
// Push branch to remote
// git push origin polecat/{beadId}
// Update state
await state.updateWorkStatus(workItem.beadId, 'done');
await state.clearHook(myAgentId);
await state.updateAgentStatus(myAgentId, 'terminated');
// Send completion mail
const completion: AgentMessage = {
from: myAgentId,
to: 'mayor',
channel: 'mail',
payload: `DONE: ${workItem.beadId} - branch pushed, ready for merge`,
timestamp: new Date().toISOString(),
durable: true,
};
Each polecat creates a dedicated branch for its work, commits incrementally, and pushes to remote on completion.
Branch naming: polecat/{bead-id} (e.g., polecat/bead-a1b2c)
Commit strategy:
Push timing: Push only on completion (Step 4). Intermediate work stays local until the polecat calls done.
When work completes, the polecat terminates its own session. "Done means gone" -- there is no re-activation. The polecat's lifecycle is one-way:
spawned -> active -> done -> terminated
There is no "paused" state. There is no "reassigned" state. If a polecat's work needs to be reassigned, the mayor terminates the polecat and spawns a new one.
If the polecat's session restarts unexpectedly (process crash, context reset), it recovers by checking its hook:
// On startup, always check hook first
const hook = await state.getHook(myAgentId);
if (hook && hook.status === 'active') {
// Work was in progress -- resume from last commit
// Check git log on the working branch to determine progress
// Continue execution from where it left off
}
if (hook && hook.status === 'pending') {
// Work was assigned but not started -- begin GUPP from step 2
}
The hook state file is the polecat's durable memory. The session is ephemeral; the hook survives.
Polecats have minimal communication needs. They receive work and report completion. That is all.
| Channel | Source | Content |
|---|---|---|
hook | Sling (via mayor) | Work item assignment placed on hook |
nudge | Witness or Mayor | "Are you still working?" health check |
| Channel | Target | Purpose | Durability |
|---|---|---|---|
mail | Mayor / Convoy | Work started announcement | Durable |
mail | Mayor / Convoy | Work completion report | Durable |
If the polecat receives a nudge while actively working, it sends a brief status update:
// Nudge received from witness
const response: AgentMessage = {
from: myAgentId,
to: nudge.from,
channel: 'mail',
payload: `ACTIVE: working on ${currentBead.beadId}, last commit ${lastCommitHash}`,
timestamp: new Date().toISOString(),
durable: true,
};
SPAWN HOOK EXECUTE DONE
| | | |
v v v v
created -> detect work -> autonomous -> push + terminate
(idle) (GUPP step 1) execution (one-way exit)
(steps 2-3) (step 4)
The entire lifecycle is forward-only. A polecat never goes backward in this sequence.
If the polecat encounters an error during execution:
// On execution error
await state.updateWorkStatus(workItem.beadId, 'done'); // mark as done (failed)
const failureMail: AgentMessage = {
from: myAgentId,
to: 'mayor',
channel: 'mail',
payload: `FAILED: ${workItem.beadId} - ${errorDescription}`,
timestamp: new Date().toISOString(),
durable: true,
};
await state.clearHook(myAgentId);
await state.updateAgentStatus(myAgentId, 'terminated');
If the polecat's context window fills before work is complete:
If the polecat detects a hook that references a non-existent or already-completed work item:
The polecat NEVER:
The polecat is a worker. It takes one task, does it, and stops. If it finds itself managing other agents or making coordination decisions, something has gone wrong.
| Skill | Relationship |
|---|---|
mayor-coordinator | Mayor dispatches work TO polecat via hooks |
witness-observer | Witness monitors polecat health, sends nudges |
refinery-merge | Refinery processes polecat's completed branch |
beads-state | Polecat uses StateManager for hook checks and status updates |
references/gastown-origin.md -- How this pattern derives from Gastown's polecat.goreferences/examples.md -- Hook detection, autonomous execution, branch+push+donereferences/boundaries.md -- No coordination, single bead scope, lifecycle constraints