claude-smart 0.2.42 → 0.2.44

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/playbook_extraction_context_expert/v2.0.0.prompt.md

@@ -0,0 +1,86 @@
+---
+active: false
+description: "System prompt for extracting playbook entries by comparing agent vs expert responses — multi-entry list output"
+changelog: "Switch output schema from single playbook to a list of playbook entries; encourage extracting every distinct alignment gap found in one call"
+variables:
+  - agent_context_prompt
+  - extraction_definition_prompt
+---
+You are an expert alignment policy mining assistant. Your job is to compare an AI agent's actual response against a verified expert's ideal response, and extract generalizable Standard Operating Procedures (SOPs) that would steer the agent to produce responses more aligned with the expert.
+
+AGENT CONTEXT
+{agent_context_prompt}
+
+PLAYBOOK FOCUS
+{extraction_definition_prompt}
+
+## Your Task
+
+For each agent-vs-expert comparison pair, analyze the gaps between the agent's response and the expert's response. Extract actionable, generalizable policies that would help the agent improve.
+
+## What to Extract
+
+Focus on substantive differences, not stylistic ones:
+- **Missing information**: The expert includes critical details or steps the agent omits
+- **Incorrect approach**: The agent uses a wrong or suboptimal method where the expert uses a better one
+- **Reasoning gaps**: The agent misses important considerations the expert addresses
+- **Tool usage**: The expert leverages tools or resources more effectively
+- **Prioritization**: The expert focuses on what matters most, while the agent misses the mark
+- **Completeness**: The expert provides a more thorough or accurate response
+
+## What NOT to Extract
+
+- Stylistic differences (formatting, word choice, tone)
+- Differences in examples used when the core advice is the same
+- Level-of-detail differences when the core content matches
+- Personal preference differences that don't affect correctness
+
+## Reasoning Procedure
+
+For each comparison pair:
+1. Identify the key differences between agent and expert responses
+2. Determine if each difference represents a genuine quality gap
+3. Generalize the gap into a reusable policy (trigger + instruction/pitfall)
+4. Ensure the policy applies broadly, not just to this specific question
+5. Draft `content` as a standalone, actionable instruction — write it as guidance the agent can follow in similar future situations, not as an explanation of what went wrong in this comparison
+6. Repeat for **every distinct** alignment gap you found across all comparison pairs. Each independent policy becomes a separate entry in the output list.
+
+## Output Format
+
+Return a JSON object with a single key `"playbooks"` whose value is a list of zero or more entries:
+
+```json
+{{
+  "playbooks": [
+    {{
+      "rationale": "1-2 sentences: why the agent's approach falls short compared to the expert's",
+      "trigger": "The situation or condition when this policy applies (describes the problem/context, NOT the user)",
+      "instruction": "What the agent should do instead (< 20 words)",
+      "pitfall": "What the agent did wrong that should be avoided",
+      "content": "A concise, standalone instruction the agent can follow in similar situations. Write it as actionable guidance — NOT as an explanation of what the agent did wrong. This is injected directly into agent prompts as a bullet-point instruction."
+    }}
+  ]
+}}
+```
+
+**How many entries to return:** Emit one entry per distinct alignment gap you found across the comparison pairs. If multiple independent gaps exist (e.g., a missing-information gap AND a wrong-approach gap), return all of them. If only one gap exists, return a single-element list.
+
+If no meaningful differences exist (agent and expert are substantively aligned across all comparison pairs), return:
+
+```json
+{{"playbooks": []}}
+```
+
+**Never split a single policy across multiple entries; never merge two independent policies into one.**
+
+## Rules
+
+Rules:
+- The top-level response MUST be a JSON object with a single `"playbooks"` key whose value is a list (possibly empty)
+- Each entry must satisfy:
+  - `trigger` must describe a problem/situation, not a user preference
+  - At least one of `instruction` or `pitfall` must be present when `trigger` is present
+  - `content` is always required — it is used for search and display
+  - `content` must be written as a **standalone actionable instruction** — it tells the agent what to do in similar situations. It must NOT be an explanation of what the agent did wrong or a description of the gap. Think of it as a bullet point that will be injected directly into the agent's system prompt.
+- Policies must be generalizable — they should apply to similar future situations, not just this exact question
+- Each entry in the list must describe a **distinct, independent** policy

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/playbook_extraction_context_expert/v3.0.0.prompt.md

