IntermediateAgent Skill

Process Mapper

Use business process mapping to see where an order, return or internal request spends its time. Give your assistant the steps, owners, handoffs and measured timestamps; this Skill's Python tools create process views, rank bottlenecks and calculate cycle-time distributions, helping the team choose which delay to investigate first.

Views
0
Copies
0
Favorites
0
Editorial Score
80/100
01

What this Skill does

A process can look simple on paper while spending most of its time waiting between teams. Process Mapper separates the diagram from bottleneck and cycle-time analysis, using supplied records to examine both active work and delays.

Use it when reviewing a repeatable operation with identifiable steps and owners. The results help select a problem for investigation, but a suggested root cause is still a hypothesis. The tools do not observe systems live or automatically redesign the workflow after calculating a slow stage.

02

What makes it different

01

Approach and advantage

Three Python tools separate the process map, bottleneck ranking and cycle-time calculation. This lets the team compare the documented handoffs with measured delays instead of assuming the longest-looking step in a diagram is the real constraint.

02

What you can use it for

Case-level timestamps support cycle-time distributions rather than only one average. Review processing and waiting time together, then use the evidence to choose a targeted follow-up with the people responsible for the affected handoff.

03

Before you install

Inputs to prepare

Process steps, owners, handoffs, measured processing and waiting times, and case-level timestamps.

Agent and runtime

Use a Skill-capable agent with file access. Python 3 is required for the bundled Python helpers; inspect their sample schemas before supplying data.

Scope to confirm

Root-cause suggestions are hypotheses. The tools analyze supplied data and do not observe systems live or redesign the process automatically.

04

Install and get started

Copy this request into Codex or Claude Code. The assistant downloads the original repository at the specified commit, installs the complete files and checks required dependencies.

  1. Open Codex or Claude Code with local file and terminal access.
  2. Copy the request below into the app you are using. The assistant will select that app’s installation directory.
  3. Check the returned path and file checks. Start a new session if needed, then ask the assistant to use the installed Skill.
Install process-mapper in the app I am using and carry out the file installation, not just explain it. Original repository: https://github.com/alirezarezvani/claude-skills.git Commit: 6d2f02ea077eead1bee5411a31bcc6db5a11a70c Skill folder: business-operations/skills/process-mapper 1. Download this exact source into a new directory. Read SKILL.md and its setup references before running any bundled scripts. Do not substitute another author’s package. 2. For Codex, use ~/.agents/skills/process-mapper; for Claude Code, use ~/.claude/skills/process-mapper. Install only for my current app. Install the complete Skill folder, including scripts, references, assets and bundled notices. Keep any root license with the installed folder. Check all destination folders first; if any already exist, report differences before replacing them. 3. Compare the source and installed file lists and hashes. Inspect documented runtimes, dependencies and required connections. Configure only the local dependencies needed for this Skill; use an isolated environment when appropriate. Ask me to complete any account login locally, without putting credentials in chat. 4. Report the source commit, actual installation path, file-check results and any remaining runtime setup. Explain how to invoke process-mapper in this app. Check discovery separately from file copying; start a new session if needed. Do not run production tasks or claim a successful business outcome from installation alone.
05

Original Skill.md

This is the unchanged source SKILL.md for the reviewed version. Install the complete package to retain referenced scripts, assets, and instructions. Starter prompts below are EcomAgentTools examples.

