abelworkflow 1.0.0-rc.1 → 1.1.0

package/skills/grok-search/SKILL.md

@@ -24,7 +24,7 @@ Use this skill for web search, webpage retrieval, and current-information lookup
 ```bash
 cp "<SKILL_DIR>/.env.example" "<SKILL_DIR>/.env"
 
-python "<SKILL_DIR>/scripts/groksearch_entry.py" web_search --query "search terms" [--platform "GitHub"] [--min-results 3] [--max-results 10] [--model "grok-4.20-auto"] [--extra-sources 3]
+python "<SKILL_DIR>/scripts/groksearch_entry.py" web_search --query "search terms" [--platform "GitHub"] [--min-results 3] [--max-results 10] [--model "grok-4.20-non-reasoning"] [--extra-sources 3]
 
 python "<SKILL_DIR>/scripts/groksearch_entry.py" web_fetch --url "https://..." [--out file.md] [--fallback-grok]
 

package/skills/grok-search/defaults.json

@@ -1,3 +1,3 @@
 {
-  "model": "grok-4.20-auto"
+  "model": "grok-4.20-non-reasoning"
 }

package/skills/grok-search/scripts/groksearch_cli.py

@@ -216,7 +216,17 @@ def _emit_tavily_warning(message: str) -> None:
 RETRYABLE_STATUS_CODES = {408, 429, 500, 502, 503, 504}
 
 
+class StreamEmbeddedError(Exception):
+    """SSE 流内嵌错误事件（HTTP 200 + data: {"error": ...}）。"""
+
+
+class EmptyStreamError(Exception):
+    """流式响应解析完成但内容为空。"""
+
+
 def _is_retryable_exception(exc) -> bool:
+    if isinstance(exc, (StreamEmbeddedError, EmptyStreamError)):
+        return True
     if isinstance(exc, (httpx.TimeoutException, httpx.NetworkError, httpx.ConnectError, httpx.RemoteProtocolError)):
         return True
     if isinstance(exc, httpx.HTTPStatusError):
@@ -501,6 +511,7 @@ def _normalize_tavily_base_url(raw: str) -> str:
 
 _http_client: Optional[httpx.AsyncClient] = None
 _DEFAULT_TIMEOUT = httpx.Timeout(connect=6.0, read=60.0, write=10.0, pool=None)
+_NON_STREAM_TIMEOUT = httpx.Timeout(connect=6.0, read=10.0, write=10.0, pool=None)
 
 
 async def get_http_client() -> httpx.AsyncClient:
@@ -586,16 +597,23 @@ class GrokSearchProvider:
         return await self._execute(payload)
 
     async def _execute(self, payload: dict) -> str:
-        """执行请求：先尝试非流式，失败时回退到流式。"""
+        """执行请求：流式优先，失败时回退到非流式（10s 超时 fail-fast）。"""
         try:
+            return await self._execute_stream(payload)
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code not in RETRYABLE_STATUS_CODES:
+                raise
+            if config.debug_enabled:
+                print(f"[DEBUG] 流式失败: {e}，回退到非流式", file=sys.stderr)
             return await self._execute_non_stream(payload)
-        except (httpx.HTTPStatusError, json.JSONDecodeError) as e:
+        except (httpx.TimeoutException, httpx.NetworkError, httpx.RemoteProtocolError,
+                StreamEmbeddedError, EmptyStreamError, json.JSONDecodeError) as e:
             if config.debug_enabled:
-                print(f"[DEBUG] 非流式失败: {e}，回退到流式", file=sys.stderr)
-            return await self._execute_stream(payload)
+                print(f"[DEBUG] 流式失败: {e}，回退到非流式", file=sys.stderr)
+            return await self._execute_non_stream(payload)
 
     async def _execute_non_stream(self, payload: dict) -> str:
-        """非流式请求（首选，对短响应更快）。"""
+        """非流式请求（流式失败后的回退方案，10s read 超时 fail-fast）。"""
         payload_copy = {**payload, "stream": False}
         client = await get_http_client()
 
@@ -610,6 +628,7 @@ class GrokSearchProvider:
                     f"{self.api_url}/chat/completions",
                     headers=self._headers,
                     json=payload_copy,
+                    timeout=_NON_STREAM_TIMEOUT,
                 )
                 response.raise_for_status()
                 data = response.json()
@@ -619,7 +638,7 @@ class GrokSearchProvider:
                 return ""
 
     async def _execute_stream(self, payload: dict) -> str:
-        """流式请求（大响应的回退方案）。"""
+        """流式请求（首选，chunk 保活避免网关超时）。"""
         payload_copy = {**payload, "stream": True}
         client = await get_http_client()
 
@@ -655,24 +674,30 @@ class GrokSearchProvider:
                 try:
                     json_str = line[5:].lstrip()
                     data = json.loads(json_str)
-                    choices = data.get("choices", [])
-                    if choices:
-                        delta = choices[0].get("delta", {})
-                        if "content" in delta:
-                            content += delta["content"]
                 except (json.JSONDecodeError, IndexError):
                     continue
+                if isinstance(data, dict) and "error" in data:
+                    raise StreamEmbeddedError(json.dumps(data["error"], ensure_ascii=False)[:300])
+                choices = data.get("choices", [])
+                if choices:
+                    delta = choices[0].get("delta", {})
+                    if "content" in delta:
+                        content += delta["content"]
 
         if not content and full_body_buffer:
             try:
                 full_text = "".join(full_body_buffer)
                 data = json.loads(full_text)
+                if isinstance(data, dict) and "error" in data:
+                    raise StreamEmbeddedError(json.dumps(data["error"], ensure_ascii=False)[:300])
                 if "choices" in data and data["choices"]:
                     message = data["choices"][0].get("message", {})
                     content = message.get("content", "")
             except json.JSONDecodeError:
                 pass
 
+        if not content.strip():
+            raise EmptyStreamError("流式响应内容为空")
         return content
 
 
@@ -935,8 +960,9 @@ async def cmd_web_search(args):
     except ValueError as e:
         print(json.dumps({"error": str(e)}, ensure_ascii=False), file=sys.stderr)
         sys.exit(1)
-    except httpx.HTTPStatusError as e:
-        print(json.dumps({"error": f"API错误: {e.response.status_code}"}, ensure_ascii=False), file=sys.stderr)
+    except httpx.HTTPError as e:
+        detail = str(e.response.status_code) if isinstance(e, httpx.HTTPStatusError) else (str(e) or type(e).__name__)
+        print(json.dumps({"error": f"API错误: {detail}"}, ensure_ascii=False), file=sys.stderr)
         sys.exit(1)
 
 
@@ -974,8 +1000,9 @@ async def cmd_web_fetch(args):
         except ValueError as e:
             print(f"错误: {e}", file=sys.stderr)
             sys.exit(1)
-        except httpx.HTTPStatusError as e:
-            print(f"API错误: {e.response.status_code}", file=sys.stderr)
+        except httpx.HTTPError as e:
+            detail = str(e.response.status_code) if isinstance(e, httpx.HTTPStatusError) else (str(e) or type(e).__name__)
+            print(f"API错误: {detail}", file=sys.stderr)
             sys.exit(1)
 
     if not result and tavily_error and not use_grok_fallback:

package/skills/prompt-enhancer/SKILL.md

@@ -2,7 +2,6 @@
 name: prompt-enhancer
 description: |
   Rewrite a raw prompt into a clearer prompt for a coding agent. Use only when the user explicitly asks to improve, optimize, rewrite, or structure a prompt for Codex, Claude Code, Gemini CLI, or another AI agent. Triggers: "improve this prompt", "rewrite this prompt", "optimize this prompt for Codex", "make this prompt better for an AI agent".
-allowed-tools: Bash(python:*), Bash(python3:*), Bash(uv:*), Read, Grep
 ---
 
 # Prompt Enhancer
@@ -19,31 +18,7 @@ Do not use this for general writing edits like email, docs, or PR copy.
 
 ## Do
 
-- Default path: rewrite the prompt directly with the current agent using the structure from [TEMPLATE.md](TEMPLATE.md).
-- Third-party path: use the Python entrypoint only when the user explicitly provides `url`, `apiKey`, and `model`, or when all three are already configured in `<SKILL_DIR>/.env`.
-
-```bash
-python "<SKILL_DIR>/scripts/prompt_enhancer_entry.py" "user's raw prompt here"
-```
-
-- Do not call `scripts/enhance.py` directly.
-- Use the installed skill directory for `<SKILL_DIR>`.
-- If any of `url`, `apiKey`, or `model` is missing, do not invoke the script. Use the current agent directly instead.
-- Optional setup: `cp "<SKILL_DIR>/.env.example" "<SKILL_DIR>/.env"`
-
-## Output
-
-- Read the enhanced prompt from `stdout`.
-- Keep `stderr` for usage or optional debug output only.
+- Rewrite the prompt directly with the current agent, following the structure from [TEMPLATE.md](TEMPLATE.md).
 - Preserve the user's intent and explicit constraints.
 - Add structure and missing execution context only when it helps the agent act.
-- When running directly in the current agent, use placeholders for unknown context instead of inventing new requirements.
-
-## Notes
-
-- Local config file: `<SKILL_DIR>/.env`
-- The entrypoint auto-loads `<SKILL_DIR>/.env` before bootstrap and dependency install.
-- Optional debug flag: `PE_DEBUG=1`
-- Bootstrap controls: `PROMPT_ENHANCER_VENV_DIR`, `PROMPT_ENHANCER_PYTHON`, `AGENTS_SKILLS_PYTHON`
-- Setup and troubleshooting: [ADVANCED.md](ADVANCED.md)
-- Prompt template reference: [TEMPLATE.md](TEMPLATE.md)
+- Use placeholders for unknown context instead of inventing new requirements.

package/lib/installer/render.mjs

@@ -1,46 +0,0 @@
-const augmentContextEngineRetrievalTool = "mcp__augment-context-engine__codebase-retrieval";
-const localCodebaseRetrievalPolicy = "Use local codebase retrieval with `rg`, `rg --files`, `git grep`, and direct file reads. Do not require augment-context-engine MCP.";
-const augmentCodebaseRetrievalPolicy = `Use \`${augmentContextEngineRetrievalTool}\` as the primary codebase search tool.`;
-
-function resolveAugmentContextEngineFeature(options = {}, previousMetadata = {}) {
-  if (typeof options.augmentContextEngine === "boolean") return options.augmentContextEngine;
-  if (typeof previousMetadata?.features?.augmentContextEngine === "boolean") {
-    return previousMetadata.features.augmentContextEngine;
-  }
-  return false;
-}
-
-function getWorkflowRenderValues(augmentContextEngine) {
-  return {
-    CODEBASE_RETRIEVAL_POLICY: augmentContextEngine ? augmentCodebaseRetrievalPolicy : localCodebaseRetrievalPolicy,
-    AUGMENT_CONTEXT_ENGINE_VALIDATION: augmentContextEngine
-      ? `Verify MCP availability:\n   - \`${augmentContextEngineRetrievalTool}\``
-      : "Skip augment-context-engine MCP validation; use local retrieval tools.",
-    CODEBASE_RETRIEVAL_MANDATORY_RULE: augmentContextEngine
-      ? `Mandatory use of \`${augmentContextEngineRetrievalTool}\``
-      : "Mandatory use of configured codebase retrieval policy.",
-    CODEBASE_RETRIEVAL_STRUCTURE_REFERENCE: augmentContextEngine
-      ? `Inspect codebase structure: \`${augmentContextEngineRetrievalTool}\` with \`file list --recursive\`.`
-      : "Inspect codebase structure with `rg --files`, `git grep`, and direct file reads.",
-    CODEBASE_RETRIEVAL_PATTERN_AUDIT: augmentContextEngine
-      ? `Use augment-context-engine to validate against existing codebase patterns.\n   ${augmentContextEngineRetrievalTool}: "Search for existing implementations similar to change <change_name>. Keywords: [key concepts from proposal]"`
-      : "Use `rg`, `rg --files`, `git grep`, and direct file reads to validate against existing codebase patterns."
-  };
-}
-
-function renderWorkflowTemplate(content, { augmentContextEngine = false } = {}) {
-  let nextContent = content;
-  for (const [key, value] of Object.entries(getWorkflowRenderValues(augmentContextEngine))) {
-    nextContent = nextContent.replaceAll(`{{${key}}}`, value);
-  }
-  if (nextContent.includes("{{") || nextContent.includes("}}")) {
-    throw new Error("工作流模板包含未解析占位符");
-  }
-  return nextContent;
-}
-
-export {
-  getWorkflowRenderValues,
-  renderWorkflowTemplate,
-  resolveAugmentContextEngineFeature
-};

