tim/SlipItIn
1
0
Fork 0
Code Pull Requests 1 Actions 1 Packages Releases Wiki Activity

Neue Skills, Referenzen & OpenWiki-Doku integriert

Browse Source 
Umfangreiche Erweiterung der Skill-Bibliothek: Neue Skills für Humanisierung (Englisch/PT-BR), Design-Validierung, AI-SEO und Coolify-Deployment inkl. Regelwerke, Presets, Pattern-Referenzen, Testfälle und Automatisierungsskripte. Zusätzliche Skills für Revenue-Centric Design, Pier Cloud, OKF, Lebenslauf- und LinkedIn-Optimierung sowie zahlreiche Referenzdateien, Checklisten und YAML/JSON/Markdown-Templates. Einführung einer vollständigen OpenWiki-Dokumentation mit Architektur-, Domain- und Workflow-Beschreibungen, zentralem Index und automatisierten Updates. Modularer Aufbau, restriktive Lizenzen und umfassende Qualitäts- und Evaluationsmechanismen für alle neuen Inhalte.
This commit is contained in:
Tim Krampitz
2026-07-26 14:00:58 +02:00
parent 070727d5cd
commit 01046b01e4
202 changed files with 31290 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
.github/skills/loop-architect/examples/ai-workflow-mapping/LOOP.md vendored Normal file
View File

@@ -0,0 +1,86 @@
# ai-workflow-mapping
Map a customer's manual workflow into an agent-ready process.
## Goal
Produce an agent workflow map that converts the process notes into a stepwise design with tool calls, model responsibilities, and human checkpoints.
## Definition of Done
A LOOP.md-style workflow map exists, every step has an owner, input, output, and checkpoint decision where needed, and there are no TBDs.
## Verification
- `required-sections` (programmatic)
- `covers-goal` (judge)
## Council
- `reviewer-1`: judge via claude (default)
## Gates
- Plan gate: revise_until_clean
- Delivery gate: revise_until_clean
## Loop Control
- Max iterations: 12
- Budget: `{"tokens": 2000000, "usd": 5.0, "wall_clock_min": 30}`
- No-progress: `{"action": "stop", "max_stalled_iterations": 2, "signals": ["same blocking issue repeats", "delivery artifact has no material change", "verifier output is unchanged"]}`
## Execution Boundary
- Mode: `in_session`
- Isolation: `current_workspace`
- Side effects: `{"duplicate_action_check": true, "requires_approval": true}`
## Observability
- State file: `state.json`
- Run log: `run-log.md`
- Checkpoint granularity: `gate`
## Flow Preview
```text
+--------------------------------+
| 1. Goal + context |
| read sources |
+--------------------------------+
|
v
+--------------------------------+
| 2. Draft plan.md |
| state -> state.json |
+--------------------------------+
|
v
+--------------------------------+
| 3. Plan gate |
| verdict: reviewer-1 |
+--------------------------------+
| needs work -> revise <= 3 -> step 2
| pass
v
+--------------------------------+
| 4. Write delivery-N.md |
| log -> run-log.md |
+--------------------------------+
|
v
+--------------------------------+
| 5. Delivery gate |
| verdict: reviewer-1 |
+--------------------------------+
| needs work -> revise <= 3 -> step 4
| pass
v
+--------------------------------+
| 6. Final output |
| all gates clean |
+--------------------------------+
Stops: pass gates | max 12 iterations | no progress x2 | budget 30m, $5.0, 2000000 tokens
```

19
.github/skills/loop-architect/examples/ai-workflow-mapping/README.md vendored Normal file
View File

@@ -0,0 +1,19 @@
# AI Workflow Mapping Example
This example shows the Looper artifact shape for mapping customer process notes
into an agent-ready workflow.
Compile after editing:
```bash
python ../../scripts/looper.py compile loop.yaml --out loop.resolved.json --render LOOP.md --session-prompt RUN_IN_SESSION.md
```
The easy path is to ask the current LLM session to follow `RUN_IN_SESSION.md`.
Use the Python runner only when you want to run the loop outside the LLM
session, after reviewing model invocations and privacy egress:
```bash
python run-loop.py
```

108
.github/skills/loop-architect/examples/ai-workflow-mapping/RUN_IN_SESSION.md vendored Normal file
View File

