### Install via Codex

Source: https://github.com/gg-mo/areyousure/blob/main/README.md

Follow the provided URL for installation instructions.

```text
Follow the installation instructions here: https://github.com/gg-mo/AreYouSure/blob/main/.codex/INSTALL.md
```

--------------------------------

### Running Examples and Tests

Source: https://github.com/gg-mo/areyousure/blob/main/are_you_sure/README.md

Commands to execute the example scripts and run unit tests for the package. Ensure Python 3 is available.

```bash
python3 examples.py
```

```bash
python3 -m unittest discover -s tests -p 'test_*.py'
```

--------------------------------

### Install Are You Sure via Gemini CLI

Source: https://github.com/gg-mo/areyousure/blob/main/INSTALL.md

Installs the extension from the GitHub repository using the Gemini CLI.

```bash
gemini extensions install https://github.com/gg-mo/AreYouSure
```

--------------------------------

### Install via Claude Code

Source: https://github.com/gg-mo/areyousure/blob/main/README.md

Options for installing the plugin via marketplace, local development, or CLAUDE.md configuration.

```bash
/plugin marketplace add gg-mo/AreYouSure
/plugin install are-you-sure@are-you-sure
```

```bash
git clone https://github.com/gg-mo/AreYouSure.git ~/.claude/are-you-sure
/plugin marketplace add ~/.claude/are-you-sure/.claude-plugin/marketplace.json
/plugin install are-you-sure@are-you-sure
```

```bash
curl -o CLAUDE.md https://raw.githubusercontent.com/gg-mo/AreYouSure/main/CLAUDE.md
```

```bash
echo "" >> CLAUDE.md
curl https://raw.githubusercontent.com/gg-mo/AreYouSure/main/CLAUDE.md >> CLAUDE.md
```

--------------------------------

### Install via Cursor

Source: https://github.com/gg-mo/areyousure/blob/main/README.md

Commands for adding the plugin via marketplace or local file path in Cursor Agent chat.

```text
/add-plugin are-you-sure
```

```bash
git clone https://github.com/gg-mo/AreYouSure.git ~/.cursor/are-you-sure
```

```text
/add-plugin
```

```text
~/.cursor/are-you-sure/.cursor-plugin/plugin.json
```

--------------------------------

### Install Are You Sure for Gemini CLI

Source: https://context7.com/gg-mo/areyousure/llms.txt

Command to install the Are You Sure extension for the Gemini CLI.

```bash
# Gemini CLI
gemini extensions install https://github.com/gg-mo/AreYouSure
```

--------------------------------

### CLI Example Output

Source: https://context7.com/gg-mo/areyousure/llms.txt

Illustrative output from the CLI when processing a critique request. It includes the critique status, a summary, alignment details, concerns, assumptions, and recommended next steps.

```json
# Example output:
# {
#   "status": "prompt_human",
#   "summary": "Prompt the human/engineer before continuing...",
#   "goal_alignment": "Partial match; some intent elements need tighter coverage.",
#   "concerns": ["Risk is marked high...", "The action is marked irreversible..."],
#   "assumptions": ["The rationale includes uncertainty language..."],
#   "better_options": ["Add an explicit rollback or safety plan..."],
#   "challenge_prompt": "Are we choosing this direction because it is truly the best fit...",
#   "recommended_next_step": "Pause execution and ask the human/engineer...",
#   "prompt_to_human": "Before I continue, which exact outcome do you want...",
#   "confidence": 0.52,
#   "decision_factors": ["high_risk", "ambiguity", "alignment_score:0.421"]
# }
```

--------------------------------

### Install Are You Sure Plugin for Claude

Source: https://context7.com/gg-mo/areyousure/llms.txt

Commands for installing the Are You Sure plugin for Claude, both via the marketplace for recommended use and for local development by cloning the repository.

```bash
# Claude Code - Plugin (recommended)
/plugin marketplace add gg-mo/AreYouSure
/plugin install are-you-sure@are-you-sure

# Claude Code - Local development
git clone https://github.com/gg-mo/AreYouSure.git ~/.claude/are-you-sure
/plugin marketplace add ~/.claude/are-you-sure/.claude-plugin/marketplace.json
/plugin install are-you-sure@are-you-sure
```

--------------------------------

### Install Are You Sure Plugin for Cursor

