skilldrop-cli 0.16.3__py3-none-any.whl

skilldrop_cli/data/packs/infra-as-code/skills/terraform-plan-review/scripts/plan_summary.py

@@ -0,0 +1,361 @@
+#!/usr/bin/env python3
+"""Summarise a Terraform JSON plan and list the changes a reviewer must look at. Stdlib only.
+
+Input is the machine-readable plan that `terraform show -json <planfile>` prints (the
+documented JSON output format: resource_changes[], each with change.actions, and
+replace_paths / action_reason when a resource is replaced; resource_drift[] for objects
+that changed outside Terraform). The script never calls Terraform and never prints
+attribute values, so sensitive values in the plan stay out of its output.
+
+Usage:
+  terraform plan -out=tfplan && terraform show -json tfplan > plan.json
+  python3 plan_summary.py plan.json [--scope module.api --scope aws_lb.public] [-o summary.md]
+  terraform show -json tfplan | python3 plan_summary.py - [--format json]
+
+Exit codes: 0 summary written; 2 bad input (not JSON, not a plan, unreadable file).
+The floor verdict is mechanical: the reviewer reads every flagged change and may raise it,
+or lower it only when the user confirms the change is intended and recoverable.
+"""
+import argparse
+import json
+import re
+import sys
+
+# Resource types that hold data: a delete or replace loses it unless there is a backup.
+# An entry ending in "_" matches as a prefix (a family of types); any other entry must equal
+# the resource type, so aws_s3_bucket does not also match aws_s3_bucket_policy.
+STATEFUL_PATTERNS = (
+    "aws_db_instance", "aws_rds_cluster", "aws_neptune_cluster", "aws_docdb_cluster",
+    "aws_dynamodb_table", "aws_s3_bucket", "aws_s3_directory_bucket", "aws_ebs_volume",
+    "aws_efs_file_system", "aws_fsx_", "aws_elasticache_cluster", "aws_elasticache_replication_group",
+    "aws_elasticache_serverless_cache", "aws_memorydb_cluster", "aws_redshift_cluster",
+    "aws_opensearch_domain", "aws_elasticsearch_domain", "aws_msk_cluster", "aws_kinesis_stream",
+    "aws_sqs_queue", "aws_kms_key", "aws_secretsmanager_secret", "aws_backup_vault",
+    "google_sql_database_instance", "google_sql_database", "google_storage_bucket",
+    "google_compute_disk", "google_bigquery_dataset", "google_bigquery_table",
+    "google_spanner_instance", "google_spanner_database", "google_bigtable_instance",
+    "google_bigtable_table", "google_redis_instance", "google_filestore_instance",
+    "google_kms_crypto_key", "google_pubsub_topic", "google_pubsub_subscription",
+    "azurerm_storage_account", "azurerm_storage_container", "azurerm_mssql_server",
+    "azurerm_mssql_database", "azurerm_mssql_managed_instance", "azurerm_postgresql_server",
+    "azurerm_postgresql_flexible_server", "azurerm_postgresql_flexible_server_database",
+    "azurerm_mysql_flexible_server", "azurerm_mysql_flexible_database", "azurerm_cosmosdb_",
+    "azurerm_managed_disk", "azurerm_redis_cache", "azurerm_key_vault",
+)
+
+# Resource types that grant access or open network paths.
+ACCESS_PATTERNS = (
+    "_iam_", "iam_policy", "iam_role", "_security_group", "_firewall", "network_security",
+    "_role_assignment", "_policy_attachment", "bucket_policy", "_bucket_acl", "public_access_block",
+    "_kms_grant", "_key_policy", "_lambda_permission", "_network_acl",
+)
+
+OPEN_CIDRS = ("0.0.0.0/0", "::/0")
+# Attributes where true means "protected"; a true -> false change removes a safety net.
+PROTECTION_FLAGS = ("deletion_protection", "enable_deletion_protection", "deletion_protection_enabled",
+                    "disable_api_termination")
+# S3 public access block settings; true -> false opens the bucket or account to public access.
+PUBLIC_BLOCK_FLAGS = ("block_public_acls", "block_public_policy", "ignore_public_acls",
+                      "restrict_public_buckets")
+
+
+def die(msg):
+    print(f"error: {msg}", file=sys.stderr)
+    sys.exit(2)
+
+
+def load_plan(path):
+    try:
+        raw = sys.stdin.read() if path == "-" else open(path, encoding="utf-8").read()
+    except OSError as e:
+        die(f"cannot read {path}: {e.strerror}")
+    stripped = raw.lstrip()
+    if not stripped:
+        die("input is empty")
+    if not stripped.startswith("{"):
+        if re.search(r"Terraform will perform|Plan: \d+ to add|No changes\.", raw):
+            die("this is the human-readable plan text. Save the plan and convert it: "
+                "terraform plan -out=tfplan && terraform show -json tfplan > plan.json "
+                "(or review the text by hand, following the skill's SKILL.md)")
+        die("input is not JSON")
+    try:
+        plan = json.loads(raw)
+    except json.JSONDecodeError as e:
+        die(f"input is not valid JSON: {e}")
+    if not isinstance(plan, dict) or "format_version" not in plan:
+        die("no format_version key: this is not output of `terraform show -json`")
+    if "values" in plan and "planned_values" not in plan and "resource_changes" not in plan:
+        die("this looks like a state file (`terraform show -json` with no plan file), not a plan")
+    if "planned_values" not in plan and "resource_changes" not in plan:
+        die("no planned_values or resource_changes: this is not a plan")
+    rc = plan.get("resource_changes", [])
+    if not isinstance(rc, list):
+        die("resource_changes is not a list")
+    return plan
+
+
+def kind(actions):
+    a = list(actions or [])
+    if a == ["delete", "create"]:
+        return "replace (destroy then create)"
+    if a == ["create", "delete"]:
+        return "replace (create then destroy)"
+    if len(a) == 1:
+        return {"create": "create", "update": "update", "delete": "delete", "read": "read",
+                "no-op": "no-op", "forget": "forget"}.get(a[0], a[0])
+    return "+".join(a) or "unknown"
+
+
+def fmt_path(path):
+    out = ""
+    for step in path:
+        if isinstance(step, int):
+            out += f"[{step}]"
+        else:
+            out += ("." if out else "") + str(step)
+    return out or "(root)"
+
+
+def changed_keys(change):
+    """Top-level attribute names whose value differs or becomes unknown. Names only, no values."""
+    before = change.get("before") or {}
+    after = change.get("after") or {}
+    unknown = change.get("after_unknown") or {}
+    if not isinstance(before, dict) or not isinstance(after, dict):
+        return []
+    keys = set(before) | set(after) | (set(unknown) if isinstance(unknown, dict) else set())
+    out = []
+    for k in sorted(keys):
+        if isinstance(unknown, dict) and unknown.get(k) is True and k not in before:
+            continue  # computed attribute appearing on create
+        if before.get(k) != after.get(k) or (isinstance(unknown, dict) and unknown.get(k)):
+            out.append(k)
+    return out
+
+
+def walk_strings(value):
+    """Every string in a resource body, skipping egress blocks (open egress is normal)."""
+    if isinstance(value, str):
+        yield value
+    elif isinstance(value, dict):
+        for k, v in value.items():
+            if k == "egress":
+                continue
+            for s in walk_strings(v):
+                yield s
+    elif isinstance(value, list):
+        for v in value:
+            for s in walk_strings(v):
+                yield s
+
+
+def as_list(v):
+    return v if isinstance(v, list) else [v]
+
+
+def broad_grants(value, rtype=""):
+    """Set of broad-access markers found in a resource body: open ingress CIDRs and wildcard policy statements."""
+    found = set()
+    egress_rule = "egress" in rtype or (isinstance(value, dict) and value.get("type") == "egress")
+    for s in walk_strings(value):
+        for cidr in OPEN_CIDRS:
+            if s == cidr and not egress_rule:
+                found.add(f"open CIDR {cidr}")
+        if '"Statement"' in s or "'Statement'" in s:
+            try:
+                doc = json.loads(s)
+            except ValueError:
+                continue
+            for st in as_list(doc.get("Statement", [])) if isinstance(doc, dict) else []:
+                if not isinstance(st, dict) or st.get("Effect") != "Allow":
+                    continue
+                actions = [a for a in as_list(st.get("Action", [])) if isinstance(a, str)]
+                if any(a == "*" or a.endswith(":*") for a in actions):
+                    found.add("policy allows wildcard action " +
+                              ", ".join(sorted(a for a in actions if a == "*" or a.endswith(":*"))))
+                if "*" in as_list(st.get("Resource", [])) and actions:
+                    found.add("policy allows Resource \"*\"")
+                principal = st.get("Principal")
+                if principal == "*" or (isinstance(principal, dict) and
+                                        "*" in as_list(principal.get("AWS", []))):
+                    found.add("policy allows Principal \"*\"")
+    return found
+
+
+def is_stateful(rtype):
+    return any(rtype.startswith(p) if p.endswith("_") else rtype == p for p in STATEFUL_PATTERNS)
+
+
+def is_access(rtype):
+    return any(p in rtype for p in ACCESS_PATTERNS)
+
+
+def in_scope(address, scopes):
+    if not scopes:
+        return True
+    for s in scopes:
+        if address == s or address.startswith(s + ".") or address.startswith(s + "["):
+            return True
+    return False
+
+
+def analyse(plan, scopes):
+    counts = {}
+    flagged = []
+    for rc in plan.get("resource_changes", []):
+        if not isinstance(rc, dict):
+            continue
+        change = rc.get("change") or {}
+        actions = change.get("actions") or []
+        k = kind(actions)
+        counts[k] = counts.get(k, 0) + 1
+        if k in ("no-op", "read"):
+            continue
+        addr = rc.get("address", "?")
+        if rc.get("deposed"):
+            addr += f" (deposed object {rc['deposed']})"
+        rtype = rc.get("type", "")
+        reasons = []
+        severity = 0  # 1 care, 2 do-not-apply floor
+        destructive = "delete" in actions
+        if destructive:
+            what = "replaced" if "create" in actions else "destroyed"
+            line = f"will be {what}"
+            paths = change.get("replace_paths") or []
+            if paths:
+                line += "; replacement forced by: " + ", ".join(fmt_path(p) for p in paths)
+            if rc.get("action_reason"):
+                line += f" (action_reason: {rc['action_reason']})"
+            reasons.append(line)
+            severity = max(severity, 1)
+        if is_stateful(rtype):
+            if destructive:
+                reasons.append("stateful resource: data is lost unless a backup or snapshot exists")
+                severity = 2
+            elif k == "update":
+                reasons.append("stateful resource changed in place")
+                severity = max(severity, 1)
+        before = change.get("before") or {}
+        after = change.get("after") or {}
+        if isinstance(before, dict) and isinstance(after, dict):
+            for flag in PROTECTION_FLAGS:
+                if before.get(flag) is True and after.get(flag) is False:
+                    reasons.append(f"{flag} turned off")
+                    severity = max(severity, 1)
+            for flag in PUBLIC_BLOCK_FLAGS:
+                if before.get(flag) is True and after.get(flag) is False:
+                    reasons.append(f"access widened: {flag} turned off")
+                    severity = 2
+        if "create" in actions or k == "update":
+            new = broad_grants(after, rtype) - broad_grants(before, rtype)
+            if new:
+                reasons.append("access widened: " + "; ".join(sorted(new)))
+                public = any("open CIDR" in n or "Principal" in n for n in new)
+                admin = any("wildcard action" in n for n in new) and any("Resource" in n for n in new)
+                severity = 2 if (public or admin) else max(severity, 1)
+            elif is_access(rtype) and not any("access widened" in r for r in reasons):
+                reasons.append("access-control resource changed: read the before/after")
+                severity = max(severity, 1)
+        if change.get("importing"):
+            reasons.append("import: Terraform will take over an existing object")
+            severity = max(severity, 1)
+        if k == "forget":
+            reasons.append("forget: removed from state, the real object is left running")
+            severity = max(severity, 1)
+        if not in_scope(rc.get("address", ""), scopes):
+            reasons.append("outside the stated scope")
+            severity = max(severity, 1)
+        if k == "update" and not reasons:
+            continue
+        if k == "create" and not reasons:
+            continue
+        flagged.append({
+            "address": addr, "type": rtype, "action": k, "severity": severity,
+            "reasons": reasons,
+            "changed_attributes": changed_keys(change) if k == "update" else [],
+        })
+
+    drift = []
+    for rd in plan.get("resource_drift", []) or []:
+        if not isinstance(rd, dict):
+            continue
+        ch = rd.get("change") or {}
+        drift.append({"address": rd.get("address", "?"), "action": kind(ch.get("actions")),
+                      "changed_attributes": changed_keys(ch)})
+
+    floor = "SAFE TO APPLY"
+    if flagged or drift:
+        floor = "APPLY WITH CARE"
+    if any(f["severity"] == 2 for f in flagged):
+        floor = "DO NOT APPLY"
+    if plan.get("errored") is True:
+        floor = "DO NOT APPLY"
+    flagged.sort(key=lambda f: (-f["severity"], f["address"]))
+    return {
+        "terraform_version": plan.get("terraform_version", "unknown"),
+        "format_version": plan.get("format_version"),
+        "errored": plan.get("errored") is True,
+        "counts": counts, "flagged": flagged, "drift": drift,
+        "scope": scopes, "floor_verdict": floor,
+    }
+
+
+SEV = {2: "DO NOT APPLY", 1: "CARE", 0: "NOTE"}
+
+
+def to_markdown(r):
+    c = r["counts"]
+    replace = c.get("replace (destroy then create)", 0) + c.get("replace (create then destroy)", 0)
+    lines = [
+        "# Terraform plan summary", "",
+        f"Terraform {r['terraform_version']}, JSON format {r['format_version']}.", "",
+        f"**Floor verdict: {r['floor_verdict']}** (mechanical; the reviewer reads every flagged change)", "",
+        "| create | update | replace | destroy | read | forget | no-op |",
+        "|---|---|---|---|---|---|---|",
+        f"| {c.get('create', 0)} | {c.get('update', 0)} | {replace} | {c.get('delete', 0)} | "
+        f"{c.get('read', 0)} | {c.get('forget', 0)} | {c.get('no-op', 0)} |", "",
+    ]
+    if r["errored"]:
+        lines += ["The plan errored (errored: true). It is incomplete; do not apply it.", ""]
+    lines += [f"Scope: {', '.join(r['scope'])}" if r["scope"] else "Scope: not given (no out-of-scope check)", ""]
+    lines += ["## Changes to review", ""]
+    if not r["flagged"]:
+        lines += ["None flagged.", ""]
+    for f in r["flagged"]:
+        lines.append(f"- [{SEV[f['severity']]}] `{f['address']}` ({f['action']})")
+        for reason in f["reasons"]:
+            lines.append(f"  - {reason}")
+        if f["changed_attributes"]:
+            lines.append("  - changed attributes: " + ", ".join(f["changed_attributes"]))
+    lines += ["", "## Drift (changed outside Terraform)", ""]
+    if not r["drift"]:
+        lines += ["None reported in resource_drift."]
+    for d in r["drift"]:
+        attrs = ", ".join(d["changed_attributes"]) or "no attribute detail"
+        lines.append(f"- `{d['address']}` ({d['action']}): {attrs}")
+    return "\n".join(lines) + "\n"
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("plan", help="path to `terraform show -json` output, or - for stdin")
+    ap.add_argument("--scope", action="append", default=[],
+                    help="address prefix the change is meant to touch (repeatable), e.g. module.api")
+    ap.add_argument("--format", choices=("md", "json"), default="md")
+    ap.add_argument("-o", "--out", help="write here instead of stdout")
+    args = ap.parse_args()
+    result = analyse(load_plan(args.plan), args.scope)
+    text = to_markdown(result) if args.format == "md" else json.dumps(result, indent=2) + "\n"
+    if args.out:
+        try:
+            with open(args.out, "w", encoding="utf-8") as fh:
+                fh.write(text)
+        except OSError as e:
+            die(f"cannot write {args.out}: {e.strerror}")
+        print(f"wrote {args.out}", file=sys.stderr)
+    else:
+        sys.stdout.write(text)
+
+
+if __name__ == "__main__":
+    main()

