@rune-kit/rune 2.8.0 → 2.11.0

package/extensions/saas/skills/team-management.md

@@ -1,144 +1,144 @@
----
-name: "team-management"
-pack: "@rune/saas"
-description: "Organization, team, and member permissions — RBAC hierarchy, invite flow with expiry, permission checking at API and UI layers, and audit trail for permission changes."
-model: sonnet
-tools: [Read, Edit, Write, Grep, Glob, Bash]
----
-
-# team-management
-
-Organization, team, and member permissions — RBAC hierarchy, invite flow with expiry, permission checking at API and UI layers, and audit trail for permission changes.
-
-#### Role Hierarchy
-
-```
-Owner (1 per org)
-  └── Admin (multiple)
-        └── Member (default role)
-              └── Viewer (read-only)
-```
-
-Org-level roles apply across all teams. Team-level roles can be more restrictive (e.g., org Member can be team Admin for a specific team).
-
-#### Permission Matrix
-
-| Action | Owner | Admin | Member | Viewer |
-|---|---|---|---|---|
-| Delete organization | ✅ | ❌ | ❌ | ❌ |
-| Manage billing | ✅ | ✅ | ❌ | ❌ |
-| Invite members | ✅ | ✅ | ❌ | ❌ |
-| Create teams | ✅ | ✅ | ❌ | ❌ |
-| Create projects | ✅ | ✅ | ✅ | ❌ |
-| View projects | ✅ | ✅ | ✅ | ✅ |
-| Manage team members | ✅ | ✅ (own teams) | ❌ | ❌ |
-
-#### Workflow
-
-**Step 1 — Design org/team schema**
-Model: `Organization → Team → Membership (userId, orgId, teamId?, role)`. Org-level membership has `teamId = null`. Team-level membership scopes the role to a specific team. Use a single `Membership` table with nullable `teamId` rather than separate `OrgMember` and `TeamMember` tables.
-
-**Step 2 — Implement RBAC middleware**
-Create a `requirePermission(action)` middleware that reads `req.user.id` + `req.tenantId`, loads the user's role for that org, and checks against a permission map. Fail fast: return 403 immediately if permission not found. Never trust client-provided role claims.
-
-**Step 3 — Build invite flow**
-Invite: generate a signed token (`crypto.randomBytes(32).hex`), store with `{ email, orgId, role, invitedBy, expiresAt: +7d }`, send email with link. Accept: verify token not expired, not already accepted, create Membership record, mark invite as accepted. Resend: invalidate old token, create new one with fresh expiry. Pending invites visible to admins in settings.
-
-**Step 4 — Add permission UI gates**
-In React: `<CanAccess action="invite_members"><InviteButton /></CanAccess>` — hides UI elements the user can't use. Also disable + tooltip pattern: show the button but disable it with "Upgrade to invite members" tooltip (better UX than hiding, helps users understand what's possible). Enforce the same check in the API — UI gates are cosmetic only.
-
-**Step 5 — Emit audit trail**
-Every permission change, role assignment, invite, and removal MUST log to an `AuditLog` table: `{ orgId, actorId, targetId, action, before, after, ip, userAgent, timestamp }`. Surface the last 100 entries in the org settings Security tab. Retain for 90 days minimum (compliance requirement for SOC2).
-
-#### Example
-
-```typescript
-// Prisma schema — org, team, membership
-model Organization {
-  id        String       @id @default(cuid())
-  name      String
-  slug      String       @unique
-  members   Membership[]
-  teams     Team[]
-}
-
-model Team {
-  id      String       @id @default(cuid())
-  orgId   String
-  name    String
-  org     Organization  @relation(fields: [orgId], references: [id])
-  members Membership[]
-}
-
-model Membership {
-  id        String       @id @default(cuid())
-  userId    String
-  orgId     String
-  teamId    String?      // null = org-level role
-  role      Role
-  user      User         @relation(fields: [userId], references: [id])
-  org       Organization @relation(fields: [orgId], references: [id])
-  team      Team?        @relation(fields: [teamId], references: [id])
-
-  @@unique([userId, orgId, teamId]) // one role per user per scope
-}
-
-enum Role { OWNER ADMIN MEMBER VIEWER }
-
-// Permission map
-const PERMISSIONS = {
-  delete_org:      ['OWNER'],
-  manage_billing:  ['OWNER', 'ADMIN'],
-  invite_members:  ['OWNER', 'ADMIN'],
-  create_projects: ['OWNER', 'ADMIN', 'MEMBER'],
-  view_projects:   ['OWNER', 'ADMIN', 'MEMBER', 'VIEWER'],
-} as const;
-type Action = keyof typeof PERMISSIONS;
-
-// RBAC middleware — never trust client-provided role
-const requirePermission = (action: Action) => async (req: Request, res: Response, next: NextFunction) => {
-  const membership = await prisma.membership.findFirst({
-    where: { userId: req.user!.id, orgId: req.tenantId!, teamId: null },
-  });
-  if (!membership || !(PERMISSIONS[action] as readonly string[]).includes(membership.role)) {
-    return res.status(403).json({ error: { code: 'FORBIDDEN', action } });
-  }
-  req.userRole = membership.role;
-  next();
-};
-
-// React permission hook
-function usePermission(action: Action): boolean {
-  const { membership } = useOrg();
-  if (!membership) return false;
-  return (PERMISSIONS[action] as readonly string[]).includes(membership.role);
-}
-
-// Invite flow
-const createInvite = async (orgId: string, email: string, role: Role, invitedBy: string) => {
-  const token = crypto.randomBytes(32).toString('hex');
-  await prisma.invite.create({
-    data: { orgId, email, role, invitedBy, token, expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000) },
-  });
-  await emailQueue.add('invite', { email, token, orgId });
-  return token;
-};
-
-const acceptInvite = async (token: string, userId: string) => {
-  const invite = await prisma.invite.findUnique({ where: { token } });
-  if (!invite || invite.acceptedAt || invite.expiresAt < new Date()) {
-    throw new Error('Invalid or expired invite');
-  }
-  await prisma.$transaction([
-    prisma.membership.create({ data: { userId, orgId: invite.orgId, role: invite.role } }),
-    prisma.invite.update({ where: { token }, data: { acceptedAt: new Date() } }),
-    prisma.auditLog.create({ data: { orgId: invite.orgId, actorId: userId, action: 'MEMBER_JOINED', targetId: userId } }),
-  ]);
-};
-```
-
-**Sharp edges for team-management:**
-- **Permission escalation**: an Admin inviting another Admin is fine, but an Admin promoting themselves to Owner must be blocked. Rule: you can only assign roles lower than your own.
-- **Cross-org data leak**: when loading team resources, always filter by `orgId`. A user who belongs to two orgs must never see org B's data when acting in org A's context.
-- **Invite token reuse**: after an invite is accepted, mark it accepted immediately in the same transaction as membership creation. Race condition: two tabs accepting the same invite → use `@@unique` on membership + catch unique constraint error.
-- **Owner removal**: prevent the last Owner from being removed or downgraded. Always require at least one Owner per org. Check before processing the role change.
+---
+name: "team-management"
+pack: "@rune/saas"
+description: "Organization, team, and member permissions — RBAC hierarchy, invite flow with expiry, permission checking at API and UI layers, and audit trail for permission changes."
+model: sonnet
+tools: [Read, Edit, Write, Grep, Glob, Bash]
+---
+
+# team-management
+
+Organization, team, and member permissions — RBAC hierarchy, invite flow with expiry, permission checking at API and UI layers, and audit trail for permission changes.
+
+#### Role Hierarchy
+
+```
+Owner (1 per org)
+  └── Admin (multiple)
+        └── Member (default role)
+              └── Viewer (read-only)
+```
+
+Org-level roles apply across all teams. Team-level roles can be more restrictive (e.g., org Member can be team Admin for a specific team).
+
+#### Permission Matrix
+
+| Action | Owner | Admin | Member | Viewer |
+|---|---|---|---|---|
+| Delete organization | ✅ | ❌ | ❌ | ❌ |
+| Manage billing | ✅ | ✅ | ❌ | ❌ |
+| Invite members | ✅ | ✅ | ❌ | ❌ |
+| Create teams | ✅ | ✅ | ❌ | ❌ |
+| Create projects | ✅ | ✅ | ✅ | ❌ |
+| View projects | ✅ | ✅ | ✅ | ✅ |
+| Manage team members | ✅ | ✅ (own teams) | ❌ | ❌ |
+
+#### Workflow
+
+**Step 1 — Design org/team schema**
+Model: `Organization → Team → Membership (userId, orgId, teamId?, role)`. Org-level membership has `teamId = null`. Team-level membership scopes the role to a specific team. Use a single `Membership` table with nullable `teamId` rather than separate `OrgMember` and `TeamMember` tables.
+
+**Step 2 — Implement RBAC middleware**
+Create a `requirePermission(action)` middleware that reads `req.user.id` + `req.tenantId`, loads the user's role for that org, and checks against a permission map. Fail fast: return 403 immediately if permission not found. Never trust client-provided role claims.
+
+**Step 3 — Build invite flow**
+Invite: generate a signed token (`crypto.randomBytes(32).hex`), store with `{ email, orgId, role, invitedBy, expiresAt: +7d }`, send email with link. Accept: verify token not expired, not already accepted, create Membership record, mark invite as accepted. Resend: invalidate old token, create new one with fresh expiry. Pending invites visible to admins in settings.
+
+**Step 4 — Add permission UI gates**
+In React: `<CanAccess action="invite_members"><InviteButton /></CanAccess>` — hides UI elements the user can't use. Also disable + tooltip pattern: show the button but disable it with "Upgrade to invite members" tooltip (better UX than hiding, helps users understand what's possible). Enforce the same check in the API — UI gates are cosmetic only.
+
+**Step 5 — Emit audit trail**
+Every permission change, role assignment, invite, and removal MUST log to an `AuditLog` table: `{ orgId, actorId, targetId, action, before, after, ip, userAgent, timestamp }`. Surface the last 100 entries in the org settings Security tab. Retain for 90 days minimum (compliance requirement for SOC2).
+
+#### Example
+
+```typescript
+// Prisma schema — org, team, membership
+model Organization {
+  id        String       @id @default(cuid())
+  name      String
+  slug      String       @unique
+  members   Membership[]
+  teams     Team[]
+}
+
+model Team {
+  id      String       @id @default(cuid())
+  orgId   String
+  name    String
+  org     Organization  @relation(fields: [orgId], references: [id])
+  members Membership[]
+}
+
+model Membership {
+  id        String       @id @default(cuid())
+  userId    String
+  orgId     String
+  teamId    String?      // null = org-level role
+  role      Role
+  user      User         @relation(fields: [userId], references: [id])
+  org       Organization @relation(fields: [orgId], references: [id])
+  team      Team?        @relation(fields: [teamId], references: [id])
+
+  @@unique([userId, orgId, teamId]) // one role per user per scope
+}
+
+enum Role { OWNER ADMIN MEMBER VIEWER }
+
+// Permission map
+const PERMISSIONS = {
+  delete_org:      ['OWNER'],
+  manage_billing:  ['OWNER', 'ADMIN'],
+  invite_members:  ['OWNER', 'ADMIN'],
+  create_projects: ['OWNER', 'ADMIN', 'MEMBER'],
+  view_projects:   ['OWNER', 'ADMIN', 'MEMBER', 'VIEWER'],
+} as const;
+type Action = keyof typeof PERMISSIONS;
+
+// RBAC middleware — never trust client-provided role
+const requirePermission = (action: Action) => async (req: Request, res: Response, next: NextFunction) => {
+  const membership = await prisma.membership.findFirst({
+    where: { userId: req.user!.id, orgId: req.tenantId!, teamId: null },
+  });
+  if (!membership || !(PERMISSIONS[action] as readonly string[]).includes(membership.role)) {
+    return res.status(403).json({ error: { code: 'FORBIDDEN', action } });
+  }
+  req.userRole = membership.role;
+  next();
+};
+
+// React permission hook
+function usePermission(action: Action): boolean {
+  const { membership } = useOrg();
+  if (!membership) return false;
+  return (PERMISSIONS[action] as readonly string[]).includes(membership.role);
+}
+
+// Invite flow
+const createInvite = async (orgId: string, email: string, role: Role, invitedBy: string) => {
+  const token = crypto.randomBytes(32).toString('hex');
+  await prisma.invite.create({
+    data: { orgId, email, role, invitedBy, token, expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000) },
+  });
+  await emailQueue.add('invite', { email, token, orgId });
+  return token;
+};
+
+const acceptInvite = async (token: string, userId: string) => {
+  const invite = await prisma.invite.findUnique({ where: { token } });
+  if (!invite || invite.acceptedAt || invite.expiresAt < new Date()) {
+    throw new Error('Invalid or expired invite');
+  }
+  await prisma.$transaction([
+    prisma.membership.create({ data: { userId, orgId: invite.orgId, role: invite.role } }),
+    prisma.invite.update({ where: { token }, data: { acceptedAt: new Date() } }),
+    prisma.auditLog.create({ data: { orgId: invite.orgId, actorId: userId, action: 'MEMBER_JOINED', targetId: userId } }),
+  ]);
+};
+```
+
+**Sharp edges for team-management:**
+- **Permission escalation**: an Admin inviting another Admin is fine, but an Admin promoting themselves to Owner must be blocked. Rule: you can only assign roles lower than your own.
+- **Cross-org data leak**: when loading team resources, always filter by `orgId`. A user who belongs to two orgs must never see org B's data when acting in org A's context.
+- **Invite token reuse**: after an invite is accepted, mark it accepted immediately in the same transaction as membership creation. Race condition: two tabs accepting the same invite → use `@@unique` on membership + catch unique constraint error.
+- **Owner removal**: prevent the last Owner from being removed or downgraded. Always require at least one Owner per org. Check before processing the role change.