Source: https://context7.com/gg-mo/areyousure/llms.txt

Steps to install the Are You Sure plugin for Cursor, involving cloning the repository and adding the plugin via the agent chat interface.

```bash
# Cursor - Local plugin install
git clone https://github.com/gg-mo/AreYouSure.git ~/.cursor/are-you-sure
# Then in Cursor Agent chat:
# /add-plugin
# Select: ~/.cursor/are-you-sure/.cursor-plugin/plugin.json
```

--------------------------------

### CLI Auto-fill Mode with Plain Text

Source: https://context7.com/gg-mo/areyousure/llms.txt

Run the CLI in auto-fill mode using standard input (stdin) with plain text. This is a simple way to get a critique payload generated from a single line of text.

```bash
# Auto-fill mode with plain text (default)
echo "We are about to merge a risky migration plan." | python3 scripts/are_you_sure_cli.py
```

--------------------------------

### Initialize and Run RuleBasedCritiqueEngine

Source: https://context7.com/gg-mo/areyousure/llms.txt

Demonstrates configuring the engine, creating a critique input payload, and processing the result to obtain structured feedback.

```python
from are_you_sure import (
    CritiqueInput,
    CritiqueOutput,
    RuleBasedCritiqueEngine,
    EngineConfig,
    ProposalType,
    RiskLevel,
    Stage,
    CritiqueMode,
)

# Initialize the critique engine with optional configuration
config = EngineConfig(
    mode=CritiqueMode.STRICT,  # 'strict' or 'fast'
    semantic_backend="heuristic",  # 'heuristic' or 'semantic_keyword'
    confidence_slope=1.0,
    confidence_intercept=0.0,
)
engine = RuleBasedCritiqueEngine(config=config)

# Create a critique input payload
critique_input = CritiqueInput(
    original_intent="Migrate user billing safely without downtime.",
    current_context="Migration scripts are drafted and dry-run completed.",
    proposal_type=ProposalType.ACTION,
    proposal="Run migration in one batch during business hours.",
    rationale="This likely finishes faster and should be fine based on staging.",
    constraints=[
        "No production downtime",
        "Rollback plan required",
    ],
    risk_level=RiskLevel.HIGH,
    stage=Stage.PRE_EXECUTION,
    should_challenge=True,
)

# Run the critique
result: CritiqueOutput = engine.critique(critique_input)

# Access structured output
print(f"Status: {result.status}")  # 'proceed', 'revise', or 'prompt_human'
print(f"Summary: {result.summary}")
print(f"Goal Alignment: {result.goal_alignment}")
print(f"Concerns: {result.concerns}")
print(f"Assumptions: {result.assumptions}")
print(f"Better Options: {result.better_options}")
print(f"Challenge Prompt: {result.challenge_prompt}")
print(f"Recommended Next Step: {result.recommended_next_step}")
print(f"Prompt to Human: {result.prompt_to_human}")
print(f"Confidence: {result.confidence}")
print(f"Decision Factors: {result.decision_factors}")

# Convert to dictionary for JSON serialization
output_dict = result.to_dict()
```

--------------------------------

### Quick Use of RuleBasedCritiqueEngine

Source: https://github.com/gg-mo/areyousure/blob/main/are_you_sure/README.md

Demonstrates how to initialize and use the RuleBasedCritiqueEngine with a CritiqueInput object. Ensure all necessary imports are present before execution.

```python
from are_you_sure import CritiqueInput, ProposalType, RiskLevel, RuleBasedCritiqueEngine, Stage

engine = RuleBasedCritiqueEngine()
request = CritiqueInput(
    original_intent="Help the user build a safe release process.",
    current_context="Team converged quickly on skipping rollback tests.",
    proposal_type=ProposalType.DECISION,
    proposal="Ship without rollback rehearsal.",
    rationale="This is faster and likely okay.",
    constraints=["Minimize release risk"],
    risk_level=RiskLevel.HIGH,
    stage=Stage.CONVERGENCE,
    should_challenge=True,
)

result = engine.critique(request)
print(result.to_dict())
```

--------------------------------

### Execute CLI with Input File

Source: https://github.com/gg-mo/areyousure/blob/main/skills/are-you-sure/SKILL.md

Use the command-line interface to run the critique engine with a JSON input file. Ensure the script path and input file path are correct.