---
name: process-mapper
description: Use when a BizOps lead, COO, or process-improvement owner needs to document an end-to-end business process (procurement, employee onboarding, incident handoff, customer-onboarding, claims adjudication) in BPMN-style notation, measure cycle times by stage, surface where work spends most of its time waiting vs. being worked, and quantify the gap between processing time and total elapsed time. Pairs Lean / Six Sigma / Theory-of-Constraints canon with deterministic stdlib-only Python tools to produce a process map, a ranked bottleneck list (with severity + root-cause hypothesis), and a cycle-time analysis (P50, P90, value-add ratio, Little's-Law throughput). Distinct from sales-pipeline, system-reliability (SLO), and strategic-OKR work — this is tactical process documentation for internal operations.
license: MIT
metadata:
  version: 2.8.0
  author: claude-code-skills
  tags: [bizops, process, bpmn, bottleneck, cycle-time, lean, six-sigma, value-stream]
  compatible_tools: [claude-code, codex-cli, cursor, antigravity, opencode, gemini-cli]
---

# process-mapper

BPMN-style business process documentation, bottleneck detection, and cycle-time analysis for internal-operations leaders.

## Purpose

Internal-operations work suffers from three recurring failure modes:

1. **Implicit process** — the steps exist only in tribal knowledge, so handoffs drop and onboarding takes weeks.
2. **Invisible waiting** — most of the elapsed time on any business process is queue / wait / approval time, not actual work; teams optimize the wrong stage.
3. **Local optimization** — Goldratt's Theory of Constraints is ignored; resources are added to non-constraint stages, gaining nothing.

This skill produces a documented process map, identifies where work waits, and points the constraint out by name with deterministic logic — not LLM intuition.

## When to use

- Documenting a new business process (procurement intake, vendor onboarding, employee onboarding, incident handoff, expense reimbursement, customer onboarding, claims adjudication).
- An existing process is "too slow" but nobody can name the bottleneck.
- Cycle time is being measured but value-add ratio is not — so the team can't tell whether the process is healthy or waste-heavy.
- Cross-functional handoffs are dropping work and root cause is unclear.

## Workflow

Five-step deterministic flow:

1. **Intake.** Capture the process as a JSON file with one entry per stage: `name`, `owner`, `type` (`value-add` | `wait` | `rework`), `duration_minutes_p50`, `duration_minutes_p90`. Use `assets/process_template.md` and its JSON skeleton.
2. **Map stages.** Run `process_documenter.py` to produce an ASCII swim-lane diagram + a normalized JSON artifact. The swim-lane separates lanes by owner so cross-functional handoffs become visible.
3. **Measure cycle time.** Run `cycle_time_analyzer.py` to compute total P50, total P90, value-add ratio (VA%), and a Little's-Law throughput estimate. Verdict: VA% > 25% = HEALTHY, 10–25% = TYPICAL, < 10% = WASTE-HEAVY.
4. **Detect bottlenecks.** Run `bottleneck_detector.py` with the appropriate `--profile` (saas / services / manufacturing / healthcare). Output is a ranked list with severity (CRITICAL / HIGH / MEDIUM), root-cause hypothesis, and one recommended action per finding.
5. **Recommend.** Pair the bottleneck list with the cycle-time verdict; recommend a single constraint-focused intervention per Goldratt's "subordinate everything to the constraint" rule. Don't recommend optimization of a non-constraint stage.

## Scripts

**`scripts/process_documenter.py`** — Reads a process JSON, validates it, and emits a text-based BPMN-style swim-lane diagram in Markdown (lanes by owner, stages annotated with type + duration). Also outputs a normalized JSON artifact for downstream tools. Stdlib only. `--sample` prints a 6-stage procurement-intake example.

**`scripts/bottleneck_detector.py`** — Applies three deterministic detection rules: (a) stage P50 > 2× mean of value-add stages, (b) wait-state % > 40% of total cycle, (c) rework % > 15%. Thresholds adjust by `--profile` because SaaS, services, manufacturing, and healthcare have different "normal" wait ratios. Output is a ranked list with severity, hypothesis, action.

**`scripts/cycle_time_analyzer.py`** — Computes total P50 and P90 cycle time, value-add ratio (VA%), wait %, rework %, and a Little's-Law throughput estimate (WIP / cycle time). Per Lean canon: VA% > 25% = HEALTHY, 10–25% = TYPICAL (most non-manufacturing processes land here), < 10% = WASTE-HEAVY.

## Quick example

```bash
# Renders a BPMN-style swim-lane diagram + normalized JSON for the built-in 6-stage procurement-intake example
cd business-operations/skills/process-mapper && python3 scripts/process_documenter.py --sample
```

## References

- `references/lean_six_sigma_canon.md` — TIMWOOD wastes, value-stream mapping, Theory of Constraints, Kanban WIP, Little's Law. Cites Womack & Jones, Rother & Shook, Goldratt, Ohno, Liker, Pyzdek, Anderson.
- `references/bpmn_essentials.md` — Pools, lanes, gateways, events, message flows, common notation mistakes. Cites the OMG BPMN 2.0 spec, Silver, Allweyer, Freund/Rücker, OASIS, ISO/IEC 19510:2013.
- `references/bottleneck_anti_patterns.md` — Seven specific anti-patterns drawn from Goldratt, Kim et al., Spear, DORA, Deming, and process-mining research.

## Assumptions

1. The user can provide stage-level cycle-time data (even rough P50 / P90 estimates). If they cannot, the first step is to instrument the process — not to map it.
2. "Process" here means a repeatable business workflow with discrete stages, not a one-off project.
3. The user has authority to act on bottlenecks (or can route findings to someone who does). Without that, the output is academic.
4. Stage `type` is honest: a "value-add" stage labeled as such by the user really does change the work product from the customer's perspective. Mis-labelling waiting as value-add is the most common data-quality failure.

## Anti-patterns

- **Mapping every process at once.** Pick one. Goldratt: the constraint is a single point.
- **Optimizing the non-constraint.** If stage 4 is the bottleneck, speeding up stage 2 just builds inventory in front of stage 4. Subordinate everything to the constraint.
- **Mistaking total cycle time for processing time.** They are almost never the same; VA% reveals the gap.
- **Adding people to a wait-bound process.** Wait time is not solved by more headcount; it's solved by removing the handoff or batch.
- **Treating rework as a separate problem.** Rework loops belong in the process map. Hiding them understates true cycle time.

## Distinct from

- **business-growth skills** — external sales motion, lead-funnel conversion, customer-success retention. Process-mapper is *internal* operations.
- **engineering/slo-architect** — system-reliability SLOs / error budgets / burn-rate alerts. Process-mapper is *business-process* cycle time, not system uptime.
- **c-level-advisor (COO / CEO)** — strategic prioritization of which processes to fix. Process-mapper is the tactical instrument used after that prioritization decision.
- **project-management skills** — Jira / Confluence ticket workflow tooling. Process-mapper is process *design*, not ticket *tracking*.

## Forcing-question library (Matt Pocock grill discipline)

Before invoking the tools, the orchestrator (or `/cs-grill-bizops`) walks the user through these questions **one at a time, with a recommended answer + canon citation**. Never bundled.

1. **"Do you have measured cycle times for the top-3 longest stages, or only estimates?"**
   Recommended: insist on measured data.
   Canon: Goldratt 1984 (*The Goal*) — optimizing estimated bottlenecks reliably attacks the wrong constraint.

2. **"Are you mapping the *current* process (as-is) or the *intended* process (to-be)?"**
   Recommended: map as-is first. To-be after bottleneck is identified.
   Canon: Rother & Shook 1999 (*Learning to See*) — value-stream mapping starts with the current state, always.

3. **"Where do handoffs occur between teams, and how long does each handoff wait?"**
   Recommended: log every handoff with median wait time.
   Canon: Reinertsen 2009 (*Principles of Product Development Flow*) — wait time at handoffs is the largest invisible cost.

4. **"What's your batch size at each stage?"**
   Recommended: drive batch size toward 1 wherever possible.
   Canon: Anderson 2010 (*Kanban*) — batch size correlates 1:1 with cycle time variance.

5. **"What's the rework rate per stage?"**
   Recommended: surface it explicitly; rework loops belong in the map.
   Canon: Pyzdek (*Six Sigma Handbook*) — hidden rework drives 30-50% of total cycle time in service processes.

Walk depth-first. Don't open question 4 before 1-3 are answered. After all 5 are locked, invoke `process_documenter.py` → `bottleneck_detector.py` → `cycle_time_analyzer.py` in sequence.
06

Get started

Starter prompts for the main use cases—copy and use them directly.

01

Map supplier onboarding and approval handoffs

Map supplier onboarding and approval handoffs Use for: Map supplier onboarding and approval handoffs. Prepare: Process steps, owners, handoffs, measured processing and waiting times, and case-level timestamps.

Show prompt and variablesHide prompt and variables
Use the installed process-mapper Skill. Task: Map supplier onboarding and approval handoffs. Inputs: [INPUT]. Constraints: [CONSTRAINTS]. Check missing information first. Produce a reviewable result with evidence, assumptions, and next steps. Root-cause suggestions are hypotheses. The tools analyze supplied data and do not observe systems live or redesign the process automatically.

Replace these variables

[INPUT]
Process steps, owners, handoffs, measured processing and waiting times, and case-level timestamps.
[CONSTRAINTS]
Scope, allowed actions, output format, and review requirements.
02

Locate waiting-time bottlenecks in an operations process

Locate waiting-time bottlenecks in an operations process Use for: Locate waiting-time bottlenecks in an operations process. Prepare: Process steps, owners, handoffs, measured processing and waiting times, and case-level timestamps.

Show prompt and variablesHide prompt and variables
Use the installed process-mapper Skill. Task: Locate waiting-time bottlenecks in an operations process. Inputs: [INPUT]. Constraints: [CONSTRAINTS]. Check missing information first. Produce a reviewable result with evidence, assumptions, and next steps. Root-cause suggestions are hypotheses. The tools analyze supplied data and do not observe systems live or redesign the process automatically.

Replace these variables

[INPUT]
Process steps, owners, handoffs, measured processing and waiting times, and case-level timestamps.
[CONSTRAINTS]
Scope, allowed actions, output format, and review requirements.
03

Compare cycle times before and after a process change

Compare cycle times before and after a process change Use for: Compare cycle times before and after a process change. Prepare: Process steps, owners, handoffs, measured processing and waiting times, and case-level timestamps.

Show prompt and variablesHide prompt and variables
Use the installed process-mapper Skill. Task: Compare cycle times before and after a process change. Inputs: [INPUT]. Constraints: [CONSTRAINTS]. Check missing information first. Produce a reviewable result with evidence, assumptions, and next steps. Root-cause suggestions are hypotheses. The tools analyze supplied data and do not observe systems live or redesign the process automatically.

Replace these variables

[INPUT]
Process steps, owners, handoffs, measured processing and waiting times, and case-level timestamps.
[CONSTRAINTS]
Scope, allowed actions, output format, and review requirements.
07

Worked example: Identify why a return-review workflow mostly waits

Six stages from return request to authorized instructions cover Mia’s preparation/rework and Alex’s approval with timing data. The merchant needs the first bottleneck to address rather than equal time cuts everywhere.

Steps and prompt

  1. Prepare the attached business materials, preserving amounts, units, dates and metric definitions.
  2. Map the supplied order-to-refund process and explain where elapsed time is lost. Calculate value-added work, waiting and rework, identify the longest approval queue, and model a practical improvement. Deliver the process map and an action plan with owners and the event-log measurements needed to verify improvement.
  3. Submit the exact prompt below. Read the primary deliverable on the right and download all deliverables for the team handoff.

Case input files: business-inputs.zip

Use the process-mapper Skill.

Map the supplied order-to-refund process and explain where elapsed time is lost. Calculate value-added work, waiting and rework, identify the longest approval queue, and model a practical improvement. Deliver the process map and an action plan with owners and the event-log measurements needed to verify improvement.

The attached business materials are:
- inputs/brief.json
- inputs/intake.md

Deliver a complete result.md report that the operations team can read, plus any finished files needed for this task. Keep supporting calculations and evidence with the deliverables. Write the report in English; use the requested target language for customer-facing copy. The business datasets are fictional examples unless the brief explicitly names a live public website.

What the run produced

The primary file produced by this prompt is shown below in its original language.

HarborMug return-review process and improvement plan

Prioritize Alex’s merchant-approval queue. It accounts for 480 of 800 minutes (60%) in the current planning baseline, while the approval work itself takes five minutes. Replace the daily batch of typically eight cases with smaller, frequent reviews, retaining merchant authorization. A scenario that reduces approval waiting to 120/240 minutes reduces the sum-of-stage P50 baseline by 360 minutes (45%). This is a proposed pilot, not an achieved saving.

All supplied business data are synthetic; stage percentiles describe a 20-case correction cohort, not production observations.

Scope and interpretation

The trigger is receipt of a return request; completion is delivery of merchant-authorized handling instructions. Parcel return, inspection and payment refund are outside the supplied boundary. This therefore maps the return-review portion of order-to-refund, not the entire refund lifecycle. Alex owns escalation and merchant approval; Mia owns support preparation, correction and delivery. Alex should be accountable for the pilot end to end.

The six stages follow the JSON numbering exactly. Every one of the 20 correction-cohort cases has one rework visit: 100% within this selected cohort, not a storewide rework rate. The intake also mentions a separate complete-evidence cohort with 0/20 rework, approval waiting of 80/160 minutes and observed WIP of zero. Its full stage timings and population mix are absent, so it is not combined with this analysis or treated as a causal benchmark.

All durations are continuous elapsed minutes. Sums of stage P50s and P90s are planning scenarios, not measured end-to-end percentiles. End-to-end quantiles require case-level durations; the stage dependence is unknown. No receipt-to-preparation queue is separately supplied, so the totals assume no additional unlisted delay.

Current process map

One merchant pool, two owner lanes. V = value-add as classified in intake; W = waiting; R = rework. Cross-lane arrows are internal sequence flows. The numbered sequence below governs order; the separate generated swim-lane map groups activities by owner.

Start: return request received
  |
Mia   #1 [V] Prepare corrected return dossier           10 / 20 min
  | handoff: Mia -> Alex
Alex  #2 [W] Wait for merchant approval               480 / 1440 min
  |
Alex  #3 [V] Authorize return disposition                5 / 10 min
  | handoff: Alex -> Mia; missing evidence requires correction
Mia   #4 [W] Wait for dossier correction               240 / 720 min
  |
Mia   #5 [R] Correct missing order evidence             60 / 180 min
  | correction returns dossier to delivery readiness
Mia   #6 [V] Deliver approved return instructions         5 / 10 min
  |
End: merchant-authorized instructions sent

Each duration is stage P50 / P90. Despite the wording “corrected” in stage 1, stage 5 is the supplied explicit rework visit; neither is removed or reordered. The record places authorization before correction and has no timed second approval. Treat this as an authorization whose release depends on completing the evidence. Mia must verify recorded authorization covers the completed dossier before sending. If correction changes the disposition or authorization is absent, hold delivery and return to Alex; that additional review is an unmeasured exception, not included in these totals. Log it as another approval visit rather than silently assuming it takes zero time.

A100 is within the stated 30-day unused-return window: request 14 days after delivery, unopened, with order evidence initially missing. Eligibility supports review; it does not itself authorize a refund.

Where elapsed time is lost

StageOwnerTypeP50 minP90 minShare of P50 sum
Prepare corrected return dossierMiaV10201.25%
Wait for merchant approvalAlexW4801,44060.00%
Authorize return dispositionAlexV5100.63%
Wait for dossier correctionMiaW24072030.00%
Correct missing order evidenceMiaR601807.50%
Deliver approved return instructionsMiaV5100.63%
Total8002,380100%

Percentages are rounded. The baseline is 13 hours 20 minutes; the P90-stage sum is 39 hours 40 minutes.

ComponentP50-stage sumP90-stage sumShare of P50 sum
Value-added work20 min40 min2.5%
Waiting720 min2,160 min90.0%
Rework60 min180 min7.5%
Total touch work, including rework80 min220 min10.0%

Waiting plus rework consumes 780 minutes (97.5%) of the baseline. Approval waiting is two-thirds of all waiting. The correction episode costs 300 minutes including its queue, but only 60 minutes is active rework; these are distinct measures. Rework is 75% of touch work.

The tool verdict is WASTE-HEAVY. The services analyzer uses 8% for typical and 20% for healthy, differing from the Skill’s generic 10%/25% prose bands; 2.5% is below either. Approval is a proxy value-add classification in this three-type schema. Under a stricter Lean classification treating its five minutes as necessary non-value-added work, customer-value work is 15 minutes and the ratio is 1.875%; the priority remains unchanged.

Ranked bottlenecks and hypotheses

RankFinding and severityEvidenceRoot-cause hypothesisOperational response
1Approval queue — CRITICAL, R1480 min; 72× mean value-add stepDaily batching and one named approver delay ready workPilot frequent, small reviews by Alex
2Correction queue — CRITICAL, R1240 min; 36× mean value-add stepReturned dossiers wait in Mia’s support queueObserve queue age during pilot; reassess after approval constraint moves
3Evidence correction — CRITICAL, R160 min; 9× mean value-add stepMissing order evidence escaped preparationRecord defect origin; consider an upstream evidence check after first pilot
4Aggregate waiting — HIGH, R290% versus services threshold of 50%Handoffs and batch policies dominate elapsed timeUse as system-level confirmation of priority 1

The value-add mean is 20/3 = 6.67 minutes; services R1 flags stages above 2.5× that mean (16.67 minutes). Rework share of elapsed time is 7.5%, below R3’s strict >15% threshold, so R3 does not fire. That does not mean rework incidence is low. Aggregate waiting overlaps ranks 1 and 2; its 720 minutes must not be added again as potential savings. Severity is a deterministic screening signal, not proof of resource capacity or causation.

Practical improvement model

Run one constraint-focused intervention: Alex reviews ready cases individually at frequent scheduled checks instead of one daily batch. Mia submits cases as ready rather than holding them for the next batch. Aim for a check at least every two hours during coverage; review oldest-ready cases first. Alex must establish coverage for absences and out-of-hours arrivals before treating continuous-minute targets as service commitments. This cadence alone does not guarantee the modeled quantiles.

Assume approval waiting changes from 480/1,440 to 120/240 minutes and every other stage stays unchanged, including correction. These are explicit scenario assumptions, not values inferred from the complete-evidence cohort. Merchant approval and the release check remain required. No extra headcount or removed authorization is assumed.

MeasureCurrent scenarioProposed scenarioDifference
Sum of stage P50s800 min440 min (7h 20m)−360 min; −45.0%
Sum of stage P90s2,380 min1,180 min (19h 40m)−1,200 min; −50.4%
Value-add work, P50 sum20 min20 minNone
Waiting, P50 sum720 min360 min−50.0%
Rework, P50 sum60 min60 minNone
Value-add ratio2.50%4.55%+2.05 percentage points
Wait share90.00%81.82%−8.18 percentage points

The model remains waste-heavy. Correction waiting becomes the longest remaining queue at 240 minutes, compared with proposed approval waiting of 120 minutes. Rework share rises to 13.64% solely because the denominator shrinks. Reassess the next constraint after verifying the approval change; do not claim this pilot eliminates missing evidence.

At representative WIP 8, the analyzer’s median-based throughput proxy is 8/(800/60) = 0.600 cases/hour; at unchanged WIP and proposed cycle sum it is 1.091 cases/hour. These are scenario arithmetic, not capacity forecasts. Little’s Law requires stable averages and mean elapsed time, not sums of medians. If throughput actually stays at 0.600/hour, the corresponding modeled WIP is 0.600×440/60 = 4.4 cases, rather than a promised throughput increase. Validate with time-weighted WIP and observed completions over the same boundary and period.

Action plan and decision gates

TimingOwnerAction and completed-definition
Before pilotAlex, accountable; Mia, loggingConfirm authorization/rework semantics; document when evidence changes require another Alex review. Ensure no instructions are released without valid authorization.
Baseline periodMiaCapture all consecutive in-scope requests for two weeks, extending if fewer than 20 completed correction cases. Keep complete-evidence and correction cohorts separate; retain open cases. Publish observed queue and end-to-end distributions.
Pilot setupAlexEstablish frequent review slots, absence coverage and oldest-ready handling; publish the review cadence. Record actual batch sizes and each missed review. Use queue-age escalation at 120 minutes and overdue escalation at 240 minutes; these are pilot thresholds.
Two-week pilotAlex and MiaAlex reviews ready cases without daily batching. Mia submits immediately and logs corrections and authorization checks. Extend until at least 20 completed correction cases are available; do not exclude slow open cases.
Pilot reviewAlex, with MiaCompare matched cohorts and actual end-to-end distributions. Seek approval-wait P50 ≤120 and P90 ≤240 minutes, lower end-to-end elapsed time, and no increase in correction incidence or unauthorized release. Report counts and uncertainty; 20 cases gives only a rough tail estimate.
After reviewAlexRetain cadence only if observed results support it. If approval wait falls but total time does not, inspect correction queue and additional approval visits. Then consider Mia’s upstream evidence checklist as the next experiment.

The 440-minute stage-sum scenario is a planning reference, not an empirical end-to-end P50 acceptance target. Do not defer logging customer request receipt until a dossier becomes ready: that would shift waiting outside the measured process.

Event-log measurements to verify improvement

Use the supplied empty CSV template; it contains no invented event records. Use pseudonymous case keys and role names, and keep customer details and evidence content outside the analytical log.

Record request_received, instructions_sent, and each stage’s queue_entered, work_started, work_paused, work_resumed, and work_completed events as applicable. Record approval_recorded, correction_requested, evidence_completed, release_check_passed, and any approval_reopened events. Each event needs an unambiguous UTC timestamp, stage number, visit number, process version, cohort, owner role and queue name. Capture actual review batch identifier/size, evidence-complete status, decision state and structured rework reason. Cohort is finalized from the observed path; log all arrivals before that classification is known.

MeasurementCalculation and control
Approval queue timeApproval work start minus queue entry, per visit; include repeat-review queues separately and in total case waiting
Correction queue timeCorrection work start minus correction queue entry; do not label active correction as waiting
Touch workSum active work intervals, excluding pauses; classify each interval V or R and retain necessary non-value-added approval separately for sensitivity
End-to-end timeInstructions sent minus request received; calculate case-level P50/P90 directly, using a declared nearest-rank method
Rework incidence and intensityCases with ≥1 correction / all eligible received cases with resolved paths; correction visits per case and active correction minutes; show each cohort and overall counts
Queue behaviorTime-weighted queue WIP, oldest age, arrival/completion rates, actual batch size and approval revisit count
Release qualityReleases without valid authorization, reopened decisions and instructions needing correction; reconcile sends against approval records
Flow validationMean system WIP = area under open-case count / observation time; throughput = completions / elapsed hours; compare WIP with throughput × mean case cycle only under stable conditions

Check event order, missing timestamps, duplicate events, overlapping work, orphaned visits and time-zone normalization. Include all pauses as a reason-coded elapsed-time component so queue + active work + other elapsed time reconciles to each case’s total. Flag unexplained gaps rather than assigning them to value-add. Report open-case ages and follow cohorts to completion to avoid making the pilot look faster by omitting unfinished cases. Compare similar request days and staffing coverage; do not mix return transit or payment processing into these review metrics.

Supporting files and basis

  • process-map.md: generated as-is swim lanes and stage sequence; its “Total P50/P90” labels mean sums of stage quantiles as qualified above.
  • as-is.json, to-be.json: validated baseline and explicit scenario stage inputs.
  • bottlenecks.json: unedited services-profile detection results; generic action suggestions are interpreted by the action plan above.
  • cycle-time.json, to-be-cycle-time.json: analyzer results; total percentile fields and throughput fields carry the qualifications above.
  • scenario-calculations.csv: comparison arithmetic.
  • event-log-template.csv: empty instrumentation template.

Business evidence: supplied brief.json and intake.md. Method: the process-mapper Skill and its Lean/Six Sigma, BPMN and bottleneck references; specifically Rother & Shook, Learning to See (1999), Goldratt, The Goal (1984), Anderson, Kanban (2010), Reinertsen, Principles of Product Development Flow (2009), and Pyzdek & Keller, The Six Sigma Handbook (2018). The map is a human-readable BPMN-style representation, not an executable BPMN model.

Merchant business data is synthetic. Website observations, when present, come from the public URLs listed in the report.

08

Risks and operating notes

Known limits

Root-cause suggestions are hypotheses. The tools analyze supplied data and do not observe systems live or redesign the process automatically.

Evidence and review

Source and package files reviewed: GitHub 6d2f02ea077e. This is a static review, not an installation or business-outcome test.

Before acting on the result

Use authorized inputs and keep secrets out of prompts. Review customer-facing claims, calculations, code changes, and any proposed external action before applying them.

Frequently asked questions

What does it do, and what is the advantage?

Document business processes and analyze bottlenecks, waiting time, and cycle-time distributions. Three Python tools separate process maps, bottleneck ranking, and cycle-time calculations.

How do I install it and start?

Choose the method for your agent and install the complete package, not just the displayed SKILL.md. Process steps, owners, handoffs, measured processing and waiting times, and case-level timestamps. Start a new agent session and explicitly ask to use process-mapper. Try one use case below with a small sample and review the output.

Which situations is it useful for?

Map supplier onboarding and approval handoffs; Locate waiting-time bottlenecks in an operations process; Compare cycle times before and after a process change

What limitations should I know?

Root-cause suggestions are hypotheses. The tools analyze supplied data and do not observe systems live or redesign the process automatically.

What was checked for this page?

Source and package files reviewed: GitHub 6d2f02ea077e. This is a static review, not an installation or business-outcome test.

No reviews yet.

Leave a review

Rate every dimension, then share your real experience.

Task effectiveness
Setup and ease of use
Reliability and guardrails
Documentation clarity
Time to first useful result
Author / maintainer

Alireza Rezvani

Source and package files reviewed: GitHub 6d2f02ea077e. This is a static review, not an installation or business-outcome test.