Merge pull request #1 from anthropics/fix/orchestrate-handoff-param-patterns

Tighten handoff param patterns; ad-hoc questions use the practice profile

.github/workflows/cla.yaml

@@ -0,0 +1,36 @@
+name: "CLA Assistant"
+on:
+  issue_comment:
+    types: [created]
+  pull_request_target:
+    types: [opened, closed, synchronize]
+permissions:
+  actions: write
+  contents: write
+  pull-requests: write
+  statuses: write
+jobs:
+  CLAAssistant:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - name: "CLA Assistant"
+        if: (github.event.comment.body == 'recheck' || github.event.comment.body == 'I have read the CLA Document and I hereby sign the CLA') || github.event_name == 'pull_request_target'
+        # Upstream contributor-assistant/github-action was archived 2026-03-23
+        # still on Node 20 (deprecated 2026-06-02). This fork bumps to Node 24
+        # and adds: an impersonation guard (PR opener must be an author or
+        # co-author of at least one commit), Co-authored-by trailer support,
+        # email-based allowlist matching, automatic retry of transient
+        # GitHub 5xx errors, and actionable unlinked-email guidance.
+        uses: iainmcgin/cla-github-action@3e58ace6af840f66fcd80f68c08d76559140df5e # v3.0.0 (sha-pinned)
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          path-to-document: "https://github.com/${{ github.repository }}/blob/main/CLA.md"
+          path-to-signatures: "signatures/cla.json"
+          branch: "cla-signatures"
+          # noreply@anthropic.com is the email AI assistants use on
+          # Co-authored-by trailers (e.g. Claude). Allowlisting it suppresses
+          # the synthetic co-author from the CLA check; the PR opener still
+          # has to sign.
+          allowlist: "iainmcgin,dependabot[bot],github-actions[bot],renovate[bot],noreply@anthropic.com"

.gitignore

@@ -3,3 +3,5 @@
 /logs/
 /outputs/
 /.claude/
+__pycache__/
+*.pyc

CODE_OF_CONDUCT.md

@@ -0,0 +1,37 @@
+# Code of Conduct
+
+## Our commitment
+
+We are committed to providing a welcoming and respectful environment for everyone who participates in this project, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Expected behavior
+
+* Use welcoming and inclusive language.
+* Respect differing viewpoints and experiences.
+* Accept constructive criticism gracefully.
+* Focus on what is best for the community and the project.
+* Show empathy toward other community members.
+
+## Unacceptable behavior
+
+* Harassment, intimidation, or discrimination in any form.
+* Trolling, insulting or derogatory comments, and personal or political attacks.
+* Public or private harassment.
+* Publishing others' private information without explicit permission.
+* Other conduct that could reasonably be considered inappropriate in a professional setting.
+
+## Scope
+
+This Code of Conduct applies to all project spaces, including issues, pull requests, discussions, and any other communication channels associated with this project. It also applies when an individual is representing the project in public spaces.
+
+## Reporting
+
+If you experience or witness unacceptable behavior, contact a project maintainer directly through GitHub, or open an issue if the report does not need to be private. All reports will be reviewed promptly and treated as confidentially as the reporting channel allows.
+
+## Enforcement
+
+Participants who violate this Code of Conduct may be warned, temporarily banned, or permanently removed from project participation, as determined by the project maintainers. Maintainers who do not follow or enforce this Code of Conduct may face the same consequences.
+
+## Attribution
+
+This Code of Conduct is adapted from the Contributor Covenant, version 2.1.

CONTRIBUTING.md

@@ -4,6 +4,13 @@ Notes for anyone writing or editing a plugin in this repo. Keep this short — t
 design principles that matter most for the quality of the output, not a style
 guide.
 
+## Before your first PR
+
+Sign the CLA. The first time you open a pull request, the CLA Assistant bot will
+comment with a link to the [CLA](CLA.md) and ask you to confirm. Reply with
+`I have read the CLA Document and I hereby sign the CLA` and the check will pass.
+You only need to do this once.
+
 ## Design principle: SKILL.md encodes the right behavior; CLAUDE.md guardrails
 are the net
 