@@ -0,0 +1,108 @@
# Run `ai-workflow-mapping` In This Session
Use this prompt when the user wants to run the Looper-designed loop in the current LLM session.
This is the default/easy execution path. The Python runner is the advanced path for running later or outside the session.
## Operator Instructions
You are executing a Looper-designed loop in this current session.
Follow the resolved spec below, write handoff files into the workspace, and enforce the caps manually.
Do not use `run-loop.py` unless the user explicitly asks for the advanced external runner.
1. Create the workspace directory if it does not exist.
2. Read the context sources before drafting the plan.
3. Draft `plan.md` in the workspace.
4. Run the plan gate. Apply programmatic checks when available. For judge criteria, use the configured judge only after consent for any non-local egress; otherwise ask the user to approve a human/current-session substitute.
5. Revise until the gate passes or `max_revisions` is reached.
6. Produce `delivery-N.md` in the workspace.
7. Run the delivery gate after each delivery.
8. Stop when all delivery criteria pass, a cap is reached, or the user stops the loop.
9. Keep `state.json` current with status, iteration, last gate, consent, and blockers.
10. Append a compact entry to `run-log.md` after every context read, model call, check, gate verdict, revision, blocker, and stop decision.
11. Compare each blocker against the previous blocker. If the same blocker repeats for the configured no-progress window, stop or ask for the configured human checkpoint instead of revising again.
12. Treat token and USD budgets as operator limits in this session: if exact accounting is unavailable, stop and ask before continuing when the loop appears likely to exceed them.
## Files
- Source spec: `loop.yaml`
- Human summary: `LOOP.md`
- Resolved spec: `loop.resolved.json`
- Workspace: `./loop-workspace`
- State file: `state.json`
- Run log: `run-log.md`
## Goal
Produce an agent workflow map that converts the process notes into a stepwise design with tool calls, model responsibilities, and human checkpoints.
## Definition Of Done
A LOOP.md-style workflow map exists, every step has an owner, input, output, and checkpoint decision where needed, and there are no TBDs.
## Context Sources
- Read file `./inputs/process-notes.md`
## Verification Criteria
- `required-sections` programmatic: run `["python", "scripts/check-loop-doc.py", "loop-workspace/delivery-1.md"]` and expect `exit_zero`
- `covers-goal` judge rubric: Every part of the goal statement is addressed. Each workflow step has an owner, required input, output artifact, and human checkpoint where business judgment is needed. No step depends on information the loop never gathers. There are no unresolved TBDs.
## Council
- `reviewer-1` judge via `["claude", "-p"]` (non-local; timeout 600s)
## Gates
### plan_gate
- When: `after_plan`
- Policy: `revise_until_clean`
- Verdict source: `reviewer-1`
- Criteria: `covers-goal`
- Max revisions: `3`
### delivery_gate
- When: `after_each_delivery`
- Policy: `revise_until_clean`
- Verdict source: `reviewer-1`
- Criteria: `required-sections, covers-goal`
- Max revisions: `3`
## Loop Control
- Max iterations: `12`
- Budget: `{"tokens": 2000000, "usd": 5.0, "wall_clock_min": 30}`
- No-progress: `{"action": "stop", "max_stalled_iterations": 2, "signals": ["same blocking issue repeats", "delivery artifact has no material change", "verifier output is unchanged"]}`
- Human checkpoints: `none`
- Stop conditions:
- all deliveries pass their gate clean
- max_iterations reached
- same blocker repeats for 2 iterations
- any budget cap exceeded
## Execution Boundary
- Mode: `in_session`
- Isolation: `current_workspace`
- Side effects: `{"duplicate_action_check": true, "requires_approval": true}`
If the loop needs scheduled runs, child-agent lifecycle management, concurrency control, or restart-safe step retries, stop and tell the user this Looper spec should be handed to a durable orchestrator.
## Observability
- State file: `state.json`
- Run log: `run-log.md`
- Checkpoint granularity: `gate`
Use `state.json` for the latest resumable status and `run-log.md` for the append-only history of what happened.
## Privacy
- Before sending `plan, deliveries` to `reviewer-1`, confirm consent and apply redactions `.env, .env.*, secrets/**, **/*.key`.
## Start Now
If the user asked to run now, begin at step 1 under Operator Instructions and keep going until a stop condition is reached.

14
.github/skills/loop-architect/examples/ai-workflow-mapping/inputs/process-notes.md vendored Normal file
View File