```bash
python3 scripts/are_you_sure_cli.py --input path/to/input.json
```

--------------------------------

### Manual Invocation and Skip Command

Source: https://context7.com/gg-mo/areyousure/llms.txt

Demonstrates how to manually invoke the Are You Sure tool using the command line and how to skip critique with a reason.

```bash
# Manual invocation in any agent
are-you-sure

# Skip critique (one-shot bypass)
[ays:skip reason for skipping]
#ays-skip
```

--------------------------------

### Calibrate confidence and benchmark

Source: https://github.com/gg-mo/areyousure/blob/main/README.md

Run confidence calibration followed by benchmark tests.

```bash
./scripts/calibrate_confidence.py
./scripts/run_benchmark.py
```

--------------------------------

### Execute CLI with Piped Input

Source: https://github.com/gg-mo/areyousure/blob/main/skills/are-you-sure/SKILL.md

Run the critique engine using standard input for auto-fill mode. This is useful for quick checks where manual schema field entry is not required.

```bash
echo "We are about to merge a risky migration plan." | python3 scripts/are_you_sure_cli.py
```

--------------------------------

### Build LLM Prompts with Are You Sure SDK

Source: https://context7.com/gg-mo/areyousure/llms.txt

Utilize the Are You Sure SDK to construct system and user prompts for LLM-backed critique implementations. This includes accessing the SYSTEM_PROMPT and building user prompts from CritiqueInput objects.

```python
from are_you_sure import (
    SYSTEM_PROMPT,
    build_user_prompt,
    CritiqueInput,
    ProposalType,
    Stage,
)

# Get the system prompt for LLM-backed critique
print(SYSTEM_PROMPT)
# Output: "You are the critique engine for a standalone agent skill called **Are You Sure**..."

# Build user prompt from input payload
critique_input = CritiqueInput(
    original_intent="Implement secure user authentication.",
    current_context="Discussed OAuth vs JWT, leaning toward JWT.",
    proposal_type=ProposalType.DECISION,
    proposal="Use JWT with 24-hour expiration and refresh tokens.",
    rationale="JWT is stateless and easier to scale.",
    stage=Stage.CONVERGENCE,
)

user_prompt = build_user_prompt(critique_input)
print(user_prompt)
# Output: "Critique this proposal using the required JSON schema. Return JSON only.
#
# Input:
# {
#   "original_intent": "Implement secure user authentication.",
#   ...
# }"

# Use with any LLM API
# response = llm.chat(
#     messages=[
#         {"role": "system", "content": SYSTEM_PROMPT},
#         {"role": "user", "content": user_prompt},
#     ]
# )
# result = json.loads(response.content)
```

--------------------------------

### Import and Use Critique Engine

Source: https://github.com/gg-mo/areyousure/blob/main/skills/are-you-sure/SKILL.md

Import the necessary components from the 'are_you_sure' package to use the critique engine programmatically. This allows for direct integration into Python applications.

```python
from are_you_sure import CritiqueInput, RuleBasedCritiqueEngine
```

--------------------------------

### Run the critique engine via CLI

Source: https://github.com/gg-mo/areyousure/blob/main/README.md

Execute the critique engine using a JSON payload or piped input.

```bash
python3 scripts/are_you_sure_cli.py --input payload.json
```

```bash
cat payload.json | python3 scripts/are_you_sure_cli.py
```

```bash
echo "We are about to deploy a risky migration; are we sure?" | python3 scripts/are_you_sure_cli.py
```

```bash
python3 scripts/are_you_sure_cli.py --input payload.json --input-mode manual
```

--------------------------------

### Auto-fill Helper for CritiqueInput

Source: https://github.com/gg-mo/areyousure/blob/main/are_you_sure/README.md

Shows how to use the build_payload_from_partial helper function to construct a CritiqueInput object from a partial dictionary. This is useful for pre-populating requests.

```python
from are_you_sure import RuleBasedCritiqueEngine, CritiqueInput, build_payload_from_partial

partial = {"request": "We are about to merge this production migration quickly."}
payload = build_payload_from_partial(partial)
result = RuleBasedCritiqueEngine().critique(CritiqueInput.from_dict(payload))
print(result.to_dict())
```

--------------------------------

### Add Are You Sure to Claude Project

Source: https://context7.com/gg-mo/areyousure/llms.txt