package/lib/templates/workflow/commands/abel-plan.md

@@ -1,82 +0,0 @@
----
-name: abel-plan
-description: Refine approved change into a zero-decision executable plan.
-category: abel
-tags: [abel, plan, PBT]
-argument-hint: [change_name]
----
-<!-- ABEL:START -->
-**Guardrails**
-- Strictly adhere to **OpenSpec** rules when writing **standardized spec-structured projects**.
-- The goal of this phase is to eliminate ALL decision points from the task flow—implementation should be pure mechanical execution.
-- Do not proceed to implementation until every ambiguity is resolved and every constraint is explicitly documented.
-- Every requirement must have Property-Based Testing (PBT) properties defined—focus on invariants, not just example-based tests.
-- If constraints cannot be fully specified, escalate back to the user or return to the research phase rather than making assumptions.
-- Refer to `openspec/AGENTS.md` for additional conventions; run `openspec update` if the file is missing.
-
-**Skill Integration**: See `Stage Skill Matrix` (Plan column)
-
-**FORBIDDEN**: Direct implementation code generation
-
-**Steps**
-1. Run `openspec view` to display all **Active Changes**, then confirm with the user which change folder (`<change_name>`) they wish to refine into a zero-decision plan.
-
-2. Navigate to `openspec/changes/<change_name>/` and review existing artifacts:
-   - Check `openspec status --change <change_name>` for artifact completion
-   - Use `openspec instructions specs --change <change_name>` for specs guidance
-
-3. **Implementation Analysis**: Perform systematic analysis to derive a plan. If the proposal has 3+ interconnected requirements, first break it down into components, identify dependencies, evaluate architectural trade-offs, and surface potential conflicts. Then invoke `/context7-auto-research` to validate framework/library choices:
-   ```
-   /context7-auto-research: "For each technology mentioned in change <change_name>, retrieve official documentation patterns and best practices."
-   ```
-   Produce a consolidated, constraint-complete plan and list any missing constraints as questions to the user.
-
-4. **Uncertainty Elimination Audit**: Invoke skills to detect and eliminate remaining ambiguities:
-   ```
-   # First, validate against existing codebase patterns
-   {{CODEBASE_RETRIEVAL_PATTERN_AUDIT}}
-   # Then audit for ambiguities directly and list them explicitly
-   Review change <change_name> for decision points that remain unspecified. For each: [AMBIGUITY] <description> → [REQUIRED CONSTRAINT] <what must be specified>.
-   Identify implicit assumptions in change <change_name>. For each: [ASSUMPTION] <description> → [EXPLICIT CONSTRAINT NEEDED] <concrete specification>.
-   ```
-   
-   **Anti-Pattern Detection** (flag and reject):
-   - Information collection without decision boundaries (e.g., "JWT vs OAuth2 vs session—all viable")
-   - Technical comparisons without selection criteria
-   - Deferred decisions marked as "to be determined during implementation"
-   
-   **Target Pattern** (required for approval):
-   - Explicit technology choices with parameters (e.g., "JWT with accessToken TTL=15min, refreshToken TTL=7days")
-   - Concrete algorithm selections with configurations (e.g., "bcrypt with cost factor=12")
-   - Precise behavioral rules (e.g., "Lock account for 30min after 5 failed login attempts")
-   
-   Iterate with user until ALL ambiguities are resolved into explicit constraints.
-
-5. **PBT Property Extraction**: Invoke skills to derive testable invariants:
-   ```
-   "Extract Property-Based Testing properties from change <change_name>. For each requirement: [INVARIANT] <must always hold> → [FALSIFICATION STRATEGY] <how to generate counterexamples>."
-   "Define system properties for change <change_name>: [PROPERTY] <name> | [DEFINITION] <formal description> | [BOUNDARY CONDITIONS] <edge cases> | [COUNTEREXAMPLE GENERATION] <approach>."
-   ```
-   
-   **PBT Property Categories to Extract**:
-   - **Commutativity/Associativity**: Order-independent operations
-   - **Idempotency**: Repeated operations yield same result
-   - **Round-trip**: Encode→Decode returns original
-   - **Invariant Preservation**: State constraints maintained across operations
-   - **Monotonicity**: Ordering guarantees (e.g., timestamps always increase)
-   - **Bounds**: Value ranges, size limits, rate constraints
-
-**Reference**
-- Use `openspec show <change_name> --json --deltas-only` to inspect proposal structure when validation fails.
-- Use `openspec list --specs` to check for conflicts with existing specifications.
-- Search existing patterns with `rg -n "INVARIANT:|PROPERTY:|Constraint:" openspec/` before defining new ones.
-- For complex proposals, consider running steps 2-4 iteratively on sub-components.
-- Ask the user directly for ANY ambiguity—do not assume or guess.
-
-**Exit Criteria**
-A proposal is ready to exit the Plan phase only when:
-- [ ] Zero ambiguities remain (verified by step 4 audit)
-- [ ] All PBT properties documented with falsification strategies
-- [ ] `openspec validate <change_name> --strict` returns zero issues
-- [ ] User has explicitly approved all constraint decisions
-<!-- ABEL:END -->