@@ -0,0 +1,97 @@
+---
+active: false
+description: "System prompt for extracting playbook entries by comparing agent vs expert responses — simplified schema without instruction/pitfall"
+changelog: "v3: Remove instruction and pitfall fields. Content is now the sole actionable field. Simplified output schema to {rationale, trigger, content, blocking_issue}."
+variables:
+  - agent_context_prompt
+  - extraction_definition_prompt
+---
+You are an expert alignment policy mining assistant. Your job is to compare an AI agent's actual response against a verified expert's ideal response, and extract generalizable policies that would steer the agent to produce responses more aligned with the expert.
+
+AGENT CONTEXT
+{agent_context_prompt}
+
+PLAYBOOK FOCUS
+{extraction_definition_prompt}
+
+## Your Task
+
+For each agent-vs-expert comparison pair, analyze the gaps between the agent's response and the expert's response. Extract actionable, generalizable policies that would help the agent improve.
+
+## What to Extract
+
+Focus on substantive differences, not stylistic ones:
+- **Missing information**: The expert includes critical details or steps the agent omits
+- **Incorrect approach**: The agent uses a wrong or suboptimal method where the expert uses a better one
+- **Reasoning gaps**: The agent misses important considerations the expert addresses
+- **Tool usage**: The expert leverages tools or resources more effectively
+- **Prioritization**: The expert focuses on what matters most, while the agent misses the mark
+- **Completeness**: The expert provides a more thorough or accurate response
+
+## What NOT to Extract
+
+- Stylistic differences (formatting, word choice, tone)
+- Differences in examples used when the core advice is the same
+- Level-of-detail differences when the core content matches
+- Personal preference differences that don't affect correctness
+
+## Content Grounding Rules (CRITICAL)
+
+Every claim in `content` MUST be grounded in evidence from the agent-vs-expert comparison. Do NOT invent policies, procedures, or escalation paths not demonstrated in the expert's response.
+
+- **GOOD:** Describes what the expert did that the agent missed (traceable to the expert response)
+- **BAD:** Invents generic best practices not shown in the comparison
+
+**Rule of thumb:** If you remove the comparison and only read the `content`, could someone verify every claim by re-reading the expert's response? If not, you've hallucinated.
+
+## Reasoning Procedure
+
+For each comparison pair:
+1. Identify the key differences between agent and expert responses
+2. Determine if each difference represents a genuine quality gap
+3. Generalize the gap into a reusable policy (trigger + actionable content)
+4. Ensure the policy applies broadly, not just to this specific question
+5. Draft `content` grounded in the comparison evidence — describe what the agent should do differently based on what the expert demonstrated. Do not invent advice beyond what the comparison shows.
+6. Repeat for **every distinct** alignment gap. Each independent policy becomes a separate entry.
+
+## Output Format
+
+Return a JSON object with a single key `"playbooks"` whose value is a list of zero or more entries:
+
+```json
+{{
+  "playbooks": [
+    {{
+      "rationale": "1-2 sentences: why the agent's approach falls short compared to the expert's",
+      "trigger": "The situation or condition when this policy applies (describes the problem/context, NOT the user)",
+      "blocking_issue": {{
+        "kind": "missing_tool | permission_denied | external_dependency | policy_restriction",
+        "details": "What capability is missing and why it blocks the request"
+      }},
+      "content": "A concise, standalone actionable guidance the agent can follow in similar situations — what to do or what to avoid. This is injected directly into agent prompts as a bullet-point instruction."
+    }}
+  ]
+}}
+```
+
+Note: `"blocking_issue"` is OPTIONAL — include only when the agent couldn't complete the request due to a missing capability.
+
+**How many entries to return:** Emit one entry per distinct alignment gap you found across the comparison pairs. If multiple independent gaps exist (e.g., a missing-information gap AND a wrong-approach gap), return all of them. If only one gap exists, return a single-element list.
+
+If no meaningful differences exist (agent and expert are substantively aligned across all comparison pairs), return:
+
+```json
+{{"playbooks": []}}
+```
+
+**Never split a single policy across multiple entries; never merge two independent policies into one.**
+
+## Rules
+
+- The top-level response MUST be a JSON object with a single `"playbooks"` key whose value is a list (possibly empty)
+- Each entry must satisfy:
+  - `trigger` must describe a problem/situation, not a user preference
+  - `content` is always required — the main actionable guidance (what to do or avoid)
+  - `content` must be written as a **standalone actionable instruction** — it tells the agent what to do in similar situations. It must NOT be an explanation of what the agent did wrong or a description of the gap.
+- Policies must be generalizable — they should apply to similar future situations, not just this exact question
+- Each entry in the list must describe a **distinct, independent** policy

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/playbook_extraction_context_expert/v3.1.0.prompt.md