Instructions for adding Are You Sure to a project's CLAUDE.md file using a curl command to download the configuration.

```bash
# Claude Code - Per-project CLAUDE.md
curl -o CLAUDE.md https://raw.githubusercontent.com/gg-mo/AreYouSure/main/CLAUDE.md
```

--------------------------------

### Run project benchmarks

Source: https://github.com/gg-mo/areyousure/blob/main/INSTALL.md

Executes the benchmark suite for the project.

```python
./scripts/run_benchmark.py
```

--------------------------------

### Critique and Auto-Critique with Python SDK

Source: https://github.com/gg-mo/areyousure/blob/main/sdk/README.md

Use these functions to send payloads for critique or auto-critique. Ensure the `are_you_sure_sdk` is imported.

```python
from sdk.python.are_you_sure_sdk import critique, critique_auto
result = critique(payload)
result_auto = critique_auto({"request": "We are about to deploy this now."})
```

--------------------------------

### Regenerate platform manifests

Source: https://github.com/gg-mo/areyousure/blob/main/INSTALL.md

Uses the canonical configuration to regenerate platform-specific adapters.

```python
./scripts/generate_platform_manifests.py
```

--------------------------------

### Custom Alignment Scoring Backends

Source: https://context7.com/gg-mo/areyousure/llms.txt

Initializes different alignment scoring backends to measure proposal intent matching.

```python
from are_you_sure import (
    CritiqueInput,
    RuleBasedCritiqueEngine,
    EngineConfig,
    HeuristicAlignmentScorer,
    SemanticKeywordAlignmentScorer,
    ProposalType,
    Stage,
)

# Default heuristic scorer (lexical overlap + phrase coverage)
heuristic_scorer = HeuristicAlignmentScorer()

# Semantic keyword scorer (uses synonym expansion)
semantic_scorer = SemanticKeywordAlignmentScorer()
```

--------------------------------

### CLI Override Critique Mode and Explainability

Source: https://context7.com/gg-mo/areyousure/llms.txt

Customize the CLI's critique process by overriding the default mode to 'fast' and setting explainability to 'compact'. This can speed up critiques and reduce output verbosity.

```bash
# Override critique mode and explainability
python3 scripts/are_you_sure_cli.py --input payload.json --mode fast --explainability compact
```

--------------------------------

### Python SDK Critique with Full Payload

Source: https://context7.com/gg-mo/areyousure/llms.txt

Perform a critique using the Python SDK's `critique` function with a complete payload. This function requires all necessary fields to be present in the input dictionary.

```python
from sdk.python.are_you_sure_sdk import critique, critique_auto

# Full payload critique (requires all required fields)
payload = {
    "original_intent": "Ship a robust notification system.",
    "current_context": "Team converged on login-time checks only.",
    "proposal_type": "decision",
    "proposal": "Finalize login-time checks only.",
    "rationale": "It is simpler and avoids background workers.",
    "constraints": ["Must support inactive agents"],
    "risk_level": "medium",
    "stage": "convergence",
}

result = critique(payload)
print(result["status"])  # 'proceed', 'revise', or 'prompt_human'
print(result["summary"])
```

--------------------------------

### Run cross-platform smoke checks

Source: https://github.com/gg-mo/areyousure/blob/main/INSTALL.md

Executes the smoke test suite to verify packaging across platforms.

```bash
./scripts/smoke/all.sh
```

--------------------------------

### CLI Auto-fill Mode with JSON File

Source: https://context7.com/gg-mo/areyousure/llms.txt

Execute the CLI in auto-fill mode by providing a JSON payload file as input. This allows for more complex initial inputs to be processed.

```bash
# Auto-fill mode with JSON file
python3 scripts/are_you_sure_cli.py --input payload.json
```

--------------------------------

### Create CritiqueInput from Dictionary

Source: https://context7.com/gg-mo/areyousure/llms.txt

Instantiate `CritiqueInput` from a Python dictionary, useful for JSON payloads. This demonstrates creating an input object from a predefined dictionary structure.

```python
payload = {
    "original_intent": "Help design a lightweight notification system.",
    "current_context": "Human and agent explored passive and active approaches.",
    "proposal_type": "idea",
    "proposal": "Start with activity-triggered notifications.",
    "rationale": "Fast way to validate demand before investing in a broader system.",
    "risk_level": "low",
    "stage": "brainstorming",
}
critique_input = CritiqueInput.from_dict(payload)
```

