@draht/coding-agent 2026.3.2 → 2026.3.4

package/dist/prompts/commands/execute-phase.md

@@ -8,36 +8,36 @@ Execute all plans in a phase with atomic commits.
 ```
 
 ## Steps
-1. Run `draht discover-plans N` to find and order plans
+1. Run `draht-tools discover-plans N` to find and order plans
 2. For each plan in dependency order:
-   a. Load plan: `draht read-plan N P`
+   a. Load plan: `draht-tools read-plan N P`
    b. Execute each task in strict TDD cycle:
 
       **🔴 RED — Write failing tests first**
       - Write the test cases from `<test>`
       - Run tests — confirm they FAIL (if they pass, the test is wrong)
-      - Commit failing tests: `draht commit-task N P T "red: test description"`
+      - Commit failing tests: `draht-tools commit-task N P T "red: test description"`
 
       **🟢 GREEN — Minimal implementation**
       - Write the minimum code from `<action>` to make tests pass
       - Use domain language from `<context>` and `<domain>` for all names
       - Run tests — confirm they PASS
-      - Commit: `draht commit-task N P T "green: task name"`
+      - Commit: `draht-tools commit-task N P T "green: task name"`
 
       **🔵 REFACTOR — Clean up with safety net**
       - Apply improvements from `<refactor>` (if any)
       - Run tests after each change — must stay green
       - Verify domain language compliance (names match DOMAIN.md)
-      - Commit: `draht commit-task N P T "refactor: description"`
+      - Commit: `draht-tools commit-task N P T "refactor: description"`
 
       **✅ VERIFY**
       - Run the `<verify>` step
       - Confirm `<done>` criteria met
 
-   c. Write summary: `draht write-summary N P`
-3. Phase verification: `draht verify-phase N`
-4. Update state: `draht update-state`
-5. Final commit: `draht commit-docs "complete phase N execution"`
+   c. Write summary: `draht-tools write-summary N P`
+3. Phase verification: `draht-tools verify-phase N`
+4. Update state: `draht-tools update-state`
+5. Final commit: `draht-tools commit-docs "complete phase N execution"`
 
 ## TDD Rules
 - Never write implementation before a failing test exists

package/dist/prompts/commands/fix.md

@@ -0,0 +1,29 @@
+# /fix
+
+Diagnose and fix a specific bug or failing task with TDD discipline.
+
+## Usage
+```
+/fix [description of what's broken]
+```
+
+## Steps
+1. **Diagnose**: Read the relevant code and error output to identify the root cause
+   - If a test is failing, run it first to see the actual error
+   - If a runtime bug, reproduce it and capture the error
+2. **Write a reproducing test**: Before touching any implementation:
+   - Write a test that demonstrates the bug (it must fail)
+   - Commit: `draht-tools commit-docs "red: reproduce bug"`
+3. **Minimal fix**: Write the smallest change that makes the test pass
+   - Do not refactor or add features — just fix the bug
+   - Run the full test suite to check for regressions
+   - Commit: `draht-tools commit-docs "green: fix description"`
+4. **Refactor** (if needed): Clean up without changing behavior
+   - Tests must stay green after every change
+   - Commit: `draht-tools commit-docs "refactor: description"`
+5. **Update state**: `draht-tools update-state`
+
+## Rules
+- Always reproduce before fixing — a fix without a test is a guess
+- One bug, one fix, one commit. Do not bundle unrelated changes.
+- If the root cause spans multiple files, explain the chain in the commit message

package/dist/prompts/commands/init-project.md

@@ -0,0 +1,49 @@
+# /init-project
+
+Initialize GSD planning framework for an existing project: codebase mapping → questioning → domain model → requirements → roadmap.
+
+## Usage
+```
+/init-project [focus area or goal]
+```
+
+Use this when you have an existing codebase and want to add GSD methodology.
+For greenfield projects, use `/new-project` instead.
+
+## Steps
+1. Run `draht-tools init` to check preconditions (git repo, etc.)
+2. Run `draht-tools map-codebase` to build a structural map of the existing code
+3. Analyze the codebase map to understand architecture, tech stack, and conventions
+4. Deep questioning phase (3-7 rounds, 1-2 questions at a time):
+   - What is this project? Who uses it?
+   - What are the current pain points or goals?
+   - What is MVP vs aspirational scope?
+   - What constraints exist (infra, team size, deadlines)?
+5. Run `draht-tools create-project` with gathered info
+6. Run `draht-tools create-domain-model` to define bounded contexts, entities, and ubiquitous language
+7. Create `.planning/DOMAIN.md` with:
+   - `## Bounded Contexts` — each context with name, responsibility, and brief description
+   - `## Ubiquitous Language` — glossary of domain terms agreed with the user (term → definition)
+   - `## Context Map` — how bounded contexts relate to each other (upstream/downstream, shared kernel, ACL)
+   - `## Aggregates` — aggregates and their root entities per context
+   - `## Domain Events` — named events that cross context boundaries
+8. Create `.planning/TEST-STRATEGY.md` with:
+   - `## Test Framework` — chosen framework and rationale
+   - `## Directory Conventions` — where test files live relative to source
+   - `## Coverage Goals` — target coverage percentage and which paths are critical
+   - `## Testing Levels` — what is tested at unit level vs integration vs e2e, with examples
+   - `## Excluded` — what is explicitly not tested and why (config files, generated code, etc.)
+9. Optional research phase via `draht-tools research`
+10. Run `draht-tools create-requirements` with v1/v2/out-of-scope (map requirements to bounded contexts)
+11. Run `draht-tools create-roadmap` with phases
+12. Run `draht-tools init-state`
+13. Git commit via `draht-tools commit-docs "initialize GSD planning"`
+
+## Rules
+- Ask 1-2 questions at a time, never dump 10 at once
+- Follow threads based on answers
+- Use examples ("Like Stripe Checkout, or custom?")
+- Confirm, don't assume
+- 3-7 follow-up rounds typical
+- Respect what already exists — do not propose rewriting working code
+- Stop when you have: current state, goals, MVP scope, constraints, success criteria

package/dist/prompts/commands/map-codebase.md

@@ -8,7 +8,7 @@ Analyze existing codebase before planning.
 ```
 
 ## Steps
-1. Run `draht map-codebase [dir]`
+1. Run `draht-tools map-codebase [dir]`
 2. Tool generates: STACK.md, ARCHITECTURE.md, CONVENTIONS.md, CONCERNS.md
 3. Review output, supplement with your own analysis if needed
 4. Identify implicit bounded contexts from directory structure:
@@ -29,4 +29,4 @@ Analyze existing codebase before planning.
    - Existing coverage configuration and goals (if any)
    - Which layers have tests today (unit, integration, e2e)
    - Gaps and recommendations
-8. Commit: `draht commit-docs "map existing codebase"`
+8. Commit: `draht-tools commit-docs "map existing codebase"`

package/dist/prompts/commands/new-project.md

@@ -8,11 +8,11 @@ Initialize a new GSD project: questioning → research → requirements → road
 ```
 
 ## Steps
-1. Run `draht init` to check preconditions
-2. If existing code detected, run `draht map-codebase` first
+1. Run `draht-tools init` to check preconditions
+2. If existing code detected, run `draht-tools map-codebase` first
 3. Deep questioning phase (3-7 rounds, 1-2 questions at a time)
-4. Run `draht create-project` with gathered info
-5. Run `draht create-domain-model` to define bounded contexts, entities, and ubiquitous language
+4. Run `draht-tools create-project` with gathered info
+5. Run `draht-tools create-domain-model` to define bounded contexts, entities, and ubiquitous language
 6. Create `.planning/DOMAIN.md` with:
    - `## Bounded Contexts` — each context with name, responsibility, and brief description
    - `## Ubiquitous Language` — glossary of domain terms agreed with the user (term → definition)
@@ -25,11 +25,11 @@ Initialize a new GSD project: questioning → research → requirements → road
    - `## Coverage Goals` — target coverage percentage and which paths are critical
    - `## Testing Levels` — what is tested at unit level vs integration vs e2e, with examples
    - `## Excluded` — what is explicitly not tested and why (config files, generated code, etc.)
-8. Optional research phase via `draht research`
-9. Run `draht create-requirements` with v1/v2/out-of-scope (map requirements to bounded contexts)
-10. Run `draht create-roadmap` with phases
-11. Run `draht init-state`
-12. Git commit via `draht commit-docs "initialize GSD project"`
+8. Optional research phase via `draht-tools research`
+9. Run `draht-tools create-requirements` with v1/v2/out-of-scope (map requirements to bounded contexts)
+10. Run `draht-tools create-roadmap` with phases
+11. Run `draht-tools init-state`
+12. Git commit via `draht-tools commit-docs "initialize GSD project"`
 
 ## Rules
 - Ask 1-2 questions at a time, never dump 10 at once

package/dist/prompts/commands/next-milestone.md

@@ -0,0 +1,44 @@
+# /next-milestone
+
+Plan the next milestone after the current one is complete.
+
+## Usage
+```
+/next-milestone
+```
+
+## Prerequisites
+- `.planning/ROADMAP.md` must exist
+- Current milestone should be complete or nearly complete
+
+## Steps
+1. Load project context:
+   - Read `.planning/ROADMAP.md` — identify the completed milestone and its phases
+   - Read `.planning/STATE.md` — understand current status
+   - Read `.planning/REQUIREMENTS.md` — check which requirements are satisfied
+   - Read `.planning/DOMAIN.md` (if exists) — review domain model for evolution needs
+2. Review completed work:
+   - Scan `.planning/phases/` for all UAT reports (`*-UAT.md`) and summaries (`*-SUMMARY.md`)
+   - Note what was built, what worked well, what had issues
+3. Assess requirements:
+   - Which v1 requirements are now satisfied?
+   - Which v1 requirements remain?
+   - Should any v2 requirements be promoted based on what we learned?
+   - Are there new requirements discovered during implementation?
+4. Propose next milestone:
+   - Define 3-5 phases, each with a clear goal (outcome, not activity)
+   - Order phases by dependency
+   - Map each phase to specific requirements
+   - Estimate relative complexity
+5. Present the proposed milestone for user approval before writing files
+6. After approval:
+   - Update `ROADMAP.md` with the new milestone and phases
+   - Update `STATE.md` to reflect milestone transition
+   - Update `REQUIREMENTS.md` if requirements changed
+   - Update `DOMAIN.md` if domain model needs evolution
+   - Commit: `draht-tools commit-docs "plan next milestone"`
+
+## Rules
+- Always review what was actually built, not just what was planned
+- Be honest about requirements that slipped or changed scope
+- Each phase goal must be testable — "user can X" not "implement Y"

package/dist/prompts/commands/pause-work.md

@@ -8,5 +8,5 @@ Create a handoff document for session continuity.
 ```
 
 ## Steps
-1. Run `draht pause` — creates CONTINUE-HERE.md
-2. Commit: `draht commit-docs "pause work"`
+1. Run `draht-tools pause` — creates CONTINUE-HERE.md
+2. Commit: `draht-tools commit-docs "pause work"`

package/dist/prompts/commands/plan-phase.md

@@ -8,17 +8,17 @@ Create atomic execution plans for a roadmap phase.
 ```
 
 ## Steps
-1. Run `draht load-phase-context N` to gather all context
-2. Optional: `draht research-phase N` for domain research
+1. Run `draht-tools load-phase-context N` to gather all context
+2. Optional: `draht-tools research-phase N` for domain research
 3. Goal-backward planning:
    a. State the goal (outcome, not activity)
    b. Derive observable truths (3-7 from user perspective)
    c. From each observable truth, derive the test scenarios that would prove it (specific inputs → expected outputs or state changes)
    d. Map to required artifacts (files, endpoints, schemas)
    e. Break into atomic tasks (2-5 per plan)
-4. Write plans: `draht create-plan N P`
-5. Validate: `draht validate-plans N`
-6. Commit: `draht commit-docs "create phase N plans"`
+4. Write plans: `draht-tools create-plan N P`
+5. Validate: `draht-tools validate-plans N`
+6. Commit: `draht-tools commit-docs "create phase N plans"`
 
 ## Plan Format
 Plans use XML task format:

package/dist/prompts/commands/progress.md

@@ -8,5 +8,5 @@ Show current project status.
 ```
 
 ## Steps
-1. Run `draht progress` — outputs formatted status
+1. Run `draht-tools progress` — outputs formatted status
 2. Display the result as-is

package/dist/prompts/commands/quick.md

@@ -8,12 +8,12 @@ Execute a small ad-hoc task with GSD tracking.
 ```
 
 ## Steps
-1. Run `draht next-quick-number` to get task number
-2. Create quick plan: `draht create-quick-plan NNN "description"`
+1. Run `draht-tools next-quick-number` to get task number
+2. Create quick plan: `draht-tools create-quick-plan NNN "description"`
 3. Execute tasks following the TDD cycle:
    - **🔴 RED** — Write a failing test that describes the desired behaviour
    - **🟢 GREEN** — Write the minimum implementation to make it pass
    - **🔵 REFACTOR** — Clean up while keeping the test green
    - *Exception: skip the TDD cycle only for pure config or documentation-only tasks that have no testable behaviour*
-4. Write summary: `draht write-quick-summary NNN`
-5. Update state: `draht update-state`
+4. Write summary: `draht-tools write-quick-summary NNN`
+5. Update state: `draht-tools update-state`

package/dist/prompts/commands/resume-work.md

@@ -8,6 +8,6 @@ Resume from last session state.
 ```
 
 ## Steps
-1. Run `draht resume` — loads CONTINUE-HERE.md or STATE.md
+1. Run `draht-tools resume` — loads CONTINUE-HERE.md or STATE.md
 2. Display context and ask to continue
 3. Delete CONTINUE-HERE.md after confirmation

package/dist/prompts/commands/review.md

@@ -0,0 +1,26 @@
+# /review
+
+Ad-hoc code review and security audit of recent changes or a specific scope.
+
+## Usage
+```
+/review [scope]
+```
+
+If no scope given, reviews all recent uncommitted changes.
+
+## Steps
+1. Identify the scope:
+   - If argument given: review those files/directories/description
+   - If no argument: run `git diff --stat` and `git diff --cached --stat` to find changes
+2. For each changed file, examine:
+   - Correctness: logic errors, off-by-one, null handling, error paths
+   - Type safety: any `as` casts, `any` types, missing null checks
+   - Conventions: naming, file organization, import style
+   - Security: injection risks, auth bypasses, secrets in code, unsafe deserialization
+   - Performance: unnecessary allocations, missing indexes, N+1 queries
+3. Produce a prioritized findings report:
+   - **Critical** — must fix before merge (security, data loss, crashes)
+   - **Important** — should fix (bugs, type issues, missing error handling)
+   - **Minor** — style, naming, or optional improvements
+4. For each finding: cite the exact file and line, explain the issue, suggest the fix

package/dist/prompts/commands/verify-work.md

@@ -15,13 +15,13 @@ Walk through acceptance testing of completed phase work.
    - Load `.planning/DOMAIN.md` and extract all defined terms
    - Scan source files for PascalCase identifiers not present in the glossary
    - Flag any bounded context boundary violations (cross-context direct imports)
-3. Run quality gate: `draht quality-gate --strict`
-4. Run `draht extract-deliverables N` to get testable items
+3. Run quality gate: `draht-tools quality-gate --strict`
+4. Run `draht-tools extract-deliverables N` to get testable items
 5. Walk user through each deliverable one at a time
 6. Record results (pass/fail/partially/skip)
-7. For failures: diagnose and create fix plans via `draht create-fix-plan N P`
+7. For failures: diagnose and create fix plans via `draht-tools create-fix-plan N P`
    - Fix plans MUST include a reproducing test that demonstrates the failure before any implementation
-8. Write UAT report: `draht write-uat N`
+8. Write UAT report: `draht-tools write-uat N`
    - Report must include: test health summary (pass/fail/coverage), domain model status (any glossary violations), deliverable results
 9. If all passed: mark phase complete
 10. If failures: route to `execute-phase N --gaps-only`

package/docs/compaction.md

@@ -2,14 +2,14 @@
 
 LLMs have limited context windows. When conversations grow too long, pi uses compaction to summarize older content while preserving recent work. This page covers both auto-compaction and branch summarization.
 
-**Source files** ([pi-mono](https://github.com/badlogic/pi-mono)):
-- [`packages/coding-agent/src/core/compaction/compaction.ts`](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/src/core/compaction/compaction.ts) - Auto-compaction logic
-- [`packages/coding-agent/src/core/compaction/branch-summarization.ts`](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/src/core/compaction/branch-summarization.ts) - Branch summarization
-- [`packages/coding-agent/src/core/compaction/utils.ts`](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/src/core/compaction/utils.ts) - Shared utilities (file tracking, serialization)
-- [`packages/coding-agent/src/core/session-manager.ts`](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/src/core/session-manager.ts) - Entry types (`CompactionEntry`, `BranchSummaryEntry`)
-- [`packages/coding-agent/src/core/extensions/types.ts`](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/src/core/extensions/types.ts) - Extension event types
+**Source files** ([pi-mono](https://github.com/draht-dev/draht)):
+- [`packages/coding-agent/src/core/compaction/compaction.ts`](https://github.com/draht-dev/draht/blob/main/packages/coding-agent/src/core/compaction/compaction.ts) - Auto-compaction logic
+- [`packages/coding-agent/src/core/compaction/branch-summarization.ts`](https://github.com/draht-dev/draht/blob/main/packages/coding-agent/src/core/compaction/branch-summarization.ts) - Branch summarization
+- [`packages/coding-agent/src/core/compaction/utils.ts`](https://github.com/draht-dev/draht/blob/main/packages/coding-agent/src/core/compaction/utils.ts) - Shared utilities (file tracking, serialization)
+- [`packages/coding-agent/src/core/session-manager.ts`](https://github.com/draht-dev/draht/blob/main/packages/coding-agent/src/core/session-manager.ts) - Entry types (`CompactionEntry`, `BranchSummaryEntry`)
+- [`packages/coding-agent/src/core/extensions/types.ts`](https://github.com/draht-dev/draht/blob/main/packages/coding-agent/src/core/extensions/types.ts) - Extension event types
 
-For TypeScript definitions in your project, inspect `node_modules/@mariozechner/pi-coding-agent/dist/`.
+For TypeScript definitions in your project, inspect `node_modules/@draht/coding-agent/dist/`.
 
 ## Overview
 
@@ -116,7 +116,7 @@ Never cut at tool results (they must stay with their tool call).
 
 ### CompactionEntry Structure
 
-Defined in [`session-manager.ts`](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/src/core/session-manager.ts):
+Defined in [`session-manager.ts`](https://github.com/draht-dev/draht/blob/main/packages/coding-agent/src/core/session-manager.ts):
 
 ```typescript
 interface CompactionEntry<T = unknown> {
@@ -140,7 +140,7 @@ interface CompactionDetails {
 
 Extensions can store any JSON-serializable data in `details`. The default compaction tracks file operations, but custom extension implementations can use their own structure.
 
-See [`prepareCompaction()`](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/src/core/compaction/compaction.ts) and [`compact()`](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/src/core/compaction/compaction.ts) for the implementation.
+See [`prepareCompaction()`](https://github.com/draht-dev/draht/blob/main/packages/coding-agent/src/core/compaction/compaction.ts) and [`compact()`](https://github.com/draht-dev/draht/blob/main/packages/coding-agent/src/core/compaction/compaction.ts) for the implementation.
 
 ## Branch Summarization
 
@@ -183,7 +183,7 @@ This means file tracking accumulates across multiple compactions or nested branc
 
 ### BranchSummaryEntry Structure
 
-Defined in [`session-manager.ts`](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/src/core/session-manager.ts):
+Defined in [`session-manager.ts`](https://github.com/draht-dev/draht/blob/main/packages/coding-agent/src/core/session-manager.ts):
 
 ```typescript
 interface BranchSummaryEntry<T = unknown> {
@@ -206,7 +206,7 @@ interface BranchSummaryDetails {
 
 Same as compaction, extensions can store custom data in `details`.
 
-See [`collectEntriesForBranchSummary()`](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/src/core/compaction/branch-summarization.ts), [`prepareBranchEntries()`](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/src/core/compaction/branch-summarization.ts), and [`generateBranchSummary()`](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/src/core/compaction/branch-summarization.ts) for the implementation.
+See [`collectEntriesForBranchSummary()`](https://github.com/draht-dev/draht/blob/main/packages/coding-agent/src/core/compaction/branch-summarization.ts), [`prepareBranchEntries()`](https://github.com/draht-dev/draht/blob/main/packages/coding-agent/src/core/compaction/branch-summarization.ts), and [`generateBranchSummary()`](https://github.com/draht-dev/draht/blob/main/packages/coding-agent/src/core/compaction/branch-summarization.ts) for the implementation.
 
 ## Summary Format
 
@@ -250,7 +250,7 @@ path/to/changed.ts
 
 ### Message Serialization
 
-Before summarization, messages are serialized to text via [`serializeConversation()`](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/src/core/compaction/utils.ts):
+Before summarization, messages are serialized to text via [`serializeConversation()`](https://github.com/draht-dev/draht/blob/main/packages/coding-agent/src/core/compaction/utils.ts):
 
 ```
 [User]: What they said
@@ -264,7 +264,7 @@ This prevents the model from treating it as a conversation to continue.
 
 ## Custom Summarization via Extensions
 
-Extensions can intercept and customize both compaction and branch summarization. See [`extensions/types.ts`](https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/src/core/extensions/types.ts) for event type definitions.
+Extensions can intercept and customize both compaction and branch summarization. See [`extensions/types.ts`](https://github.com/draht-dev/draht/blob/main/packages/coding-agent/src/core/extensions/types.ts) for event type definitions.
 
 ### session_before_compact
 
@@ -305,7 +305,7 @@ pi.on("session_before_compact", async (event, ctx) => {
 To generate a summary with your own model, convert messages to text using `serializeConversation`:
 
 ```typescript
-import { convertToLlm, serializeConversation } from "@mariozechner/pi-coding-agent";
+import { convertToLlm, serializeConversation } from "@draht/coding-agent";
 
 pi.on("session_before_compact", async (event, ctx) => {
   const { preparation } = event;

package/docs/custom-provider.md

@@ -31,7 +31,7 @@ See these complete provider examples:
 ## Quick Reference
 
 ```typescript
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@draht/coding-agent";
 
 export default function (pi: ExtensionAPI) {
   // Override baseUrl for existing provider
@@ -172,10 +172,17 @@ models: [{
   // ...
   compat: {
     supportsDeveloperRole: false,      // use "system" instead of "developer"
-    supportsReasoningEffort: false,    // disable reasoning_effort param
+    supportsReasoningEffort: true,
+    reasoningEffortMap: {              // map pi-ai levels to provider values
+      minimal: "default",
+      low: "default",
+      medium: "default",
+      high: "default",
+      xhigh: "default"
+    },
     maxTokensField: "max_tokens",      // instead of "max_completion_tokens"
     requiresToolResultName: true,      // tool results need name field
-    requiresMistralToolIds: true       // tool IDs must be 9 alphanumeric chars
+    requiresMistralToolIds: true,
     thinkingFormat: "qwen"             // uses enable_thinking: true
   }
 }]
@@ -200,7 +207,7 @@ pi.registerProvider("custom-api", {
 Add OAuth/SSO authentication that integrates with `/login`:
 
 ```typescript
-import type { OAuthCredentials, OAuthLoginCallbacks } from "@mariozechner/pi-ai";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "@draht/ai";
 
 pi.registerProvider("corporate-ai", {
   baseUrl: "https://ai.corp.com/v1",
@@ -293,11 +300,11 @@ interface OAuthCredentials {
 For providers with non-standard APIs, implement `streamSimple`. Study the existing provider implementations before writing your own:
 
 **Reference implementations:**
-- [anthropic.ts](https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/providers/anthropic.ts) - Anthropic Messages API
-- [openai-completions.ts](https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/providers/openai-completions.ts) - OpenAI Chat Completions
-- [openai-responses.ts](https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/providers/openai-responses.ts) - OpenAI Responses API
-- [google.ts](https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/providers/google.ts) - Google Generative AI
-- [amazon-bedrock.ts](https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/providers/amazon-bedrock.ts) - AWS Bedrock
+- [anthropic.ts](https://github.com/draht-dev/draht/blob/main/packages/ai/src/providers/anthropic.ts) - Anthropic Messages API
+- [openai-completions.ts](https://github.com/draht-dev/draht/blob/main/packages/ai/src/providers/openai-completions.ts) - OpenAI Chat Completions
+- [openai-responses.ts](https://github.com/draht-dev/draht/blob/main/packages/ai/src/providers/openai-responses.ts) - OpenAI Responses API
+- [google.ts](https://github.com/draht-dev/draht/blob/main/packages/ai/src/providers/google.ts) - Google Generative AI
+- [amazon-bedrock.ts](https://github.com/draht-dev/draht/blob/main/packages/ai/src/providers/amazon-bedrock.ts) - AWS Bedrock
 
 ### Stream Pattern
 
@@ -312,7 +319,7 @@ import {
   type SimpleStreamOptions,
   calculateCost,
   createAssistantMessageEventStream,
-} from "@mariozechner/pi-ai";
+} from "@draht/ai";
 
 function streamMyProvider(
   model: Model<any>,
@@ -469,7 +476,7 @@ pi.registerProvider("my-provider", {
 
 ## Testing Your Implementation
 
-Test your provider against the same test suites used by built-in providers. Copy and adapt these test files from [packages/ai/test/](https://github.com/badlogic/pi-mono/tree/main/packages/ai/test):
+Test your provider against the same test suites used by built-in providers. Copy and adapt these test files from [packages/ai/test/](https://github.com/draht-dev/draht/tree/main/packages/ai/test):
 
 | Test | Purpose |
 |------|---------|
@@ -568,6 +575,7 @@ interface ProviderModelConfig {
     supportsStore?: boolean;
     supportsDeveloperRole?: boolean;
     supportsReasoningEffort?: boolean;
+    reasoningEffortMap?: Partial<Record<"minimal" | "low" | "medium" | "high" | "xhigh", string>>;
     supportsUsageInStreaming?: boolean;
     maxTokensField?: "max_completion_tokens" | "max_tokens";
     requiresToolResultName?: boolean;

package/docs/development.md

@@ -5,7 +5,7 @@ See [AGENTS.md](../../../AGENTS.md) for additional guidelines.
 ## Setup
 
 ```bash
-git clone https://github.com/badlogic/pi-mono
+git clone https://github.com/draht-dev/draht
 cd pi-mono
 npm install
 npm run build