pascal-agent 0.8.2__tar.gz → 1.0.1__tar.gz

{pascal_agent-0.8.2 → pascal_agent-1.0.1}/.gitignore

@@ -36,3 +36,4 @@ runs/
 artifacts/
 scratch/
 .gstack/
+.pascal_tmp/

{pascal_agent-0.8.2 → pascal_agent-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pascal-agent
-Version: 0.8.2
+Version: 1.0.1
 Summary: Pascal — autonomous AI employee runtime
 Project-URL: Homepage, https://gitlab.com/laum0621/pascal
 Project-URL: Repository, https://gitlab.com/laum0621/pascal

pascal_agent-1.0.1/docs/specs/2026-03-29-prompt-schema-runtime-redesign.md

@@ -0,0 +1,76 @@
+# Pascal Agent — Prompt/Schema/Runtime Redesign Spec
+
+**Date:** 2026-03-29
+**Status:** Approved
+**Authors:** GPT 5.4 Pro (architecture), Claude Opus 4.6 (refinement + implementation spec)
+
+## Summary
+
+Fix 7 critical bugs by enforcing a single invariant: the tool schema is the sole source of truth for what the LLM can do, and every tool result is an unambiguous success or failure.
+
+- **Prompt** = identity and policy (who Pascal is, how to prioritize)
+- **Schema** = capability (what tools exist, what params they accept)
+- **Desk** = state (what's happening right now)
+- **Runtime** = contracts (validation before dispatch, honest errors after)
+
+These four layers never overlap.
+
+## The 7 Bugs and Their Structural Fixes
+
+| Bug | Root Cause | Fix | Layer |
+|-----|-----------|-----|-------|
+| #1 Tool name = action | `action` param collides with tool name | Rename to `op` + enum validation + delete silent auto-correct | Schema + Runtime |
+| #2 Same URL 6x | In-memory stagnation, exact string match | DB-persisted stagnation with URL normalization | Runtime |
+| #3 notif_ as task_id | No ID format validation | `pattern: "^task_"` + runtime rejection | Schema + Runtime |
+| #4 Percent-encoding | Rule buried in prompt | Rule in shell tool description + runtime error on % | Schema + Runtime |
+| #5 Think loops | 4-think threshold, resets on restart | 2-think threshold, DB-persisted | Runtime |
+| #6 channel_reply in CLI | Tool exists but silently fails | Excluded from CLI schema + reply_sent=false is error | Schema + Runtime |
+| #7 Repeat after compaction | Compaction drops failure memory | Do Not Repeat from DB + compaction includes Failed Approaches | Desk + Runtime |
+
+## Migration Phases
+
+### Phase 1: Stop the Bleeding
+1. Delete silent auto-correction in tools.py
+2. Add normalize_result() post-dispatch
+3. Add task_id validation in pick_task handler
+
+### Phase 2: Schema Overhaul
+4. Rename action -> op on computer, editor, uia
+5. Add uia to schema as first-class tool
+6. Replace preset system with mode-based build_tool_schemas(mode, has_mcp)
+7. Add additionalProperties: false to all schemas
+
+### Phase 3: Runtime Hardening
+8. Add validate_tool_call() pre-dispatch
+9. Create stagnation_log DB table, replace in-memory detection
+10. Lower think threshold to 2, persist in DB
+
+### Phase 4: Desk & Prompt
+11. Rewrite SYSTEM_PROMPT to ~800 tokens
+12. Add Do Not Repeat section to desk render
+13. Remove tool lists from desk
+14. Update compaction prompt for Failed Approaches
+
+### Phase 5: Verification
+15. Replay audit.jsonl scenarios against new system
+16. Add regression tests
+
+## Key Design Decisions
+
+1. **op rename over atomic tools**: 3-line fix vs 38-tool explosion. Same bug prevention, far less complexity.
+2. **think kept with 2-consecutive limit**: Model needs reasoning ability, just not infinite loops.
+3. **LLM compaction summary kept**: Adds Failed Approaches section rather than replacing with pure deterministic resume.
+4. **Shell kept for URLs**: Runtime validates percent-encoding rather than creating new browser_search tool.
+5. **Legacy plan steps kept**: Auto-wrapped into tree for backward compat.
+
+## Files Changed
+
+| File | Change |
+|------|--------|
+| schemas.py | Rewrite: action->op, mode-based, uia added, additionalProperties:false |
+| prompt.py | Rewrite to ~800 tokens |
+| desk.py | Add Do Not Repeat, remove tool lists |
+| loop.py | Add validate/normalize, DB stagnation, mode presets, read op not action |
+| tools.py | Delete silent auto-correct, fix channel_reply error handling |
+| state.py | Add stagnation_log table |
+| actions.py | Read params["op"] not params["action"] |

pascal_agent-1.0.1/docs/superpowers/plans/2026-03-29-computer-surface-simplification.md

@@ -0,0 +1,290 @@
+# Computer Surface Simplification Implementation Plan
+
+> **For agentic workers:** REQUIRED: Use superpowers:subagent-driven-development (if subagents available) or superpowers:executing-plans to implement this plan. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make `computer` the only model-visible desktop interface while keeping Windows UIA code as an internal, quarantined implementation detail until a later cleanup pass.
+
+**Architecture:** Collapse the public desktop contract onto `computer` so the prompt, tool schema, desk text, and runtime registry all tell the same story: screenshot-first, coordinate-driven interaction. Do not hard-delete `src/pascal/uia.py` in the same pass. Instead, remove `uia` from the model-facing surface and leave a narrow compatibility path that returns a redirect/error if legacy action payloads still reference it.
+
+**Tech Stack:** Python 3.12+, pytest, pyautogui, optional pywinauto, Pascal's existing tool schema + action dispatcher architecture.
+
+---
+
+## Step 0
+
+### Scope Challenge
+
+- Existing code already solves the main interaction problem through `computer` in [prompt.py](C:\Users\laum3\Downloads\Pascal\src\pascal\prompt.py), [schemas.py](C:\Users\laum3\Downloads\Pascal\src\pascal\schemas.py), and [tools.py](C:\Users\laum3\Downloads\Pascal\src\pascal\tools.py).
+- Existing code also still exposes a second desktop control language through `uia`, `ref`, and snapshot-driven control in [actions.py](C:\Users\laum3\Downloads\Pascal\src\pascal\actions.py), [tools.py](C:\Users\laum3\Downloads\Pascal\src\pascal\tools.py), and [uia.py](C:\Users\laum3\Downloads\Pascal\src\pascal\uia.py).
+- This is already a coherence bug: [test_loop.py](C:\Users\laum3\Downloads\Pascal\tests\test_loop.py) expects the minimal preset to exclude `uia`, while the runtime still carries it in several public places.
+- Minimum viable change is not "delete all UIA code." Minimum viable change is "remove UIA from the public contract and align every exposed layer around `computer`."
+- Full deletion of `uia.py` is a second-phase cleanup, not part of this plan. Doing both in one pass mixes interface surgery with backend removal and increases rollback cost.
+
+### What Already Exists
+
+- `computer` already covers screenshot, click, type, hotkey, and scroll.
+- The prompt already teaches the model a screenshot-first coordinate loop.
+- `uia.py` is already isolated in one file plus related helpers in `tools.py`.
+- The test suite already has one explicit signal that `uia` should not be in the minimal tool preset.
+
+### Not In Scope
+
+- Full deletion of [uia.py](C:\Users\laum3\Downloads\Pascal\src\pascal\uia.py).
+- Designing a new semantic desktop abstraction on top of accessibility APIs.
+- Adding browser DOM/CDP automation as a first-class backend.
+- Reworking the sandbox failures currently isolated in `tests/test_sandbox_budget.py`.
+
+## Chunk 1: Align The Public Contract
+
+### Task 1: Remove `uia` from the model-facing prompt/schema/desk surface
+
+**Files:**
+- Modify: `C:\Users\laum3\Downloads\Pascal\src\pascal\prompt.py`
+- Modify: `C:\Users\laum3\Downloads\Pascal\src\pascal\desk.py`
+- Modify: `C:\Users\laum3\Downloads\Pascal\src\pascal\schemas.py`
+- Test: `C:\Users\laum3\Downloads\Pascal\tests\test_loop.py`
+
+- [ ] **Step 1: Write the failing tests that define the new public contract**
+
+Add or update assertions in `tests/test_loop.py` so they verify:
+
+```python
+tool_names = {t["function"]["name"] for t in build_tool_schemas(preset="minimal")}
+assert "uia" not in tool_names
+
+standard_names = {t["function"]["name"] for t in build_tool_schemas(preset="standard")}
+assert "uia" not in standard_names
+
+full_names = {t["function"]["name"] for t in build_tool_schemas(preset="full")}
+assert "uia" not in full_names
+
+prompt = runner._render_system_prompt("minimal")
+assert "UIA first" not in prompt
+assert "screenshot fallback" not in prompt
+assert "computer(action=\"click\"" in prompt
+```
+
+- [ ] **Step 2: Run the focused test and confirm it fails for the right reason**
+
+Run:
+
+```powershell
+python -m pytest -q tests/test_loop.py::TestDeskRendering::test_minimal_prompt_keeps_desktop_and_notification_guidance
+```
+
+Expected: FAIL because some combination of schema, prompt, or desk text still exposes `uia`.
+
+- [ ] **Step 3: Update the public contract**
+
+Implement the smallest coherent diff:
+
+- Remove `uia` from every preset in `schemas.py`.
+- Remove `UIA first` and other UIA-first guidance from `desk.py`.
+- Remove public prompt language that suggests `uia` is a model-visible action.
+- Keep the screenshot-first `computer` guidance intact and explicit.
+
+- [ ] **Step 4: Re-run the focused test and confirm it passes**
+
+Run:
+
+```powershell
+python -m pytest -q tests/test_loop.py::TestDeskRendering::test_minimal_prompt_keeps_desktop_and_notification_guidance
+```
+
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add tests/test_loop.py src/pascal/prompt.py src/pascal/desk.py src/pascal/schemas.py
+git commit -m "refactor: remove uia from public desktop contract"
+```
+
+## Chunk 2: Remove The Public Runtime Entry Point
+
+### Task 2: Stop treating `uia` as a first-class public action
+
+**Files:**
+- Modify: `C:\Users\laum3\Downloads\Pascal\src\pascal\actions.py`
+- Modify: `C:\Users\laum3\Downloads\Pascal\src\pascal\tools.py`
+- Test: `C:\Users\laum3\Downloads\Pascal\tests\test_actions.py`
+- Test: `C:\Users\laum3\Downloads\Pascal\tests\test_tools.py`
+
+- [ ] **Step 1: Write failing tests for the runtime surface**
+
+Add tests that express the intended boundary:
+
+```python
+from pascal.tools import TOOL_REGISTRY
+assert "uia" not in TOOL_REGISTRY
+
+result = await execute_action(
+    store,
+    {"action": "click", "ref": "e1"},
+    "uia",
+    max_effect="E2",
+)
+assert result["status"] == "error"
+assert "use computer" in result["error"].lower()
+```
+
+Also update the old registry expectation:
+
+```python
+for action in ("shell", "editor", "computer", "code", "channel_reply", "execute"):
+    assert action in ACTION_HANDLERS
+assert "uia" not in ACTION_HANDLERS
+```
+
+- [ ] **Step 2: Run the targeted tests to verify the old public surface still exists**
+
+Run:
+
+```powershell
+python -m pytest -q tests/test_actions.py tests/test_tools.py
+```
+
+Expected: FAIL because `uia` is still registered and still behaves like a first-class action/tool.
+
+- [ ] **Step 3: Apply the runtime boundary change**
+
+Implement the public-surface removal with backwards-compatible failure semantics:
+
+- Remove `uia` from `ACTION_HANDLERS` and `VALID_ACTIONS`.
+- Remove `uia` from `TOOL_REGISTRY`, `TOOL_EFFECTS`, and `_TOOL_SUBACTION_EFFECTS`.
+- Keep private UIA helper functions in `tools.py` if they are still referenced internally or likely to be reused later.
+- Add a narrow legacy-compat path in `execute_action()` or a dedicated shim so if older persisted plan/action payloads call `uia`, the runtime returns a clear structured error such as:
+
+```python
+{"error": "The public 'uia' action was removed. Use computer screenshot/click/type flow instead.", "status": "error"}
+```
+
+This keeps rollback and migration safer than deleting the codepath outright.
+
+- [ ] **Step 4: Re-run the targeted tests**
+
+Run:
+
+```powershell
+python -m pytest -q tests/test_actions.py tests/test_tools.py
+```
+
+Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add tests/test_actions.py tests/test_tools.py src/pascal/actions.py src/pascal/tools.py
+git commit -m "refactor: remove public uia runtime entry points"
+```
+
+## Chunk 3: Quarantine UIA As Internal Code
+
+### Task 3: Keep UIA code importable, but mark it internal and stop testing it as public API
+
+**Files:**
+- Modify: `C:\Users\laum3\Downloads\Pascal\src\pascal\uia.py`
+- Modify: `C:\Users\laum3\Downloads\Pascal\tests\test_uia.py`
+
+- [ ] **Step 1: Rewrite the module and test intent around internal use**
+
+Update module docstrings and tests so they stop claiming UIA is a public tool family.
+
+Examples:
+
+```python
+"""Internal Windows UI Automation helpers.
+
+This module is not part of Pascal's model-visible tool surface.
+It remains available for future internal desktop backends and operator-only integrations.
+"""
+```
+
+And in tests:
+
+```python
+def test_uia_is_not_in_public_tool_registry():
+    from pascal.tools import TOOL_REGISTRY
+    assert "uia" not in TOOL_REGISTRY
+```
+
+Keep the unit tests for `UIElement`, ref assignment, stale-ref handling, and renderer helpers if the file remains in-tree. Those tests now validate a private utility module, not a public runtime surface.
+
+- [ ] **Step 2: Run the focused UIA test module**
+
+Run:
+
+```powershell
+python -m pytest -q tests/test_uia.py
+```
+
+Expected: PASS.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add tests/test_uia.py src/pascal/uia.py
+git commit -m "test: quarantine uia as internal helper module"
+```
+
+## Chunk 4: Document The New Boundary And Verify The Suite
+
+### Task 4: Update docs and verify the coherent desktop story end to end
+
+**Files:**
+- Modify: `C:\Users\laum3\Downloads\Pascal\README.md`
+- Modify: `C:\Users\laum3\Downloads\Pascal\ARCHITECTURE.md`
+
+- [ ] **Step 1: Update docs to match the new contract**
+
+Make the docs say:
+
+- public desktop interaction is `computer`
+- UIA may still exist internally for Windows-specific backend work
+- model-visible desktop reasoning is screenshot-first and coordinate-driven
+
+Do not claim `uia` is still a public tool/action.
+
+- [ ] **Step 2: Run the focused desktop-control regression suite**
+
+Run:
+
+```powershell
+python -m pytest -q tests/test_loop.py tests/test_actions.py tests/test_tools.py tests/test_uia.py
+```
+
+Expected: PASS.
+
+- [ ] **Step 3: Run the full suite to compare against baseline**
+
+Run:
+
+```powershell
+python -m pytest -q
+```
+
+Expected:
+
+- no new failures in loop/action/tool/UIA areas
+- existing baseline may still include the current sandbox failures in `tests/test_sandbox_budget.py` unless fixed separately
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add README.md ARCHITECTURE.md tests/test_loop.py tests/test_actions.py tests/test_tools.py tests/test_uia.py
+git commit -m "docs: clarify computer-only desktop surface"
+```
+
+## Failure Modes To Watch
+
+- Legacy persisted actions or plans may still contain `"uia"` and need a structured redirect instead of a crash.
+- Tests may still encode contradictory assumptions, especially around public registry vs minimal schema.
+- Documentation drift can reintroduce the old mixed mental model even if runtime behavior is correct.
+- If coordinate-only desktop flows prove too brittle in real Windows app automation, this plan must not delete internal UIA code prematurely.
+
+## Why This Plan Is The Recommended Shape
+
+- It reduces public complexity without giving up the option of internal Windows-specific capability later.
+- It makes the prompt, schema, registry, and tests all agree on one desktop language.
+- It keeps the diff targeted: interface simplification first, backend deletion later if still warranted.
+- It is reversible. If the simplification hurts real-world automation quality, reintroducing an internal backend is far cheaper than restoring a deleted subsystem from scratch.

pascal_agent-1.0.1/docs/superpowers/specs/2026-03-29-pascal-analysis-package-design.md

@@ -0,0 +1,67 @@
+# Pascal Analysis And Packaging Design
+
+## Goal
+
+Produce two user-facing artifacts for the local Pascal workspace snapshot:
+
+1. A single master Markdown document in `C:\Users\laum3\Downloads` that allows an experienced engineer to understand the project's structure, architecture, runtime model, safety model, and operational behavior without re-deriving them from source.
+2. A clean distributable zip in `C:\Users\laum3\Downloads` containing the Pascal project source snapshot, tests, core docs, packaging metadata, and the new master guide, while excluding VCS state, caches, local virtual environments, and generated artifacts.
+
+## Approved Direction
+
+- Use a code-grounded reverse-engineering approach rather than rephrasing existing docs.
+- Treat `README.md`, `ARCHITECTURE.md`, `pyproject.toml`, `src/pascal/**`, and `tests/**` as the analysis basis.
+- Structure the master guide so a reader can move from high-level system purpose to low-level execution paths and quality signals.
+- Build the zip from a clean staging copy so the source workspace is not mutated during packaging.
+
+## Deliverables
+
+### Master guide
+
+- Format: Markdown
+- Output location: `C:\Users\laum3\Downloads\Pascal_Master_Guide_2026-03-29.md`
+- Required sections:
+  - Executive summary
+  - Repository map
+  - Runtime architecture
+  - Core module responsibilities
+  - State and data model
+  - Safety model
+  - LLM and tool integration
+  - Execution flows
+  - Testing and quality signals
+  - Deployment artifact policy
+
+### Clean distribution zip
+
+- Output location: `C:\Users\laum3\Downloads\Pascal_Clean_Distribution_2026-03-29.zip`
+- Must include:
+  - `src/`
+  - `tests/`
+  - `README.md`
+  - `ARCHITECTURE.md`
+  - `pyproject.toml`
+  - `.gitignore`
+  - `.gitlab-ci.yml`
+  - A copy of the master guide as `PASCAL_MASTER_GUIDE.md`
+- Must exclude:
+  - `.git/`
+  - `.audit-venv-*`
+  - `.mypy_cache/`
+  - `.pytest_cache/`
+  - `.ruff_cache/`
+  - `dist/`
+  - `__pycache__/`
+  - local temporary files and other generated artifacts
+
+## Analysis Principles
+
+- Prefer code over stale prose when sources disagree.
+- Preserve the fact that this snapshot includes local uncommitted changes if they are present in the workspace.
+- Record runtime validation signals from an actual local test run when feasible.
+- Keep the document useful for handoff, not just for marketing or onboarding.
+
+## Implementation Notes
+
+- The packaged snapshot should reflect the current local workspace content, including uncommitted source edits, but not development debris.
+- The master guide should explicitly call out documentation drift where found, especially version or test-count mismatches.

pascal_agent-1.0.1/gpt-pro-prompt.md

@@ -0,0 +1,101 @@
+# Pascal Agent — Full Prompt/Schema/Runtime Redesign
+
+## Your Role
+You are the architect for Pascal, an autonomous AI employee runtime. Your job is to redesign the **prompt system, tool schema contract, and runtime feedback loop** from scratch, using the architectural patterns from Claude Code, Codex CLI, and Anthropic CU as reference.
+
+## Current State: Broken
+
+Pascal is currently non-functional ("폐기물 수준"). The audit log reveals 7 critical failure modes that all stem from one root cause: **the prompt, schema, and runtime layers have no shared contract**.
+
+### 7 Failure Modes (from audit.jsonl analysis)
+
+1. **Tool Name = Action confusion**: LLM calls `computer(action="computer")` instead of `computer(action="screenshot")`, and `uia(action="uia")` instead of `uia(action="snapshot")`. The runtime **silently auto-corrects** this in tools.py, hiding the error from the LLM so it never learns.
+
+2. **Same URL opened 6+ times**: YouTube search for "랄로" opened 6 times across compactions. Stagnation detection uses exact string match, so `start chrome "url"` vs `start chrome url` (with/without quotes) bypasses it. Runner restart also resets the counter.
+
+3. **Notification ID confused with Task ID**: LLM calls `pick_task(task_id="notif_64c796401e")` — notifications and tasks look identical in the desk render.
+
+4. **URL percent-encoding despite explicit rule**: Prompt says "use raw text, not percent-encoding" but it's buried in line 89 of 165 and LLM ignores it.
+
+5. **Think loops**: 3-4 consecutive `think` actions before any real action. The runtime allows 4 before blocking, and the counter resets on runner restart.
+
+6. **channel_reply in CLI mode**: Returns `reply_sent: false` but NOT as an error. Notification is marked as handled even though nothing was sent. LLM thinks it succeeded.
+
+7. **Same actions repeated after context compaction**: Compaction summary doesn't preserve what was already tried/failed, so the LLM starts over.
+
+## Reference Architectures Analyzed
+
+### Codex CLI (GPT 5.4, Rust) — verified against source
+- **Prompt**: Single `prompt.md` compiled via `include_str!()`. Model-specific variations via runtime template substitution. Organized: Identity → How You Work → Planning → Task Execution → Validation → Tool Guidelines.
+- **Schema**: `ToolSpec` enum (6 variants: Function, ToolSearch, LocalShell, ImageGeneration, WebSearch, Freeform). Tools are JSON schemas (`ToolDefinition` → `ResponsesApiTool`) passed separately from prompt in the `Prompt` struct's `tools` field.
+- **Key pattern**: Prompt provides **narrative guidance** (when to use tools), schema provides **structure** (how to call them). They don't repeat each other.
+- **Anti-confusion**: Explicit warning `"NEVER try applypatch or apply-patch, only apply_patch"` (verbatim in prompt.md).
+- **Loop**: `submission_loop()` → `spawn_turn()` → stream `ResponseEvent`s → tool execution → continue if `sess.has_pending_input()`.
+- **Error handling**: Tool errors injected directly into conversation history as `FunctionCallOutput`. No silent corrections.
+- **Stagnation**: Token budget enforces progress. Compact task runs automatically.
+
+### Anthropic CU (Claude, Python) — verified against docs + reference impl
+- **Tool**: Anthropic-defined tool type (`computer_20250124` or `computer_20251124` depending on model). Schema is built into the model and unmodifiable — you pass the tool type but NOT an input_schema. 16 actions total (screenshot, left_click, type, key, mouse_move, scroll, left_click_drag, right_click, middle_click, double_click, triple_click, left_mouse_down, left_mouse_up, hold_key, wait, zoom).
+- **Anti-screenshot-loop**: Explicit prompt: "After each step, take a screenshot and carefully evaluate... Only when you confirm a step was executed correctly should you move on."
+- **Loop**: Simple `while True` loop. No tool calls = done. No built-in max_iterations (documentation example shows it but reference implementation does not enforce it).
+- **Error handling**: `is_error: true` flag in tool results. Clear signal. 466-499 tokens system prompt overhead.
+- **Anti-stagnation**: No built-in deduplication or watchdog. The harness developer is responsible for implementing these.
+
+### Claude Code (Claude, TypeScript)
+- **Loop**: 15 lines. No tool calls = done (`stop_reason`).
+- **Tools = Actions**: No meta-tool or wrapper. Each tool IS the action.
+- **Termination**: `stop_reason="end_turn"` — single check.
+
+## What I Need From You
+
+Design a new prompt/schema/runtime contract for Pascal that makes these bugs **structurally impossible**. Not "add more instructions to the prompt" — redesign the architecture.
+
+### Deliverables
+
+#### 1. New Schema Architecture
+- How should Pascal's tool schemas be structured?
+- Should `action` field be renamed to avoid tool-name confusion? (e.g., `op`, `sub_action`)
+- Should `uia` be a real schema tool or removed?
+- How should tool descriptions relate to the system prompt?
+- Should the prompt reference tools at all, or let schemas be self-documenting?
+
+#### 2. New System Prompt Architecture
+- What sections should exist and in what order?
+- How should the prompt be modular (always-present vs. contextual)?
+- What should the desk render include vs. exclude?
+- How should mode awareness work (CLI vs daemon)?
+- How should anti-patterns be communicated?
+- Target token budget?
+
+#### 3. New Runtime Contract
+- How should tool errors be reported? (never silent)
+- How should stagnation detection work across compactions?
+- How should compaction preserve failure memory?
+- How should channel_reply behave in CLI mode? (not in schema? hard error?)
+- How should pick_task validate task IDs?
+- What validation should happen before tool dispatch?
+
+#### 4. Desk Render Redesign
+- What should the desk show each iteration?
+- How should it differ between full render and delta render?
+- Should it include tool documentation or leave that to schemas?
+- How should mode/environment be displayed?
+
+### Constraints
+- Model: GPT-5.4 via Codex Responses API (OpenAI function calling)
+- Platform: Windows 11 (cmd.exe shell, NOT PowerShell/bash)
+- Tools: shell, editor, computer, uia, code, channel_reply, + meta tools (plan, delegate, etc.)
+- Must support both CLI (one-shot) and daemon (Telegram) modes
+- Korean + English bilingual user
+- Simplicity first — 3 lines over a module, no over-engineering
+
+### Output Format
+Provide:
+1. **Architecture overview** — one paragraph summary of the new contract
+2. **Schema definitions** — actual JSON tool schemas (or pseudocode)
+3. **System prompt draft** — actual text, not description of text
+4. **Desk render spec** — what sections, what order, what conditions
+5. **Runtime validation rules** — what checks happen before/after tool dispatch
+6. **Migration path** — what to change first, second, third
+
+Focus on making bugs structurally impossible rather than adding more prompt instructions to prevent them.

{pascal_agent-0.8.2 → pascal_agent-1.0.1}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["src/pascal"]
 
 [project]
 name = "pascal-agent"
-version = "0.8.2"
+version = "1.0.1"
 description = "Pascal — autonomous AI employee runtime"
 readme = "README.md"
 license = {text = "MIT"}

{pascal_agent-0.8.2 → pascal_agent-1.0.1}/src/pascal/__init__.py

@@ -1,3 +1,3 @@
 """Pascal -- autonomous AI employee built on a working-document loop."""
 
-__version__ = "0.8.2"
+__version__ = "1.0.1"

{pascal_agent-0.8.2 → pascal_agent-1.0.1}/src/pascal/__main__.py

@@ -951,58 +951,6 @@ def _print_banner() -> None:
     print()
 
 
-async def _run_one_task(task: str, config, *, force_task: bool = False) -> None:
-    """Run a single task through the loop.
-
-    force_task=True: always create as task (one-shot CLI mode).
-    force_task=False: push as notification, let LLM decide (REPL mode).
-    """
-    global _active_model
-    _active_model = config.model
-    store = PascalStore(config.db_path)
-    if force_task:
-        store.add_task(task, source="cli")
-    else:
-        # Let the LLM decide: casual chat → reply, real work → create_task
-        store.push_notification(
-            source="user",
-            message=task,
-            priority="normal",
-            event_type="user_message",
-        )
-
-    from pascal.config import create_llm
-    llm = create_llm(config)
-
-    ledger_path = Path(config.db_path).expanduser().parent / "audit.jsonl"
-    ledger = Ledger(str(ledger_path))
-
-    from pascal.mcp import MCPManager
-    mcp_manager = MCPManager()
-    mcp_configs = _load_mcp_configs(config)
-    if mcp_configs:
-        try:
-            await mcp_manager.connect_all(mcp_configs)
-        except Exception:
-            pass  # MCP is optional
-
-    _start_spinner("thinking...")
-    try:
-        await _run_loop_until_idle(
-            store, llm, verifier_llm=llm, ledger=ledger,
-            mcp_manager=mcp_manager if mcp_manager.connected_servers else None,
-            max_effect=config.max_effect,
-            max_tool_rounds=_resolve_max_tool_rounds(config, None, daemon_mode=False),
-            on_action=_print_action,
-        )
-    finally:
-        _stop_spinner()
-        try:
-            await mcp_manager.disconnect_all()
-        except Exception:
-            pass
-        store.close()
-
 
 def _interactive() -> None:
     """Interactive REPL mode -- persistent context, like Claude Code / Codex CLI."""