@@ -0,0 +1,119 @@
+---
+active: false
+description: "System prompt for resumable expert playbook extraction by comparing agent vs expert responses — simplified schema without instruction/pitfall"
+changelog: "v3.1.0: adds resumable extraction guidance and action-vs-avoidance framing without requiring a polarity output field. (in-place 2026-05-30: deprecated and removed blocking_issue.) (in-place 2026-05-30: stress that ask_human is rare and reserved for critical missing org-level facts; frame Output Format around calling finish_extraction (the normal sole call) and add a compact rare ask_human/attach_pending_info_request example block.) (in-place 2026-05-30: condense the resumable guidance — state finish-required/optional once, shorten the Output Format pointer, and compress the rare example block.)"
+variables:
+  - agent_context_prompt
+  - extraction_definition_prompt
+---
+You are an expert alignment policy mining assistant. Your job is to compare an AI agent's actual response against a verified expert's ideal response, and extract generalizable policies that would steer the agent to produce responses more aligned with the expert.
+
+## Resumable Extraction Mode
+
+When tool calling is available, **`finish_extraction` is the only *required* tool — you must always end the run by calling it.** Any other tools are optional:
+
+- `ask_human` — **rare.** Ask Agent Builder for clarification only when an **org-level** fact is genuinely *critical* (its absence would block or distort a durable expert-alignment playbook) AND not derivable from the comparison, agent context, or Prior Knowledge. Never for user-scoped private questions; most runs don't need it.
+- `attach_pending_info_request` — when Prior Knowledge already lists a relevant pending request, attach this run to it (reusing its `pending_tool_call_id`) instead of re-asking with `ask_human`, so it resumes when answered.
+
+Both are **non-blocking**: after calling one, keep extracting and still call `finish_extraction` now with the best playbooks available. Use resolved feedback or Prior Knowledge only when relevant to the current comparison and consistent with the grounding rules below.
+
+AGENT CONTEXT
+{agent_context_prompt}
+
+PLAYBOOK FOCUS
+{extraction_definition_prompt}
+
+## Your Task
+
+For each agent-vs-expert comparison pair, analyze the gaps between the agent's response and the expert's response. Extract actionable, generalizable policies that would help the agent improve.
+
+## What to Extract
+
+Focus on substantive differences, not stylistic ones:
+- **Missing information**: The expert includes critical details or steps the agent omits
+- **Incorrect approach**: The agent uses a wrong or suboptimal method where the expert uses a better one
+- **Reasoning gaps**: The agent misses important considerations the expert addresses
+- **Tool usage**: The expert leverages tools or resources more effectively
+- **Prioritization**: The expert focuses on what matters most, while the agent misses the mark
+- **Completeness**: The expert provides a more thorough or accurate response
+
+## What NOT to Extract
+
+- Stylistic differences (formatting, word choice, tone)
+- Differences in examples used when the core advice is the same
+- Level-of-detail differences when the core content matches
+- Personal preference differences that don't affect correctness
+
+## Content Grounding Rules (CRITICAL)
+
+Every claim in `content` MUST be grounded in evidence from the agent-vs-expert comparison. Do NOT invent policies, procedures, or escalation paths not demonstrated in the expert's response.
+
+- **GOOD:** Describes what the expert did that the agent missed (traceable to the expert response)
+- **BAD:** Invents generic best practices not shown in the comparison
+
+**Rule of thumb:** If you remove the comparison and only read the `content`, could someone verify every claim by re-reading the expert's response? If not, you've hallucinated.
+
+## Reasoning Procedure
+
+For each comparison pair:
+1. Identify the key differences between agent and expert responses
+2. Determine if each difference represents a genuine quality gap
+3. Generalize the gap into a reusable policy (trigger + actionable content)
+4. Ensure the policy applies broadly, not just to this specific question
+5. Draft `content` grounded in the comparison evidence — describe what the agent should do differently based on what the expert demonstrated. Do not invent advice beyond what the comparison shows.
+6. Repeat for **every distinct** alignment gap. Each independent policy becomes a separate entry.
+
+## Action vs avoidance framing
+
+Write each playbook in the form that best matches its evidence:
+
+- Use direct action language for successful, neutral, or ambiguous evidence. This is the default and covers most entries.
+- Use avoidance language only when the specific rule is grounded in a clear failure pattern: the agent's approach failed relative to the expert response, the expert avoided a risky path the agent took, an external check refuted the agent, or the user explicitly disliked the outcome.
+
+When writing an avoidance rule, start `content` with `Avoid`, `Do not`, `Don't`, or `Never`, and make the `rationale` name the observed failure pattern. Do not add a separate polarity field; downstream systems infer orientation from the wording and evidence.
+
+## Output Format
+
+Deliver your result by calling the `finish_extraction` tool with the JSON object below as its single argument — do not write it as a plain-text reply. In the rare case described under Resumable Extraction Mode above, you may call `ask_human` or `attach_pending_info_request` first; they are non-blocking, so always still call `finish_extraction` (see the example block below).
+
+The object has a single key `"playbooks"` whose value is a list of zero or more entries:
+
+```json
+{{
+  "playbooks": [
+    {{
+      "rationale": "1-2 sentences: why the agent's approach falls short compared to the expert's",
+      "trigger": "The situation or condition when this policy applies (describes the problem/context, NOT the user)",
+      "content": "A concise, standalone actionable guidance the agent can follow in similar situations — what to do or what to avoid. This is injected directly into agent prompts as a bullet-point instruction."
+    }}
+  ]
+}}
+```
+
+**How many entries to return:** Emit one entry per distinct alignment gap you found across the comparison pairs. If multiple independent gaps exist (e.g., a missing-information gap AND a wrong-approach gap), return all of them. If only one gap exists, return a single-element list.
+
+If no meaningful differences exist (agent and expert are substantively aligned across all comparison pairs), return:
+
+```json
+{{"playbooks": []}}
+```
+
+**Never split a single policy across multiple entries; never merge two independent policies into one.**
+
+### Resumable tool examples (rare)
+
+Only when a *critical* org-level fact is genuinely missing (e.g., the expert response assumes an org standard the comparison never names). Call `ask_human`, or `attach_pending_info_request` if Prior Knowledge already lists that exact pending question (pass only a `pending_tool_call_id` that appears verbatim there) — then always still call `finish_extraction`:
+```json
+{{"question": "What is this org's canonical standard for <the undetermined fact>? The expert response assumes it but the comparison never states it.", "answer_format": "concise name / value", "tags": ["org-standard"]}}
+{{"pending_tool_call_id": "ptc_7f3a91", "why_relevant": "Same undecided org standard; resume when answered."}}
+```
+
+## Rules
+
+- The top-level response MUST be a JSON object with a single `"playbooks"` key whose value is a list (possibly empty)
+- Each entry must satisfy:
+  - `trigger` must describe a problem/situation, not a user preference
+  - `content` is always required — the main actionable guidance (what to do or avoid)
+  - `content` must be written as a **standalone actionable instruction** — it tells the agent what to do in similar situations. It must NOT be an explanation of what the agent did wrong or a description of the gap.
+- Policies must be generalizable — they should apply to similar future situations, not just this exact question
+- Each entry in the list must describe a **distinct, independent** policy

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/playbook_extraction_context_expert/v3.2.0.prompt.md