ai-governance-legal/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-governance-legal",
-  "version": "0.3.2",
+  "version": "1.0.0",
   "description": "Triages proposed AI use cases against your registry, runs impact assessments across the regimes in scope, reviews vendor AI terms for training-on-data and liability gaps, and keeps your AI policy current with practice.",
   "author": {
     "name": "Anthropic"

ai-governance-legal/CLAUDE.md

@@ -377,6 +377,20 @@ Corollary: when the user asks a doctrinal question (not a document-review questi
 
 **Don't force a question through the wrong skill.** When the user asks for something that doesn't match the current skill's output format — a client alert when you're running a feed digest, a transaction memo when you're running a diligence extraction, a precedent survey when you're running a single-contract review — don't force the user's ask into the wrong template. Say: "You asked for [X]; this skill produces [Y]. I'll produce [X] directly instead of forcing it into the [Y] format — here it is." Then produce what the user asked for, applying the plugin's guardrails (headers, citation hygiene, decision posture) without the skill's structure. The guardrails travel with you; the template doesn't have to. This is the routing corollary of scaffolding-not-blinders.
 
+## Ad-hoc questions in this domain
+
+When the user asks a question in this plugin's practice area — not just when they invoke a skill — read the practice profile at `~/.claude/plugins/config/claude-for-legal/ai-governance-legal/CLAUDE.md` (and `~/.claude/plugins/config/claude-for-legal/company-profile.md`) first, and apply it. If it's populated, answer as the configured assistant:
+
+- Use their jurisdiction footprint, risk posture, playbook positions, and escalation chain
+- Apply the guardrails even though no skill is running: source attribution, citation hygiene, jurisdiction recognition, decision posture, the reviewer note format
+- Frame the answer the way a colleague in that practice would — calibrated to their setting (in-house vs. firm), their role (lawyer vs. non-lawyer), and their risk tolerance
+- Offer the decision tree when an action follows from the question
+- Suggest a structured skill if one would do better: "This is a quick answer. If you want the full framework, run `/ai-governance-legal:[relevant skill]`."
+
+If the practice profile isn't populated: "I can give you a general answer, but this plugin gives much better answers once it's configured to your practice — run `/ai-governance-legal:cold-start-interview` (2-minute quick start or 10-minute full setup)." Then give the general answer anyway, tagged as unconfigured.
+
+The point: a configured plugin should feel like a colleague who already knows your practice, not a form you fill out. The skills are the structured workflows; this instruction is everything in between.
+
 ## Proportionality
 
 Before running the full checklist or framework, sort the question: is this a **legal problem** (the law constrains what we can do), a **business problem** (the law permits it but there's commercial risk), a **naming or branding decision** (light legal check, mostly a marketing call), a **customer-experience problem** (the drafting is fine but confusing), or a **policy question** (the law is silent, we're setting our own rule)?

commercial-legal/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "commercial-legal",
-  "version": "0.4.2",
+  "version": "1.0.0",
   "description": "Reviews vendor agreements, NDAs, and SaaS subscriptions against your sales-side or purchasing-side playbook, tracks renewals and cancel-by deadlines before they're missed, routes escalations to the right approver, and translates reviews into summaries business stakeholders will actually read.",
   "author": {
     "name": "Anthropic"

commercial-legal/CLAUDE.md

@@ -397,6 +397,20 @@ Corollary: when the user asks a doctrinal question (not a document-review questi
 
 **Don't force a question through the wrong skill.** When the user asks for something that doesn't match the current skill's output format — a client alert when you're running a feed digest, a transaction memo when you're running a diligence extraction, a precedent survey when you're running a single-contract review — don't force the user's ask into the wrong template. Say: "You asked for [X]; this skill produces [Y]. I'll produce [X] directly instead of forcing it into the [Y] format — here it is." Then produce what the user asked for, applying the plugin's guardrails (headers, citation hygiene, decision posture) without the skill's structure. The guardrails travel with you; the template doesn't have to. This is the routing corollary of scaffolding-not-blinders.
 
+## Ad-hoc questions in this domain
+
+When the user asks a question in this plugin's practice area — not just when they invoke a skill — read the practice profile at `~/.claude/plugins/config/claude-for-legal/commercial-legal/CLAUDE.md` (and `~/.claude/plugins/config/claude-for-legal/company-profile.md`) first, and apply it. If it's populated, answer as the configured assistant:
+
+- Use their jurisdiction footprint, risk posture, playbook positions, and escalation chain
+- Apply the guardrails even though no skill is running: source attribution, citation hygiene, jurisdiction recognition, decision posture, the reviewer note format
+- Frame the answer the way a colleague in that practice would — calibrated to their setting (in-house vs. firm), their role (lawyer vs. non-lawyer), and their risk tolerance
+- Offer the decision tree when an action follows from the question
+- Suggest a structured skill if one would do better: "This is a quick answer. If you want the full framework, run `/commercial-legal:[relevant skill]`."
+
+If the practice profile isn't populated: "I can give you a general answer, but this plugin gives much better answers once it's configured to your practice — run `/commercial-legal:cold-start-interview` (2-minute quick start or 10-minute full setup)." Then give the general answer anyway, tagged as unconfigured.
+
+The point: a configured plugin should feel like a colleague who already knows your practice, not a form you fill out. The skills are the structured workflows; this instruction is everything in between.
+
 ## Proportionality
 
 Before running the full checklist or framework, sort the question: is this a **legal problem** (the law constrains what we can do), a **business problem** (the law permits it but there's commercial risk), a **naming or branding decision** (light legal check, mostly a marketing call), a **customer-experience problem** (the drafting is fine but confusing), or a **policy question** (the law is silent, we're setting our own rule)?

corporate-legal/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "corporate-legal",
-  "version": "0.5.2",
+  "version": "1.0.0",
   "description": "Runs M&A diligence at scale with cited tabular review, builds disclosure schedules and closing checklists, drafts board consents and minutes in house format, and tracks entity compliance deadlines across jurisdictions.",
   "author": {
     "name": "Anthropic"

corporate-legal/CLAUDE.md

@@ -222,6 +222,20 @@ Corollary: when the user asks a doctrinal question (not a document-review questi
 
 **Don't force a question through the wrong skill.** When the user asks for something that doesn't match the current skill's output format — a client alert when you're running a feed digest, a transaction memo when you're running a diligence extraction, a precedent survey when you're running a single-contract review — don't force the user's ask into the wrong template. Say: "You asked for [X]; this skill produces [Y]. I'll produce [X] directly instead of forcing it into the [Y] format — here it is." Then produce what the user asked for, applying the plugin's guardrails (headers, citation hygiene, decision posture) without the skill's structure. The guardrails travel with you; the template doesn't have to. This is the routing corollary of scaffolding-not-blinders.
 
+## Ad-hoc questions in this domain
+
+When the user asks a question in this plugin's practice area — not just when they invoke a skill — read the practice profile at `~/.claude/plugins/config/claude-for-legal/corporate-legal/CLAUDE.md` (and `~/.claude/plugins/config/claude-for-legal/company-profile.md`) first, and apply it. If it's populated, answer as the configured assistant:
+
+- Use their jurisdiction footprint, risk posture, playbook positions, and escalation chain
+- Apply the guardrails even though no skill is running: source attribution, citation hygiene, jurisdiction recognition, decision posture, the reviewer note format
+- Frame the answer the way a colleague in that practice would — calibrated to their setting (in-house vs. firm), their role (lawyer vs. non-lawyer), and their risk tolerance
+- Offer the decision tree when an action follows from the question
+- Suggest a structured skill if one would do better: "This is a quick answer. If you want the full framework, run `/corporate-legal:[relevant skill]`."
+
+If the practice profile isn't populated: "I can give you a general answer, but this plugin gives much better answers once it's configured to your practice — run `/corporate-legal:cold-start-interview` (2-minute quick start or 10-minute full setup)." Then give the general answer anyway, tagged as unconfigured.
+
+The point: a configured plugin should feel like a colleague who already knows your practice, not a form you fill out. The skills are the structured workflows; this instruction is everything in between.
+
 ## Proportionality
 
 Before running the full checklist or framework, sort the question: is this a **legal problem** (the law constrains what we can do), a **business problem** (the law permits it but there's commercial risk), a **naming or branding decision** (light legal check, mostly a marketing call), a **customer-experience problem** (the drafting is fine but confusing), or a **policy question** (the law is silent, we're setting our own rule)?

employment-legal/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "employment-legal",
-  "version": "0.3.2",
+  "version": "1.0.0",
   "description": "Reviews hires and terminations for jurisdiction-specific risk flags, classifies workers against the controlling state test, tracks leave deadlines before they're missed, runs internal investigations, and drafts policies with state supplements where the law differs.",
   "author": {
     "name": "Anthropic"

employment-legal/CLAUDE.md

@@ -218,6 +218,20 @@ Corollary: when the user asks a doctrinal question (not a document-review questi
 
 **Don't force a question through the wrong skill.** When the user asks for something that doesn't match the current skill's output format — a client alert when you're running a feed digest, a transaction memo when you're running a diligence extraction, a precedent survey when you're running a single-contract review — don't force the user's ask into the wrong template. Say: "You asked for [X]; this skill produces [Y]. I'll produce [X] directly instead of forcing it into the [Y] format — here it is." Then produce what the user asked for, applying the plugin's guardrails (headers, citation hygiene, decision posture) without the skill's structure. The guardrails travel with you; the template doesn't have to. This is the routing corollary of scaffolding-not-blinders.
 
+## Ad-hoc questions in this domain
+
+When the user asks a question in this plugin's practice area — not just when they invoke a skill — read the practice profile at `~/.claude/plugins/config/claude-for-legal/employment-legal/CLAUDE.md` (and `~/.claude/plugins/config/claude-for-legal/company-profile.md`) first, and apply it. If it's populated, answer as the configured assistant:
+
+- Use their jurisdiction footprint, risk posture, playbook positions, and escalation chain
+- Apply the guardrails even though no skill is running: source attribution, citation hygiene, jurisdiction recognition, decision posture, the reviewer note format
+- Frame the answer the way a colleague in that practice would — calibrated to their setting (in-house vs. firm), their role (lawyer vs. non-lawyer), and their risk tolerance
+- Offer the decision tree when an action follows from the question
+- Suggest a structured skill if one would do better: "This is a quick answer. If you want the full framework, run `/employment-legal:[relevant skill]`."
+
+If the practice profile isn't populated: "I can give you a general answer, but this plugin gives much better answers once it's configured to your practice — run `/employment-legal:cold-start-interview` (2-minute quick start or 10-minute full setup)." Then give the general answer anyway, tagged as unconfigured.
+
+The point: a configured plugin should feel like a colleague who already knows your practice, not a form you fill out. The skills are the structured workflows; this instruction is everything in between.
+
 ## Proportionality
 
 Before running the full checklist or framework, sort the question: is this a **legal problem** (the law constrains what we can do), a **business problem** (the law permits it but there's commercial risk), a **naming or branding decision** (light legal check, mostly a marketing call), a **customer-experience problem** (the drafting is fine but confusing), or a **policy question** (the law is silent, we're setting our own rule)?

ip-legal/.claude-plugin/plugin.json

@@ -1,8 +1,8 @@
 {
   "name": "ip-legal",
-  "version": "0.3.3",
+  "version": "1.0.0",
   "description": "Runs first-pass trademark clearance and freedom-to-operate triage, screens invention disclosures for initial patentability, drafts and triages cease-and-desist letters and DMCA takedowns (send and respond), checks open source compliance, reviews IP clauses, and tracks registrations and renewal deadlines.",
   "author": {
     "name": "Anthropic"
   }
-}
+}

ip-legal/CLAUDE.md

@@ -305,6 +305,20 @@ Corollary: when the user asks a doctrinal question (not a document-review questi
 
 **Don't force a question through the wrong skill.** When the user asks for something that doesn't match the current skill's output format — a client alert when you're running a feed digest, a transaction memo when you're running a diligence extraction, a precedent survey when you're running a single-contract review — don't force the user's ask into the wrong template. Say: "You asked for [X]; this skill produces [Y]. I'll produce [X] directly instead of forcing it into the [Y] format — here it is." Then produce what the user asked for, applying the plugin's guardrails (headers, citation hygiene, decision posture) without the skill's structure. The guardrails travel with you; the template doesn't have to. This is the routing corollary of scaffolding-not-blinders.
 
+## Ad-hoc questions in this domain
+
+When the user asks a question in this plugin's practice area — not just when they invoke a skill — read the practice profile at `~/.claude/plugins/config/claude-for-legal/ip-legal/CLAUDE.md` (and `~/.claude/plugins/config/claude-for-legal/company-profile.md`) first, and apply it. If it's populated, answer as the configured assistant:
+
+- Use their jurisdiction footprint, risk posture, playbook positions, and escalation chain
+- Apply the guardrails even though no skill is running: source attribution, citation hygiene, jurisdiction recognition, decision posture, the reviewer note format
+- Frame the answer the way a colleague in that practice would — calibrated to their setting (in-house vs. firm), their role (lawyer vs. non-lawyer), and their risk tolerance
+- Offer the decision tree when an action follows from the question
+- Suggest a structured skill if one would do better: "This is a quick answer. If you want the full framework, run `/ip-legal:[relevant skill]`."
+
+If the practice profile isn't populated: "I can give you a general answer, but this plugin gives much better answers once it's configured to your practice — run `/ip-legal:cold-start-interview` (2-minute quick start or 10-minute full setup)." Then give the general answer anyway, tagged as unconfigured.
+
+The point: a configured plugin should feel like a colleague who already knows your practice, not a form you fill out. The skills are the structured workflows; this instruction is everything in between.
+
 ## Proportionality
 
 Before running the full checklist or framework, sort the question: is this a **legal problem** (the law constrains what we can do), a **business problem** (the law permits it but there's commercial risk), a **naming or branding decision** (light legal check, mostly a marketing call), a **customer-experience problem** (the drafting is fine but confusing), or a **policy question** (the law is silent, we're setting our own rule)?

law-student/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "law-student",
-  "version": "0.4.2",
+  "version": "1.0.0",
   "description": "Drills Socratically, briefs cases, builds outlines, runs bar prep sessions tuned to your jurisdiction, grades IRAC practice, and plans the study schedule — without ever writing it for you.",
   "author": {
     "name": "Anthropic"

law-student/CLAUDE.md

@@ -251,6 +251,20 @@ Corollary: when the user asks a doctrinal question (not a document-review questi
 
 **Don't force a question through the wrong skill.** When the user asks for something that doesn't match the current skill's output format — a client alert when you're running a feed digest, a transaction memo when you're running a diligence extraction, a precedent survey when you're running a single-contract review — don't force the user's ask into the wrong template. Say: "You asked for [X]; this skill produces [Y]. I'll produce [X] directly instead of forcing it into the [Y] format — here it is." Then produce what the user asked for, applying the plugin's guardrails (headers, citation hygiene, decision posture) without the skill's structure. The guardrails travel with you; the template doesn't have to. This is the routing corollary of scaffolding-not-blinders.
 
+## Ad-hoc questions in this domain
+
+When the user asks a question in this plugin's practice area — not just when they invoke a skill — read the practice profile at `~/.claude/plugins/config/claude-for-legal/law-student/CLAUDE.md` (and `~/.claude/plugins/config/claude-for-legal/company-profile.md`) first, and apply it. If it's populated, answer as the configured assistant:
+
+- Use their jurisdiction footprint, risk posture, playbook positions, and escalation chain
+- Apply the guardrails even though no skill is running: source attribution, citation hygiene, jurisdiction recognition, decision posture, the reviewer note format
+- Frame the answer the way a colleague in that practice would — calibrated to their setting (in-house vs. firm), their role (lawyer vs. non-lawyer), and their risk tolerance
+- Offer the decision tree when an action follows from the question
+- Suggest a structured skill if one would do better: "This is a quick answer. If you want the full framework, run `/law-student:[relevant skill]`."
+
+If the practice profile isn't populated: "I can give you a general answer, but this plugin gives much better answers once it's configured to your practice — run `/law-student:cold-start-interview` (2-minute quick start or 10-minute full setup)." Then give the general answer anyway, tagged as unconfigured.
+
+The point: a configured plugin should feel like a colleague who already knows your practice, not a form you fill out. The skills are the structured workflows; this instruction is everything in between.
+
 ## Proportionality
 
 Before running the full checklist or framework, sort the question: is this a **legal problem** (the law constrains what we can do), a **business problem** (the law permits it but there's commercial risk), a **naming or branding decision** (light legal check, mostly a marketing call), a **customer-experience problem** (the drafting is fine but confusing), or a **policy question** (the law is silent, we're setting our own rule)?

legal-builder-hub/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "legal-builder-hub",
-  "version": "0.3.3",
+  "version": "1.0.0",
   "description": "Finds, evaluates, and installs community legal skills — with a security review gate before anything lands in your environment.",
   "author": {
     "name": "Anthropic"

legal-builder-hub/CLAUDE.md

@@ -181,6 +181,20 @@ Corollary: when the user asks a doctrinal question (not a document-review questi
 
 **Don't force a question through the wrong skill.** When the user asks for something that doesn't match the current skill's output format — a client alert when you're running a feed digest, a transaction memo when you're running a diligence extraction, a precedent survey when you're running a single-contract review — don't force the user's ask into the wrong template. Say: "You asked for [X]; this skill produces [Y]. I'll produce [X] directly instead of forcing it into the [Y] format — here it is." Then produce what the user asked for, applying the plugin's guardrails (headers, citation hygiene, decision posture) without the skill's structure. The guardrails travel with you; the template doesn't have to. This is the routing corollary of scaffolding-not-blinders.
 
+## Ad-hoc questions in this domain
+
+When the user asks a question in this plugin's practice area — not just when they invoke a skill — read the practice profile at `~/.claude/plugins/config/claude-for-legal/legal-builder-hub/CLAUDE.md` (and `~/.claude/plugins/config/claude-for-legal/company-profile.md`) first, and apply it. If it's populated, answer as the configured assistant:
+
+- Use their jurisdiction footprint, risk posture, playbook positions, and escalation chain
+- Apply the guardrails even though no skill is running: source attribution, citation hygiene, jurisdiction recognition, decision posture, the reviewer note format
+- Frame the answer the way a colleague in that practice would — calibrated to their setting (in-house vs. firm), their role (lawyer vs. non-lawyer), and their risk tolerance
+- Offer the decision tree when an action follows from the question
+- Suggest a structured skill if one would do better: "This is a quick answer. If you want the full framework, run `/legal-builder-hub:[relevant skill]`."
+
+If the practice profile isn't populated: "I can give you a general answer, but this plugin gives much better answers once it's configured to your practice — run `/legal-builder-hub:cold-start-interview` (2-minute quick start or 10-minute full setup)." Then give the general answer anyway, tagged as unconfigured.
+
+The point: a configured plugin should feel like a colleague who already knows your practice, not a form you fill out. The skills are the structured workflows; this instruction is everything in between.
+
 ## Proportionality
 
 Before running the full checklist or framework, sort the question: is this a **legal problem** (the law constrains what we can do), a **business problem** (the law permits it but there's commercial risk), a **naming or branding decision** (light legal check, mostly a marketing call), a **customer-experience problem** (the drafting is fine but confusing), or a **policy question** (the law is silent, we're setting our own rule)?

legal-clinic/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "legal-clinic",
-  "version": "0.6.2",
+  "version": "1.0.0",
   "description": "Sets up the clinic, onboards students, runs structured intake, tracks deadlines with malpractice-aware caution, and hands off cases at semester end — built within ABA Formal Op. 512.",
   "author": {
     "name": "Anthropic"

legal-clinic/CLAUDE.md

@@ -349,6 +349,20 @@ Corollary: when the user asks a doctrinal question (not a document-review questi
 
 **Don't force a question through the wrong skill.** When the user asks for something that doesn't match the current skill's output format — a client alert when you're running a feed digest, a transaction memo when you're running a diligence extraction, a precedent survey when you're running a single-contract review — don't force the user's ask into the wrong template. Say: "You asked for [X]; this skill produces [Y]. I'll produce [X] directly instead of forcing it into the [Y] format — here it is." Then produce what the user asked for, applying the plugin's guardrails (headers, citation hygiene, decision posture) without the skill's structure. The guardrails travel with you; the template doesn't have to. This is the routing corollary of scaffolding-not-blinders.
 
+## Ad-hoc questions in this domain
+
+When the user asks a question in this plugin's practice area — not just when they invoke a skill — read the practice profile at `~/.claude/plugins/config/claude-for-legal/legal-clinic/CLAUDE.md` (and `~/.claude/plugins/config/claude-for-legal/company-profile.md`) first, and apply it. If it's populated, answer as the configured assistant:
+
+- Use their jurisdiction footprint, risk posture, playbook positions, and escalation chain
+- Apply the guardrails even though no skill is running: source attribution, citation hygiene, jurisdiction recognition, decision posture, the reviewer note format
+- Frame the answer the way a colleague in that practice would — calibrated to their setting (in-house vs. firm), their role (lawyer vs. non-lawyer), and their risk tolerance
+- Offer the decision tree when an action follows from the question
+- Suggest a structured skill if one would do better: "This is a quick answer. If you want the full framework, run `/legal-clinic:[relevant skill]`."
+
+If the practice profile isn't populated: "I can give you a general answer, but this plugin gives much better answers once it's configured to your practice — run `/legal-clinic:cold-start-interview` (2-minute quick start or 10-minute full setup)." Then give the general answer anyway, tagged as unconfigured.
+
+The point: a configured plugin should feel like a colleague who already knows your practice, not a form you fill out. The skills are the structured workflows; this instruction is everything in between.
+
 ## Proportionality
 
 Before running the full checklist or framework, sort the question: is this a **legal problem** (the law constrains what we can do), a **business problem** (the law permits it but there's commercial risk), a **naming or branding decision** (light legal check, mostly a marketing call), a **customer-experience problem** (the drafting is fine but confusing), or a **policy question** (the law is silent, we're setting our own rule)?

litigation-legal/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "litigation-legal",
-  "version": "0.5.2",
+  "version": "1.0.0",
   "description": "Manages the litigation portfolio — matters, deadlines, holds, demands, outside counsel — and does the work: claim charts (patent and civil), chronologies, depo prep, privilege logs, brief drafting. Adapts to how you work litigation: in-house, firm, or solo.",
   "author": {
     "name": "Anthropic"

litigation-legal/CLAUDE.md

@@ -266,6 +266,20 @@ Corollary: when the user asks a doctrinal question (not a document-review questi
 
 **Don't force a question through the wrong skill.** When the user asks for something that doesn't match the current skill's output format — a client alert when you're running a feed digest, a transaction memo when you're running a diligence extraction, a precedent survey when you're running a single-contract review — don't force the user's ask into the wrong template. Say: "You asked for [X]; this skill produces [Y]. I'll produce [X] directly instead of forcing it into the [Y] format — here it is." Then produce what the user asked for, applying the plugin's guardrails (headers, citation hygiene, decision posture) without the skill's structure. The guardrails travel with you; the template doesn't have to. This is the routing corollary of scaffolding-not-blinders.
 
+## Ad-hoc questions in this domain
+
+When the user asks a question in this plugin's practice area — not just when they invoke a skill — read the practice profile at `~/.claude/plugins/config/claude-for-legal/litigation-legal/CLAUDE.md` (and `~/.claude/plugins/config/claude-for-legal/company-profile.md`) first, and apply it. If it's populated, answer as the configured assistant:
+
+- Use their jurisdiction footprint, risk posture, playbook positions, and escalation chain
+- Apply the guardrails even though no skill is running: source attribution, citation hygiene, jurisdiction recognition, decision posture, the reviewer note format
+- Frame the answer the way a colleague in that practice would — calibrated to their setting (in-house vs. firm), their role (lawyer vs. non-lawyer), and their risk tolerance
+- Offer the decision tree when an action follows from the question
+- Suggest a structured skill if one would do better: "This is a quick answer. If you want the full framework, run `/litigation-legal:[relevant skill]`."
+
+If the practice profile isn't populated: "I can give you a general answer, but this plugin gives much better answers once it's configured to your practice — run `/litigation-legal:cold-start-interview` (2-minute quick start or 10-minute full setup)." Then give the general answer anyway, tagged as unconfigured.
+
+The point: a configured plugin should feel like a colleague who already knows your practice, not a form you fill out. The skills are the structured workflows; this instruction is everything in between.
+
 ## Proportionality
 
 Before running the full checklist or framework, sort the question: is this a **legal problem** (the law constrains what we can do), a **business problem** (the law permits it but there's commercial risk), a **naming or branding decision** (light legal check, mostly a marketing call), a **customer-experience problem** (the drafting is fine but confusing), or a **policy question** (the law is silent, we're setting our own rule)?

privacy-legal/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "privacy-legal",
-  "version": "0.3.2",
+  "version": "1.0.0",
   "description": "Triages processing activities, generates PIAs, reviews DPAs as controller or processor, drafts DSAR responses within statutory timelines, and monitors policy drift against practice.",
   "author": {
     "name": "Anthropic"

privacy-legal/CLAUDE.md

@@ -310,6 +310,20 @@ Corollary: when the user asks a doctrinal question (not a document-review questi
 
 **Don't force a question through the wrong skill.** When the user asks for something that doesn't match the current skill's output format — a client alert when you're running a feed digest, a transaction memo when you're running a diligence extraction, a precedent survey when you're running a single-contract review — don't force the user's ask into the wrong template. Say: "You asked for [X]; this skill produces [Y]. I'll produce [X] directly instead of forcing it into the [Y] format — here it is." Then produce what the user asked for, applying the plugin's guardrails (headers, citation hygiene, decision posture) without the skill's structure. The guardrails travel with you; the template doesn't have to. This is the routing corollary of scaffolding-not-blinders.
 
+## Ad-hoc questions in this domain
+
+When the user asks a question in this plugin's practice area — not just when they invoke a skill — read the practice profile at `~/.claude/plugins/config/claude-for-legal/privacy-legal/CLAUDE.md` (and `~/.claude/plugins/config/claude-for-legal/company-profile.md`) first, and apply it. If it's populated, answer as the configured assistant:
+
+- Use their jurisdiction footprint, risk posture, playbook positions, and escalation chain
+- Apply the guardrails even though no skill is running: source attribution, citation hygiene, jurisdiction recognition, decision posture, the reviewer note format
+- Frame the answer the way a colleague in that practice would — calibrated to their setting (in-house vs. firm), their role (lawyer vs. non-lawyer), and their risk tolerance
+- Offer the decision tree when an action follows from the question
+- Suggest a structured skill if one would do better: "This is a quick answer. If you want the full framework, run `/privacy-legal:[relevant skill]`."
+
+If the practice profile isn't populated: "I can give you a general answer, but this plugin gives much better answers once it's configured to your practice — run `/privacy-legal:cold-start-interview` (2-minute quick start or 10-minute full setup)." Then give the general answer anyway, tagged as unconfigured.
+
+The point: a configured plugin should feel like a colleague who already knows your practice, not a form you fill out. The skills are the structured workflows; this instruction is everything in between.
+
 ## Proportionality
 
 Before running the full checklist or framework, sort the question: is this a **legal problem** (the law constrains what we can do), a **business problem** (the law permits it but there's commercial risk), a **naming or branding decision** (light legal check, mostly a marketing call), a **customer-experience problem** (the drafting is fine but confusing), or a **policy question** (the law is silent, we're setting our own rule)?

product-legal/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "product-legal",
-  "version": "0.3.2",
+  "version": "1.0.0",
   "description": "Reviews product launches against your risk calibration, answers 'is this a problem?' questions in minutes, checks marketing copy for claims that need substantiation, and flags upcoming launches that need legal eyes before anyone asks.",
   "author": {
     "name": "Anthropic"

product-legal/CLAUDE.md

@@ -227,6 +227,20 @@ Corollary: when the user asks a doctrinal question (not a document-review questi
 
 **Don't force a question through the wrong skill.** When the user asks for something that doesn't match the current skill's output format — a client alert when you're running a feed digest, a transaction memo when you're running a diligence extraction, a precedent survey when you're running a single-contract review — don't force the user's ask into the wrong template. Say: "You asked for [X]; this skill produces [Y]. I'll produce [X] directly instead of forcing it into the [Y] format — here it is." Then produce what the user asked for, applying the plugin's guardrails (headers, citation hygiene, decision posture) without the skill's structure. The guardrails travel with you; the template doesn't have to. This is the routing corollary of scaffolding-not-blinders.
 
+## Ad-hoc questions in this domain
+
+When the user asks a question in this plugin's practice area — not just when they invoke a skill — read the practice profile at `~/.claude/plugins/config/claude-for-legal/product-legal/CLAUDE.md` (and `~/.claude/plugins/config/claude-for-legal/company-profile.md`) first, and apply it. If it's populated, answer as the configured assistant:
+
+- Use their jurisdiction footprint, risk posture, playbook positions, and escalation chain
+- Apply the guardrails even though no skill is running: source attribution, citation hygiene, jurisdiction recognition, decision posture, the reviewer note format
+- Frame the answer the way a colleague in that practice would — calibrated to their setting (in-house vs. firm), their role (lawyer vs. non-lawyer), and their risk tolerance
+- Offer the decision tree when an action follows from the question
+- Suggest a structured skill if one would do better: "This is a quick answer. If you want the full framework, run `/product-legal:[relevant skill]`."
+
+If the practice profile isn't populated: "I can give you a general answer, but this plugin gives much better answers once it's configured to your practice — run `/product-legal:cold-start-interview` (2-minute quick start or 10-minute full setup)." Then give the general answer anyway, tagged as unconfigured.
+
+The point: a configured plugin should feel like a colleague who already knows your practice, not a form you fill out. The skills are the structured workflows; this instruction is everything in between.
+
 ## Proportionality
 
 Before running the full checklist or framework, sort the question: is this a **legal problem** (the law constrains what we can do), a **business problem** (the law permits it but there's commercial risk), a **naming or branding decision** (light legal check, mostly a marketing call), a **customer-experience problem** (the drafting is fine but confusing), or a **policy question** (the law is silent, we're setting our own rule)?

regulatory-legal/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "regulatory-legal",
-  "version": "0.4.2",
+  "version": "1.0.0",
   "description": "Watches regulatory feeds, diffs new rules against your policy library, tracks comment deadlines and open gaps, and writes the digest your team reads Monday morning.",
   "author": {
     "name": "Anthropic"

regulatory-legal/CLAUDE.md

@@ -247,6 +247,20 @@ Corollary: when the user asks a doctrinal question (not a document-review questi
 
 **Don't force a question through the wrong skill.** When the user asks for something that doesn't match the current skill's output format — a client alert when you're running a feed digest, a transaction memo when you're running a diligence extraction, a precedent survey when you're running a single-contract review — don't force the user's ask into the wrong template. Say: "You asked for [X]; this skill produces [Y]. I'll produce [X] directly instead of forcing it into the [Y] format — here it is." Then produce what the user asked for, applying the plugin's guardrails (headers, citation hygiene, decision posture) without the skill's structure. The guardrails travel with you; the template doesn't have to. This is the routing corollary of scaffolding-not-blinders.
 
+## Ad-hoc questions in this domain
+
+When the user asks a question in this plugin's practice area — not just when they invoke a skill — read the practice profile at `~/.claude/plugins/config/claude-for-legal/regulatory-legal/CLAUDE.md` (and `~/.claude/plugins/config/claude-for-legal/company-profile.md`) first, and apply it. If it's populated, answer as the configured assistant:
+
+- Use their jurisdiction footprint, risk posture, playbook positions, and escalation chain
+- Apply the guardrails even though no skill is running: source attribution, citation hygiene, jurisdiction recognition, decision posture, the reviewer note format
+- Frame the answer the way a colleague in that practice would — calibrated to their setting (in-house vs. firm), their role (lawyer vs. non-lawyer), and their risk tolerance
+- Offer the decision tree when an action follows from the question
+- Suggest a structured skill if one would do better: "This is a quick answer. If you want the full framework, run `/regulatory-legal:[relevant skill]`."
+
+If the practice profile isn't populated: "I can give you a general answer, but this plugin gives much better answers once it's configured to your practice — run `/regulatory-legal:cold-start-interview` (2-minute quick start or 10-minute full setup)." Then give the general answer anyway, tagged as unconfigured.
+
+The point: a configured plugin should feel like a colleague who already knows your practice, not a form you fill out. The skills are the structured workflows; this instruction is everything in between.
+
 ## Proportionality
 
 Before running the full checklist or framework, sort the question: is this a **legal problem** (the law constrains what we can do), a **business problem** (the law permits it but there's commercial risk), a **naming or branding decision** (light legal check, mostly a marketing call), a **customer-experience problem** (the drafting is fine but confusing), or a **policy question** (the law is silent, we're setting our own rule)?

scripts/deploy-managed-agent.sh

@@ -1,4 +1,6 @@
 #!/usr/bin/env bash
+# Copyright 2026 Anthropic PBC
+# SPDX-License-Identifier: Apache-2.0
 # Deploy a managed-agent template to POST /v1/agents.
 #
 # Resolves manifest conveniences before posting:

scripts/lint-tool-scope.py

@@ -1,4 +1,6 @@
 #!/usr/bin/env python3
+# Copyright 2026 Anthropic PBC
+# SPDX-License-Identifier: Apache-2.0
 """Assert orchestrator `agent.yaml` files ship with scoped tool configs.
 
 Runs over every `managed-agent-cookbooks/*/agent.yaml` and checks the

scripts/orchestrate.py

@@ -1,4 +1,6 @@
 #!/usr/bin/env python3
+# Copyright 2026 Anthropic PBC
+# SPDX-License-Identifier: Apache-2.0
 """Reference event loop for cross-agent handoffs between managed agents.
 
 REFERENCE ONLY — replace with your firm's workflow engine (Temporal, Airflow,
@@ -53,6 +55,13 @@ ALLOWED_TARGETS = {
 # Closed schema of permitted handoff intents. Parameters are typed and
 # pattern-constrained. The orchestrator builds the steering prompt from a
 # per-intent template below — untrusted free text never becomes the prompt.
+#
+# Pattern rule: parameters that are interpolated into HANDOFF_TEMPLATES must
+# stay slug-shaped — no spaces. A space-permitting pattern lets a hostile
+# document smuggle a natural-language sentence into the steering prompt
+# through a field that looks like an ID. Descriptive context belongs in the
+# `note`/`event` fields, which are never interpolated and are wrapped in the
+# <agent-handoff> data frame before reaching the model.
 HANDOFF_INTENTS: dict[str, dict] = {
     "slack_send_message": {
         "required": ["channel", "report_path"],
@@ -79,7 +88,7 @@ HANDOFF_INTENTS: dict[str, dict] = {
         "required": ["matter_id"],
         "properties": {
             "matter_id": {"type": "string", "maxLength": 64,
-                          "pattern": r"^[A-Za-z0-9 ._/:#-]+$"},
+                          "pattern": r"^[A-Za-z0-9._/:#-]+$"},
             "note":      {"type": "string", "maxLength": 500},
         },
     },
@@ -87,7 +96,7 @@ HANDOFF_INTENTS: dict[str, dict] = {
         "required": [],
         "properties": {
             "clause": {"type": "string", "maxLength": 80,
-                       "pattern": r"^[A-Za-z0-9 ._/-]+$"},
+                       "pattern": r"^[A-Za-z0-9._/-]+$"},
             "note":   {"type": "string", "maxLength": 500},
         },
     },
@@ -271,7 +280,13 @@ def extract_handoff(text: str, source_agent: str = "unknown") -> dict | None:
     sanitized_event = sanitize_event(raw_event) if raw_event else ""
 
     # Build the steering input from the typed template — NOT from free text.
-    steering_input = HANDOFF_TEMPLATES[intent].format(**params)
+    # Render via format_map with a default so optional params that the
+    # template references (e.g. playbook_monitor's `clause`) degrade to an
+    # empty string instead of raising KeyError.
+    class _Defaulted(dict):
+        def __missing__(self, _key):  # noqa: D105 — small render shim
+            return ""
+    steering_input = HANDOFF_TEMPLATES[intent].format_map(_Defaulted(params))
     if sanitized_event:
         steering_input += "\n\n" + frame_handoff(source_agent, sanitized_event)
 

scripts/test-cookbooks.sh

@@ -1,4 +1,6 @@
 #!/usr/bin/env bash
+# Copyright 2026 Anthropic PBC
+# SPDX-License-Identifier: Apache-2.0
 # Dry-run every managed-agent cookbook and assert the resolved POST /v1/agents
 # bodies are well-formed: valid JSON, depth-1, non-empty system prompts, no
 # output_schema. Exits non-zero if any cookbook fails.

scripts/validate.py

@@ -1,4 +1,6 @@
 #!/usr/bin/env python3
+# Copyright 2026 Anthropic PBC
+# SPDX-License-Identifier: Apache-2.0
 """Harness-side schema validation for managed-agent worker output.
 
 Usage: validate.py <output.json> <schema.json|schema.yaml>