@@ -0,0 +1,14 @@
# Process Notes
The team currently turns customer process interviews into workflow maps by
reading notes, identifying handoffs, drafting a diagram, and asking a lead
consultant to check whether each step has an owner.
The loop should produce a map with:
- each process step
- owner type: tool, model, or human
- required input for the step
- output artifact for the step
- explicit human checkpoint when business judgment is needed

194
.github/skills/loop-architect/examples/ai-workflow-mapping/loop.resolved.json vendored Normal file
View File

@@ -0,0 +1,194 @@
{
"$schema": "https://github.com/ksimback/looper/schema/loop.resolved.v1.json",
"compiled_at": "2026-06-19T07:09:26+00:00",
"council": [
{
"cli": "claude",
"id": "reviewer-1",
"invoke": [
"claude",
"-p"
],
"local": false,
"model": "default",
"role": "judge",
"scope": [
"plan",
"delivery"
],
"timeout_sec": 600
}
],
"council_by_id": {
"reviewer-1": {
"cli": "claude",
"id": "reviewer-1",
"invoke": [
"claude",
"-p"
],
"local": false,
"model": "default",
"role": "judge",
"scope": [
"plan",
"delivery"
],
"timeout_sec": 600
}
},
"criteria_by_id": {
"covers-goal": {
"id": "covers-goal",
"rubric": "Every part of the goal statement is addressed. Each workflow step has an owner, required input, output artifact, and human checkpoint where business judgment is needed. No step depends on information the loop never gathers. There are no unresolved TBDs.\n",
"type": "judge"
},
"required-sections": {
"check": [
"python",
"scripts/check-loop-doc.py",
"loop-workspace/delivery-1.md"
],
"expect": "exit_zero",
"id": "required-sections",
"type": "programmatic"
}
},
"execution": {
"isolation": "current_workspace",
"mode": "in_session",
"side_effects": {
"duplicate_action_check": true,
"requires_approval": true
}
},
"gates": {
"delivery_gate": {
"criteria": [
"required-sections",
"covers-goal"
],
"max_revisions": 3,
"members": [
"reviewer-1"
],
"verdict_policy": "revise_until_clean",
"verdict_source": "reviewer-1",
"when": "after_each_delivery"
},
"plan_gate": {
"criteria": [
"covers-goal"
],
"max_revisions": 3,
"members": [
"reviewer-1"
],
"verdict_policy": "revise_until_clean",
"verdict_source": "reviewer-1",
"when": "after_plan"
}
},
"goal": {
"context_sources": [
{
"file": "./inputs/process-notes.md"
}
],
"definition_of_done": "A LOOP.md-style workflow map exists, every step has an owner, input, output, and checkpoint decision where needed, and there are no TBDs.\n",
"statement": "Produce an agent workflow map that converts the process notes into a stepwise design with tool calls, model responsibilities, and human checkpoints.\n",
"verification": [
{
"check": [
"python",
"scripts/check-loop-doc.py",
"loop-workspace/delivery-1.md"
],
"expect": "exit_zero",
"id": "required-sections",
"type": "programmatic"
},
{
"id": "covers-goal",
"rubric": "Every part of the goal statement is addressed. Each workflow step has an owner, required input, output artifact, and human checkpoint where business judgment is needed. No step depends on information the loop never gathers. There are no unresolved TBDs.\n",
"type": "judge"
}
]
},
"host": {
"cli": "codex",
"invoke": [
"codex",
"exec",
"--model",
"gpt-5"
],
"model": "gpt-5",
"timeout_sec": 600
},
"loop_control": {
"budget": {
"tokens": 2000000,
"usd": 5.0,
"wall_clock_min": 30
},
"human_checkpoints": [],
"max_iterations": 12,
"no_progress": {
"action": "stop",
"max_stalled_iterations": 2,
"signals": [
"same blocking issue repeats",
"delivery artifact has no material change",
"verifier output is unchanged"
]
},
"stop_conditions": [
"all deliveries pass their gate clean",
"max_iterations reached",
"same blocker repeats for 2 iterations",
"any budget cap exceeded"
]
},
"meta": {
"author": "ksimback",
"created": "2026-06-18",
"description": "Map a customer's manual workflow into an agent-ready process.",
"name": "ai-workflow-mapping"
},
"observability": {
"checkpoint_granularity": "gate",
"run_log": "run-log.md",
"state_file": "state.json"
},
"privacy": {
"egress": [
{
"consent": "required",
"redact": [
".env",
".env.*",
"secrets/**",
"**/*.key"
],
"sends": [
"plan",
"deliveries"
],
"to": "reviewer-1"
}
]
},
"source": "C:\\Users\\kevin\\looper\\examples\\ai-workflow-mapping\\loop.yaml",
"version": 1,
"workspace": {
"dir": "./loop-workspace",
"layout": [
"plan.md",
"delivery-{n}.md",
"review-{n}.md",
"state.json",
"run-log.md"
]
}
}