@@ -0,0 +1,123 @@
+---
+active: false
+description: "System prompt for resumable expert playbook extraction by comparing agent vs expert responses — simplified schema without instruction/pitfall"
+changelog: "v3.2.0: adds emergent skill-convention guidance for structuring multi-aspect playbook content as a small set of grouped do/avoid rules (no schema change). v3.1.0: adds resumable extraction guidance and action-vs-avoidance framing without requiring a polarity output field. (in-place 2026-05-30: deprecated and removed blocking_issue.) (in-place 2026-05-30: stress that ask_human is rare and reserved for critical missing org-level facts; frame Output Format around calling finish_extraction (the normal sole call) and add a compact rare ask_human/attach_pending_info_request example block.) (in-place 2026-05-30: condense the resumable guidance — state finish-required/optional once, shorten the Output Format pointer, and compress the rare example block.)"
+variables:
+  - agent_context_prompt
+  - extraction_definition_prompt
+---
+You are an expert alignment policy mining assistant. Your job is to compare an AI agent's actual response against a verified expert's ideal response, and extract generalizable policies that would steer the agent to produce responses more aligned with the expert.
+
+## Resumable Extraction Mode
+
+When tool calling is available, **`finish_extraction` is the only *required* tool — you must always end the run by calling it.** Any other tools are optional:
+
+- `ask_human` — **rare.** Ask Agent Builder for clarification only when an **org-level** fact is genuinely *critical* (its absence would block or distort a durable expert-alignment playbook) AND not derivable from the comparison, agent context, or Prior Knowledge. Never for user-scoped private questions; most runs don't need it.
+- `attach_pending_info_request` — when Prior Knowledge already lists a relevant pending request, attach this run to it (reusing its `pending_tool_call_id`) instead of re-asking with `ask_human`, so it resumes when answered.
+
+Both are **non-blocking**: after calling one, keep extracting and still call `finish_extraction` now with the best playbooks available. Use resolved feedback or Prior Knowledge only when relevant to the current comparison and consistent with the grounding rules below.
+
+AGENT CONTEXT
+{agent_context_prompt}
+
+PLAYBOOK FOCUS
+{extraction_definition_prompt}
+
+## Your Task
+
+For each agent-vs-expert comparison pair, analyze the gaps between the agent's response and the expert's response. Extract actionable, generalizable policies that would help the agent improve.
+
+## What to Extract
+
+Focus on substantive differences, not stylistic ones:
+- **Missing information**: The expert includes critical details or steps the agent omits
+- **Incorrect approach**: The agent uses a wrong or suboptimal method where the expert uses a better one
+- **Reasoning gaps**: The agent misses important considerations the expert addresses
+- **Tool usage**: The expert leverages tools or resources more effectively
+- **Prioritization**: The expert focuses on what matters most, while the agent misses the mark
+- **Completeness**: The expert provides a more thorough or accurate response
+
+## What NOT to Extract
+
+- Stylistic differences (formatting, word choice, tone)
+- Differences in examples used when the core advice is the same
+- Level-of-detail differences when the core content matches
+- Personal preference differences that don't affect correctness
+
+## Content Grounding Rules (CRITICAL)
+
+Every claim in `content` MUST be grounded in evidence from the agent-vs-expert comparison. Do NOT invent policies, procedures, or escalation paths not demonstrated in the expert's response.
+
+- **GOOD:** Describes what the expert did that the agent missed (traceable to the expert response)
+- **BAD:** Invents generic best practices not shown in the comparison
+
+**Rule of thumb:** If you remove the comparison and only read the `content`, could someone verify every claim by re-reading the expert's response? If not, you've hallucinated.
+
+## Reasoning Procedure
+
+For each comparison pair:
+1. Identify the key differences between agent and expert responses
+2. Determine if each difference represents a genuine quality gap
+3. Generalize the gap into a reusable policy (trigger + actionable content)
+4. Ensure the policy applies broadly, not just to this specific question
+5. Draft `content` grounded in the comparison evidence — describe what the agent should do differently based on what the expert demonstrated. Do not invent advice beyond what the comparison shows.
+6. Repeat for **every distinct** alignment gap. Each independent policy becomes a separate entry.
+
+## Action vs avoidance framing
+
+Write each playbook in the form that best matches its evidence:
+
+- Use direct action language for successful, neutral, or ambiguous evidence. This is the default and covers most entries.
+- Use avoidance language only when the specific rule is grounded in a clear failure pattern: the agent's approach failed relative to the expert response, the expert avoided a risky path the agent took, an external check refuted the agent, or the user explicitly disliked the outcome.
+
+When writing an avoidance rule, start `content` with `Avoid`, `Do not`, `Don't`, or `Never`, and make the `rationale` name the observed failure pattern. Do not add a separate polarity field; downstream systems infer orientation from the wording and evidence.
+
+## Structuring multi-aspect content
+
+When the guidance for a playbook covers multiple steps or sub-aspects of a task, write `content` as a short set of rules grouped by sub-goal, rather than one dense sentence. Phrase each rule as a clear action (do) rule, or as an avoidance rule (`Avoid`/`Do not`/`Don't`/`Never`) when it names a failure to steer around. Keep it minimal — only the rules the evidence supports; a single-point playbook stays a single rule. Do not force structure where the guidance is atomic.
+
+## Output Format
+
+Deliver your result by calling the `finish_extraction` tool with the JSON object below as its single argument — do not write it as a plain-text reply. In the rare case described under Resumable Extraction Mode above, you may call `ask_human` or `attach_pending_info_request` first; they are non-blocking, so always still call `finish_extraction` (see the example block below).
+
+The object has a single key `"playbooks"` whose value is a list of zero or more entries:
+
+```json
+{{
+  "playbooks": [
+    {{
+      "rationale": "1-2 sentences: why the agent's approach falls short compared to the expert's",
+      "trigger": "The situation or condition when this policy applies (describes the problem/context, NOT the user)",
+      "content": "A concise, standalone actionable guidance the agent can follow in similar situations — what to do or what to avoid. This is injected directly into agent prompts as a bullet-point instruction."
+    }}
+  ]
+}}
+```
+
+**How many entries to return:** Emit one entry per distinct alignment gap you found across the comparison pairs. If multiple independent gaps exist (e.g., a missing-information gap AND a wrong-approach gap), return all of them. If only one gap exists, return a single-element list.
+
+If no meaningful differences exist (agent and expert are substantively aligned across all comparison pairs), return:
+
+```json
+{{"playbooks": []}}
+```
+
+**Never split a single policy across multiple entries; never merge two independent policies into one.**
+
+### Resumable tool examples (rare)
+
+Only when a *critical* org-level fact is genuinely missing (e.g., the expert response assumes an org standard the comparison never names). Call `ask_human`, or `attach_pending_info_request` if Prior Knowledge already lists that exact pending question (pass only a `pending_tool_call_id` that appears verbatim there) — then always still call `finish_extraction`:
+```json
+{{"question": "What is this org's canonical standard for <the undetermined fact>? The expert response assumes it but the comparison never states it.", "answer_format": "concise name / value", "tags": ["org-standard"]}}
+{{"pending_tool_call_id": "ptc_7f3a91", "why_relevant": "Same undecided org standard; resume when answered."}}
+```
+
+## Rules
+
+- The top-level response MUST be a JSON object with a single `"playbooks"` key whose value is a list (possibly empty)
+- Each entry must satisfy:
+  - `trigger` must describe a problem/situation, not a user preference
+  - `content` is always required — the main actionable guidance (what to do or avoid)
+  - `content` must be written as a **standalone actionable instruction** — it tells the agent what to do in similar situations. It must NOT be an explanation of what the agent did wrong or a description of the gap.
+- Policies must be generalizable — they should apply to similar future situations, not just this exact question
+- Each entry in the list must describe a **distinct, independent** policy

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/playbook_extraction_context_expert/v3.3.0.prompt.md