--------------------------------

### Running Golden Behavior Checks

Source: https://github.com/gg-mo/areyousure/blob/main/are_you_sure/README.md

Command to include fixture-backed golden behavior checks in the test suite. This requires the tests to be set up correctly.

```bash
python3 -m unittest discover -s tests -p 'test_*.py'
```

--------------------------------

### Auto-fill Critique Payload in Python

Source: https://context7.com/gg-mo/areyousure/llms.txt

Builds a critique payload from partial input and uses a semantic keyword scorer for improved matching.

```python
partial = {
    "request": "Deploy the new payment gateway to production now.",
}

result = critique_auto(partial)
print(result["status"])  # likely 'prompt_human' for high-risk production deploy
print(result["concerns"])

# Use semantic keyword scorer for better synonym matching
result = critique(payload, semantic_backend="semantic_keyword")
```

--------------------------------

### Calibrate confidence

Source: https://github.com/gg-mo/areyousure/blob/main/INSTALL.md

Runs the confidence calibration script.

```python
./scripts/calibrate_confidence.py
```

--------------------------------

### Define CritiqueInput Schema

Source: https://context7.com/gg-mo/areyousure/llms.txt

Shows the construction of a CritiqueInput object including all optional parameters for detailed risk and context assessment.

```python
from are_you_sure import (
    CritiqueInput,
    ProposalType,
    RiskLevel,
    Stage,
    CritiqueMode,
    ExplainabilityMode,
    Reversibility,
    CostLevel,
    BlastRadius,
)

# Full input with all optional parameters
critique_input = CritiqueInput(
    # Required fields
    original_intent="Ship a robust notification system that works when agents are inactive.",
    current_context="After back-and-forth, team converged on login-time checks only.",
    proposal_type=ProposalType.DECISION,  # idea, decision, design, plan, action, tool_call, response
    proposal="Finalize login-time checks only and skip passive delivery.",
    rationale="It is simpler and avoids background workers.",

    # Optional fields with defaults
    constraints=["Must support inactive agents", "Avoid missing urgent messages"],
    risk_level=RiskLevel.MEDIUM,  # low, medium, high
    stage=Stage.CONVERGENCE,  # brainstorming, convergence, pre_execution, post_feedback
    should_challenge=True,
    mode=CritiqueMode.STRICT,  # strict, fast
    explainability=ExplainabilityMode.STANDARD,  # compact, standard, detailed
    reversibility=Reversibility.PARTIALLY_REVERSIBLE,  # reversible, partially_reversible, irreversible, unknown
    estimated_cost=CostLevel.MEDIUM,  # low, medium, high, unknown
    blast_radius=BlastRadius.TEAM,  # local, team, org, public, unknown
)
```

--------------------------------

### Auto-fill Payload from Minimal Input

Source: https://context7.com/gg-mo/areyousure/llms.txt

Use `build_payload_from_partial` to automatically generate a complete critique payload from minimal input, such as just a request string. The function infers missing fields like `original_intent`, `current_context`, and `risk_level`.

```python
from are_you_sure import build_payload_from_partial, CritiqueInput, RuleBasedCritiqueEngine

# Minimal input - just a request string
partial_payload = {
    "request": "We are about to deploy a risky database migration to production."
}

# Auto-fill infers all required fields
complete_payload = build_payload_from_partial(partial_payload)
# Result includes inferred: original_intent, current_context, proposal_type,
# proposal, rationale, constraints, risk_level, stage, reversibility, etc.
```

--------------------------------

### Score Critiques with RuleBasedCritiqueEngine

Source: https://context7.com/gg-mo/areyousure/llms.txt

Use RuleBasedCritiqueEngine to score critique inputs using heuristic and semantic scorers. Lower heuristic scores indicate missed synonyms, while higher semantic scores capture them.