104
.github/skills/loop-architect/examples/ai-workflow-mapping/loop.yaml vendored Normal file
View File

@@ -0,0 +1,104 @@
version: 1
meta:
name: ai-workflow-mapping
description: Map a customer's manual workflow into an agent-ready process.
author: ksimback
created: 2026-06-18
goal:
statement: >
Produce an agent workflow map that converts the process notes into a
stepwise design with tool calls, model responsibilities, and human
checkpoints.
context_sources:
- file: ./inputs/process-notes.md
definition_of_done: >
A LOOP.md-style workflow map exists, every step has an owner, input,
output, and checkpoint decision where needed, and there are no TBDs.
verification:
- id: required-sections
type: programmatic
check: ["python", "scripts/check-loop-doc.py", "loop-workspace/delivery-1.md"]
expect: exit_zero
- id: covers-goal
type: judge
rubric: >
Every part of the goal statement is addressed. Each workflow step has
an owner, required input, output artifact, and human checkpoint where
business judgment is needed. No step depends on information the loop
never gathers. There are no unresolved TBDs.
host:
cli: codex
model: gpt-5
invoke: ["codex", "exec", "--model", "gpt-5"]
timeout_sec: 600
council:
- id: reviewer-1
role: judge
cli: claude
model: default
invoke: ["claude", "-p"]
timeout_sec: 600
scope: [plan, delivery]
local: false
gates:
plan_gate:
when: after_plan
members: [reviewer-1]
verdict_policy: revise_until_clean
verdict_source: reviewer-1
criteria: [covers-goal]
max_revisions: 3
delivery_gate:
when: after_each_delivery
members: [reviewer-1]
verdict_policy: revise_until_clean
verdict_source: reviewer-1
criteria: [required-sections, covers-goal]
max_revisions: 3
loop_control:
max_iterations: 12
budget:
usd: 5.0
tokens: 2000000
wall_clock_min: 30
no_progress:
max_stalled_iterations: 2
signals:
- same blocking issue repeats
- delivery artifact has no material change
- verifier output is unchanged
action: stop
human_checkpoints: []
stop_conditions:
- all deliveries pass their gate clean
- max_iterations reached
- same blocker repeats for 2 iterations
- any budget cap exceeded
execution:
mode: in_session
isolation: current_workspace
side_effects:
requires_approval: true
duplicate_action_check: true
observability:
state_file: state.json
run_log: run-log.md
checkpoint_granularity: gate
privacy:
egress:
- to: reviewer-1
sends: [plan, deliveries]
redact: [".env", ".env.*", "secrets/**", "**/*.key"]
consent: required
workspace:
dir: ./loop-workspace
layout: [plan.md, "delivery-{n}.md", "review-{n}.md", state.json, run-log.md]

12
.github/skills/loop-architect/examples/ai-workflow-mapping/run-loop.py vendored Normal file
View File

@@ -0,0 +1,12 @@
#!/usr/bin/env python3
"""Example runner wrapper that uses the root template."""
from __future__ import annotations
from pathlib import Path
import runpy
ROOT = Path(__file__).resolve().parents[2]
runpy.run_path(str(ROOT / "templates" / "run-loop.py"), run_name="__main__")

31
.github/skills/loop-architect/examples/ai-workflow-mapping/scripts/check-loop-doc.py vendored Normal file
View File

@@ -0,0 +1,31 @@
#!/usr/bin/env python3
"""Check that a generated workflow map has the expected sections."""
from __future__ import annotations
from pathlib import Path
import sys
REQUIRED = ["Owner", "Input", "Output", "Checkpoint"]
def main() -> int:
if len(sys.argv) != 2:
print("usage: check-loop-doc.py <delivery-path>", file=sys.stderr)
return 2
path = Path(sys.argv[1])
if not path.exists():
print(f"missing file: {path}", file=sys.stderr)
return 1
text = path.read_text(encoding="utf-8")
missing = [item for item in REQUIRED if item not in text]
if missing:
print(f"missing required text: {', '.join(missing)}", file=sys.stderr)
return 1
return 0
if __name__ == "__main__":
raise SystemExit(main())