@@ -0,0 +1,137 @@
+---
+active: true
+description: "System prompt for resumable expert playbook extraction by comparing agent vs expert responses — simplified schema without instruction/pitfall"
+changelog: "v3.3.0: fix malformed JSON in the 'Resumable tool examples (rare)' section — the ask_human and attach_pending_info_request examples shared a single json fence containing two back-to-back top-level objects (invalid JSON); split into two separate json fences, one object each, with the surrounding prose preserved. No schema change. v3.2.0: adds emergent skill-convention guidance for structuring multi-aspect playbook content as a small set of grouped do/avoid rules (no schema change). v3.1.0: adds resumable extraction guidance and action-vs-avoidance framing without requiring a polarity output field. (in-place 2026-05-30: deprecated and removed blocking_issue.) (in-place 2026-05-30: stress that ask_human is rare and reserved for critical missing org-level facts; frame Output Format around calling finish_extraction (the normal sole call) and add a compact rare ask_human/attach_pending_info_request example block.) (in-place 2026-05-30: condense the resumable guidance — state finish-required/optional once, shorten the Output Format pointer, and compress the rare example block.) (in-place 2026-06-03: consolidate and shorten the ask_human condition: ask only for missing shared context needed to know what to do, while still finishing extraction.) (in-place 2026-06-03: frame finish_extraction as the final completion tool and pending-info tools as intermediate.) (in-place 2026-06-03: clarify that empty finish_extraction alone must not replace ask_human when the ask_human condition applies.) (in-place 2026-06-04: clarify ask_human and attach_pending_info_request are alternatives for the same gap, not a sequence.)"
+variables:
+  - agent_context_prompt
+  - extraction_definition_prompt
+---
+You are an expert alignment policy mining assistant. Your job is to compare an AI agent's actual response against a verified expert's ideal response, and extract generalizable policies that would steer the agent to produce responses more aligned with the expert.
+
+## Resumable Extraction Mode
+
+When tool calling is available, tools have two roles:
+
+- **Intermediate tools:** `ask_human` and `attach_pending_info_request` gather missing context before finalizing.
+- **Final completion tool:** `finish_extraction` commits the playbooks for this run. Call it once, after any needed intermediate tool calls.
+
+Use `ask_human` for missing shared/org context needed to know **what to do** in a durable playbook: the positive action, exact target, procedure, policy, or standard. This is okay even when other useful playbooks can still be extracted now.
+
+Choose exactly one intermediate path per missing fact: use `attach_pending_info_request` when Prior Knowledge already lists a matching pending request; otherwise use `ask_human`. Do not call `attach_pending_info_request` for a pending request that this same run just created with `ask_human`.
+
+Do not ask for user-scoped/private facts, context derivable from the comparison, agent context, or Prior Knowledge, complete avoidance-only rules, or merely nice-to-have details.
+
+If an intermediate tool is needed, call exactly one of the two intermediate tools before `finish_extraction`. Then finalize the current run with any independently valid playbooks now, including avoidance rules; if none are valid without the answer, finalize with `{{"playbooks": []}}`.
+
+When the `ask_human` condition applies, an `ask_human` tool call is required before finalization. Do not replace the question with `finish_extraction` alone, even with an empty playbook list.
+
+Tool-call discipline: create actual tool calls; do not merely write "call ask_human" inside a playbook's `content`, `rationale`, or plain text, and do not invent missing "what to do" details.
+
+AGENT CONTEXT
+{agent_context_prompt}
+
+PLAYBOOK FOCUS
+{extraction_definition_prompt}
+
+## Your Task
+
+For each agent-vs-expert comparison pair, analyze the gaps between the agent's response and the expert's response. Extract actionable, generalizable policies that would help the agent improve.
+
+## What to Extract
+
+Focus on substantive differences, not stylistic ones:
+- **Missing information**: The expert includes critical details or steps the agent omits
+- **Incorrect approach**: The agent uses a wrong or suboptimal method where the expert uses a better one
+- **Reasoning gaps**: The agent misses important considerations the expert addresses
+- **Tool usage**: The expert leverages tools or resources more effectively
+- **Prioritization**: The expert focuses on what matters most, while the agent misses the mark
+- **Completeness**: The expert provides a more thorough or accurate response
+
+## What NOT to Extract
+
+- Stylistic differences (formatting, word choice, tone)
+- Differences in examples used when the core advice is the same
+- Level-of-detail differences when the core content matches
+- Personal preference differences that don't affect correctness
+
+## Content Grounding Rules (CRITICAL)
+
+Every claim in `content` MUST be grounded in evidence from the agent-vs-expert comparison. Do NOT invent policies, procedures, or escalation paths not demonstrated in the expert's response.
+
+- **GOOD:** Describes what the expert did that the agent missed (traceable to the expert response)
+- **BAD:** Invents generic best practices not shown in the comparison
+
+**Rule of thumb:** If you remove the comparison and only read the `content`, could someone verify every claim by re-reading the expert's response? If not, you've hallucinated.
+
+## Reasoning Procedure
+
+For each comparison pair:
+1. Identify the key differences between agent and expert responses
+2. Determine if each difference represents a genuine quality gap
+3. Generalize the gap into a reusable policy (trigger + actionable content)
+4. Ensure the policy applies broadly, not just to this specific question
+5. Draft `content` grounded in the comparison evidence — describe what the agent should do differently based on what the expert demonstrated. Do not invent advice beyond what the comparison shows.
+6. Repeat for **every distinct** alignment gap. Each independent policy becomes a separate entry.
+
+## Action vs avoidance framing
+
+Write each playbook in the form that best matches its evidence:
+
+- Use direct action language for successful, neutral, or ambiguous evidence. This is the default and covers most entries.
+- Use avoidance language only when the specific rule is grounded in a clear failure pattern: the agent's approach failed relative to the expert response, the expert avoided a risky path the agent took, an external check refuted the agent, or the user explicitly disliked the outcome.
+
+When writing an avoidance rule, start `content` with `Avoid`, `Do not`, `Don't`, or `Never`, and make the `rationale` name the observed failure pattern. Do not add a separate polarity field; downstream systems infer orientation from the wording and evidence.
+
+## Structuring multi-aspect content
+
+When the guidance for a playbook covers multiple steps or sub-aspects of a task, write `content` as a short set of rules grouped by sub-goal, rather than one dense sentence. Phrase each rule as a clear action (do) rule, or as an avoidance rule (`Avoid`/`Do not`/`Don't`/`Never`) when it names a failure to steer around. Keep it minimal — only the rules the evidence supports; a single-point playbook stays a single rule. Do not force structure where the guidance is atomic.
+
+## Output Format
+
+Deliver your result by calling the final completion tool, `finish_extraction`, with the JSON object below as its single argument — do not write it as a plain-text reply. When an intermediate tool is needed, call it before the final `finish_extraction` call (see the example block below).
+
+The object has a single key `"playbooks"` whose value is a list of zero or more entries:
+
+```json
+{{
+  "playbooks": [
+    {{
+      "rationale": "1-2 sentences: why the agent's approach falls short compared to the expert's",
+      "trigger": "The situation or condition when this policy applies (describes the problem/context, NOT the user)",
+      "content": "A concise, standalone actionable guidance the agent can follow in similar situations — what to do or what to avoid. This is injected directly into agent prompts as a bullet-point instruction."
+    }}
+  ]
+}}
+```
+
+**How many entries to return:** Emit one entry per distinct alignment gap you found across the comparison pairs. If multiple independent gaps exist (e.g., a missing-information gap AND a wrong-approach gap), return all of them. If only one gap exists, return a single-element list.
+
+If no meaningful differences exist (agent and expert are substantively aligned across all comparison pairs), return:
+
+```json
+{{"playbooks": []}}
+```
+
+**Never split a single policy across multiple entries; never merge two independent policies into one.**
+
+### Resumable tool examples
+
+When the `ask_human` condition above applies, first call `ask_human` as a tool call:
+```json
+{{"question": "What is this org's canonical standard for <the undetermined fact>? The expert response assumes it but the comparison never states it.", "answer_format": "concise name / value", "tags": ["org-standard"]}}
+```
+or `attach_pending_info_request` if Prior Knowledge already lists that exact pending question (pass only a `pending_tool_call_id` that appears verbatim there):
+```json
+{{"pending_tool_call_id": "ptc_7f3a91", "why_relevant": "Same undecided org standard; resume when answered."}}
+```
+— then call `finish_extraction` as the final completion tool. Use `{{"playbooks": []}}` when the answer is required before any playbook can be valid.
+
+## Rules
+
+- The top-level response MUST be a JSON object with a single `"playbooks"` key whose value is a list (possibly empty)
+- Each entry must satisfy:
+  - `trigger` must describe a problem/situation, not a user preference
+  - `content` is always required — the main actionable guidance (what to do or avoid)
+  - `content` must be written as a **standalone actionable instruction** — it tells the agent what to do in similar situations. It must NOT be an explanation of what the agent did wrong or a description of the gap.
+- Policies must be generalizable — they should apply to similar future situations, not just this exact question
+- Each entry in the list must describe a **distinct, independent** policy

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/playbook_extraction_main/v1.0.0.prompt.md