```python
from are_you_sure import CritiqueInput, ProposalType, RuleBasedCritiqueEngine, EngineConfig

test_input = CritiqueInput(
    original_intent="Notify users about critical system alerts.",
    current_context="Discussing notification delivery mechanisms.",
    proposal_type=ProposalType.DESIGN,
    proposal="Send ping notifications when alerts trigger.",  # "ping" is synonym of "notify"
    rationale="Users need timely awareness of system status.",
)

heuristic_score = heuristic_scorer.score(test_input)
semantic_score = semantic_scorer.score(test_input)
print(f"Heuristic alignment: {heuristic_score:.3f}")  # Lower (misses synonym)
print(f"Semantic alignment: {semantic_score:.3f}")   # Higher (catches "ping" = "notify")

# Use custom scorer with engine
engine = RuleBasedCritiqueEngine(
    config=EngineConfig(semantic_backend="semantic_keyword"),
    scorer=semantic_scorer,
)
result = engine.critique(test_input)
```

--------------------------------

### FallbackCritiqueEngine Escalation

Source: https://context7.com/gg-mo/areyousure/llms.txt

Configures a wrapper engine to escalate to a secondary engine when the primary engine returns low-confidence results for high-risk inputs.

```python
from are_you_sure import (
    CritiqueInput,
    RuleBasedCritiqueEngine,
    FallbackCritiqueEngine,
    EngineConfig,
    ProposalType,
    RiskLevel,
    Stage,
)

# Primary rule-based engine
primary_engine = RuleBasedCritiqueEngine()

# Optional fallback engine (could be LLM-backed)
# For this example, using another rule-based engine with different config
fallback_engine = RuleBasedCritiqueEngine(
    config=EngineConfig(semantic_backend="semantic_keyword")
)

# Combine with fallback behavior
engine = FallbackCritiqueEngine(
    primary=primary_engine,
    fallback=fallback_engine,
)

# Escalation triggers when:
# - primary returns 'revise' status
# - stage is 'convergence' or 'pre_execution'
# - risk_level is 'medium' or 'high'
# - confidence < 0.72

high_risk_input = CritiqueInput(
    original_intent="Deploy zero-downtime database migration.",
    current_context="Scripts ready, staging passed, team eager to ship.",
    proposal_type=ProposalType.ACTION,
    proposal="Run migration during peak hours to finish before EOD.",
    rationale="Staging looked fine, probably will be okay in production too.",
    constraints=["Zero downtime required", "Customer data integrity"],
    risk_level=RiskLevel.HIGH,
    stage=Stage.PRE_EXECUTION,
    should_challenge=True,
)

result = engine.critique(high_risk_input)
# If primary returns low-confidence 'revise', fallback engine runs
print(f"Status: {result.status}")
print(f"Confidence: {result.confidence}")
```

--------------------------------

### RuleBasedCritiqueEngine - Critique Execution

Source: https://context7.com/gg-mo/areyousure/llms.txt

The core engine endpoint for evaluating a proposal against the original intent using rule-based heuristics.

```APIDOC
## POST /critique

### Description
Evaluates a proposal against the original intent and context to determine if an agent should proceed, revise, or prompt a human.

### Method
POST

### Endpoint
/critique

### Request Body
- **original_intent** (string) - Required - The goal or intent behind the action.
- **current_context** (string) - Required - The current state or environment context.
- **proposal_type** (string) - Required - Type of proposal (idea, decision, design, plan, action, tool_call, response).
- **proposal** (string) - Required - The specific action or decision being proposed.
- **rationale** (string) - Required - The reasoning behind the proposal.
- **constraints** (list) - Optional - List of constraints to adhere to.
- **risk_level** (string) - Optional - Risk level (low, medium, high).
- **stage** (string) - Optional - Current stage (brainstorming, convergence, pre_execution, post_feedback).
- **should_challenge** (boolean) - Optional - Whether to trigger the challenge logic.

### Response
#### Success Response (200)
- **status** (string) - The decision outcome: 'proceed', 'revise', or 'prompt_human'.
- **summary** (string) - Summary of the critique.
- **goal_alignment** (string) - Analysis of how well the proposal aligns with the intent.
- **concerns** (list) - Identified concerns.
- **assumptions** (list) - Identified weak assumptions.
- **better_options** (list) - Suggested alternatives.
- **challenge_prompt** (string) - Prompt used for the challenge.
- **recommended_next_step** (string) - The recommended action.
- **prompt_to_human** (string) - Specific prompt for human intervention if required.
- **confidence** (float) - Confidence score of the critique.
- **decision_factors** (dict) - Factors influencing the decision.
```

--------------------------------

### Auto-fill Payload with Conversation History