package/extensions/security/PACK.md

@@ -1,99 +1,99 @@
----
-name: "@rune/security"
-description: Deep security analysis — OWASP audit, penetration testing patterns, secret management, compliance checking, supply chain security, and API hardening.
-metadata:
-  author: runedev
-  version: "0.3.0"
-  layer: L4
-  price: "$15"
-  target: Security engineers
-  format: split
-tools:
-  - Read
-  - Grep
-  - Bash
-  - Edit
-  - Write
----
-
-# @rune/security
-
-## Purpose
-
-@rune/security delivers manual-grade security analysis for teams that need more than an automated gate. Where `sentinel` (L2) runs fast checks on every commit, this pack runs thorough, on-demand audits: threat modeling entire auth flows, mapping real attack surfaces, designing vault strategies, auditing supply chain integrity, hardening API surfaces, enforcing multi-layer validation, and producing compliance audit trails. All seven skills share the same threat mindset — assume breach, prove safety, document evidence.
-
-## Triggers
-
-- `/rune security` — manual invocation, full pack audit
-- `/rune owasp-audit` | `/rune pentest-patterns` | `/rune secret-mgmt` | `/rune compliance` | `/rune supply-chain` | `/rune api-security` | `/rune defense-in-depth` — single skill invocation
-- Called by `cook` (L1) when auth, crypto, payment, or PII-handling code is detected
-- Called by `review` (L2) when security-critical patterns are flagged during code review
-- Called by `deploy` (L2) before production releases when security scope is active
-
-## Skills Included
-
-| Skill | Model | Description |
-|-------|-------|-------------|
-| [owasp-audit](skills/owasp-audit.md) | opus | Deep OWASP Top 10 (2021) + API Security Top 10 (2023) audit with manual code review, CI/CD pipeline security, and exploitability-rated findings. |
-| [pentest-patterns](skills/pentest-patterns.md) | opus | Attack surface mapping, PoC construction, JWT attack pattern detection, automated fuzzing setup, and GraphQL hardening. |
-| [secret-mgmt](skills/secret-mgmt.md) | sonnet | Audit secret handling, design vault/env strategy, implement rotation policies, and verify zero leaks in logs and source history. |
-| [compliance](skills/compliance.md) | opus | SOC 2, GDPR, HIPAA, PCI-DSS v4.0 gap analysis, automated evidence collection, and audit-ready evidence packages. |
-| [supply-chain](skills/supply-chain.md) | sonnet | Dependency confusion attacks, typosquatting, lockfile injection, manifest confusion, and SLSA provenance verification. |
-| [api-security](skills/api-security.md) | sonnet | Rate limiting, input sanitization, CORS, CSP generation, and security headers middleware for Express, Fastify, and Next.js. |
-| [defense-in-depth](skills/defense-in-depth.md) | sonnet | Multi-layer validation strategy — add validation at every layer data passes through (entry, business logic, environment, instrumentation). |
-
-## Connections
-
-```
-Calls → scout (L2): scan codebase for security patterns before audit
-Calls → verification (L3): run security tooling (Semgrep, Trivy, npm audit, gitleaks)
-Calls → @rune/backend (L4): auth pattern overlap — security audits reference backend auth flows
-Called By ← review (L2): when security-critical code detected during review
-Called By ← cook (L1): when auth/input/payment/PII code is in scope
-Called By ← deploy (L2): pre-release security gate when security scope active
-```
-
-## Constraints
-
-1. MUST use opus model for auth, crypto, and payment code review — these domains require maximum reasoning depth.
-2. MUST NOT rely solely on automated tool output — every finding requires manual confirmation of exploitability before reporting.
-3. MUST produce actionable findings: each issue includes file:line reference, severity rating, and concrete remediation steps.
-4. MUST differentiate scope from sentinel — @rune/security does deep on-demand analysis; sentinel does fast automated gates on every commit. Never duplicate sentinel's job.
-5. MUST generate defensive examples only — no offensive exploit code beyond minimal PoC sufficient to confirm exploitability.
-
-## Sharp Edges
-
-| Failure Mode | Severity | Mitigation |
-|---|---|---|
-| Reporting false positives as confirmed vulnerabilities | HIGH | Always verify exploitability manually before including in final report |
-| Auditing only code, missing infra/config attack surface | HIGH | Include Dockerfile, CI/CD yaml, nginx/CDN config, and .npmrc in scope |
-| Secret scan misses base64-encoded or env-injected secrets | HIGH | Scan both raw and decoded forms; check CI/CD variable lists |
-| Compliance gap analysis based on outdated standard version | MEDIUM | Reference standard version explicitly (e.g., GDPR 2016/679, PCI-DSS v4.0) |
-| OWASP audit skips indirect dependencies (transitive vulns) | MEDIUM | Run `npm audit --all` or `pip-audit` to surface transitive CVEs |
-| Pentest PoC accidentally run against production | CRITICAL | Confirm target environment before executing any PoC — add env guard to scripts |
-| Supply chain: only checking direct deps, missing transitive | HIGH | Use `npm ls --all` or `pip-audit` — transitive deps are equally exploitable |
-| Rate limits enforced in-process only (bypassed at scale) | HIGH | Use Redis-backed store; in-process limits don't survive horizontal scaling |
-| CSP nonce reuse across requests | CRITICAL | Generate a new `crypto.randomBytes(16)` nonce per request, never cache |
-| BOLA check missed on bulk/list endpoints | HIGH | List endpoints that return multiple objects must also filter by authenticated user's scope |
-
-## Difference from sentinel
-
-`sentinel` = lightweight automated gate (every commit, fast, cheap, blocks bad merges)
-`@rune/security` = deep manual-grade audit (on-demand, thorough, expensive, produces audit-ready reports)
-
-sentinel catches: known CVEs in deps, hardcoded secrets, obvious injection patterns.
-@rune/security catches: logic flaws in auth flows, missing authorization on specific routes, supply chain confusion attacks, API rate limiting gaps, compliance gaps, attack chains spanning multiple services.
-
-## Done When
-
-- All OWASP Top 10 (2021) + API Security Top 10 (2023) categories explicitly assessed (confirmed safe or finding raised)
-- Every HIGH/CRITICAL finding has a PoC or reproduction steps confirming exploitability
-- Secret audit covers source history, not just current HEAD; pre-commit hook configured
-- Supply chain report emitted to `.rune/security/supply-chain-report.md` with all collision/typosquatting risks
-- Security headers middleware generated and wired into the application
-- Compliance report maps each applicable standard requirement to a code location or gap, with remediation roadmap
-- Structured security report emitted with severity ratings and remediation steps
-
-## Cost Profile
-
-~10,000–28,000 tokens per full pack audit depending on codebase size and number of skills invoked. opus default for auth/crypto/payment/compliance review — these require maximum reasoning depth. haiku for initial pattern scanning (scout phase) and dependency inventory. sonnet for supply-chain analysis and API hardening code generation. Expect 5–10 minutes elapsed for a mid-size application running the full pack.
+---
+name: "@rune/security"
+description: Deep security analysis — OWASP audit, penetration testing patterns, secret management, compliance checking, supply chain security, and API hardening.
+metadata:
+  author: runedev
+  version: "0.3.0"
+  layer: L4
+  price: "$15"
+  target: Security engineers
+  format: split
+tools:
+  - Read
+  - Grep
+  - Bash
+  - Edit
+  - Write
+---
+
+# @rune/security
+
+## Purpose
+
+@rune/security delivers manual-grade security analysis for teams that need more than an automated gate. Where `sentinel` (L2) runs fast checks on every commit, this pack runs thorough, on-demand audits: threat modeling entire auth flows, mapping real attack surfaces, designing vault strategies, auditing supply chain integrity, hardening API surfaces, enforcing multi-layer validation, and producing compliance audit trails. All seven skills share the same threat mindset — assume breach, prove safety, document evidence.
+
+## Triggers
+
+- `/rune security` — manual invocation, full pack audit
+- `/rune owasp-audit` | `/rune pentest-patterns` | `/rune secret-mgmt` | `/rune compliance` | `/rune supply-chain` | `/rune api-security` | `/rune defense-in-depth` — single skill invocation
+- Called by `cook` (L1) when auth, crypto, payment, or PII-handling code is detected
+- Called by `review` (L2) when security-critical patterns are flagged during code review
+- Called by `deploy` (L2) before production releases when security scope is active
+
+## Skills Included
+
+| Skill | Model | Description |
+|-------|-------|-------------|
+| [owasp-audit](skills/owasp-audit.md) | opus | Deep OWASP Top 10 (2021) + API Security Top 10 (2023) audit with manual code review, CI/CD pipeline security, and exploitability-rated findings. |
+| [pentest-patterns](skills/pentest-patterns.md) | opus | Attack surface mapping, PoC construction, JWT attack pattern detection, automated fuzzing setup, and GraphQL hardening. |
+| [secret-mgmt](skills/secret-mgmt.md) | sonnet | Audit secret handling, design vault/env strategy, implement rotation policies, and verify zero leaks in logs and source history. |
+| [compliance](skills/compliance.md) | opus | SOC 2, GDPR, HIPAA, PCI-DSS v4.0 gap analysis, automated evidence collection, and audit-ready evidence packages. |
+| [supply-chain](skills/supply-chain.md) | sonnet | Dependency confusion attacks, typosquatting, lockfile injection, manifest confusion, and SLSA provenance verification. |
+| [api-security](skills/api-security.md) | sonnet | Rate limiting, input sanitization, CORS, CSP generation, and security headers middleware for Express, Fastify, and Next.js. |
+| [defense-in-depth](skills/defense-in-depth.md) | sonnet | Multi-layer validation strategy — add validation at every layer data passes through (entry, business logic, environment, instrumentation). |
+
+## Connections
+
+```
+Calls → scout (L2): scan codebase for security patterns before audit
+Calls → verification (L3): run security tooling (Semgrep, Trivy, npm audit, gitleaks)
+Calls → @rune/backend (L4): auth pattern overlap — security audits reference backend auth flows
+Called By ← review (L2): when security-critical code detected during review
+Called By ← cook (L1): when auth/input/payment/PII code is in scope
+Called By ← deploy (L2): pre-release security gate when security scope active
+```
+
+## Constraints
+
+1. MUST use opus model for auth, crypto, and payment code review — these domains require maximum reasoning depth.
+2. MUST NOT rely solely on automated tool output — every finding requires manual confirmation of exploitability before reporting.
+3. MUST produce actionable findings: each issue includes file:line reference, severity rating, and concrete remediation steps.
+4. MUST differentiate scope from sentinel — @rune/security does deep on-demand analysis; sentinel does fast automated gates on every commit. Never duplicate sentinel's job.
+5. MUST generate defensive examples only — no offensive exploit code beyond minimal PoC sufficient to confirm exploitability.
+
+## Sharp Edges
+
+| Failure Mode | Severity | Mitigation |
+|---|---|---|
+| Reporting false positives as confirmed vulnerabilities | HIGH | Always verify exploitability manually before including in final report |
+| Auditing only code, missing infra/config attack surface | HIGH | Include Dockerfile, CI/CD yaml, nginx/CDN config, and .npmrc in scope |
+| Secret scan misses base64-encoded or env-injected secrets | HIGH | Scan both raw and decoded forms; check CI/CD variable lists |
+| Compliance gap analysis based on outdated standard version | MEDIUM | Reference standard version explicitly (e.g., GDPR 2016/679, PCI-DSS v4.0) |
+| OWASP audit skips indirect dependencies (transitive vulns) | MEDIUM | Run `npm audit --all` or `pip-audit` to surface transitive CVEs |
+| Pentest PoC accidentally run against production | CRITICAL | Confirm target environment before executing any PoC — add env guard to scripts |
+| Supply chain: only checking direct deps, missing transitive | HIGH | Use `npm ls --all` or `pip-audit` — transitive deps are equally exploitable |
+| Rate limits enforced in-process only (bypassed at scale) | HIGH | Use Redis-backed store; in-process limits don't survive horizontal scaling |
+| CSP nonce reuse across requests | CRITICAL | Generate a new `crypto.randomBytes(16)` nonce per request, never cache |
+| BOLA check missed on bulk/list endpoints | HIGH | List endpoints that return multiple objects must also filter by authenticated user's scope |
+
+## Difference from sentinel
+
+`sentinel` = lightweight automated gate (every commit, fast, cheap, blocks bad merges)
+`@rune/security` = deep manual-grade audit (on-demand, thorough, expensive, produces audit-ready reports)
+
+sentinel catches: known CVEs in deps, hardcoded secrets, obvious injection patterns.
+@rune/security catches: logic flaws in auth flows, missing authorization on specific routes, supply chain confusion attacks, API rate limiting gaps, compliance gaps, attack chains spanning multiple services.
+
+## Done When
+
+- All OWASP Top 10 (2021) + API Security Top 10 (2023) categories explicitly assessed (confirmed safe or finding raised)
+- Every HIGH/CRITICAL finding has a PoC or reproduction steps confirming exploitability
+- Secret audit covers source history, not just current HEAD; pre-commit hook configured
+- Supply chain report emitted to `.rune/security/supply-chain-report.md` with all collision/typosquatting risks
+- Security headers middleware generated and wired into the application
+- Compliance report maps each applicable standard requirement to a code location or gap, with remediation roadmap
+- Structured security report emitted with severity ratings and remediation steps
+
+## Cost Profile
+
+~10,000–28,000 tokens per full pack audit depending on codebase size and number of skills invoked. opus default for auth/crypto/payment/compliance review — these require maximum reasoning depth. haiku for initial pattern scanning (scout phase) and dependency inventory. sonnet for supply-chain analysis and API hardening code generation. Expect 5–10 minutes elapsed for a mid-size application running the full pack.