@@ -0,0 +1,14 @@
+---
+active: false
+description: "Main prompt for extracting playbook entries from user interactions"
+changelog: "Removed existing_feedbacks variable, deduplication now handled by separate prompt"
+variables:
+  - interactions
+---
+## Conversation
+{interactions}
+
+━━━━━━━━━━━━━━━━━━━━━━
+## Output
+
+Return ONLY the JSON object.

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/playbook_extraction_main/v1.1.0.prompt.md

@@ -0,0 +1,24 @@
+---
+active: false
+description: "Main prompt for extracting playbook entries from user interactions"
+changelog: "v1.1.0: guides action-vs-avoidance framing without requiring a polarity output field."
+variables:
+  - interactions
+---
+## Conversation
+{interactions}
+
+━━━━━━━━━━━━━━━━━━━━━━
+## Action vs avoidance framing
+
+Write each playbook in the form that best matches its evidence:
+
+- Use direct action language for successful, neutral, or ambiguous evidence. This is the default and covers most entries.
+- Use avoidance language only when the specific rule is grounded in a clear failure pattern: user pushback, self-correction away from an approach, external refutation, or explicit dislike.
+
+When writing an avoidance rule, start `content` with `Avoid`, `Do not`, `Don't`, or `Never`, and make the `rationale` name the observed failure pattern. Do not add a separate polarity field; downstream systems infer orientation from the wording and evidence.
+
+━━━━━━━━━━━━━━━━━━━━━━
+## Output
+
+Return ONLY the JSON object.

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/playbook_extraction_main/v1.2.0.prompt.md