package/lib/templates/workflow/commands/abel-research.md

@@ -1,126 +0,0 @@
----
-name: abel-research
-description: Transform user requirements into constraint sets via structured exploration (NO implementation)
-category: abel
-tags: [abel, research, constraints, exploration, subagents]
----
-
-<!-- ABEL:RESEARCH:START -->
-
-# abel-research — Operating Mode (Constraints & Specs Only)
-
-## Non‑Negotiable Rules (Highest Priority)
-1. RESEARCH MODE ONLY.
-   - You MUST NOT generate code.
-2. WRITE SCOPE IS RESTRICTED.
-   - You MAY create/edit files ONLY under: openspec/changes/<change-name>/** (and only after passing the confirmation gates).
-   - You MUST NOT write anywhere else.
-3. Output must be constraint sets + verifiable success criteria, not an information dump.
-
-## Goal
-Produce constraint sets that narrow the solution space, plus measurable success criteria.
-
----
-
-
-
-## Phase 0 — Requirement Intake Gate (MANDATORY)
-- **MUST** confirm the user’s requirement exists and is clear **before** any research/action.
-- If missing/unclear, **MUST** ask the user directly in a concise grouped message to collect: goal, in-scope area, top scenarios, non-goals, known constraints, success signals.
-- **MUST NOT** run `/opsx:new`, any codebase retrieval, spawn subagents, or generate artifacts until the user confirms a brief requirement summary.
-
----
-
-## Phase 1 — Initialize OpenSpec Change Folder
-1) Run: /opsx:new <change-name>
-2) From now on, you may write ONLY under openspec/changes/<change-name>/**.
-
----
-
-## Phase 2 — Initial Codebase Assessment (Read‑Only)
-- {{CODEBASE_RETRIEVAL_POLICY}}
-- If technical research needed (architectural patterns, best practices), invoke `/grok-search` skill
-- If the codebase spans multiple modules/directories, dispatch parallel explore subagents by context boundary.
-
----
-
-## Phase 3 — Define Exploration Boundaries (Context-Based Division Only)
-- Identify natural context boundaries in the codebase (NOT functional roles).
-- Example divisions:
-  * Subagent 1: User domain code (user models, user services, user UI)
-  * Subagent 2: Authentication & authorization code (auth middleware, session, tokens)
-  * Subagent 3: Configuration & infrastructure (configs, deployments, build scripts)
-- Each boundary should be self-contained: no cross-communication needed between subagents.
-- Define exploration scope and expected output for each subagent.
-
----
-
-## Phase 4 — Subagent Output Template (MANDATORY JSON)
-All explore subagents MUST return valid JSON using this schema:
-{
-  "module_name": "字符串 - 所探索的上下文边界",
-  "existing_structures": ["发现的关键结构/模式列表"],
-  "existing_conventions": ["当前使用的约定/标准列表"],
-  "constraints_discovered": ["限制解决方案空间的硬约束列表"],
-  "open_questions": ["需要用户输入的歧义问题列表"],
-  "dependencies": ["对其他模块/系统的依赖列表"],
-  "risks": ["潜在风险或阻碍列表"],
-  "success_criteria_hints": ["指示成功的可观察行为列表"]
-}
-
----
-
-## Phase 5 — Parallel Subagent Dispatch
-- Monitor subagent execution and collect structured reports.
-- For each boundary, spawn an Explore subagent with:
-  - {{CODEBASE_RETRIEVAL_MANDATORY_RULE}}
-  - Clear scope
-  - self-contained with independent output
-  - Required output template (from Phase 4)
-  - If boundary involves 3+ interconnected components, require explicit step-by-step dependency analysis
-  - Clear success criteria: complete analysis of assigned boundary
-
-
----
-
-## Phase 6 — Aggregate & Synthesize
-- Collect all subagent JSON outputs.
-- Merge findings into unified constraint sets:
-  * **Hard constraints**: Technical limitations, existing patterns that cannot be violated.
-  * **Soft constraints**: Conventions, preferences, style guides.
-  * **Dependencies**: Cross-module relationships that affect implementation order.
-  * **Risks**: Potential blockers that need mitigation.
-- Identify **open questions** from all reports that require user clarification.
-- Synthesize **success criteria** from scenario hints across all contexts.
-
----
-
-## Phase 7 — User Interaction for Ambiguity Resolution
-- Compile prioritized list of open questions from aggregated reports.
-- Present questions directly to the user in a concise grouped message:
-  * Group related questions together.
-  * Provide context for each question.
-  * Suggest default answers when applicable.
-- Capture user responses as additional constraints.
-- Update constraint sets with confirmed decisions.
-
----
-
-## Phase 8 — Generate OpenSpec Artifacts
-- Transform finalized constraint sets into OpenSpec proposal/specs/design/tasks.
-- Every requirement MUST have a verifiable scenario and success criteria.
-- Keep all writes inside openspec/changes/<change-name>/**.
-
-## Reference
-- Review existing constraints: `rg -n "Constraint:|MUST|MUST NOT" openspec/specs`
-- {{CODEBASE_RETRIEVAL_STRUCTURE_REFERENCE}}
-
-- Check prior research outputs: `ls openspec/changes/*/`
-- OpenSpec CLI commands:
-  - `openspec view` - Interactive dashboard to browse changes
-  - `openspec list --changes` - List all active changes
-  - `openspec status --change <name>` - Check artifact completion status
-  - `openspec instructions proposal --change <name>` - Get proposal instructions
-- Validate subagent outputs conform to template before aggregation.
-- Ask the user directly for ANY ambiguity—do not assume or guess.
-<!-- ABEL:RESEARCH:END -->

package/skills/prompt-enhancer/.env.example

@@ -1,12 +0,0 @@
-# Prompt Enhancer CLI configuration
-# Copy this file to .env and fill in the values you want to use.
-
-# Optional: third-party OpenAI-compatible base URL
-PE_API_URL=
-
-# Optional: third-party OpenAI-compatible API key
-PE_API_KEY=
-
-# Optional: model name for the third-party endpoint
-# Leave all three fields blank to use the current agent directly.
-PE_MODEL=

package/skills/prompt-enhancer/ADVANCED.md

@@ -1,103 +0,0 @@
-# Advanced Usage
-
-## Using the Python Script Directly
-
-Use the bootstrap entrypoint from the installed skill directory:
-
-```bash
-# Assuming third-party config is already set in <SKILL_DIR>/.env or the environment
-python "<SKILL_DIR>/scripts/prompt_enhancer_entry.py" "your prompt here"
-```
-
-`prompt_enhancer_entry.py` is the canonical entrypoint. It creates or reuses a skill-local virtual environment and then runs `scripts/enhance.py`.
-If `PE_API_URL`, `PE_API_KEY`, and `PE_MODEL` are not all present, do not call the script; rewrite the prompt directly with the current agent instead.
-
-## Environment Variables
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `PE_API_URL` | Third-party OpenAI-compatible base URL | - |
-| `PE_API_KEY` | Third-party OpenAI-compatible API key | - |
-| `PE_MODEL` | Model to use on the third-party endpoint | - |
-| `PE_DEBUG` | Print bootstrap and fallback diagnostics to `stderr` | `0` |
-| `PROMPT_ENHANCER_VENV_DIR` | Override the skill-local venv path | `skills/prompt-enhancer/.venv` |
-| `PROMPT_ENHANCER_PYTHON` | Python version/spec for `uv venv --python` | - |
-| `AGENTS_SKILLS_PYTHON` | Absolute path to fallback/bootstrap Python | - |
-
-## Local `.env`
-
-The CLI loads `<SKILL_DIR>/.env` automatically if present:
-
-```bash
-cp "<SKILL_DIR>/.env.example" "<SKILL_DIR>/.env"
-python "<SKILL_DIR>/scripts/prompt_enhancer_entry.py" "your prompt here"
-```
-
-## Integration with Other Tools
-
-The enhanced prompt is written to `stdout`. Usage or debug diagnostics stay on `stderr`, and bootstrap/fallback diagnostics are only emitted when `PE_DEBUG=1`.
-
-### Piping Output
-
-Assuming `PE_API_URL`, `PE_API_KEY`, and `PE_MODEL` are already configured:
-
-```bash
-# Pipe to clipboard (macOS)
-python "<SKILL_DIR>/scripts/prompt_enhancer_entry.py" "my prompt" | pbcopy
-
-# Pipe to file
-python "<SKILL_DIR>/scripts/prompt_enhancer_entry.py" "my prompt" > enhanced.md
-
-# Chain with other commands
-python "<SKILL_DIR>/scripts/prompt_enhancer_entry.py" "my prompt" | claude -p
-```
-
-### In Shell Scripts
-
-Assuming the environment is already configured:
-
-```bash
-#!/bin/bash
-ENHANCED=$(python "$HOME/.agents/skills/prompt-enhancer/scripts/prompt_enhancer_entry.py" "$1")
-echo "$ENHANCED"
-```
-
-## Manual Enhancement (Current Agent)
-
-If the user does not provide `url`, `apiKey`, and `model`, use the current agent directly and apply the enhancement principles:
-
-1. Read the user's prompt
-2. Apply the template from [TEMPLATE.md](TEMPLATE.md)
-3. Preserve every explicit user constraint
-4. Use placeholders for unknown context instead of inventing requirements
-5. Structure the output with:
-   - Context section
-   - Objective section
-   - Step-by-step instructions
-   - Constraints
-
-## Troubleshooting
-
-### Script Not Found
-Verify the canonical entrypoint exists:
-```bash
-ls "$HOME/.agents/skills/prompt-enhancer/scripts/prompt_enhancer_entry.py"
-```
-
-### Permission Denied
-Run it through Python instead of executing the file directly:
-```bash
-python "$HOME/.agents/skills/prompt-enhancer/scripts/prompt_enhancer_entry.py" "your prompt here"
-```
-
-### Show Usage
-Run the entrypoint without a prompt to print usage information:
-```bash
-python "$HOME/.agents/skills/prompt-enhancer/scripts/prompt_enhancer_entry.py"
-```
-
-### Missing Third-Party Config
-The script requires `PE_API_URL`, `PE_API_KEY`, and `PE_MODEL`. If any field is missing, skip the script and use the current agent directly.
-
-### Debug Fallbacks
-Set `PE_DEBUG=1` to show dependency-install or configuration diagnostics on `stderr`.

package/skills/prompt-enhancer/requirements.txt

@@ -1 +0,0 @@
-openai>=1.30,<2

package/skills/prompt-enhancer/scripts/_dotenv.py

@@ -1,32 +0,0 @@
-"""Shared .env loader for Prompt Enhancer scripts."""
-
-import os
-from pathlib import Path
-
-
-def load_dotenv() -> bool:
-    env_path = Path(__file__).resolve().parent.parent / ".env"
-    if not env_path.exists():
-        return False
-    try:
-        seen_keys = set()
-        with open(env_path, "r", encoding="utf-8") as f:
-            for line in f:
-                line = line.strip()
-                if not line or line.startswith("#") or "=" not in line:
-                    continue
-                key, _, value = line.partition("=")
-                key = key.strip()
-                value = value.strip()
-                if (value.startswith('"') and value.endswith('"')) or (
-                    value.startswith("'") and value.endswith("'")
-                ):
-                    value = value[1:-1]
-                if not key or key in seen_keys:
-                    continue
-                seen_keys.add(key)
-                if not os.environ.get(key):
-                    os.environ[key] = value
-        return True
-    except IOError:
-        return False