htmlgraph 0.23.0__tar.gz → 0.23.2__tar.gz

{htmlgraph-0.23.0 → htmlgraph-0.23.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlgraph
-Version: 0.23.0
+Version: 0.23.2
 Summary: HTML is All You Need - Graph database on web standards
 Project-URL: Homepage, https://github.com/Shakes-tzd/htmlgraph
 Project-URL: Documentation, https://github.com/Shakes-tzd/htmlgraph#readme

{htmlgraph-0.23.0 → htmlgraph-0.23.2}/packages/gemini-extension/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "htmlgraph",
-  "version": "0.23.0",
+  "version": "0.23.2",
   "description": "HtmlGraph session tracking and documentation for Gemini CLI. Ensures proper activity attribution, feature awareness, and continuous work tracking.",
   "author": "Shakes",
   "license": "MIT",

{htmlgraph-0.23.0 → htmlgraph-0.23.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "htmlgraph"
-version = "0.23.0"
+version = "0.23.2"
 description = "HTML is All You Need - Graph database on web standards"
 authors = [{name = "Shakes", email = "shakestzd@gmail.com"}]
 readme = "README.md"

{htmlgraph-0.23.0 → htmlgraph-0.23.2}/src/python/htmlgraph/__init__.py

@@ -84,7 +84,7 @@ from htmlgraph.types import (
 )
 from htmlgraph.work_type_utils import infer_work_type, infer_work_type_from_id
 
-__version__ = "0.23.0"
+__version__ = "0.23.2"
 __all__ = [
     # Exceptions
     "HtmlGraphError",

{htmlgraph-0.23.0 → htmlgraph-0.23.2}/src/python/htmlgraph/event_log.py

@@ -38,6 +38,22 @@ class EventRecord:
     session_status: str | None = None
     file_paths: list[str] | None = None
     payload: dict[str, Any] | None = None
+    # Phase 1: Enhanced Event Data Schema for multi-AI delegation tracking
+    delegated_to_ai: str | None = (
+        None  # "gemini", "codex", "copilot", "claude", or None
+    )
+    task_id: str | None = None  # Unique task ID for parallel tracking
+    task_status: str | None = (
+        None  # "pending", "running", "completed", "failed", "timeout"
+    )
+    model_selected: str | None = None  # Specific model (e.g., "gemini-2.0-flash")
+    complexity_level: str | None = None  # "low", "medium", "high", "very-high"
+    budget_mode: str | None = None  # "free", "balanced", "performance"
+    execution_duration_seconds: float | None = None  # How long delegation took
+    tokens_estimated: int | None = None  # Estimated token usage
+    tokens_actual: int | None = None  # Actual token usage
+    cost_usd: float | None = None  # Calculated cost
+    task_findings: str | None = None  # Results from delegated task
 
     def to_json(self) -> dict[str, Any]:
         return {
@@ -56,6 +72,18 @@ class EventRecord:
             "session_status": self.session_status,
             "file_paths": self.file_paths or [],
             "payload": self.payload,
+            # Delegation fields
+            "delegated_to_ai": self.delegated_to_ai,
+            "task_id": self.task_id,
+            "task_status": self.task_status,
+            "model_selected": self.model_selected,
+            "complexity_level": self.complexity_level,
+            "budget_mode": self.budget_mode,
+            "execution_duration_seconds": self.execution_duration_seconds,
+            "tokens_estimated": self.tokens_estimated,
+            "tokens_actual": self.tokens_actual,
+            "cost_usd": self.cost_usd,
+            "task_findings": self.task_findings,
         }
 
 

{htmlgraph-0.23.0 → htmlgraph-0.23.2}/src/python/htmlgraph/hooks/orchestrator.py

@@ -107,6 +107,23 @@ def is_allowed_orchestrator_operation(tool: str, params: dict) -> tuple[bool, st
         - reason_if_not: Explanation if blocked (empty if allowed)
         - category: Operation category for logging
     """
+    # Get enforcement level from manager
+    try:
+        cwd = Path.cwd()
+        graph_dir = cwd / ".htmlgraph"
+        if not graph_dir.exists():
+            for parent in [cwd.parent, cwd.parent.parent, cwd.parent.parent.parent]:
+                candidate = parent / ".htmlgraph"
+                if candidate.exists():
+                    graph_dir = candidate
+                    break
+        manager = OrchestratorModeManager(graph_dir)
+        enforcement_level = (
+            manager.get_enforcement_level() if manager.is_enabled() else "guidance"
+        )
+    except Exception:
+        enforcement_level = "guidance"
+
     # Use OrchestratorValidator for comprehensive validation
     validator = OrchestratorValidator()
     result, reason = validator.validate_tool_use(tool, params)
@@ -121,6 +138,10 @@ def is_allowed_orchestrator_operation(tool: str, params: dict) -> tuple[bool, st
     if tool in ["Task", "AskUserQuestion", "TodoWrite"]:
         return True, "", "orchestrator-core"
 
+    # FIX #2: Block Skills in strict mode (must be invoked via Task delegation)
+    if tool == "Skill" and enforcement_level == "strict":
+        return False, "Skills must be invoked via Task delegation", "skill-blocked"
+
     # Category 2: SDK Operations - Always allowed
     if tool == "Bash":
         command = params.get("command", "")
@@ -141,11 +162,51 @@ def is_allowed_orchestrator_operation(tool: str, params: dict) -> tuple[bool, st
         if "from htmlgraph import" in command or "import htmlgraph" in command:
             return True, "", "sdk-inline"
 
+        # FIX #3: Check if bash command is in allowed whitelist (strict mode only)
+        # If we've gotten here, it's not a whitelisted command above
+        # Block non-whitelisted bash commands in strict mode
+        if enforcement_level == "strict":
+            # Check if it's a blocked test/build pattern (handled below)
+            blocked_patterns = [
+                r"^npm (run|test|build)",
+                r"^pytest",
+                r"^uv run pytest",
+                r"^python -m pytest",
+                r"^cargo (build|test)",
+                r"^mvn (compile|test|package)",
+                r"^make (test|build)",
+            ]
+            is_blocked_pattern = any(
+                re.match(pattern, command) for pattern in blocked_patterns
+            )
+
+            if not is_blocked_pattern:
+                # Not a specifically blocked pattern, but also not whitelisted
+                # In strict mode, we should delegate
+                return (
+                    False,
+                    f"Bash command not in allowed list. Delegate to subagent.\n\n"
+                    f"Command: {command[:100]}",
+                    "bash-blocked",
+                )
+
     # Category 3: Quick Lookups - Single operations only
     if tool in ["Read", "Grep", "Glob"]:
         # Check tool history to see if this is a single lookup or part of a sequence
         history = load_tool_history()
 
+        # FIX #4: Check for mixed exploration pattern
+        exploration_count = sum(
+            1 for h in history[-5:] if h["tool"] in ["Read", "Grep", "Glob"]
+        )
+        if exploration_count >= 3 and enforcement_level == "strict":
+            return (
+                False,
+                "Multiple exploration calls detected. Delegate to Explorer agent.\n\n"
+                "Use Task tool with explorer subagent.",
+                "exploration-blocked",
+            )
+
         # Look at last 3 tool calls
         recent_same_tool = sum(1 for h in history[-3:] if h["tool"] == tool)
 
@@ -181,7 +242,7 @@ def is_allowed_orchestrator_operation(tool: str, params: dict) -> tuple[bool, st
         command = params.get("command", "")
 
         # Block compilation, testing, building (should be in subagent)
-        blocked_patterns = [
+        test_build_patterns: list[tuple[str, str]] = [
             (r"^npm (run|test|build)", "npm test/build"),
             (r"^pytest", "pytest"),
             (r"^uv run pytest", "pytest"),
@@ -191,7 +252,7 @@ def is_allowed_orchestrator_operation(tool: str, params: dict) -> tuple[bool, st
             (r"^make (test|build)", "make test/build"),
         ]
 
-        for pattern, name in blocked_patterns:
+        for pattern, name in test_build_patterns:
             if re.match(pattern, command):
                 return (
                     False,
@@ -200,8 +261,11 @@ def is_allowed_orchestrator_operation(tool: str, params: dict) -> tuple[bool, st
                     "test-build-blocked",
                 )
 
-    # Default: Allow with guidance
-    return True, "Allowed but consider if delegation would be better", "allowed-default"
+    # FIX #1: Remove "allowed-default" escape hatch in strict mode
+    if enforcement_level == "strict":
+        return False, "Not in allowed whitelist", "strict-blocked"
+    else:
+        return True, "Allowed in guidance mode", "guidance-allowed"
 
 
 def create_task_suggestion(tool: str, params: dict) -> str:

htmlgraph-0.23.2/src/python/htmlgraph/orchestrator-system-prompt-optimized.txt

@@ -0,0 +1,92 @@
+# ORCHESTRATOR SYSTEM PROMPT
+
+**Core Principle:** Delegation > Direct Execution. Cascading failures consume exponentially more context than structured delegation.
+
+## What is HtmlGraph?
+
+Lightweight graph database for AI coordination and human observability. HTML files = nodes, hyperlinks = edges, CSS selectors = queries. Zero dependencies, offline-first. Use SDK for ALL operations tracking.
+
+## Operation Backbone: HtmlGraph + Git
+
+ALWAYS use both:
+- **HtmlGraph SDK**: Track what you're doing (features, spikes, sessions, analytics)
+- **Git**: Track code changes, commits, attribution
+- Together: Complete project history + observability
+
+## Speed & Currency
+
+- Use WebSearch for up-to-date information (check current date/time)
+- Use scripting (Python, Bash) for automation
+- Prefer web lookups over assumptions for time-sensitive tasks
+
+## Spec-Driven Development
+
+Write specs before implementation:
+- Use TrackBuilder for multi-feature planning
+- Document requirements and acceptance criteria
+- Pattern: Plan → Implement → Validate
+
+## Testing Philosophy
+
+- UI testing: Use browser automation tools (Chrome MCP)
+- Test incrementally, not at the end
+- Automated testing is non-negotiable
+- Quality gates: ruff, mypy, pytest
+
+## Layered Planning Model
+
+Delegate planning based on complexity and inputs:
+
+1. **Exploration** → Gemini (affordable, high context)
+   - Broad research, codebase exploration, options analysis
+
+2. **Strategic Planning** → Claude Opus (concrete inputs needed)
+   - High-level architecture, elegant solutions, critical decisions
+
+3. **Coordination** → Claude Sonnet (mid-level)
+   - Feature orchestration, multi-component decisions
+
+4. **Execution** → Haiku (tactical)
+   - Implementation, file operations, testing
+
+Execute directly ONLY:
+- SDK operations (feature/spike creation)
+- User clarification (AskUserQuestion)
+- TodoWrite (task tracking)
+
+## Delegate Everything Else
+
+Git, code changes, testing, research, deployment - DELEGATE.
+
+**Context cost:** Direct = 7+ tool calls | Delegation = 2 tool calls
+
+## Quick Decision Tree
+
+1. SDK/TodoWrite/User question? → Execute directly
+2. Exploration/research? → Delegate to Gemini
+3. Strategic planning (with inputs)? → Delegate to Opus
+4. Everything else → DELEGATE (Sonnet/Haiku)
+
+## Spawner Selection (Brief)
+
+- Code work → `/multi-ai-orchestration` skill
+- Images/analysis → spawn_gemini
+- Git/PRs → spawn_copilot
+- Complex reasoning → spawn_claude
+
+For detailed spawner selection, cost analysis, and patterns:
+→ Use `/multi-ai-orchestration` skill
+
+## HtmlGraph Integration
+
+```python
+sdk = SDK(agent="orchestrator")
+feature = sdk.features.create("Title").save()
+Task(prompt="...", description="...")
+```
+
+For complete patterns: → Use `/orchestrator-directives` skill
+
+---
+
+**Key Insight:** Smart routing → fewer tool calls → better context → faster resolution.