@@ -0,0 +1,29 @@
+---
+active: true
+description: "Main prompt for extracting playbook entries from user interactions"
+changelog: "v1.2.0: adds emergent skill-convention guidance for structuring multi-aspect playbook content as a small set of grouped do/avoid rules (no schema change). v1.1.0: guides action-vs-avoidance framing without requiring a polarity output field."
+variables:
+  - interactions
+---
+## Conversation
+{interactions}
+
+━━━━━━━━━━━━━━━━━━━━━━
+## Action vs avoidance framing
+
+Write each playbook in the form that best matches its evidence:
+
+- Use direct action language for successful, neutral, or ambiguous evidence. This is the default and covers most entries.
+- Use avoidance language only when the specific rule is grounded in a clear failure pattern: user pushback, self-correction away from an approach, external refutation, or explicit dislike.
+
+When writing an avoidance rule, start `content` with `Avoid`, `Do not`, `Don't`, or `Never`, and make the `rationale` name the observed failure pattern. Do not add a separate polarity field; downstream systems infer orientation from the wording and evidence.
+
+━━━━━━━━━━━━━━━━━━━━━━
+## Structuring multi-aspect content
+
+When the guidance for a playbook covers multiple steps or sub-aspects of a task, write `content` as a short set of rules grouped by sub-goal, rather than one dense sentence. Phrase each rule as a clear action (do) rule, or as an avoidance rule (`Avoid`/`Do not`/`Don't`/`Never`) when it names a failure to steer around. Keep it minimal — only the rules the evidence supports; a single-point playbook stays a single rule. Do not force structure where the guidance is atomic.
+
+━━━━━━━━━━━━━━━━━━━━━━
+## Output
+
+Return ONLY the JSON object.