Source: https://context7.com/gg-mo/areyousure/llms.txt

Enhance payload auto-filling by providing conversation history to `build_payload_from_partial`. This allows for more accurate inference of intent and context, including detecting higher risk levels based on keywords like 'billing' and 'migrate'.

```python
# With conversation history for better context
partial_with_history = {
    "request": "are-you-sure",
    "history": [
        {"role": "user", "content": "I need to migrate the billing database safely.",},
        {"role": "assistant", "content": "I can help with that. Let me draft migration scripts.",},
        {"role": "user", "content": "Great, let's run it during business hours to finish faster.",},
    ]
}

complete_payload = build_payload_from_partial(partial_with_history)
# Infers original_intent from first user message
# Infers proposal from latest context
# Detects risk_level=high from "billing" and "migrate"

# Create CritiqueInput and run critique
critique_input = CritiqueInput.from_dict(complete_payload)
engine = RuleBasedCritiqueEngine()
result = engine.critique(critique_input)
print(result.status)  # likely 'prompt_human' due to high-risk migration
```

--------------------------------

### CLI Use Semantic Keyword Alignment Scorer

Source: https://context7.com/gg-mo/areyousure/llms.txt

Configure the CLI to use a specific semantic backend, such as 'semantic_keyword', for scoring alignment. This allows for different methods of evaluating the relationship between input and intent.

```bash
# Use semantic keyword alignment scorer
python3 scripts/are_you_sure_cli.py --input payload.json --semantic-backend semantic_keyword
```

--------------------------------

### Convert CritiqueInput to Dictionary

Source: https://context7.com/gg-mo/areyousure/llms.txt

Convert a `CritiqueInput` object back into a dictionary format. This is useful for serializing the critique input for storage or transmission.

```python
output = critique_input.to_dict()
```

--------------------------------

### CritiqueInput - Input Schema

Source: https://context7.com/gg-mo/areyousure/llms.txt

Detailed schema for the input payload required by the critique engine.

```APIDOC
### Request Body Parameters
- **original_intent** (string) - Required - The original goal.
- **current_context** (string) - Required - Current state context.
- **proposal_type** (string) - Required - Type of proposal.
- **proposal** (string) - Required - The proposal content.
- **rationale** (string) - Required - Reasoning for the proposal.
- **constraints** (list) - Optional - List of constraints.
- **risk_level** (string) - Optional - low, medium, high.
- **stage** (string) - Optional - brainstorming, convergence, pre_execution, post_feedback.
- **should_challenge** (boolean) - Optional - Enable challenge logic.
- **mode** (string) - Optional - strict, fast.
- **explainability** (string) - Optional - compact, standard, detailed.
- **reversibility** (string) - Optional - reversible, partially_reversible, irreversible, unknown.
- **estimated_cost** (string) - Optional - low, medium, high, unknown.
- **blast_radius** (string) - Optional - local, team, org, public, unknown.
```

--------------------------------

### CLI Pipe JSON Payload via Stdin

Source: https://context7.com/gg-mo/areyousure/llms.txt

Send a JSON payload directly to the CLI via standard input (stdin) using a heredoc. This is an alternative to using `--input` for providing JSON data.

```bash
# Pipe JSON payload
cat <<EOF | python3 scripts/are_you_sure_cli.py
{
  "original_intent": "Publish a legally accurate public statement.",
  "current_context": "Legal sign-off status is unclear.",
  "proposal_type": "response",
  "proposal": "Publish now with minor edits and refine later.",
  "rationale": "Timing is important and legal concerns are probably minimal."
}
EOF
```

--------------------------------

### Are You Sure API v1

Source: https://github.com/gg-mo/areyousure/blob/main/docs/api/v1.md

This snippet details the input and output contract for the Are You Sure API v1.

