End-to-end source processing -- seed, reduce, process all claims through reflect/reweave/verify, archive. The full pipeline in one command. Triggers on "/pipeline", "/pipeline [file]", "process this end to end", "full pipeline".
Standardmäßig ist der Prompt ausgewählt, der zuerst die Quelle prüft. Sie können zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.
Quelldateien prüfen
Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich für eine Installation entscheiden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
End-to-end source processing -- seed, reduce, process all claims through reflect/reweave/verify, archive. The full pipeline in one command. Triggers on "/pipeline", "/pipeline [file]", "process this end to end", "full pipeline".
version
1.0
generated_from
arscontexta-v1.6
user-invocable
true
context
fork
model
sonnet
allowed-tools
Read, Write, Edit, Grep, Glob, Bash, Task
argument-hint
[file] — path to source file to process end-to-end
EXECUTE NOW
Target: $ARGUMENTS
Parse immediately:
Source file path: the file to process (required)
--handoff: output RALPH HANDOFF block at end (for chaining)
If target is empty: list files in {DOMAIN:inbox}/ and ask which to process
Step 0: Read Vocabulary
Read ops/derivation-manifest.md (or fall back to ops/derivation.md) for domain vocabulary mapping. All output must use domain-native terms. If neither file exists, use universal terms.
START NOW. Run the full pipeline.
Pipeline Overview
The pipeline chains four phases. Each phase uses skill invocation or /ralph for subagent-based processing. State lives in the queue file — the pipeline is stateless orchestration on top of stateful queue entries.
Source file
|
v
Phase 1: /seed — create extract task, move source to archive
|
v
Phase 2: /reduce (via /ralph) — extract claims from source
|
v
Phase 3: /ralph (all claims) — create -> reflect -> reweave -> verify
|
v
Phase 4: /archive-batch — move task files, generate summary
|
v
Complete
The pipeline is the convenience wrapper. /ralph is the engine. /seed is the entry point.
Phase 1: Seed
Invoke /seed on the target file to create the extract task, check for duplicates, and move the source to its archive folder.
How to invoke:
Use the Skill tool if available, otherwise execute the /seed workflow directly:
Validate source exists
Check for prior processing (duplicate detection)
Create archive folder
Move source from {DOMAIN:inbox} to archive
Create extract task file
Add extract task to queue
Capture from seed output:
Batch ID: the source basename (used for --batch filtering in subsequent steps)
Archive folder path: where the source was moved
next_claim_start: the claim numbering start
Report: $ Seeded: {source-name}
If seed reports the file was already processed: Ask the user whether to proceed or skip. Do NOT auto-skip — the user may want to re-process with different scope.
Phase 2: Extract (Reduce)
Process the extract task via /ralph. This spawns a subagent that runs /reduce, extracting claims from the source and creating task entries in the queue.
After completion, read the queue to count extracted claims and enrichments:
Check how many pending tasks exist for this batch. The reduce phase creates 1 queue entry per claim and 1 per enrichment.
Report:
$ Extracted: {N} {DOMAIN:note_plural}, {M} enrichments
Processing {total_tasks} tasks through the pipeline...
If zero claims extracted: Report the issue. For TFT sources, zero extraction is a bug — the source almost certainly contains extractable content. Ask the user whether to retry with different scope or skip.
Phase 3: Process All Claims
Count total pending tasks for this batch from the queue. Then process all of them through the full phase sequence.
This processes every claim through: create -> reflect -> reweave -> verify. And every enrichment through: enrich -> reflect -> reweave -> verify.
Each phase runs in an isolated subagent with fresh context. /ralph handles all the orchestration: subagent spawning, handoff parsing, queue advancement, learnings capture.
Progress reporting:
The /ralph invocation reports progress per task. The pipeline relays this:
For large batches (20+ claims): /ralph handles context isolation automatically via subagents. The pipeline does NOT need to chunk — /ralph processes N tasks sequentially with fresh context per phase.
Phase 4: Verify Completion
After /ralph finishes, verify all tasks for this batch are done.
Check the queue: count tasks for this batch that are NOT done.
If tasks remain pending:
Report which tasks are incomplete and at which phase
Show the specific task IDs and their current_phase
Suggest: "Run /ralph --batch {batch_id} to continue from where it stopped"
Do NOT proceed to archive
If all tasks are done: Proceed to Phase 5.
Phase 5: Archive Batch
When all tasks for the batch are complete, archive the batch.
How to invoke:
/archive-batch {batch_id}
Or execute directly:
Move all task files from ops/queue/ to ops/queue/archive/{date}-{batch_id}/
Generate a batch summary file: {batch_id}-summary.md
Remove completed entries from the queue (or mark as archived)
=== RALPH HANDOFF: pipeline ===
Target: {source_file}
Work Done:
- Seeded source: {batch_id}
- Extracted {N} {DOMAIN:note_plural} and {M} enrichments
- Processed all claims through 4-phase pipeline
- Archived batch to {archive_path}
Files Modified:
- {DOMAIN:notes}/ ({N} new {DOMAIN:note_plural})
- ops/queue/archive/{date}-{batch_id}/ (archived)
Learnings:
- [Friction]: {description} | NONE
- [Surprise]: {description} | NONE
- [Methodology]: {description} | NONE
- [Process gap]: {description} | NONE
Queue Updates:
- All tasks for batch {batch_id} marked done and archived
=== END HANDOFF ===
Error Handling
Phase failure at any stage:
Report the failure with context (which phase, which task, what error)
Show the current queue state for this batch
Suggest remediation: "Run /ralph --batch {batch_id} to continue from where it stopped"
Do NOT attempt to continue automatically past failures
The pipeline is resumable. Queue state persists across sessions:
/seed detects prior processing and asks whether to proceed
/ralph picks up from the last completed phase (queue is the source of truth)
/archive-batch verifies completeness before archiving
Seed failure: If /seed fails (file not found, duplicate detected and user declines), stop the pipeline entirely.
Extract failure: If /reduce extracts zero claims, report and stop. Do not proceed to an empty processing phase.
Processing failure: If /ralph fails mid-batch, the queue preserves state. Individual claims resume from their failed phase on next /ralph invocation.
Archive failure: If archiving fails, the claims are still created and connected. Only the organizational cleanup is missing — re-run /archive-batch manually.
Resumability
The pipeline is designed to be interrupted and resumed at any point:
Interrupted At
How to Resume
Before seed
Run /pipeline again (starts fresh)
After seed, before reduce
/ralph 1 --batch {id} --type extract
After reduce, during claims
/ralph --batch {id} (picks up from failed phase)
After all claims, before archive
/archive-batch {id}
State lives in the queue file. The pipeline reads queue state, not session state. This means you can interrupt, close the session, and resume later.
Edge Cases
No target file: List {DOMAIN:inbox}/ candidates, suggest the best one based on age and relevance.
Source already seeded: /seed detects this and asks the user. If they decline, the pipeline stops cleanly.
Large source (2500+ lines): /reduce handles chunking automatically. The pipeline does not need special handling.
No ops/derivation-manifest.md: Use universal vocabulary for all output.
Critical Constraints
never:
Skip the seed phase (duplicate detection is important)
Continue past a failed phase automatically
Process claims inline instead of via /ralph subagents
Archive a batch with incomplete tasks
always:
Report progress at each phase boundary
Verify all tasks are done before archiving
Show the user what was created (list of {DOMAIN:note_plural})
Suggest next steps if interrupted
Use domain-native vocabulary from derivation manifest