skilldrop_cli/data/packs/product-manager/loops/discover/LOOP.md

@@ -0,0 +1,81 @@
+---
+name: discover
+description: Take raw signal — interviews, journeys, a strategy question — to a requirement a human has ratified, so design starts from an agreed problem rather than an assumed one. Use when the user is deciding what to build, scoping a feature, or turning stakeholder conversations into requirements.
+---
+
+# discover
+
+The first loop of the lifecycle, and the cheapest one to run twice. Everything downstream
+inherits whatever this loop got wrong, which is why it ends at a **human** gate rather than a
+script: no check can tell you that you solved the wrong problem well.
+
+## Stages
+
+| # | Stage | Type | Skills | Gate |
+|---|---|---|---|---|
+| 1 | `gather` | generate | [`requirements-interview`](../../skills/requirements-interview/SKILL.md), [`user-journey-map`](../../skills/user-journey-map/SKILL.md), [`strategy-analysis`](../../skills/strategy-analysis/SKILL.md) | — |
+| 2 | `structure` | generate | [`brief-intake`](../../../core/skills/brief-intake/SKILL.md) | — |
+| 3 | `specify` | generate | [`prd-draft`](../../skills/prd-draft/SKILL.md) | — |
+| 4 | `ratify` | gate | [`doc-critique`](../../../core/skills/doc-critique/SKILL.md) | **G0** human |
+
+## How to run this loop
+
+1. **Gather from whichever direction the signal arrives.** A stakeholder conversation →
+   `requirements-interview`. An existing experience with known friction → `user-journey-map`.
+   An open strategic question → `strategy-analysis`. Run one; running all three on the same
+   input produces three views of the same thing and no more information.
+2. **Structure once.** `brief-intake` tags every field `[explicit]` / `[implied]` /
+   `[inferred]` / `[missing]` with verbatim quotes. The tags are the deliverable — an
+   untagged brief hides which parts are somebody's assumption.
+3. **Resolve the missing before specifying.** `brief-intake` ends with what the downstream
+   skill will refuse to start without. Answer those; do not let `prd-draft` invent them.
+4. **Specify.** `prd-draft` turns the brief into numbered requirements a design can be held to.
+5. **Ratify at G0.** Run `doc-critique` against the PRD, then put the decision to a human.
+   The critique informs; the human decides. `REVISE` returns to `structure`, not to `specify`
+   — a weak PRD almost always means a thin brief.
+
+## Verdicts
+
+Defined in [`contracts/terminals.json`](../../../../contracts/terminals.json). G0 emits `PROCEED`,
+`PROCEED WITH CONDITIONS`, `REVISE`, `RECONSIDER`, or `BLOCKED`. `RECONSIDER` leaves the loop:
+the problem itself is wrong, and no amount of re-briefing fixes that.
+
+## Non-interactive runs
+
+With no human present, G0 cannot be satisfied. Emit `BLOCKED: need ratification of <the
+brief's central claim>` and stop. Do not self-ratify — a fabricated goal corrupts every
+artifact the other four loops produce.
+
+## When a stage's skill is not installed
+
+Name the missing skill and skilldrop as its source, do the minimal inline version of that
+stage, and record that it ran degraded. Never skip G0.
+
+## Run log (opt-in)
+
+Only when the environment variable `SKILLDROP_LOOP_LOG` is set to a file path: after each
+gate's verdict, append one JSON line to that file. Nothing else is recorded, and nothing is
+sent anywhere. When the variable isn't set, or you can't read it, skip this section.
+
+```bash
+printf '%s\n' '{"ts":"2026-10-01T14:03:00Z","loop":"discover","stage":"ratify","gate":"G0","verdict":"PROCEED","round":1}' >> "$SKILLDROP_LOOP_LOG"
+```
+
+Fields: `ts` (UTC), `loop`, `stage`, `gate` (`null` for a stage without one), `verdict` (the
+gate's exact word), and `round` (1 for the first attempt, counting returns under the cap).
+`skilldrop loop-stats` summarises the file: which gates pass first time, which loop back, and
+which end in `BLOCKED`.
+
+## Quality bar
+
+- **Every field carries a provenance tag.** A brief that does not distinguish quoted from inferred cannot be ratified, only believed.
+- **`[missing]` is resolved or stated, never filled.** Inventing the goal, the customer, or the success measure is the one failure this loop exists to prevent.
+- **The requirements are numbered and testable.** "Fast" is not a requirement; a latency target is.
+- **A human ratifies before design starts.** G0 is the loop's only reason to exist — an unratified brief is a draft, whatever the critique said.
+
+## Anti-patterns to avoid
+
+- ❌ **Running all three `gather` skills to be thorough.** Three lenses on one input is not three inputs; pick the one that matches where the signal came from.
+- ❌ **Letting `prd-draft` fill a `[missing]` field.** That converts an open question into a fact nobody agreed to.
+- ❌ **Treating `doc-critique`'s `SHIP IT` as ratification.** The critique judges the document; G0 judges the problem.
+- ❌ **Returning `REVISE` to `specify`.** Re-writing the PRD from the same thin brief reproduces the same gaps in better prose.

skilldrop_cli/data/packs/product-manager/loops/discover/evals/eval_queries.json

@@ -0,0 +1,30 @@
+[
+  {
+    "query": "turn these stakeholder notes into requirements",
+    "should_trigger": true
+  },
+  {
+    "query": "run the discover loop on this complaint",
+    "should_trigger": true
+  },
+  {
+    "query": "what problem are we actually solving here?",
+    "should_trigger": true
+  },
+  {
+    "query": "get this idea to a ratified brief",
+    "should_trigger": true
+  },
+  {
+    "query": "split this epic into stories",
+    "should_trigger": false
+  },
+  {
+    "query": "write the design doc for this",
+    "should_trigger": false
+  },
+  {
+    "query": "review my pull request",
+    "should_trigger": false
+  }
+]

skilldrop_cli/data/packs/product-manager/loops/discover/evals/evals.json

@@ -0,0 +1,26 @@
+{
+  "loop_name": "discover",
+  "evals": [
+    {
+      "id": "refuses-to-specify-on-a-thin-brief",
+      "prompt": "Run the discover loop. An account manager says enterprise customers keep hitting our API limits and are complaining.",
+      "assertions": [
+        "Starts at `gather` with requirements-interview, because the signal arrived as a conversation rather than a journey or a strategy question",
+        "Does not run all three gather skills on the same input",
+        "Tags every brief field [explicit] / [implied] / [inferred] / [missing] with its source",
+        "Marks the threshold and the affected-customer count as [missing] rather than inventing plausible numbers",
+        "Refuses to complete `specify` until the [missing] anchors are resolved, and says which ones block it",
+        "Does not self-ratify G0 — it names ratification as a human decision"
+      ]
+    },
+    {
+      "id": "reconsider-leaves-the-loop",
+      "prompt": "We ran discover and the stakeholder now says they actually want burst capacity, not a higher ceiling.",
+      "assertions": [
+        "Classifies this as RECONSIDER, a redirect-class verdict",
+        "States that a redirect leaves the loop rather than revising within it",
+        "Does not route back to `structure` for another brief on the original problem"
+      ]
+    }
+  ]
+}

skilldrop_cli/data/packs/product-manager/loops/discover/loop.json

@@ -0,0 +1,41 @@
+{
+  "$comment": "RFC-0028. The first loop of the lifecycle: nothing is designed or built until a human has ratified what problem is being solved. Cheapest loop to redo and the most expensive to skip.",
+  "name": "discover",
+  "version": "0.2.0",
+  "description": "Take raw signal — interviews, journeys, a strategy question — to a requirement a human has ratified, so design starts from an agreed problem rather than an assumed one. Use when the user is deciding what to build, scoping a feature, or turning stakeholder conversations into requirements.",
+  "entrypoint": "LOOP.md",
+  "kind": "loop",
+  "cap": 3,
+  "stages": [
+    {
+      "id": "gather",
+      "type": "generate",
+      "intent": "Collect the raw signal from whichever direction it arrives: a stakeholder conversation, an existing user journey, or a strategic question.",
+      "skills": ["requirements-interview", "user-journey-map", "strategy-analysis"]
+    },
+    {
+      "id": "structure",
+      "type": "generate",
+      "intent": "Turn the mess into one brief with every field tagged explicit / implied / inferred / missing, so downstream can see what was assumed.",
+      "skills": ["brief-intake"]
+    },
+    {
+      "id": "specify",
+      "type": "generate",
+      "intent": "Turn the ratified brief into numbered requirements a design can be held to.",
+      "skills": ["prd-draft"]
+    },
+    {
+      "id": "ratify",
+      "type": "gate",
+      "intent": "A human agrees this is the problem worth solving. The critique informs that decision; it does not make it.",
+      "skills": ["doc-critique"],
+      "gate": {
+        "id": "G0",
+        "kind": "human",
+        "verdicts": ["PROCEED", "PROCEED WITH CONDITIONS", "REVISE", "RECONSIDER", "BLOCKED"],
+        "revise_to": "structure"
+      }
+    }
+  ]
+}

skilldrop_cli/data/packs/product-manager/pack.json

@@ -0,0 +1,61 @@
+{
+  "description": "Direction to requirements: PR/FAQs, strategy frameworks, OKRs, business cases, interviews, PRDs, journey maps, and success measurement.",
+  "display_name": "Product manager",
+  "keywords": ["prfaq", "prd", "strategy", "okr", "discovery"],
+  "links": {
+    "documentation": "https://sananthanarayan.github.io/skilldrop/packs/product-manager/"
+  },
+  "maintainers": [
+    {
+      "name": "sananthanarayan"
+    }
+  ],
+  "first-value": {
+    "audience-posture": "non-technical",
+    "prerequisites": [],
+    "starter-task": "Pressure-test a product idea before anyone builds it",
+    "starter-prompt": "Write a PR/FAQ for a feature that lets customers pause their subscription for up to three months instead of cancelling.",
+    "verification": "prfaq returns a launch press release, a customer FAQ and an internal FAQ that names the hard questions.",
+    "recovery": "If prfaq does not activate, ask for it by name (\"use prfaq\") and check that its folder exists in your skills folder (`~/.claude/skills/` by default)."
+  },
+  "requires": ["core"],
+  "journey": {
+    "when": "You are deciding what to build and need a requirement a human has agreed to before design starts.",
+    "you_bring": [
+      "the feature idea or problem and who it is for",
+      "the stakeholders you can talk to",
+      "interview notes or evidence you already have"
+    ],
+    "time": "1–2 hours of working time, plus the interviews themselves",
+    "steps": [
+      {
+        "skill": "requirements-interview",
+        "you_do": "Describe the feature idea and list the stakeholders.",
+        "you_get": "An interview kit per stakeholder with up to seven questions ranked by how much the answer changes the design, at least one disconfirming question each, and an assumptions ledger."
+      },
+      {
+        "skill": "brief-intake",
+        "you_do": "Paste the interview notes once you have run the interviews.",
+        "you_get": "One brief with every field tagged explicit, implied, inferred or missing, quoting the source.",
+        "decide": "Resolve the missing fields yourself; the PRD must not invent them."
+      },
+      {
+        "skill": "prd-draft",
+        "you_do": "Hand it the resolved brief.",
+        "you_get": "A PRD with an evidence-backed problem statement, numbered MoSCoW requirements, non-goals, and a success line per goal."
+      },
+      {
+        "skill": "doc-critique",
+        "you_do": "Run it on the PRD, then take the result to whoever owns the decision.",
+        "you_get": "A severity-tagged critique of the PRD with a verdict and a fix for each finding.",
+        "decide": "Gate G0, a human call: PROCEED, PROCEED WITH CONDITIONS, REVISE (back to the brief), RECONSIDER (wrong problem) or BLOCKED."
+      },
+      {
+        "skill": "success-metrics",
+        "you_do": "Once the PRD is ratified, ask how you will know the feature worked.",
+        "you_get": "One primary metric with baseline, target and timeframe, guardrail metrics, the events to instrument, and a decision rule if the target is missed."
+      }
+    ],
+    "you_end_with": "Interview kits, a tagged brief, a ratified PRD, and a measurement plan agreed before anyone builds."
+  }
+}