```APIDOC
## Are You Sure API v1

### Description
This API endpoint is designed to assess a proposed action or change by evaluating its alignment with original intentions, current context, and potential risks.

### Method
POST

### Endpoint
/gg-mo/areyousure

### Parameters
#### Request Body
- **original_intent** (string) - Required - The original goal or intention.
- **current_context** (string) - Required - The current situation or environment.
- **proposal_type** (string) - Required - The type of proposal being made (e.g., change, action).
- **proposal** (string) - Required - The specific proposal to be evaluated.
- **rationale** (string) - Required - The reasoning behind the proposal.
- **constraints** (string) - Optional - Any constraints that apply to the proposal.
- **risk_level** (string) - Optional - The assessed level of risk associated with the proposal.
- **stage** (string) - Optional - The current stage of the process or project.
- **should_challenge** (boolean) - Optional - Indicates whether the proposal should be challenged.
- **mode** (string) - Optional - The operational mode for the API.
- **explainability** (boolean) - Optional - Whether to provide explanations for the assessment.
- **reversibility** (boolean) - Optional - Indicates if the proposed action is reversible.
- **estimated_cost** (string) - Optional - The estimated cost of implementing the proposal.
- **blast_radius** (string) - Optional - The potential impact or 'blast radius' of the proposal.

### Response
#### Success Response (200)
- **status** (string) - The status of the assessment.
- **summary** (string) - A summary of the assessment findings.
- **goal_alignment** (string) - Assessment of how well the proposal aligns with the original intent.
- **concerns** (array) - A list of concerns identified with the proposal.
- **assumptions** (array) - A list of assumptions made during the assessment.
- **better_options** (array) - Suggestions for alternative or better options.
- **challenge_prompt** (string) - A prompt to challenge the proposal.
- **recommended_next_step** (string) - Recommended next action.
- **prompt_to_human** (string) - A prompt directed to a human user.
- **confidence** (number) - The confidence level of the assessment.
- **decision_factors** (array) - Factors influencing the decision.

### Compatibility
v1 follows additive compatibility:
- Existing fields are stable.
- New optional fields may be added.
- Enum narrowing is a breaking change.
```

--------------------------------

### TypeScript SDK Integration

Source: https://context7.com/gg-mo/areyousure/llms.txt

Provides types, validation functions, and HTTP-based critique request handling for client-side applications.

```typescript
import {
  CritiqueInput,
  CritiqueOutput,
  CritiqueStatus,
  ProposalType,
  RiskLevel,
  Stage,
  validateCritiqueInput,
  validateCritiqueOutput,
  critiqueViaHttp,
} from "./sdk/ts/index";

// Define a critique input
const input: CritiqueInput = {
  original_intent: "Migrate user billing safely without downtime.",
  current_context: "Migration scripts drafted and dry-run completed.",
  proposal_type: "action",
  proposal: "Run migration in one batch during business hours.",
  rationale: "This likely finishes faster based on staging results.",
  constraints: ["No production downtime", "Rollback plan required"],
  risk_level: "high",
  stage: "pre_execution",
  should_challenge: true,
  reversibility: "partially_reversible",
  estimated_cost: "medium",
  blast_radius: "org",
};

// Validate input before sending
if (!validateCritiqueInput(input)) {
  throw new Error("Invalid critique input");
}

// Call critique endpoint via HTTP
async function runCritique() {
  try {
    const result: CritiqueOutput = await critiqueViaHttp(
      input,
      "https://api.example.com/critique"
    );

    console.log(`Status: ${result.status}`);
    console.log(`Summary: ${result.summary}`);
    console.log(`Confidence: ${result.confidence}`);
    console.log(`Concerns: ${result.concerns.join(", ")}`);

    if (result.status === "prompt_human" && result.prompt_to_human) {
      console.log(`Question for human: ${result.prompt_to_human}`);
    }
  } catch (error) {
    console.error("Critique failed:", error);
  }
}

// Validate output received from server
function handleServerResponse(data: unknown): CritiqueOutput {
  if (!validateCritiqueOutput(data)) {
    throw new Error("Invalid critique output from server");
  }
  return data;
}
```

--------------------------------

### CLI Strict Manual Mode

Source: https://context7.com/gg-mo/areyousure/llms.txt

Operate the CLI in strict manual mode, requiring a complete schema-compliant JSON input. This bypasses auto-fill and ensures all fields are explicitly provided.

```bash
# Strict manual mode (requires full schema)
python3 scripts/are_you_sure_cli.py --input payload.json --input-mode manual
```

--------------------------------

### Bypass Are You Sure Checkpoint

Source: https://github.com/gg-mo/areyousure/blob/main/docs/README.opencode.md

Use this syntax to bypass the Are You Sure checkpoint for a single operation. Provide a reason for bypassing.

```markdown
[ays:skip <reason>]
```

```markdown
#ays-skip
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.