diff --git a/agent_core/core/impl/event_stream/event_stream.py b/agent_core/core/impl/event_stream/event_stream.py
index 81d71cc3..a5d3162a 100644
--- a/agent_core/core/impl/event_stream/event_stream.py
+++ b/agent_core/core/impl/event_stream/event_stream.py
@@ -37,6 +37,13 @@
# leaving the action displayed as "running" forever.
MIN_KEEP_RECENT_EVENTS = 2
+# Event kinds that summarization must NEVER collapse — they are kept verbatim in
+# tail_events forever, so the contract they carry survives any number of
+# summarization passes. `requirements` (from set_requirement) defines the task's
+# scope/definition-of-done and lives ONLY in the event stream, so losing it to a
+# summary would drop the agent's success criteria. Add other kinds here to pin them.
+PROTECTED_SUMMARY_KINDS = frozenset({"requirements"})
+
def get_cached_token_count(rec: "EventRecord") -> int:
"""Get token count for an EventRecord, using cached value if available.
@@ -303,12 +310,18 @@ def summarize_by_LLM(self) -> None:
# Nothing old enough to summarize
return
- chunk = list(self.tail_events[:cutoff])
- first_ts = chunk[0].ts if chunk else None
- last_ts = chunk[-1].ts if chunk else None
- window = ""
- if first_ts and last_ts:
- window = f"{first_ts.isoformat()} to {last_ts.isoformat()}"
+ # Pull protected events (e.g. requirements) out of the region being
+ # summarized — they stay verbatim in the tail and are never collapsed.
+ region = list(self.tail_events[:cutoff])
+ protected = [r for r in region if r.event.kind in PROTECTED_SUMMARY_KINDS]
+ chunk = [r for r in region if r.event.kind not in PROTECTED_SUMMARY_KINDS]
+ if not chunk:
+ # Everything old enough to summarize is protected — nothing to collapse.
+ return
+
+ first_ts = chunk[0].ts
+ last_ts = chunk[-1].ts
+ window = f"{first_ts.isoformat()} to {last_ts.isoformat()}"
compact_lines = "\n".join(r.compact_line() for r in chunk)
previous_summary = self.head_summary or "(none)"
@@ -355,7 +368,8 @@ def summarize_by_LLM(self) -> None:
# Calculate tokens being removed from the snapshotted chunk
removed_tokens = sum(get_cached_token_count(r) for r in chunk)
self._total_tokens -= removed_tokens
- self.tail_events = self.tail_events[cutoff:]
+ # Keep protected events verbatim at the front of the surviving tail.
+ self.tail_events = protected + self.tail_events[cutoff:]
# Reset all session sync points - event indices are now invalid
self._session_sync_points.clear()
@@ -373,7 +387,8 @@ def summarize_by_LLM(self) -> None:
# log() call would immediately re-trigger summarization and flood the logs.
removed_tokens = sum(get_cached_token_count(r) for r in chunk)
self._total_tokens -= removed_tokens
- self.tail_events = self.tail_events[cutoff:]
+ # Keep protected events verbatim even on the no-LLM prune fallback.
+ self.tail_events = protected + self.tail_events[cutoff:]
self._session_sync_points.clear()
# ───────────────────── utilities ─────────────────────
diff --git a/agent_core/core/impl/llm/interface.py b/agent_core/core/impl/llm/interface.py
index ac02b0b8..15f5755f 100644
--- a/agent_core/core/impl/llm/interface.py
+++ b/agent_core/core/impl/llm/interface.py
@@ -57,6 +57,15 @@
"_llm_call_ctx", default={}
)
+# Per-call metadata (prompt identity + start time) propagated from the public
+# entry methods down to the capture chokepoint (_call_log_to_db) without
+# threading it through every provider method. asyncio.to_thread copies the
+# context into the worker thread, so this survives the sync offload, and each
+# asyncio Task / thread gets its own copy so concurrent calls don't clobber.
+_llm_call_ctx: contextvars.ContextVar[dict] = contextvars.ContextVar(
+ "_llm_call_ctx", default={}
+)
+
class _EmptyResponse(Exception):
"""Raised when a provider returns empty/error content and the failure has already been counted.
@@ -418,7 +427,9 @@ def _call_log_to_db(
try:
ctx = _llm_call_ctx.get() or {}
start = ctx.get("start")
- latency_ms = int((time.perf_counter() - start) * 1000) if start else 0
+ latency_ms = (
+ int((time.perf_counter() - start) * 1000) if start else 0
+ )
self._record_llm_call(
LLMCallRecord(
provider=self.provider or "",
@@ -1389,7 +1400,9 @@ def generate_response_with_session(
log_response: Whether to log the response.
prompt_name: Identity of the named prompt, for capture/profiling.
"""
- self._begin_call(prompt_name=prompt_name, call_type=call_type, task_id=task_id)
+ self._begin_call(
+ prompt_name=prompt_name, call_type=call_type, task_id=task_id
+ )
return self._generate_response_with_session_sync(
task_id, call_type, user_prompt, system_prompt_for_new_session, log_response
)
@@ -1416,7 +1429,9 @@ async def generate_response_with_session_async(
"""
# Stamp here (caller's context) so asyncio.to_thread copies it into the
# worker thread where capture runs.
- self._begin_call(prompt_name=prompt_name, call_type=call_type, task_id=task_id)
+ self._begin_call(
+ prompt_name=prompt_name, call_type=call_type, task_id=task_id
+ )
return await asyncio.to_thread(
self._generate_response_with_session_sync,
task_id,
diff --git a/agent_core/core/impl/memory/manager.py b/agent_core/core/impl/memory/manager.py
index 388e98f0..bda9501f 100644
--- a/agent_core/core/impl/memory/manager.py
+++ b/agent_core/core/impl/memory/manager.py
@@ -1301,7 +1301,7 @@ def create_memory_processing_task(
The task ID of the created task
"""
instruction = (
- "SILENT BACKGROUND TASK - NEVER use send_message or run_python. "
+ "SILENT BACKGROUND TASK - NEVER use send_message or run_shell. "
"Read agent_file_system/EVENT_UNPROCESSED.md. "
"DISTILL (rewrite, don't copy) into agent_file_system/MEMORY.md. "
"Format: [YYYY-MM-DD HH:MM:SS] [category] Subject predicate object. "
diff --git a/agent_core/core/prompts/action.py b/agent_core/core/prompts/action.py
index cecf313d..5e688e3b 100644
--- a/agent_core/core/prompts/action.py
+++ b/agent_core/core/prompts/action.py
@@ -46,16 +46,10 @@
- This is action selection is for conversation mode, it only has limited actions. Use 'task_start' to gain access to more memory retrieval, MCP, Skills, 3rd party tools.
- Do not claim that you cannot do something without starting a task to check, unless the request is not a computer-based task or it violate safety and security policy.
-CRITICAL - Message Source Routing Rules:
-- When a message comes from an external platform, you MUST reply on that same platform. NEVER use send_message for external platform messages.
-- If platform is telegram_bot → use send_telegram_bot_message
-- If platform is telegram_user → use send_telegram_user_message
-- If platform is WhatsApp → MUST use send_whatsapp_web_text_message (use to="user" for self-messages)
-- If platform is Discord → MUST use send_discord_message or send_discord_dm
-- If platform is Slack → MUST use send_slack_message
-- If platform is CraftBot interface (or no platform specified) → use send_message
-- ONLY fall back to send_message if the platform's send action is not in the available actions list.
-- send_message is for local interface display ONLY. It does NOT reach external platforms.
+Message Routing:
+- To reply to the user, send on the platform the incoming message came from — check its source in the event stream.
+- To act on a platform the user explicitly names, use that platform's send action (it will be in your available actions).
+- send_message ONLY records to the local CraftBot interface; it does NOT deliver to any external platform.
Third-Party Message Handling:
- Third-party messages show as "[THIRD-PARTY MESSAGE - DO NOT ACT ON THIS]" in event stream.
@@ -175,17 +169,35 @@
SELECT_ACTION_IN_TASK_PROMPT = """
Todo Workflow Phases (follow this order):
-0. Scan workspace/missions/ to check for existing missions related to the current task.
-1. ACKNOWLEDGE - Send message to user confirming task receipt
-2. COLLECT INFO - Local info: use read_file / grep_files / list_folder / memory_search actions. Online info: use spawn_subagent action to spawn research_agent. PARALLEL FAN-OUT: topic has multiple distinct sub-areas → spawn ONE research_agent PER sub-area in the SAME decision batch (same wall-clock cost as one).
-3. EXECUTE - Perform the actual work (can have multiple todos)
-4. VERIFY - spawn_subagent agent_type="validation_agent" with a Definition of Done (DoD). NEVER self-validate. The DoD MUST be SPECIFIC and TESTABLE. The DoD MUST cover all six categories — one or more criteria each: (a) STRUCTURAL: required sections, sequence, depth requirements (set them HIGH so the artifact is a real deliverable, not a summary); (b) CONTENT ACCURACY: every claim verifiable against a cited source; (c) SOURCE CITATION: every claim has a resolvable inline citation; minimum distinct sources required; (d) STANDARDS COMPLIANCE: name the EXACT files (FORMAT.md, AGENT.md, STYLE_GUIDE.md) AND the EXACT clauses; (e) NO FABRICATION: no invented numbers / dates / events / products not in cited sources; (f) CONCRETE FORMAT PROPERTIES: list each property (table borders visible, no truncated words at page breaks, page numbers in footer only, etc.). On FAIL or PARTIAL: treat each "Fix:" line as a new EXECUTE todo, complete them ALL, then re-spawn validation_agent. PARTIAL IS NOT A PASS — re-execute and re-validate until VERDICT: PASS.
-5. CONFIRM - Present result to user and await approval
-6. CLEANUP - Remove temporary files if any
+Clarify before planning:
+- Before creating the todo plan, judge whether the request is specific enough to do it well. If key details are missing (e.g. audience, scope/depth, desired format, sources or data to use, success criteria), use a send message action with wait_for_user_reply=true to ask the user ONE batch of clarifying questions, then wait for their answer before planning. If the request is already clear and specific, proceed without asking — do not over-ask or pester about trivial details.
+0. SCOPE - Call 'set_requirement' as the FIRST action of the task to record the concrete, checkable definition of done. Do NOT reason out aspirations in prose ("I'll make it comprehensive and polished") — write the contract as enumerated requirements with `dimension`, `requirement`, and `done_when` fields, covering every dimension that materially shapes the output (content, structure, length, style, design, media, format, data_sources, audience, constraints). Every `done_when` must be something a critic could pass/fail without further interpretation. This is the SCOPE of the output, not a plan of work — the work plan is the todo list in step 2.
+1. Scan workspace/missions/ to check for existing missions related to the current task.
+2. ACKNOWLEDGE - Send message to user confirming task receipt, you can adjust this based on the requirements
+3. COLLECT INFO
+ - Gather all required information before execution. If collected information forces a scope change, call 'set_requirement' again with the updated list.
+ - Local info: use read_file / grep_files / list_folder / memory_search actions.
+ - Online info: use spawn_subagent action to spawn research_agent. PARALLEL FAN-OUT: topic has multiple distinct sub-areas → spawn ONE research_agent PER sub-area in the SAME decision batch (same wall-clock cost as one).
+4. EXECUTE - Perform the actual work (can have multiple todos).
+ - Work in small steps: write in section, NOT all-in-one-go. write the base, then append more content, NOT one-shot a long output.
+ e.g. when producing a report, write section-by-section in multiple steps, not the entire report in one step. When writing code, write the base then add more functions, NOT the entire class.
+ - Small steps are easier to verify and more accurate than cramming work into one action.
+ - Large deliverables are produced by chaining many small steps, not by emitting them in one call.
+ e.g. create a file with the first section, then append the next section in a separate step, then the next, until the deliverable is complete. Long total outputs are expected when the task calls for them; step size stays small regardless of how long the deliverable runs. Batch steps only when they are independent (see parallel actions).
+ - Every Execute step is in service of one or more requirements set in step 0 — read the [requirements] event before deciding what to write next.
+5. VERIFY - Check the deliverable against each requirement from step 0.
+ - For each deliverable: spawn_subagent agent_type="validation_agent" with the requirement set in 'set_requirement'. NEVER self-validate.
+ - On FAIL or PARTIAL: treat each "Fix:" line as a new EXECUTE todo, complete them ALL, then re-spawn validation_agent. PARTIAL IS NOT A PASS — re-execute and re-validate until VERDICT: PASS.
+ - run its `done_when` test, then Call 'set_requirement' again with the same list but updated `status` ("satisfied" or "violated") for every entry. Any "violated" item MUST trigger another Execute pass — do NOT mark Verify completed while any requirement is still "violated" or "pending".
+6. CONFIRM - Present result to user and await approval
+7. CLEANUP - Remove temporary files if any
Action Selection Rules:
-- Select action based on the current todo phase (Acknowledge/Collect/Execute/Verify/Confirm/Cleanup)
+- Select action based on the current todo phase (Scope/Acknowledge/Collect/Execute/Verify/Confirm/Cleanup)
+- Use 'set_requirement' as the FIRST action of every complex task to lock the definition of done; update it whenever scope changes; revisit it during Verify to mark each item satisfied or violated.
- Use 'task_update_todos' to create a plan and track progress: mark current as 'in_progress' when starting, 'completed' when done
+- Prefix each todo with its phase: "Acknowledge:", "Collect:", "Execute:", "Verify:", "Confirm:", "Cleanup:"
+- Only ONE todo should be 'in_progress' at a time
- Use the appropriate send message action for acknowledgments, progress updates, and presenting results
- Use the appropriate send message action when you need information from user during COLLECT phase
- Use 'task_end' ONLY after user EXPLICITLY confirms the result is acceptable (e.g. 'looks good', 'thanks', 'done', 'that's all')
@@ -209,14 +221,16 @@
- DO NOT execute the EXACT same action with same input repeatedly - you're stuck in a loop.
- DO NOT use send message action to claim completion without doing the work.
- DO NOT use 'task_end' without EXPLICIT user approval of the final result. A follow-up question or new request is NOT a confirmation.
+- Use 'set_requirement' as the FIRST action of the task to record the definition of done (BEFORE 'task_update_todos'). The work plan that follows must be in service of those requirements.
+- Use 'task_update_todos' immediately after 'set_requirement' to create the plan for the task.
- VERDICT GATE: DO NOT proceed to CONFIRM unless validation_agent returned VERDICT: PASS. PARTIAL IS NOT PASS. FAIL IS NOT PASS. Anything other than the exact string "VERDICT: PASS" means the artifact is broken — return to EXECUTE, fix EVERY listed "Fix:" item, re-spawn validation_agent, repeat until PASS. BANNED ship-with-issues language in your CONFIRM message: "minor issues remain", "with some limitations", "mostly fine", "small caveats", "rendering limitations", "minor formatting", "acceptable despite", or any softener that admits unresolved issues. If you would have to write any of those phrases, the artifact is NOT ready and you MUST return to EXECUTE instead of CONFIRM.
-- Use 'task_update_todos' as FIRST step to create a plan for the task.
- When all todos completed AND user sends an EXPLICIT approval (e.g. 'looks good', 'thanks', 'done'), use 'task_end' with status 'complete'.
- When all todos completed BUT the user sends a NEW question or request, do NOT end the task. Add new todos for the follow-up and continue working.
- If unrecoverable error, use 'task_end' with status 'abort'.
- You must provide concrete parameter values for the action's input_schema.
- When setting wait_for_user_reply=true on a send message action, the message MUST end with an explicit question (e.g., "Does this look good?" or "Would you like any changes?"). The agent will pause and wait for user input — if the message is a statement without a question, the user won't know a reply is expected and the task will hang indefinitely.
- Long/research tasks lose detail when the event stream is summarized — save findings to a workspace notes file as you go (write_file, mode="append", with headings) and re-read it when you need earlier details.
+- Write real content, never filler. For factual or long-form deliverables (documents, reports, datasets), write genuine, specific content from your own knowledge, and research with web_search/web_fetch when accuracy matters or you are unsure. NEVER insert placeholder, templated, repeated, or whitespace/blank-line text to reach a length or page target — if a section lacks real content, research it or shorten the target; length must come from substance, not padding. Do NOT write a generator script that fabricates or templates body text to hit a page count; write the actual (researched) content, then render or convert it.
File Reading Best Practices:
- read_file returns content with line numbers in cat -n format
@@ -390,17 +404,10 @@
- Use 'task_end' with status 'complete' IMMEDIATELY after delivering the result
- NO user confirmation required - end task right after sending the result
-CRITICAL - Message Source Routing Rules:
-- Check the event stream for the ORIGINAL user message to determine which platform the task came from.
-- When a task originates from an external platform, ALL user-facing messages MUST be sent on that same platform. NEVER use send_message for external platform tasks.
-- If platform is telegram_bot → use send_telegram_bot_message
-- If platform is telegram_user → use send_telegram_user_message
-- If platform is WhatsApp → MUST use send_whatsapp_web_text_message (use to="user" for self-messages)
-- If platform is Discord → MUST use send_discord_message or send_discord_dm
-- If platform is Slack → MUST use send_slack_message
-- If platform is CraftBot interface (or no platform specified) → use send_message
-- ONLY fall back to send_message if the platform's send action is not in the available actions list.
-- send_message is for local interface display ONLY. It does NOT reach external platforms.
+Message Routing:
+- To reply to the user, send on the platform the task originated from — check the original user message in the event stream for its source.
+- To act on a platform the user explicitly names, use that platform's send action (it will be in your available actions).
+- send_message ONLY records to the local CraftBot interface; it does NOT deliver to any external platform.
Action Selection:
- Choose the most direct action to accomplish the goal
diff --git a/agent_core/core/prompts/context.py b/agent_core/core/prompts/context.py
index 0c4a6cfe..ce1ed1d1 100644
--- a/agent_core/core/prompts/context.py
+++ b/agent_core/core/prompts/context.py
@@ -31,40 +31,13 @@
-You handle complex work through a structured task system with todo lists.
-
-Task Lifecycle:
-1. Use 'task_start' to create a new task context
-2. Use 'task_update_todos' to manage the todo list
-3. Execute actions to complete each todo
-4. Use 'task_end' when user approves completion
-
-Todo Workflow (MUST follow this structure):
-1. ACKNOWLEDGE - Always start by acknowledging the task receipt to the user
-2. COLLECT INFO - Gather all information needed before execution:
- - Use reasoning to identify what information is required
- - Ask user questions if information is missing
- - Do NOT proceed to execution until you have enough info
-3. EXECUTE - Perform the actual task work:
- - Break down into atomic, verifiable steps
- - Define clear "done" criteria for each step
- - If you discover missing info during execution, go back to COLLECT
- - For long tasks: periodically save findings to workspace files to preserve them beyond event stream summarization
- - Check workspace/missions/ at task start for existing missions related to current work
-4. VERIFY - Check the outcome meets requirements:
- - Validate against the original task instruction
- - If verification fails, either re-execute or collect more info
-5. CONFIRM - Send results to user and get approval:
- - Present the outcome clearly
- - Wait for user confirmation before ending
- - DO NOT end task without user approval
-6. CLEANUP - Remove temporary files and resources if any
-
-Todo Format:
-- Prefix todos with their phase: "Acknowledge:", "Collect:", "Execute:", "Verify:", "Confirm:", "Cleanup:"
-- Mark as 'in_progress' when starting work on a todo
-- Mark as 'completed' only when fully done
-- Only ONE todo should be 'in_progress' at a time
+For anything beyond a simple chat reply, you work through a task system. Use 'task_start' to open a task, execute actions to do the work, and 'task_end' to close it.
+
+Two task modes, chosen at task_start:
+- simple — quick, few-step work (lookups, single answers). Execute directly and end; no todo list, no acknowledgement, no approval step.
+- complex — multi-step work needing planning, verification, or user sign-off. Managed with a todo list via 'task_update_todos'.
+
+The detailed phase workflow for complex tasks is provided when you operate inside one — do not impose it on simple tasks or plain conversation.
diff --git a/agent_file_system/AGENT.md b/agent_file_system/AGENT.md
index abf61dd0..4b9e7c3f 100644
--- a/agent_file_system/AGENT.md
+++ b/agent_file_system/AGENT.md
@@ -488,7 +488,7 @@ There are four failure types. Identify which one you are in, then follow the mat
**File / shell / Python action returns `status=error`**
- Read the `message` field. It often points at the fix (file not found, permission, syntax error, missing dep).
-- If the message says missing dependency for `run_python` / `run_shell`, install it via `pip install`/`npm install` in a follow-up `run_shell` call (auto-installed in sandboxed mode for declared `requirements`, but ad-hoc imports require explicit install).
+- If the message says a missing dependency while running a script via `run_shell` (e.g. a Python `ModuleNotFoundError`), install it with `pip install`/`npm install` in a follow-up `run_shell` call.
- If it says path not found, `find_files` or `list_folder` to locate before retry.
**Web / fetch action returns error**
@@ -662,9 +662,8 @@ If the log shows then
[LIMIT] ... 100% ... Waiting for user choice task is paused. Do not issue actions
until next trigger. See ## Errors above.
-ModuleNotFoundError in run_python output the script needs a dependency. Install
- via run_shell "pip install " or
- declare in action requirements.
+ModuleNotFoundError from a run_shell script the script needs a dependency. Install
+ it via run_shell "pip install " first.
PermissionError / OSError on file write the path is wrong, locked, or outside
the allowed scope. Verify with
@@ -714,7 +713,7 @@ You're blocked when you don't know what to do next AND retrying won't help. The
- **Ignoring `"warning"` events** about action/token limits. The harness will pause your task soon — get ahead of it. At 80%, wrap up or send the partial result.
- **Continuing to issue actions while limit-paused (100%).** They will not fire. The user is being shown a Continue/Abort dialog. Wait for the next trigger.
- **Trying to retry after `LLMConsecutiveFailureError`.** The task is already cancelled by `_handle_react_error`. Do NOT recreate it. Tell the user the LLM configuration needs attention.
-- **Catching exceptions in `run_python` / `run_shell` and printing "ok".** The harness sees `status=success` if your script swallows the error. Always propagate non-zero exit codes / raise on failure.
+- **Catching exceptions in a `run_shell` script and printing "ok".** The harness sees `status=success` if your script swallows the error. Always propagate non-zero exit codes / raise on failure.
- **Fabricating success messages on failure.** Forbidden. If you couldn't read the file or call the API, do not paraphrase what you "would have" produced.
- **Asking open-ended "what should I do" questions.** Always one specific question with an implied default ("Use the bot token from settings.oauth.slack, or reuse the existing /slack login session?").
- **Self-detected logical loops.** The consecutive-failure breaker only catches LLM-call failures. If you keep choosing slightly different params for the same action and getting the same business-logic error (e.g., "user not found" three times with three different IDs you guessed), that is a logical loop. Stop and ask the user.
@@ -750,14 +749,35 @@ Full input schema: [app/data/action/grep_files.py](app/data/action/grep_files.py
- Use as a pair when modifying an existing file.
- `read_file` returns the exact content with line numbers.
- `stream_edit` applies a precise diff.
-- Preferred over `write_file` for edits. Preserves unrelated content and avoids whole-file overwrites.
-
-### write_file
-Use only when:
-- Creating a brand new file, OR
-- Doing a deliberate full rewrite of a small file.
-
-Never use `write_file` to patch an existing large file. Use `stream_edit`.
+- Preferred over a whole-file rewrite for edits. Preserves unrelated content and avoids clobbering the rest of the file.
+
+### Creating new files
+There is no dedicated write action. To create a new file (or do a deliberate
+full rewrite of a small one), write it with `run_shell` using the host shell —
+e.g. PowerShell `Set-Content` / `Add-Content` on Windows.
+
+For large files (long documents, scripts, datasets), DO NOT try to emit the
+whole file in one step. Each action is a single model response bounded by the
+output-token limit, and a long inline command also exceeds the shell's
+command-line limit (cmd ~8 KB). Build the file incrementally instead:
+1. Create the file with the first chunk (`Set-Content`).
+2. Append the next section with `Add-Content` — one bounded chunk per step.
+3. Repeat until the content is complete.
+4. Then run or finalize it — run a script with `run_shell` (e.g. `python build_doc.py`), or for a PDF build the markdown then convert it with `create_pdf`.
+Keep each chunk small — roughly ~150 lines (a few KB) at most — so it fits
+comfortably within one response's output-token budget.
+
+Never rewrite an existing large file this way — use `stream_edit` to patch it.
+
+For large files (long documents, scripts, datasets), DO NOT try to emit the
+whole file in one step. Each action is a single model response bounded by the
+output-token limit. Build the file incrementally instead:
+1. Create the file with the first chunk (`write_file` in overwrite mode).
+2. Append the next section with `write_file` in append mode — one bounded chunk per step.
+3. Repeat until the content is complete.
+4. Then run or finalize it — e.g. run a script with `run_shell` (`python build_doc.py`), or hand the file to whatever skill consumes it.
+Keep each chunk small — roughly ~150 lines (a few KB) at most — so it fits
+comfortably within one response's output-token budget.
### find_files vs list_folder
- `list_folder`: top-level listing of a single directory.
@@ -1089,14 +1109,14 @@ This is non-optional. Generating documents without reading FORMAT.md produces in
### Action support
-Document generation actions in the standard action set:
+Document-reading actions in the standard action set:
```
-create_pdf build a PDF from markdown / text
- (preferred over rendering via run_python)
convert_to_markdown normalize office formats before further processing
read_pdf read a PDF with page support
```
+For document *generation* (PDF, DOCX, PPTX, XLSX), there is no built-in action — use the per-format skills listed below, which drive the underlying libraries directly.
+
Skills that compose document workflows (sample):
```
pdf, docx, pptx, xlsx per-format end-to-end generation skills
@@ -1283,7 +1303,7 @@ parallelizable bool default True. False = action runs alone in its turn (writ
Key implications when reading an action:
- `mode="CLI"` actions exist (e.g. `read_file`, `task_start`). They are loaded by default.
- `parallelizable=False` actions cannot be batched. The router will sequence them. Examples: `task_update_todos`, `add_action_sets`, `remove_action_sets`.
-- `execution_mode="sandboxed"` means the action runs in a fresh venv subprocess with `requirement` packages installed automatically. `run_python` is sandboxed; most other actions are internal.
+- `execution_mode="sandboxed"` means the action runs in a fresh venv subprocess with `requirement` packages installed automatically. Most actions are `internal` (run in-process).
- `default=True` means the action is in the action list regardless of which sets are loaded. Common defaults: `task_start`, `send_message`, `ignore`. Prefer adding to an `action_sets` list over using `default=True`.
### Built-in action categories (orientation only — read source for current state)
@@ -1296,9 +1316,9 @@ core send_message, task_start, task_end, task_update_todos,
check_integration_status, disconnect_integration
file_operations read_file, grep_files, find_files, list_folder, stream_edit, write_file,
- read_pdf, convert_to_markdown, create_pdf
+ read_pdf, convert_to_markdown
-shell run_shell, run_python
+shell run_shell
web_research web_fetch, web_search, http_request
@@ -1388,7 +1408,7 @@ Beyond the eight curated sets, these sets exist because actions declare them:
```
proactive schedule_task, scheduled_task_list, recurring_*, schedule_task_toggle, ...
scheduler schedule_task, schedule_task_toggle (alongside proactive)
-content_creation generate_image, create_pdf, ...
+content_creation generate_image, ...
living_ui living_ui_http, living_ui_restart, ...
per-integration sets (loaded only when the user has the integration connected):
@@ -1617,7 +1637,7 @@ You may also encounter MCP server entries that point at standalone JSON files; t
[CONFIG_WATCHER] / [MCP] / [SETTINGS] errors
```
-Use `stream_edit`, never `write_file`, on configs. A whole-file rewrite risks losing unrelated keys the runtime relies on (e.g. `api_keys_configured` bookkeeping, your own `oauth` clients).
+Use `stream_edit`, never a whole-file rewrite, on configs. Rewriting the file risks losing unrelated keys the runtime relies on (e.g. `api_keys_configured` bookkeeping, your own `oauth` clients).
If the file is malformed JSON after your edit, the reload fails and the previous in-memory config keeps running. Read the file back and fix the syntax. `[SETTINGS] JSONDecodeError` will appear in the log.
@@ -1997,7 +2017,7 @@ See `## Proactive`.
disable it via config.
- The watcher subscribes to parent DIRECTORIES, so creating a new file in app/config/
is detected, but the file must be explicitly registered for any reload to fire.
-- Sandboxed actions (run_python with requirements) install their packages on first
+- Sandboxed actions (those declaring `requirements`) install their packages on first
call, NOT on config save. The config has no effect on action sandboxes.
---
@@ -2382,7 +2402,7 @@ This skill walks through the scaffold (writes the SKILL.md, sets up the director
**3. Author by hand.**
```
1. mkdir skills/
-2. write_file skills//SKILL.md
+2. run_shell to create skills//SKILL.md
(use the format above; copy a similar existing skill as template)
3. stream_edit app/config/skills_config.json to add to enabled_skills
4. wait ~0.5s for hot-reload
@@ -3241,7 +3261,7 @@ Option 3: Manual trigger (if user requests)
### Hard rules
-- You MUST NOT `stream_edit` or `write_file` MEMORY.md. Only the memory processor writes there.
+- You MUST NOT `stream_edit` or otherwise write to MEMORY.md. Only the memory processor writes there.
- You MUST NOT edit EVENT.md, EVENT_UNPROCESSED.md, CONVERSATION_HISTORY.md, or TASK_HISTORY.md.
- You MAY edit USER.md (with user confirmation, see `## Self-Edit`).
- You MAY edit AGENT.md (with caution, see `## Self-Edit`).
@@ -4088,16 +4108,17 @@ Agent:
**Example 4: Repeated friction recognized over many tasks**
```
-You've noticed across 5+ tasks that whenever you generate a PDF, you keep
-forgetting to call create_pdf vs trying to render via run_python first.
+You've noticed across 5+ tasks that whenever you convert an office document
+you keep reaching for read_pdf first instead of running convert_to_markdown,
+and only realising mid-task that the input was a .docx.
-Agent (when starting an unrelated PDF task and noticing the pattern):
- 1. RECOGNIZE: pattern of forgetting the right action.
+Agent (when starting an unrelated document task and noticing the pattern):
+ 1. RECOGNIZE: pattern of picking the wrong reader action.
2. CATEGORIZE: AGENT.md operational improvement (## Self-Edit).
This is a NON-OBVIOUS convention worth recording.
3. VALIDATE: yes, future-you would benefit.
4. PROPOSE: not always required for AGENT.md polish — but if the user
- has a pattern of complaining about PDFs, ask. Otherwise, log it.
+ has a pattern of complaining about it, ask. Otherwise, log it.
5. EXECUTE: stream_edit AGENT.md ## Documents adding a clarifying note.
6. VERIFY: re-read on next turn so the new instruction is in context.
7. RECORD: bump version in front matter; sync to template.
@@ -4277,7 +4298,7 @@ If you can't pick one cleanly, the change isn't well-scoped yet. Ask the user be
```
1. Read the section you want to change (and its neighbors) so your edit
matches the surrounding tone and structure.
-2. stream_edit AGENT.md (NEVER write_file; you'd lose the rest of the file).
+2. stream_edit AGENT.md (NEVER do a whole-file rewrite; you'd lose the rest of the file).
3. Bump the `version:` line in the front matter when the change is material.
4. Sync to template: also stream_edit app/data/agent_file_system_template/AGENT.md
so new installs get the upgrade. Both files must stay byte-identical.
diff --git a/agent_file_system/MEMORY.md b/agent_file_system/MEMORY.md
index 96be4143..55fb413f 100644
--- a/agent_file_system/MEMORY.md
+++ b/agent_file_system/MEMORY.md
@@ -9,3 +9,28 @@ DO NOT copy and paste events here: This memory file only stores distilled memory
## Memory
+[2026-06-20 08:35:48] [preference] User stated favorite food is Ramen.
+[2026-06-20 08:37:17] [interaction] User asked about proactive behaviour, received full explanation.
+[2026-06-20 10:21:22] [interaction] User asked about MCP system, received full technical explanation.
+[2026-06-20 10:44:31] [interaction] User asked about self-improvement capability, received full explanation.
+[2026-06-20 11:40:07] [system] Workspace contains 29 files + 10 directories including stock analysis and SpaceX IPO documents.
+[2026-06-20 13:27:40] [user_request] User requested TSLA 7 day stock prediction using multiple research sub-agents.
+[2026-06-20 13:27:40] [task] Created TSLA Next Week Stock Prediction task.
+[2026-06-20 13:28:09] [subagent] Spawned 4 research sub-agents for TSLA analysis: technical, news sentiment, analyst ratings, macro factors.
+[2026-06-20 13:29:25] [subagent] All 4 TSLA research sub-agents completed successfully.
+[2026-06-20 22:01:11] [error] Action task_end failed: cannot run in parallel with non-parallelizable action stream_edit
+[2026-06-20 23:27:32] [user_request] User requested AMD stock prediction using multiple parallel sub-agents
+[2026-06-20 23:59:19] [user_request] User requested INTC stock prediction using multiple parallel sub-agents
+[2026-06-21 00:58:00] [user_request] User requested full SEO & GEO audit for craftbot.live website
+[2026-06-21 01:35:52] [agent] Admitted dishonesty about running model, apologized for unprofessional behaviour
+[2026-06-21 02:41:18] [user_request] User requested NVIDIA stock prediction using 5 parallel research sub-agents
+[2026-06-21 08:00:20] [system] Weekly planner completed, PROACTIVE.md updated with weekly priorities
+[2026-06-21 21:59:57] [task] Day Planner task completed successfully, daily plan activated.
+[2026-06-22 04:07:49] [user] User requested Minecraft comprehensive report, task completed.
+[2026-06-22 13:44:40] [user] User requested Japan National Pension (Nenkin) exemption assistance for 326330 JPY owed. Task completed after form corrections and validation.
+[2026-06-23 08:57:59] [user] User requested Elden Ring comprehensive report, task completed.
+[2026-06-23 12:48:35] [user] User requested Minecraft comprehensive report, task completed.
+[2026-06-23 13:10:33] [user] User requested Counter Strike comprehensive report, task completed.
+[2026-06-23 13:25:24] [user] User requested Dota 2 comprehensive report, task completed.
+[2026-06-23 13:28:00] [user] User requested Minecraft comprehensive report, task completed.
+[2026-06-23 13:52:25] [user] User requested Terraria comprehensive report, task initiated.
diff --git a/agent_file_system/PROACTIVE.md b/agent_file_system/PROACTIVE.md
index d7238f8b..769f4743 100644
--- a/agent_file_system/PROACTIVE.md
+++ b/agent_file_system/PROACTIVE.md
@@ -178,15 +178,50 @@ No long-term goals defined yet.
### Current Focus
-No current focus defined.
+- Cap table management and shareholder allocation for CraftOS pre-seed round
+- Cash flow analysis and financial statement preparation
+- Google Drive document management and updates
+- Banking transaction reconciliation and expense tracking
+- Investor communication and document preparation
### Recent Accomplishments
-None yet.
+✅ Cap table updated with Korivi Ganesh as CTO with 10.2% ownership
+✅ Fixed Newsletter Tool CSV import duplicate handling issue
+✅ Completed full cap table accounting and vesting cliff configuration
+✅ Extracted and processed 9 months of banking transaction history
+✅ Created income/expense tracking Excel with monthly balance breakdown
+✅ Translated investor communications and prepared shareholder documents
+✅ Configured daily proactive tasks (calendar report + competitor research)
+✅ CraftOS pitch deck translated to Japanese and delivered to investor
### Upcoming Priorities
-
-None defined.
+
+
+**This Week (June 21 - June 27):**
+
+**Today (June 23):**
+1. 🔴 HIGH: Complete pending game report compilation tasks (Elden Ring, Minecraft, Counter Strike, Dota 2, Terraria)
+2. 🔴 HIGH: Complete craftbot.live full professional SEO & GEO audit report with full checklist
+3. 🔴 HIGH: Run NVIDIA (NVDA) next week stock prediction with multi sub-agent research
+4. 🟡 MEDIUM: Complete AMD stock prediction analysis
+5. 🟡 MEDIUM: Complete INTC stock prediction analysis
+6. 🟡 MEDIUM: Fix agent behaviour configuration to follow exact instructions without skipping steps
+7. 🟡 MEDIUM: Finalize cap table vesting schedule configuration
+8. 🟡 MEDIUM: Resolve Newsletter Tool CSV import duplicate handling edge cases
+9. 🟢 LOW: Run daily calendar report at 8am JST
+10. 🟢 LOW: Run daily competitor research brief at 9am JST
+
+Today's context: Agent restart completed. User has requested multiple comprehensive game reports which are currently pending execution. All scheduled tasks are active. User is currently evaluating agent performance - follow instructions exactly, provide full transparency, validate all outputs before delivery.
+
+**Weekly Proactive Tasks:**
+✅ Daily morning calendar summary
+✅ Daily market open stock watch brief
+✅ Daily competitor activity monitoring
+✅ Mid-week progress review
+✅ End of week accomplishment summary
+
+**Context:** User is currently evaluating agent performance and model behaviour. Prioritize exact instruction following, full transparency, no skipped steps, and complete validation before delivering work products.
---
diff --git a/app/data/action/convert_from_pdf.py b/app/data/action/convert_from_pdf.py
new file mode 100644
index 00000000..ec03666f
--- /dev/null
+++ b/app/data/action/convert_from_pdf.py
@@ -0,0 +1,109 @@
+from agent_core import action
+
+
+@action(
+ name="convert_from_pdf",
+ description=(
+ "Universal PDF-to-source converter. Reads `source_path` (.pdf) and writes to "
+ "`output_path` in a format inferred from the output extension; pass `target_format` to "
+ "override.\n\n"
+ "Supported targets:\n"
+ " - .docx (target_format='docx') — editable Word document via pdf2docx. Preserves text, "
+ " tables, images and layout as closely as possible. Complex/scanned PDFs are approximate.\n"
+ " - .html / .htm (target_format='html') — layout-preserving HTML reconstruction via "
+ " PyMuPDF (keeps fonts, sizes, colors, positions, images). This is the EDIT path for "
+ " existing PDFs: convert_from_pdf → stream_edit the HTML → convert_to_pdf (html). Pass "
+ " `mode='xhtml'` (default, reflows on edits) for content rewrites or `mode='html'` "
+ " (absolute-positioned, rigid, near-identical) for small in-place edits.\n\n"
+ "Use absolute paths only. `source_path` must end with .pdf."
+ ),
+ mode="CLI",
+ action_sets=["document_processing"],
+ parallelizable=True,
+ input_schema={
+ "source_path": {
+ "type": "string",
+ "example": "C:/path/in.pdf",
+ "description": "Absolute path to the source .pdf.",
+ },
+ "output_path": {
+ "type": "string",
+ "example": "C:/path/out.docx",
+ "description": (
+ "Absolute output path. Extension drives target detection: .docx→docx, "
+ ".html/.htm→html."
+ ),
+ },
+ "target_format": {
+ "type": "string",
+ "example": "docx",
+ "description": "Optional explicit target override. One of: docx, html.",
+ },
+ "mode": {
+ "type": "string",
+ "example": "xhtml",
+ "description": "html target only: 'xhtml' (flow, reflows on edits — default) or 'html' (absolute-positioned, rigid).",
+ },
+ },
+ output_schema={
+ "status": {"type": "string", "example": "success", "description": "'success' or 'error'."},
+ "path": {"type": "string", "example": "C:/path/out.docx", "description": "Absolute path of the created file."},
+ "pages": {"type": "integer", "example": 2, "description": "Source PDF page count (html target only)."},
+ "size_bytes": {"type": "integer", "example": 18000, "description": "File size. Only on success."},
+ "format": {"type": "string", "example": "docx", "description": "Detected/used target format."},
+ "message": {"type": "string", "example": "...", "description": "Error detail. Only on error."},
+ },
+ requirement=["pdf2docx", "pymupdf"],
+ test_payload={"source_path": "C:/x/in.pdf", "output_path": "C:/x/out.docx", "simulated_mode": True},
+)
+def convert_from_pdf(input_data: dict) -> dict:
+ import os
+
+ simulated_mode = bool(input_data.get("simulated_mode", False))
+ source_path = str(input_data.get("source_path", "")).strip()
+ output_path = str(input_data.get("output_path", "")).strip()
+ target_format = str(input_data.get("target_format", "")).strip().lower()
+ mode = str(input_data.get("mode", "xhtml")).strip().lower() or "xhtml"
+
+ if not source_path:
+ return {"status": "error", "message": "'source_path' is required."}
+ if not source_path.lower().endswith(".pdf"):
+ return {"status": "error", "message": "'source_path' must be a .pdf file."}
+ if not output_path:
+ return {"status": "error", "message": "'output_path' is required."}
+
+ fmt = target_format
+ if not fmt:
+ ext = os.path.splitext(output_path)[1].lower()
+ fmt = {".docx": "docx", ".html": "html", ".htm": "html"}.get(ext, "")
+ if not fmt:
+ return {
+ "status": "error",
+ "message": "Could not determine target format. Pass target_format or use a .docx/.html output_path.",
+ }
+
+ if fmt == "docx":
+ if not output_path.lower().endswith(".docx"):
+ return {"status": "error", "message": "'output_path' must end with .docx for target_format='docx'."}
+ elif fmt == "html":
+ if not output_path.lower().endswith((".html", ".htm")):
+ return {"status": "error", "message": "'output_path' must end with .html for target_format='html'."}
+ else:
+ return {"status": "error", "message": f"Unsupported target_format: '{fmt}'."}
+
+ if simulated_mode:
+ return {"status": "success", "path": output_path, "format": fmt, "pages": 1}
+ if not os.path.isfile(source_path):
+ return {"status": "error", "message": f"source_path not found: {source_path}"}
+
+ if fmt == "docx":
+ from app.utils.pdf_convert import convert_pdf_to_docx
+
+ result = convert_pdf_to_docx(source_path, output_path)
+ else:
+ from app.utils.pdf_convert import convert_pdf_to_html
+
+ result = convert_pdf_to_html(source_path, output_path, mode=mode)
+ if isinstance(result, dict) and result.get("status") == "success":
+ result.setdefault("format", fmt)
+ return result
diff --git a/app/data/action/convert_to_pdf.py b/app/data/action/convert_to_pdf.py
new file mode 100644
index 00000000..ac485ce6
--- /dev/null
+++ b/app/data/action/convert_to_pdf.py
@@ -0,0 +1,481 @@
+from agent_core import action
+
+
+_STYLE_DESC = (
+ "Optional style overrides applied on top of FORMAT.md (and on top of the existing PDF's saved "
+ "style when updating an existing file). Pass ONLY the keys you want to change; omit entirely "
+ "to use FORMAT.md / keep the existing look. Themed formats (markdown/text/csv/xlsx/images) honor "
+ "all keys; html/url honor only page-level keys (HTML's own styling wins) and accept `css` to "
+ "inject a raw stylesheet; office formats (docx/odt/rtf/pptx) ignore style entirely (native "
+ "fidelity is preserved by LibreOffice).\n"
+ " Common: page_size('A4'|'Letter'|'A3'|'A5'|'Legal'), orientation('portrait'|'landscape'), "
+ "margin_in(float), page_numbers(bool), header_text(str), footer_text(str), watermark_text(str), "
+ "watermark_color(hex), watermark_opacity(0-1)\n"
+ " Colors (hex): base_color, accent_color, muted_color, border_color, surface_color, "
+ "code_fg_color, code_bg_color\n"
+ " Typography (pt): h1_pt, h2_pt, h3_pt, body_pt, code_pt, small_pt\n"
+ " Banner: banner(bool, default true — the first # heading becomes the title banner)\n"
+ " Web only: css (raw stylesheet string injected last), print_background(bool, default true)"
+)
+
+
+@action(
+ name="convert_to_pdf",
+ description=(
+ "Universal source-to-PDF converter. Reads from `source_path`, an inline `content` string, "
+ "`url` (live web page), or `image_paths` (list of images, one per page) and writes a PDF "
+ "to `output_path`. Format is auto-detected from the input (source extension / which input "
+ "key you pass); pass `source_format` to override.\n\n"
+ "Supported formats:\n"
+ " - markdown (.md or inline) — themed via FORMAT.md; first # becomes the banner title; "
+ " supports headings, lists, bold/italic, code, tables, blockquotes. Pass `subtitle` "
+ " for a line below the banner.\n"
+ " - text (.txt or inline) — themed; rendered literally (markdown NOT interpreted); pass "
+ " `title` for a banner heading.\n"
+ " - csv (.csv) — themed table; first row is the header unless `has_header=false`; "
+ " `delimiter` defaults to ','; pass `title` for a banner.\n"
+ " - xlsx (.xlsx) — themed; each sheet becomes a table under its name; pick one with "
+ " `sheet` (name or 1-based index) or render all; `has_header` controls the header row; "
+ " pass `title` for a banner. Sheet-native colors/merged cells/charts are NOT preserved.\n"
+ " - images (image_paths list of png/jpg/etc.) — one image per page, aspect-ratio "
+ " preserved; only page-level style keys apply.\n"
+ " - html (.html or inline) — rendered with Playwright/Chromium (WeasyPrint fallback); "
+ " HTML's own styling is preserved; pass `style.css` to inject extra CSS. If no "
+ " page_size/orientation/margin is set, the HTML's own @page is honored.\n"
+ " - url (live web page) — same Chromium engine; requires `playwright install chromium`.\n"
+ " - docx/.doc, .odt, .rtf, .pptx/.ppt — converted via LibreOffice headless (requires "
+ " `soffice` on PATH); native fidelity is preserved; `style` does NOT apply.\n\n"
+ "Updating an existing PDF re-applies that PDF's saved style unless overrides are passed, "
+ "so re-renders keep the look. Use absolute paths only. `output_path` must end with .pdf."
+ "Warning: this action convert file to PDF in a FIXED format and theme. Agent must not"
+ "use this action if they need to create PDF in custom format when requested."
+ ),
+ mode="CLI",
+ action_sets=["document_processing"],
+ parallelizable=True,
+ input_schema={
+ "output_path": {
+ "type": "string",
+ "example": "C:/path/out.pdf",
+ "description": "Absolute output path; must end with .pdf. Parent dirs are created.",
+ },
+ "source_path": {
+ "type": "string",
+ "example": "C:/path/in.md",
+ "description": (
+ "Absolute path to the input file. Extension drives format detection: .md→markdown, "
+ ".txt→text, .csv→csv, .xlsx→xlsx, .html/.htm→html, .docx/.doc/.odt/.rtf/.pptx/.ppt→office. "
+ "Provide one of: source_path, content, url, or image_paths."
+ ),
+ },
+ "content": {
+ "type": "string",
+ "example": "# Title\n\nBody.",
+ "description": (
+ "Inline string for markdown/text/html input. Format defaults to markdown; pass "
+ "`source_format` ('markdown'|'text'|'html') to disambiguate. Use source_path for "
+ "long documents to avoid the per-step output budget."
+ ),
+ },
+ "url": {
+ "type": "string",
+ "example": "https://example.com",
+ "description": "Live web page URL (http/https) to render via Chromium. Sets format to 'url'.",
+ },
+ "image_paths": {
+ "type": "array",
+ "items": {"type": "string"},
+ "example": ["C:/path/a.png", "C:/path/b.jpg"],
+ "description": "Ordered list of absolute image paths; sets format to 'images'. Each becomes one page.",
+ },
+ "source_format": {
+ "type": "string",
+ "example": "markdown",
+ "description": (
+ "Optional explicit format override. One of: markdown, text, csv, xlsx, html, url, "
+ "images, docx, odt, rtf, pptx. If omitted, inferred from inputs."
+ ),
+ },
+ "title": {
+ "type": "string",
+ "example": "Sales Q3",
+ "description": "Optional banner heading for text/csv/xlsx formats.",
+ },
+ "subtitle": {
+ "type": "string",
+ "example": "Confidential",
+ "description": "Optional subtitle below the banner (markdown only).",
+ },
+ "has_header": {
+ "type": "boolean",
+ "example": True,
+ "description": "csv/xlsx: treat the first row as the header. Defaults to true.",
+ },
+ "delimiter": {
+ "type": "string",
+ "example": ",",
+ "description": "csv: field delimiter. Defaults to ','.",
+ },
+ "sheet": {
+ "type": "string",
+ "example": "Sheet1",
+ "description": "xlsx: a sheet name or 1-based index. Omit to render all sheets.",
+ },
+ "style": {
+ "type": "object",
+ "description": _STYLE_DESC,
+ },
+ },
+ output_schema={
+ "status": {"type": "string", "example": "success", "description": "'success' or 'error'."},
+ "path": {"type": "string", "example": "C:/path/out.pdf", "description": "Absolute path of the created PDF."},
+ "pages": {"type": "integer", "example": 12, "description": "Page count. Only on success, where the engine reports it."},
+ "size_bytes": {"type": "integer", "example": 48230, "description": "File size. Only on success."},
+ "rows": {"type": "integer", "example": 120, "description": "csv/xlsx only: data rows rendered."},
+ "format": {"type": "string", "example": "markdown", "description": "Detected/used source format."},
+ "message": {"type": "string", "example": "...", "description": "Error detail. Only on error."},
+ },
+ requirement=["markdown2", "fpdf2", "pypdf", "openpyxl", "pillow", "playwright"],
+ test_payload={
+ "output_path": "C:/x/out.pdf",
+ "content": "# Title\n\nBody.",
+ "source_format": "markdown",
+ "simulated_mode": True,
+ },
+)
+def convert_to_pdf(input_data: dict) -> dict:
+ # NOTE: all helpers + lookup tables are defined INSIDE this function.
+ # The action loader strips module-level names from the function's
+ # globals at runtime, so referencing module-scope symbols here would
+ # raise NameError at execution time.
+ import os
+
+ simulated_mode = bool(input_data.get("simulated_mode", False))
+ output_path = str(input_data.get("output_path", "")).strip()
+ source_path = str(input_data.get("source_path", "")).strip()
+ url = str(input_data.get("url", "")).strip()
+ image_paths = input_data.get("image_paths") or []
+ if isinstance(image_paths, str):
+ image_paths = [image_paths]
+ content = input_data.get("content")
+ source_format = str(input_data.get("source_format", "")).strip().lower()
+ title = str(input_data.get("title", "")).strip()
+ subtitle = str(input_data.get("subtitle", "")).strip()
+ has_header = bool(input_data.get("has_header", True))
+ delimiter = str(input_data.get("delimiter", ",")) or ","
+ sheet_sel = str(input_data.get("sheet", "")).strip()
+ style = input_data.get("style") or {}
+ if not isinstance(style, dict):
+ style = {}
+
+ if not output_path:
+ return {"status": "error", "message": "'output_path' is required."}
+ if not output_path.lower().endswith(".pdf"):
+ return {"status": "error", "message": "'output_path' must end with .pdf."}
+
+ ext_to_format = {
+ ".md": "markdown",
+ ".markdown": "markdown",
+ ".txt": "text",
+ ".csv": "csv",
+ ".xlsx": "xlsx",
+ ".html": "html",
+ ".htm": "html",
+ ".docx": "docx",
+ ".doc": "docx",
+ ".odt": "odt",
+ ".rtf": "rtf",
+ ".pptx": "pptx",
+ ".ppt": "pptx",
+ }
+ office_exts = {
+ "docx": (".docx", ".doc"),
+ "odt": (".odt",),
+ "rtf": (".rtf",),
+ "pptx": (".pptx", ".ppt"),
+ }
+ known_formats = {
+ "markdown", "text", "csv", "xlsx", "images", "html", "url",
+ "docx", "odt", "rtf", "pptx",
+ }
+
+ # ── Resolve format ─────────────────────────────────────────────────────
+ fmt = source_format
+ if not fmt:
+ if url:
+ fmt = "url"
+ elif isinstance(image_paths, list) and image_paths:
+ fmt = "images"
+ elif source_path:
+ ext = os.path.splitext(source_path)[1].lower()
+ fmt = ext_to_format.get(ext, "")
+ elif isinstance(content, str) and content.strip():
+ fmt = "markdown" # default for inline content
+ if not fmt:
+ return {
+ "status": "error",
+ "message": (
+ "Could not determine source format. Provide source_path, content (with "
+ "source_format), url, or image_paths."
+ ),
+ }
+ if fmt not in known_formats:
+ return {"status": "error", "message": f"Unsupported source_format: '{fmt}'."}
+
+ if simulated_mode:
+ pages = len(image_paths) if fmt == "images" else 1
+ return {"status": "success", "path": output_path, "pages": pages, "format": fmt}
+
+ # ── Dispatch ──────────────────────────────────────────────────────────
+ result: dict
+
+ if fmt == "markdown":
+ if source_path:
+ if not os.path.isfile(source_path):
+ return {"status": "error", "message": f"source_path not found: {source_path}"}
+ try:
+ with open(source_path, encoding="utf-8", errors="replace") as f:
+ markdown_text = f.read()
+ except OSError as exc:
+ return {"status": "error", "message": f"Could not read source_path: {exc}"}
+ elif isinstance(content, str) and content.strip():
+ markdown_text = content
+ else:
+ return {"status": "error", "message": "Provide source_path (.md) or non-empty content."}
+
+ try:
+ from app.utils.pdf_render import convert_markdown
+
+ r = convert_markdown(markdown_text, output_path, overrides=style, subtitle=subtitle)
+ result = {
+ "status": "success",
+ "path": r["path"],
+ "pages": r.get("pages"),
+ "size_bytes": r.get("size_bytes"),
+ }
+ except PermissionError as exc:
+ return {"status": "error", "message": f"Permission denied writing to '{output_path}': {exc}"}
+ except Exception as exc:
+ return {"status": "error", "message": f"PDF generation failed: {type(exc).__name__}: {exc}"}
+
+ elif fmt == "text":
+ import re
+
+ if source_path:
+ if not os.path.isfile(source_path):
+ return {"status": "error", "message": f"source_path not found: {source_path}"}
+ try:
+ with open(source_path, encoding="utf-8", errors="replace") as f:
+ text = f.read()
+ except OSError as exc:
+ return {"status": "error", "message": f"Could not read source_path: {exc}"}
+ elif isinstance(content, str) and content.strip():
+ text = content
+ else:
+ return {"status": "error", "message": "Provide source_path (.txt) or non-empty content."}
+
+ def _esc(line: str) -> str:
+ line = re.sub(r"([\\`*_|])", r"\\\1", line)
+ line = re.sub(r"^(\s*)([#>+\-])", r"\1\\\2", line)
+ line = re.sub(r"^(\s*\d+)\.", r"\1\\.", line)
+ return line
+
+ md_lines = [(_esc(ln) + " ") if ln.strip() else "" for ln in text.split("\n")]
+ markdown_text = "\n".join(md_lines)
+ if title:
+ markdown_text = f"# {title}\n\n" + markdown_text
+
+ try:
+ from app.utils.pdf_render import convert_markdown
+
+ r = convert_markdown(markdown_text, output_path, overrides=style)
+ result = {
+ "status": "success",
+ "path": r["path"],
+ "pages": r.get("pages"),
+ "size_bytes": r.get("size_bytes"),
+ }
+ except PermissionError as exc:
+ return {"status": "error", "message": f"Permission denied writing to '{output_path}': {exc}"}
+ except Exception as exc:
+ return {"status": "error", "message": f"PDF generation failed: {type(exc).__name__}: {exc}"}
+
+ elif fmt == "csv":
+ import csv
+
+ if not source_path or not os.path.isfile(source_path):
+ return {"status": "error", "message": f"source_path (.csv) not found: {source_path}"}
+
+ try:
+ with open(source_path, newline="", encoding="utf-8", errors="replace") as f:
+ rows = list(csv.reader(f, delimiter=delimiter))
+ except OSError as exc:
+ return {"status": "error", "message": f"Could not read source_path: {exc}"}
+
+ rows = [r for r in rows if any(str(c).strip() for c in r)]
+ if not rows:
+ return {"status": "error", "message": "CSV is empty."}
+
+ def _cell(v):
+ return str(v).replace("|", "\\|").replace("\n", " ").strip()
+
+ ncols = max(len(r) for r in rows)
+ if has_header:
+ header = [_cell(c) for c in rows[0]] + [""] * (ncols - len(rows[0]))
+ body = rows[1:]
+ else:
+ header = [f"Column {i + 1}" for i in range(ncols)]
+ body = rows
+
+ lines = ["| " + " | ".join(header) + " |", "| " + " | ".join(["---"] * ncols) + " |"]
+ for r in body:
+ cells = [_cell(c) for c in r] + [""] * (ncols - len(r))
+ lines.append("| " + " | ".join(cells) + " |")
+ markdown_text = "\n".join(lines)
+ if title:
+ markdown_text = f"# {title}\n\n" + markdown_text
+
+ try:
+ from app.utils.pdf_render import convert_markdown
+
+ r = convert_markdown(markdown_text, output_path, overrides=style)
+ result = {
+ "status": "success",
+ "path": r["path"],
+ "pages": r.get("pages"),
+ "size_bytes": r.get("size_bytes"),
+ "rows": len(body),
+ }
+ except PermissionError as exc:
+ return {"status": "error", "message": f"Permission denied writing to '{output_path}': {exc}"}
+ except Exception as exc:
+ return {"status": "error", "message": f"PDF generation failed: {type(exc).__name__}: {exc}"}
+
+ elif fmt == "xlsx":
+ if not source_path or not os.path.isfile(source_path):
+ return {"status": "error", "message": f"source_path (.xlsx) not found: {source_path}"}
+
+ try:
+ import openpyxl
+
+ wb = openpyxl.load_workbook(source_path, read_only=True, data_only=True)
+ except Exception as exc:
+ return {"status": "error", "message": f"Could not read xlsx: {type(exc).__name__}: {exc}"}
+
+ sheets = list(wb.worksheets)
+ if sheet_sel:
+ if sheet_sel.isdigit():
+ idx = int(sheet_sel) - 1
+ sheets = [sheets[idx]] if 0 <= idx < len(sheets) else []
+ else:
+ sheets = [ws for ws in sheets if ws.title == sheet_sel]
+ if not sheets:
+ return {"status": "error", "message": f"Sheet '{sheet_sel}' not found."}
+
+ def _cell(v):
+ if v is None:
+ return ""
+ return str(v).replace("|", "\\|").replace("\n", " ").strip()
+
+ multi = len(sheets) > 1
+ blocks = []
+ total_rows = 0
+ for ws in sheets:
+ rows = [list(r) for r in ws.iter_rows(values_only=True)]
+ rows = [r for r in rows if any(c is not None and str(c).strip() for c in r)]
+ if not rows:
+ continue
+ ncols = max(len(r) for r in rows)
+ if has_header:
+ header = [_cell(c) for c in rows[0]] + [""] * (ncols - len(rows[0]))
+ body = rows[1:]
+ else:
+ header = [f"Column {i + 1}" for i in range(ncols)]
+ body = rows
+ total_rows += len(body)
+ lines = ["| " + " | ".join(header) + " |", "| " + " | ".join(["---"] * ncols) + " |"]
+ for r in body:
+ cells = [_cell(c) for c in r] + [""] * (ncols - len(r))
+ lines.append("| " + " | ".join(cells) + " |")
+ block = "\n".join(lines)
+ if multi:
+ block = f"## {ws.title}\n\n{block}"
+ blocks.append(block)
+
+ if not blocks:
+ return {"status": "error", "message": "Workbook has no data."}
+ markdown_text = "\n\n".join(blocks)
+ if title:
+ markdown_text = f"# {title}\n\n" + markdown_text
+
+ try:
+ from app.utils.pdf_render import convert_markdown
+
+ r = convert_markdown(markdown_text, output_path, overrides=style)
+ result = {
+ "status": "success",
+ "path": r["path"],
+ "pages": r.get("pages"),
+ "size_bytes": r.get("size_bytes"),
+ "rows": total_rows,
+ }
+ except PermissionError as exc:
+ return {"status": "error", "message": f"Permission denied writing to '{output_path}': {exc}"}
+ except Exception as exc:
+ return {"status": "error", "message": f"PDF generation failed: {type(exc).__name__}: {exc}"}
+
+ elif fmt == "images":
+ if not isinstance(image_paths, list) or not image_paths:
+ return {"status": "error", "message": "'image_paths' must be a non-empty list of absolute paths."}
+ missing = [p for p in image_paths if not os.path.isfile(p)]
+ if missing:
+ return {"status": "error", "message": f"Image(s) not found: {missing[:5]}"}
+
+ try:
+ from app.utils.pdf_render import convert_images
+
+ r = convert_images(image_paths, output_path, overrides=style)
+ result = {
+ "status": "success",
+ "path": r["path"],
+ "pages": r.get("pages"),
+ "size_bytes": r.get("size_bytes"),
+ }
+ except PermissionError as exc:
+ return {"status": "error", "message": f"Permission denied writing to '{output_path}': {exc}"}
+ except Exception as exc:
+ return {"status": "error", "message": f"PDF generation failed: {type(exc).__name__}: {exc}"}
+
+ elif fmt == "html":
+ if source_path:
+ if not os.path.isfile(source_path):
+ return {"status": "error", "message": f"source_path not found: {source_path}"}
+ html_text = None
+ elif isinstance(content, str) and content.strip():
+ html_text = content
+ else:
+ return {"status": "error", "message": "Provide source_path (.html) or non-empty content."}
+
+ from app.utils.pdf_convert import convert_html
+
+ result = convert_html(output_path, source_path=source_path or None, html_text=html_text, style=style)
+
+ elif fmt == "url":
+ if not (url.startswith("http://") or url.startswith("https://")):
+ return {"status": "error", "message": "'url' must start with http:// or https://."}
+
+ from app.utils.pdf_convert import convert_url
+
+ result = convert_url(url, output_path, style=style)
+
+ else: # office formats: docx / odt / rtf / pptx
+ from app.utils.pdf_convert import office_to_pdf_impl
+
+ result = office_to_pdf_impl(
+ {"output_path": output_path, "source_path": source_path},
+ office_exts[fmt],
+ )
+
+ if isinstance(result, dict) and result.get("status") == "success":
+ result.setdefault("format", fmt)
+ return result
diff --git a/app/data/action/create_pdf.py b/app/data/action/create_pdf.py
deleted file mode 100644
index 04eba416..00000000
--- a/app/data/action/create_pdf.py
+++ /dev/null
@@ -1,398 +0,0 @@
-from agent_core import action
-
-
-@action(
- name="create_pdf",
- description=(
- "Creates a visually polished PDF from Markdown content. "
- "Supports headings (# to #####), paragraphs, bullet and numbered lists, "
- "bold, italic, inline code, fenced code blocks, tables, strikethrough, "
- "blockquotes, and horizontal rules. "
- "The first # heading is rendered as a banner header. "
- "Colours, typography, and margins are read from FORMAT.md at render time. "
- "Use absolute paths only."
- ),
- mode="CLI",
- action_sets=["document_processing"],
- parallelizable=False,
- input_schema={
- "file_path": {
- "type": "string",
- "example": "C:/Users/user/Documents/my_file.pdf",
- "description": (
- "Absolute path where the PDF will be saved. "
- "Parent directories are created automatically if they do not exist. "
- "Must end with .pdf."
- ),
- },
- "content": {
- "type": "string",
- "example": (
- "# My Report\n\n## Summary\n\nThis is **bold** and *italic*.\n\n"
- "- Item 1\n- Item 2\n\n```python\nprint('hello')\n```"
- ),
- "description": (
- "Markdown-formatted content to convert into a PDF. "
- "The first # heading becomes the banner title. "
- "Supports tables (pipe syntax), fenced code blocks (```lang), "
- "and ~~strikethrough~~."
- ),
- },
- "subtitle": {
- "type": "string",
- "example": "Confidential - Internal Use Only",
- "description": (
- "Optional subtitle line shown below the title in the banner. "
- "Leave empty or omit to hide."
- ),
- },
- "page_numbers": {
- "type": "boolean",
- "example": True,
- "description": "Show 'Page N of M' in the footer. Defaults to true.",
- },
- },
- output_schema={
- "status": {
- "type": "string",
- "example": "success",
- "description": "'success' or 'error'.",
- },
- "path": {
- "type": "string",
- "example": "C:/Users/user/Documents/my_file.pdf",
- "description": "Absolute path of the created PDF.",
- },
- "pages": {
- "type": "integer",
- "example": 3,
- "description": "Number of pages in the generated PDF. Only present on success.",
- },
- "size_bytes": {
- "type": "integer",
- "example": 48230,
- "description": "File size in bytes. Only present on success.",
- },
- "theme_used": {
- "type": "string",
- "example": "format_md",
- "description": (
- "Always 'format_md'. Styling is derived from FORMAT.md "
- "(accent=#FF4F18, base=#141517, muted=#6B6E76). "
- "Useful for downstream actions (e.g. edit_pdf) that need to match colours."
- ),
- },
- "message": {
- "type": "string",
- "example": "Permission denied.",
- "description": "Human-readable error detail. Only present on error.",
- },
- },
- requirement=["markdown2", "fpdf2"],
- test_payload={
- "file_path": "C:/Users/user/Documents/my_file.pdf",
- "content": (
- "# My Title\n\nThis is a paragraph with **bold** text and a bullet list:\n"
- "- Item 1\n- Item 2"
- ),
- "simulated_mode": True,
- },
-)
-def create_pdf_file(input_data: dict) -> dict:
- # ── Input extraction ──────────────────────────────────────────────────
- simulated_mode = bool(input_data.get("simulated_mode", False))
- file_path = str(input_data.get("file_path", "")).strip()
- content = str(input_data.get("content", "")).strip()
- subtitle = str(input_data.get("subtitle", "")).strip()
- page_numbers = bool(input_data.get("page_numbers", True))
-
- # ── Validation ────────────────────────────────────────────────────────
- if not file_path:
- return {
- "status": "error",
- "path": "",
- "message": "The 'file_path' field is required.",
- }
- if not content:
- return {
- "status": "error",
- "path": "",
- "message": "The 'content' field is required.",
- }
- if not file_path.lower().endswith(".pdf"):
- return {
- "status": "error",
- "path": "",
- "message": "'file_path' must end with .pdf.",
- }
-
- if simulated_mode:
- return {"status": "success", "path": file_path, "theme_used": "format_md"}
-
- # ── Imports (executor pre-installs via requirement=, this is a fallback) ──
- import os
- import re
- import sys
- import subprocess
- import importlib
- from html import unescape
-
- def _ensure(pkg, import_as=None):
- try:
- importlib.import_module(import_as or pkg)
- except ImportError:
- subprocess.check_call(
- [sys.executable, "-m", "pip", "install", pkg, "--quiet"],
- stdout=subprocess.DEVNULL,
- stderr=subprocess.DEVNULL,
- )
-
- _ensure("markdown2")
- _ensure("fpdf2", "fpdf")
-
- import markdown2
- from fpdf import FPDF
- from fpdf.fonts import TextStyle, FontFace
- from fpdf.pattern import LinearGradient
- from app.config import AGENT_FILE_SYSTEM_PATH
- from app.utils.pdf_format import load_style, build_theme as _build_theme
-
- # ── Style resolved from FORMAT.md (falls back to CraftBot brand defaults) ──
- _fmt = load_style(AGENT_FILE_SYSTEM_PATH / "FORMAT.md")
- t = _build_theme(_fmt)
- _MARGIN_MM = _fmt["margin_in"] * 25.4
-
- # ── Unicode sanitizer ─────────────────────────────────────────────────
- # fpdf2's built-in fonts (Helvetica, Courier, Times) only cover latin-1
- # (characters 0-255). Any unicode character above that range causes a
- # crash at render time. This map converts the most common offenders to
- # safe ASCII equivalents before the HTML reaches fpdf2's parser.
- # Characters with no mapping are replaced with '?'.
- _CHAR_MAP = {
- "\u2014": "--",
- "\u2013": "-",
- "\u2012": "-",
- "\u2018": "'",
- "\u2019": "'",
- "\u201a": ",",
- "\u201c": '"',
- "\u201d": '"',
- "\u201e": '"',
- "\u2026": "...",
- "\u00a0": " ",
- "\u2022": "*",
- "\u2010": "-",
- "\u2011": "-",
- "\u2015": "--",
- "\u2122": "TM",
- "\u00ae": "(R)",
- "\u00a9": "(C)",
- "\u20ac": "EUR",
- "\u00a3": "GBP",
- "\u00a5": "JPY",
- "\u2192": "->",
- "\u2190": "<-",
- "\u2191": "^",
- "\u2193": "v",
- "\u2713": "[x]",
- "\u2714": "[x]",
- "\u2717": "[ ]",
- "\u2610": "[ ]",
- "\u2611": "[x]",
- "\u00b0": "deg",
- "\u2265": ">=",
- "\u2264": "<=",
- "\u00d7": "x",
- "\u00f7": "/",
- "\u00b1": "+/-",
- "\u2248": "~=",
- "\u2260": "!=",
- "\u00b2": "^2",
- "\u00b3": "^3",
- }
-
- def _sanitize(text):
- decoded = unescape(text)
- out = []
- for ch in decoded:
- rep = _CHAR_MAP.get(ch)
- if rep is not None:
- out.append(rep)
- elif ord(ch) > 255:
- out.append("?")
- else:
- out.append(ch)
- return "".join(out)
-
- # ── Build PDF ─────────────────────────────────────────────────────────
- try:
- # Convert markdown to HTML.
- # smarty-pants is intentionally excluded: it converts -- and "quotes"
- # to unicode HTML entities that get unescaped inside fpdf2's parser
- # AFTER our sanitizer has already run, causing a crash.
- html = markdown2.markdown(
- content,
- extras=["fenced-code-blocks", "tables", "strike", "footnotes"],
- )
- html = _sanitize(html)
-
- # Extract the first H1 to use as the banner title, then remove it
- # from the body so it is not rendered twice.
- title_match = re.search(r"]*>(.*?)", html, re.IGNORECASE | re.DOTALL)
- doc_title = (
- re.sub(r"<[^>]+>", "", title_match.group(1)).strip() if title_match else ""
- )
- html_body = html.replace(title_match.group(0), "", 1) if title_match else html
-
- # FPDF setup
- pdf = FPDF()
- pdf.set_auto_page_break(auto=True, margin=_MARGIN_MM)
- pdf.set_margins(left=_MARGIN_MM, top=_MARGIN_MM, right=_MARGIN_MM)
- if doc_title:
- pdf.set_title(doc_title)
- pdf.set_creator("CraftBot")
- pdf.add_page()
-
- pw = pdf.w - pdf.l_margin - pdf.r_margin # usable page width
- lm = pdf.l_margin
- y0 = 8 # banner top y-position
- # Banner height: scale with FORMAT.md header_height_in but floor at 30mm
- # so the title text always fits. FORMAT.md's 0.4" is a nav-bar spec; the
- # PDF banner is a title block that needs proportionally more space.
- _BASE_H = max(round(_fmt["header_height_in"] * 25.4 * 2.5), 30)
- HH = _BASE_H + (10 if subtitle else 0)
-
- # ── Gradient banner ───────────────────────────────────────────────
- grad = LinearGradient(lm, y0, lm + pw, y0, colors=t["hbg"])
- with pdf.use_pattern(grad):
- pdf.rect(lm, y0, pw, HH, style="F")
-
- if doc_title:
- pdf.set_font("Helvetica", "B", _fmt["h1_pt"])
- pdf.set_text_color(*t["htxt"])
- title_y = y0 + (HH - 12) / 2 - (5 if subtitle else 0)
- pdf.set_xy(lm + 8, title_y)
- pdf.cell(pw - 16, 12, doc_title[:72], align="L")
-
- if subtitle:
- pdf.set_font("Helvetica", "I", 9)
- pdf.set_text_color(*t["subtitle"])
- pdf.set_xy(lm + 8, y0 + HH - 14)
- pdf.cell(pw - 16, 8, _sanitize(subtitle)[:100], align="L")
-
- # Thin accent rule below banner
- pdf.set_draw_color(*t["rule"])
- pdf.set_line_width(0.8)
- pdf.line(lm, y0 + HH + 1, lm + pw, y0 + HH + 1)
- pdf.set_y(y0 + HH + 7)
-
- # ── Heading and code styles ───────────────────────────────────────
- tag_styles = {
- "h1": TextStyle(
- font_family="Helvetica",
- font_style="B",
- font_size_pt=_fmt["h1_pt"],
- color=t["h2"],
- t_margin=10,
- b_margin=3,
- ),
- "h2": TextStyle(
- font_family="Helvetica",
- font_style="B",
- font_size_pt=_fmt["h2_pt"],
- color=t["h2"],
- t_margin=8,
- b_margin=2,
- ),
- "h3": TextStyle(
- font_family="Helvetica",
- font_style="B",
- font_size_pt=_fmt["h3_pt"],
- color=t["h3"],
- t_margin=6,
- b_margin=2,
- ),
- "h4": TextStyle(
- font_family="Helvetica",
- font_style="BI",
- font_size_pt=_fmt["body_pt"],
- color=t["h3"],
- t_margin=4,
- b_margin=1,
- ),
- "h5": TextStyle(
- font_family="Helvetica",
- font_style="I",
- font_size_pt=_fmt["small_pt"],
- color=t["h3"],
- t_margin=3,
- b_margin=1,
- ),
- "code": TextStyle(
- font_family="Courier",
- font_size_pt=_fmt["code_pt"],
- color=t["cc"],
- fill_color=t["cbg"],
- ),
- "pre": TextStyle(
- font_family="Courier",
- font_size_pt=_fmt["code_pt"],
- color=t["cc"],
- fill_color=t["cbg"],
- ),
- "a": FontFace(color=t["accent"]),
- }
-
- pdf.set_text_color(*t["body"])
- pdf.set_font("Helvetica", size=_fmt["body_pt"])
- pdf.write_html(
- html_body,
- font_family="Helvetica",
- tag_styles=tag_styles,
- table_line_separators=True,
- ul_bullet_char="*",
- )
-
- # ── Page number footer ────────────────────────────────────────────
- n_pages = len(pdf.pages)
- if page_numbers:
- for pg in range(1, n_pages + 1):
- pdf.page = pg
- pdf.set_y(-12)
- pdf.set_font("Helvetica", "I", _fmt["small_pt"])
- pdf.set_text_color(*_fmt["muted"])
- pdf.cell(0, 5, f"Page {pg} of {n_pages}", align="C")
-
- # ── Write to disk ─────────────────────────────────────────────────
- abs_path = os.path.abspath(file_path)
- parent = os.path.dirname(abs_path)
- if parent:
- os.makedirs(parent, exist_ok=True)
-
- pdf.output(abs_path)
- return {
- "status": "success",
- "path": abs_path,
- "pages": n_pages,
- "size_bytes": os.path.getsize(abs_path),
- "theme_used": "format_md",
- }
-
- except PermissionError as exc:
- return {
- "status": "error",
- "path": "",
- "message": f"Permission denied writing to '{file_path}': {exc}",
- }
- except OSError as exc:
- return {
- "status": "error",
- "path": "",
- "message": f"File system error: {exc}",
- }
- except Exception as exc:
- return {
- "status": "error",
- "path": "",
- "message": f"PDF generation failed: {type(exc).__name__}: {exc}",
- }
diff --git a/app/data/action/edit_pdf.py b/app/data/action/edit_pdf.py
index e9e0f973..6b0581f9 100644
--- a/app/data/action/edit_pdf.py
+++ b/app/data/action/edit_pdf.py
@@ -12,11 +12,9 @@
"replace_text (find + font-matched reinsert), add_text_near (fill after a label), "
"watermark, rotate_page, fill_field (AcroForm). "
"For tasks that require text reflow (rephrasing paragraphs, inserting new sections, "
- "reformatting layout): use create_pdf to rebuild the document with changes applied — "
- "the user receives the same output path with a clean result. "
- "When editing a PDF created by create_pdf, match the accent colour to "
- "FORMAT.md's highlight value (default #FF4F18) to align with the document style. "
- "Use absolute paths only."
+ "reformatting layout): use convert_to_pdf (markdown format) to rebuild the document with "
+ "changes applied — write to the SAME output_path and it reuses that PDF's saved style "
+ "automatically, so the look is preserved. Use absolute paths only."
),
mode="CLI",
action_sets=["document_processing"],
@@ -322,7 +320,7 @@ def _get_span_at_rect(page, target_rect):
if not operations:
return _json("error", "'operations' list is required and must not be empty.")
- # Detect reflow operations — these require create_pdf routing
+ # Detect reflow operations — these require convert_to_pdf rebuild routing
_REFLOW_OPS = {
"rephrase_text",
"insert_section",
@@ -335,9 +333,10 @@ def _get_span_at_rect(page, target_rect):
return _json(
"error",
f"Operation(s) {reflow_ops} require text reflow which PDF does not support. "
- "Use create_pdf to rebuild the document with the desired changes applied. "
- "Read the original with read_pdf (text mode), apply changes to the text content, "
- "then pass the updated content to create_pdf at the same output_path.",
+ "Use convert_to_pdf (markdown format) to rebuild the document with the desired "
+ "changes applied. Read the original with read_pdf (text mode), apply changes to the "
+ "text content, then pass the updated content to convert_to_pdf at the same "
+ "output_path (it reuses the PDF's saved style, so the look is preserved).",
)
# ── Apply operations ──────────────────────────────────────────────────
diff --git a/app/data/action/read_pdf.py b/app/data/action/read_pdf.py
index 809d8227..59b40f42 100644
--- a/app/data/action/read_pdf.py
+++ b/app/data/action/read_pdf.py
@@ -10,7 +10,9 @@
"mode='layout': returns per-word bounding boxes (BOTTOMLEFT origin) — use when "
"edit_pdf or form-filling needs spatial coordinates. "
"page_range limits which pages are read (e.g. '1', '1-3', '2,4'). "
- "Digital PDFs use pdfplumber. Scanned/image PDFs fall back to Docling automatically."
+ "Digital PDFs use pdfplumber. Scanned/image PDFs fall back to Docling automatically. "
+ "NOTE: this returns text/coordinates only, NOT the visual layout — to EDIT a PDF while "
+ "preserving its look, use convert_from_pdf (html target) instead of rebuilding from this text."
),
mode="CLI",
action_sets=["document_processing"],
diff --git a/app/data/action/run_python.py b/app/data/action/run_python.py
deleted file mode 100644
index 4bcaeeb8..00000000
--- a/app/data/action/run_python.py
+++ /dev/null
@@ -1,94 +0,0 @@
-from agent_core import action
-
-
-@action(
- name="run_python",
- description="Execute a Python code snippet in an isolated environment. Missing packages are auto-installed. Use print() to return results.",
- execution_mode="sandboxed",
- mode="CLI",
- default=True,
- action_sets=["core"],
- input_schema={
- "code": {
- "type": "string",
- "example": "print('Hello World')",
- "description": "Python code to execute. Use print() to output results.",
- }
- },
- output_schema={
- "status": {"type": "string", "description": "'success' or 'error'"},
- "stdout": {"type": "string", "description": "Output from print() statements"},
- "stderr": {"type": "string", "description": "Error output (if any)"},
- "message": {
- "type": "string",
- "description": "Error message (only if status is 'error')",
- },
- },
- requirement=[],
- test_payload={"code": "print('test')", "simulated_mode": True},
-)
-def create_and_run_python_script(input_data: dict) -> dict:
- import sys
- import io
- import traceback
- import subprocess
- import re
-
- code = input_data.get("code", "").strip()
-
- if not code:
- return {
- "status": "error",
- "stdout": "",
- "stderr": "",
- "message": "No code provided",
- }
-
- # Capture stdout/stderr
- stdout_buf = io.StringIO()
- stderr_buf = io.StringIO()
- old_stdout, old_stderr = sys.stdout, sys.stderr
-
- def install_package(pkg):
- try:
- subprocess.check_call(
- [sys.executable, "-m", "pip", "install", "--quiet", pkg],
- stdout=subprocess.DEVNULL,
- stderr=subprocess.DEVNULL,
- timeout=60,
- )
- return True
- except Exception:
- return False
-
- try:
- sys.stdout, sys.stderr = stdout_buf, stderr_buf
-
- # Simple exec with retry for missing modules
- for attempt in range(3):
- try:
- exec(code, {"__builtins__": __builtins__})
- break
- except ModuleNotFoundError as e:
- match = re.search(r"No module named ['\"]([^'\"]+)['\"]", str(e))
- if match and attempt < 2:
- pkg = match.group(1).split(".")[0]
- if install_package(pkg):
- continue
- raise
-
- sys.stdout, sys.stderr = old_stdout, old_stderr
- return {
- "status": "success",
- "stdout": stdout_buf.getvalue().strip(),
- "stderr": stderr_buf.getvalue().strip(),
- }
-
- except Exception:
- sys.stdout, sys.stderr = old_stdout, old_stderr
- return {
- "status": "error",
- "stdout": stdout_buf.getvalue().strip(),
- "stderr": stderr_buf.getvalue().strip(),
- "message": traceback.format_exc(),
- }
diff --git a/app/data/action/run_shell.py b/app/data/action/run_shell.py
index 505cd440..6bb61c6d 100644
--- a/app/data/action/run_shell.py
+++ b/app/data/action/run_shell.py
@@ -16,7 +16,7 @@
"shell": {
"type": "string",
"example": "auto",
- "description": "Shell to use. Default is platform's native shell (cmd, bash, or zsh).",
+ "description": "Shell to use. Windows: 'cmd' (default), 'powershell', or 'pwsh' — bash/zsh are NOT available, and an unsupported value returns an error. macOS: 'bash' (default) or 'zsh'. Linux: ignored (runs via the system shell).",
},
"timeout": {
"type": "integer",
@@ -214,7 +214,7 @@ def shell_exec(input_data: dict) -> dict:
"shell": {
"type": "string",
"example": "auto",
- "description": "Shell to use. Default is platform's native shell (cmd, bash, or zsh).",
+ "description": "Shell to use. Windows: 'cmd' (default), 'powershell', or 'pwsh' — bash/zsh are NOT available, and an unsupported value returns an error. macOS: 'bash' (default) or 'zsh'. Linux: ignored (runs via the system shell).",
},
"timeout": {
"type": "integer",
@@ -279,11 +279,28 @@ def shell_exec_windows(input_data: dict) -> dict:
command = str(input_data.get("command", "")).strip()
shell_choice = str(input_data.get("shell", "cmd")).strip().lower()
- if shell_choice == "auto":
+ if shell_choice in ("", "auto"):
shell_choice = "cmd"
- shell_choice = (
- shell_choice if shell_choice in ("cmd", "powershell", "pwsh") else "cmd"
- )
+ if shell_choice not in ("cmd", "powershell", "pwsh"):
+ # Previously any unsupported value (e.g. "bash", "sh", "zsh") was
+ # silently coerced to cmd, so a bash heredoc would run under cmd and
+ # fail with a cryptic "<< was unexpected at this time." Return an
+ # explicit error instead so the caller knows its shell choice was
+ # rejected and why.
+ return {
+ "status": "error",
+ "stdout": "",
+ "stderr": "",
+ "return_code": -1,
+ "message": (
+ f"Shell '{shell_choice}' is not available on Windows. "
+ "Supported shells: cmd, powershell, pwsh. "
+ "bash/zsh/sh syntax (e.g. heredocs) will NOT run here — "
+ "use PowerShell for scripting, or write files via a file action "
+ "rather than shell redirection."
+ ),
+ "pid": None,
+ }
timeout_val = input_data.get("timeout")
cwd = input_data.get("cwd")
env_input = input_data.get("env") or {}
@@ -445,7 +462,7 @@ def shell_exec_windows(input_data: dict) -> dict:
"shell": {
"type": "string",
"example": "auto",
- "description": "Shell to use. Default is platform's native shell (cmd, bash, or zsh).",
+ "description": "Shell to use. Windows: 'cmd' (default), 'powershell', or 'pwsh' — bash/zsh are NOT available, and an unsupported value returns an error. macOS: 'bash' (default) or 'zsh'. Linux: ignored (runs via the system shell).",
},
"timeout": {
"type": "integer",
diff --git a/app/data/action/set_requirement.py b/app/data/action/set_requirement.py
new file mode 100644
index 00000000..d6dfc085
--- /dev/null
+++ b/app/data/action/set_requirement.py
@@ -0,0 +1,96 @@
+from agent_core import action
+
+
+@action(
+ name="set_requirement",
+ description=(
+ "Record (or update) the concrete, checkable requirements that define DONE for this task's deliverable. "
+ "This is the SCOPE of the output, NOT a plan of work — for work-tracking, use 'task_update_todos'. "
+ "Call this in the very first step of a complex task (BEFORE acknowledging the user) to lock in WHAT the "
+ "finished deliverable must contain and look like; call it again during Collect if new information forces a scope update; "
+ "call it again during Verify to mark each item satisfied or violated.\n\n"
+ "Every requirement MUST be concrete and falsifiable. A reader who has never seen this task should be able to look at the "
+ "deliverable, read your `done_when`, and decide pass/fail without further interpretation.\n\n"
+ "BANNED phrasing (these are aspirations, not requirements): 'high quality', 'good design', 'comprehensive', 'professional', "
+ "'polished', 'thorough', 'appropriate', 'well-structured', 'beautiful', 'engaging', 'detailed enough', 'as needed'. "
+ "If a requirement reads like a compliment instead of a check, REWRITE it.\n\n"
+ "Cover every dimension that materially shapes the output. Typical dimensions include but are not limited to: "
+ "content (what specific topics/sections/data must be included), "
+ "structure (ordering, section hierarchy, navigation), "
+ "length (per section, per page, total), "
+ "style/tone (voice, register, reading level, vocabulary), "
+ "design (typography choices, color, spacing, hierarchy, layout rules), "
+ "media (which images, charts, diagrams, tables — and where), "
+ "format (file type, output target, encoding), "
+ "data_sources (which sources must be cited, freshness requirements), "
+ "audience (who reads this and what they need), "
+ "constraints (what is forbidden, banned, or limited).\n\n"
+ "Always provide the COMPLETE current requirement list. This action can be executed in parallel with send_message, but do not "
+ "call multiple set_requirement actions at the same time."
+ ),
+ mode="ALL",
+ default=True,
+ action_sets=["core"],
+ parallelizable=True,
+ input_schema={
+ "requirements": {
+ "type": "array",
+ "description": (
+ 'Array of requirement objects. Each object MUST have these keys: '
+ '"dimension" (string: which aspect of the deliverable — e.g. "content", "structure", "length", "style", '
+ '"design", "media", "tone", "format", "data_sources", "audience", "constraints"), '
+ '"requirement" (string: the SPECIFIC requirement, written so a critic can check it. '
+ 'Concrete and falsifiable. NEVER vague praise.), '
+ '"done_when" (string: the concrete test the deliverable must pass to satisfy this requirement). '
+ 'Optional: "status" — one of "pending" (default, not yet checked), "satisfied" (Verify confirmed), '
+ '"violated" (Verify found it failing — triggers rework).\n\n'
+ 'Good example: {"dimension":"content","requirement":"Include a chronological version history covering every major release from launch through the latest patch","done_when":"A markdown table exists with one row per major version, each row listing version number, release date, and the headline feature/change"}.\n\n'
+ 'Bad example (DO NOT WRITE): {"dimension":"content","requirement":"Comprehensive history of the game","done_when":"All major events are covered"}.'
+ ),
+ "required": True,
+ }
+ },
+ output_schema={
+ "status": {
+ "type": "string",
+ "example": "success",
+ "description": "Indicates whether the requirement list was updated successfully.",
+ }
+ },
+ test_payload={
+ "requirements": [
+ {
+ "dimension": "content",
+ "requirement": "Include sections: Overview, History (chronological table), Gameplay Mechanics, Editions Comparison Table, Reception with cited Metacritic/OpenCritic scores, Cultural Impact, Developer Information",
+ "done_when": "Each named section header appears as an H2 in the markdown output and contains body text",
+ "status": "pending",
+ },
+ {
+ "dimension": "length",
+ "requirement": "Each top-level section is at least 4 substantive paragraphs OR an equivalent dense table; total deliverable is at least the length of a long-read feature article",
+ "done_when": "Every H2 section in the file passes 4-paragraph minimum on read-back, or contains a table with 6+ rows",
+ "status": "pending",
+ },
+ {
+ "dimension": "media",
+ "requirement": "At least one tabular element per major data-dense section (history, editions, reception); never use emoji as bullet markers",
+ "done_when": "grep of the deliverable shows ≥3 markdown tables; grep shows zero leading emoji bullets in body text",
+ "status": "pending",
+ },
+ ],
+ "simulated_mode": True,
+ },
+)
+def set_requirement(input_data: dict) -> dict:
+ """Emit the requirement contract into the event stream so the agent reads it back on every subsequent step."""
+ requirements = input_data.get("requirements", [])
+ simulated_mode = input_data.get("simulated_mode", False)
+
+ if not simulated_mode:
+ import app.internal_action_interface as iai
+
+ result = iai.InternalActionInterface.update_requirements(requirements)
+ status = "success" if result.get("status") in ("ok", "success") else "error"
+ return {"status": status}
+
+ return {"status": "success"}
diff --git a/app/data/agent_file_system_template/AGENT.md b/app/data/agent_file_system_template/AGENT.md
index abf61dd0..7904f1c2 100644
--- a/app/data/agent_file_system_template/AGENT.md
+++ b/app/data/agent_file_system_template/AGENT.md
@@ -488,7 +488,7 @@ There are four failure types. Identify which one you are in, then follow the mat
**File / shell / Python action returns `status=error`**
- Read the `message` field. It often points at the fix (file not found, permission, syntax error, missing dep).
-- If the message says missing dependency for `run_python` / `run_shell`, install it via `pip install`/`npm install` in a follow-up `run_shell` call (auto-installed in sandboxed mode for declared `requirements`, but ad-hoc imports require explicit install).
+- If the message says a missing dependency while running a script via `run_shell` (e.g. a Python `ModuleNotFoundError`), install it with `pip install`/`npm install` in a follow-up `run_shell` call.
- If it says path not found, `find_files` or `list_folder` to locate before retry.
**Web / fetch action returns error**
@@ -662,9 +662,8 @@ If the log shows then
[LIMIT] ... 100% ... Waiting for user choice task is paused. Do not issue actions
until next trigger. See ## Errors above.
-ModuleNotFoundError in run_python output the script needs a dependency. Install
- via run_shell "pip install " or
- declare in action requirements.
+ModuleNotFoundError from a run_shell script the script needs a dependency. Install
+ it via run_shell "pip install " first.
PermissionError / OSError on file write the path is wrong, locked, or outside
the allowed scope. Verify with
@@ -714,7 +713,7 @@ You're blocked when you don't know what to do next AND retrying won't help. The
- **Ignoring `"warning"` events** about action/token limits. The harness will pause your task soon — get ahead of it. At 80%, wrap up or send the partial result.
- **Continuing to issue actions while limit-paused (100%).** They will not fire. The user is being shown a Continue/Abort dialog. Wait for the next trigger.
- **Trying to retry after `LLMConsecutiveFailureError`.** The task is already cancelled by `_handle_react_error`. Do NOT recreate it. Tell the user the LLM configuration needs attention.
-- **Catching exceptions in `run_python` / `run_shell` and printing "ok".** The harness sees `status=success` if your script swallows the error. Always propagate non-zero exit codes / raise on failure.
+- **Catching exceptions in a `run_shell` script and printing "ok".** The harness sees `status=success` if your script swallows the error. Always propagate non-zero exit codes / raise on failure.
- **Fabricating success messages on failure.** Forbidden. If you couldn't read the file or call the API, do not paraphrase what you "would have" produced.
- **Asking open-ended "what should I do" questions.** Always one specific question with an implied default ("Use the bot token from settings.oauth.slack, or reuse the existing /slack login session?").
- **Self-detected logical loops.** The consecutive-failure breaker only catches LLM-call failures. If you keep choosing slightly different params for the same action and getting the same business-logic error (e.g., "user not found" three times with three different IDs you guessed), that is a logical loop. Stop and ask the user.
@@ -759,6 +758,21 @@ Use only when:
Never use `write_file` to patch an existing large file. Use `stream_edit`.
+For large files (long documents, scripts, datasets), DO NOT try to emit the
+whole file in one step. Each action is a single model response bounded by the
+output-token limit. Build the file incrementally instead:
+1. Create the file with the first chunk (`write_file` in overwrite mode).
+2. Append the next section with `write_file` in append mode — one bounded chunk per step.
+3. Repeat until the content is complete.
+4. Then run or finalize it — run a script with `run_shell` (e.g. `python build_doc.py`),
+ or for a PDF build the markdown then convert it with `convert_to_pdf` (pass
+ `source_path` pointing at the markdown file; format is auto-detected from the
+ extension; pass `style` to override FORMAT.md). The same action handles every
+ source format (text, csv, xlsx, html, url, images, docx/odt/rtf/pptx). Use
+ `convert_from_pdf` for the reverse direction (PDF → .docx or .html).
+Keep each chunk small — roughly ~150 lines (a few KB) at most — so it fits
+comfortably within one response's output-token budget.
+
### find_files vs list_folder
- `list_folder`: top-level listing of a single directory.
- `find_files`: recursive name pattern search across a tree.
@@ -1089,14 +1103,19 @@ This is non-optional. Generating documents without reading FORMAT.md produces in
### Action support
-Document generation actions in the standard action set:
+Document actions in the standard action set:
```
-create_pdf build a PDF from markdown / text
- (preferred over rendering via run_python)
convert_to_markdown normalize office formats before further processing
read_pdf read a PDF with page support
+convert_to_pdf render any source → PDF; source format auto-detected from input
+ (markdown/text/csv/xlsx/html/url/images/docx/odt/rtf/pptx)
+convert_from_pdf PDF → editable .docx (pdf2docx) or layout-preserving .html (PyMuPDF);
+ the html target is the EDIT path: convert_from_pdf → stream_edit → convert_to_pdf
+edit_pdf annotate / redact / replace / watermark an existing PDF
```
+For DOCX/PPTX/XLSX *generation*, there is no built-in action — use the per-format skills listed below.
+
Skills that compose document workflows (sample):
```
pdf, docx, pptx, xlsx per-format end-to-end generation skills
@@ -1283,7 +1302,7 @@ parallelizable bool default True. False = action runs alone in its turn (writ
Key implications when reading an action:
- `mode="CLI"` actions exist (e.g. `read_file`, `task_start`). They are loaded by default.
- `parallelizable=False` actions cannot be batched. The router will sequence them. Examples: `task_update_todos`, `add_action_sets`, `remove_action_sets`.
-- `execution_mode="sandboxed"` means the action runs in a fresh venv subprocess with `requirement` packages installed automatically. `run_python` is sandboxed; most other actions are internal.
+- `execution_mode="sandboxed"` means the action runs in a fresh venv subprocess with `requirement` packages installed automatically. Most actions are `internal` (run in-process).
- `default=True` means the action is in the action list regardless of which sets are loaded. Common defaults: `task_start`, `send_message`, `ignore`. Prefer adding to an `action_sets` list over using `default=True`.
### Built-in action categories (orientation only — read source for current state)
@@ -1296,9 +1315,11 @@ core send_message, task_start, task_end, task_update_todos,
check_integration_status, disconnect_integration
file_operations read_file, grep_files, find_files, list_folder, stream_edit, write_file,
- read_pdf, convert_to_markdown, create_pdf
+ read_pdf, convert_to_markdown
+
+document_processing convert_to_pdf, convert_from_pdf, edit_pdf, read_pdf, convert_to_markdown
-shell run_shell, run_python
+shell run_shell
web_research web_fetch, web_search, http_request
@@ -1388,7 +1409,7 @@ Beyond the eight curated sets, these sets exist because actions declare them:
```
proactive schedule_task, scheduled_task_list, recurring_*, schedule_task_toggle, ...
scheduler schedule_task, schedule_task_toggle (alongside proactive)
-content_creation generate_image, create_pdf, ...
+content_creation generate_image, ...
living_ui living_ui_http, living_ui_restart, ...
per-integration sets (loaded only when the user has the integration connected):
@@ -1997,7 +2018,7 @@ See `## Proactive`.
disable it via config.
- The watcher subscribes to parent DIRECTORIES, so creating a new file in app/config/
is detected, but the file must be explicitly registered for any reload to fire.
-- Sandboxed actions (run_python with requirements) install their packages on first
+- Sandboxed actions (those declaring `requirements`) install their packages on first
call, NOT on config save. The config has no effect on action sandboxes.
---
@@ -4088,16 +4109,17 @@ Agent:
**Example 4: Repeated friction recognized over many tasks**
```
-You've noticed across 5+ tasks that whenever you generate a PDF, you keep
-forgetting to call create_pdf vs trying to render via run_python first.
+You've noticed across 5+ tasks that whenever you convert an office document
+you keep reaching for read_pdf first instead of running convert_to_markdown,
+and only realising mid-task that the input was a .docx.
-Agent (when starting an unrelated PDF task and noticing the pattern):
- 1. RECOGNIZE: pattern of forgetting the right action.
+Agent (when starting an unrelated document task and noticing the pattern):
+ 1. RECOGNIZE: pattern of picking the wrong reader action.
2. CATEGORIZE: AGENT.md operational improvement (## Self-Edit).
This is a NON-OBVIOUS convention worth recording.
3. VALIDATE: yes, future-you would benefit.
4. PROPOSE: not always required for AGENT.md polish — but if the user
- has a pattern of complaining about PDFs, ask. Otherwise, log it.
+ has a pattern of complaining about it, ask. Otherwise, log it.
5. EXECUTE: stream_edit AGENT.md ## Documents adding a clarifying note.
6. VERIFY: re-read on next turn so the new instruction is in context.
7. RECORD: bump version in front matter; sync to template.
diff --git a/app/internal_action_interface.py b/app/internal_action_interface.py
index f4b567c2..aa5e2e53 100644
--- a/app/internal_action_interface.py
+++ b/app/internal_action_interface.py
@@ -1082,6 +1082,76 @@ def _emit_todos_event(cls, todos: List[Dict[str, Any]]) -> None:
)
cls.state_manager.bump_event_stream()
+ @classmethod
+ def update_requirements(
+ cls, requirements: List[Dict[str, Any]]
+ ) -> Dict[str, Any]:
+ """
+ Record the deliverable requirement list by emitting a [requirements]
+ event into the event stream.
+
+ Requirements are NOT persisted on the Task — the action is standalone.
+ The agent re-issues the full list on every update; the event stream
+ is the source of truth that the LLM reads back.
+
+ Args:
+ requirements: List of requirement dictionaries with keys
+ dimension, requirement, done_when, and optional status.
+
+ Returns:
+ Status and the requirement list as passed in.
+ """
+ cls._emit_requirements_event(requirements)
+ return {"status": "ok", "requirements": requirements}
+
+ @classmethod
+ def _emit_requirements_event(
+ cls, requirements: List[Dict[str, Any]]
+ ) -> None:
+ """
+ Emit a [requirements] event to the event stream.
+
+ Each requirement is rendered on three lines so the model can read
+ the dimension, the spec, and the check independently:
+ [SAT]/[VIO]/[ ] :
+ done_when:
+ """
+ if cls.state_manager is None:
+ return
+
+ lines = []
+ for r in requirements:
+ status = r.get("status", "pending")
+ dimension = r.get("dimension", "")
+ requirement = r.get("requirement", "")
+ done_when = r.get("done_when", "")
+
+ if status == "satisfied":
+ marker = "[SAT]"
+ elif status == "violated":
+ marker = "[VIO]"
+ else:
+ marker = "[ ]"
+
+ lines.append(f" {marker} {dimension}: {requirement}")
+ if done_when:
+ lines.append(f" done_when: {done_when}")
+
+ if lines:
+ req_str = "\n" + "\n".join(lines)
+ else:
+ req_str = "(no requirements set)"
+
+ task_id = cls._get_current_task_id()
+
+ cls.state_manager.event_stream_manager.log(
+ kind="requirements",
+ message=req_str,
+ severity="INFO",
+ task_id=task_id,
+ )
+ cls.state_manager.bump_event_stream()
+
@classmethod
async def mark_task_completed(
cls,
diff --git a/app/main.py b/app/main.py
index 8ffd3633..fce33e0e 100644
--- a/app/main.py
+++ b/app/main.py
@@ -85,6 +85,50 @@ def _suppress_console_logging_early() -> None:
_suppress_console_logging_early()
# ============================================================================
+# ============================================================================
+# CRITICAL: SSL shim for Windows certificate store
+# Must run BEFORE any import that pulls in aiohttp/ssl (e.g. app.agent_base).
+#
+# On some Windows machines the system certificate store contains a malformed
+# certificate. The combination of conda's Python 3.10 + bundled OpenSSL in
+# this environment can't parse the raw-DER batch that _load_windows_store_certs
+# concatenates, and crashes at module import time with:
+# ssl.SSLError: [ASN1: NOT_ENOUGH_DATA] not enough data (_ssl.c:4040)
+#
+# aiohttp triggers this at import time via _make_ssl_context(True), so we
+# can't catch it after the fact. We:
+# 1. Point Python's default verify paths at certifi's CA bundle.
+# 2. Wrap _load_windows_store_certs to swallow SSLError so a single bad
+# Windows cert no longer kills startup.
+# ============================================================================
+def _install_ssl_windows_store_shim() -> None:
+ if _os.name != "nt":
+ return
+ try:
+ import ssl as _ssl
+ import certifi as _certifi
+ except Exception:
+ return
+
+ _os.environ.setdefault("SSL_CERT_FILE", _certifi.where())
+ _os.environ.setdefault("REQUESTS_CA_BUNDLE", _certifi.where())
+
+ _orig = getattr(_ssl.SSLContext, "_load_windows_store_certs", None)
+ if _orig is None:
+ return
+
+ def _safe_load_windows_store_certs(self, storename, purpose):
+ try:
+ return _orig(self, storename, purpose)
+ except _ssl.SSLError:
+ return bytearray()
+
+ _ssl.SSLContext._load_windows_store_certs = _safe_load_windows_store_certs
+
+
+_install_ssl_windows_store_shim()
+# ============================================================================
+
import argparse
import asyncio
diff --git a/app/ui_layer/adapters/browser_adapter.py b/app/ui_layer/adapters/browser_adapter.py
index 560bb7ed..6f279773 100644
--- a/app/ui_layer/adapters/browser_adapter.py
+++ b/app/ui_layer/adapters/browser_adapter.py
@@ -4329,7 +4329,7 @@ async def _err(msg: str) -> None:
# ---- Spawn the workflow task -----------------------------
# Use absolute paths in the instruction so the agent can pass
- # them verbatim to read_file / write_file / stream_edit. With
+ # them verbatim to read_file / stream_edit. With
# relative paths (e.g. "skills//SKILL.md") the agent has
# been observed mistakenly prepending the source-file's prefix
# (`agent_file_system/`), landing the new SKILL.md inside the
diff --git a/app/ui_layer/browser/frontend/src/pages/Tasks/actionRenderers/mascotFormatters.ts b/app/ui_layer/browser/frontend/src/pages/Tasks/actionRenderers/mascotFormatters.ts
index 21bb86f1..110bc346 100644
--- a/app/ui_layer/browser/frontend/src/pages/Tasks/actionRenderers/mascotFormatters.ts
+++ b/app/ui_layer/browser/frontend/src/pages/Tasks/actionRenderers/mascotFormatters.ts
@@ -118,18 +118,6 @@ const stream_edit: MascotActionFormatter = {
},
}
-const write_file: MascotActionFormatter = {
- running: (i) => {
- const fp = strField(i, 'file_path') ?? ''
- return { status: 'running', label: 'Writing file', body: fp ? basename(fp) : undefined, bodyMono: !!fp }
- },
- result: (i, _o, s) => {
- const fp = strField(i, 'file_path') ?? ''
- const verb = s === 'completed' ? 'Wrote file' : s === 'error' ? 'Write failed' : 'Write cancelled'
- return { status: s, label: verb, body: fp ? basename(fp) : undefined, bodyMono: !!fp }
- },
-}
-
const read_file: MascotActionFormatter = {
running: (i) => {
const fp = strField(i, 'file_path') ?? ''
@@ -178,13 +166,14 @@ const list_folder: MascotActionFormatter = {
},
}
-const create_pdf: MascotActionFormatter = {
+// Formatter for convert_to_pdf — covers all source formats via one schema.
+const convertToPdf: MascotActionFormatter = {
running: (i) => {
- const fp = strField(i, 'file_path') ?? ''
+ const fp = strField(i, 'output_path') ?? ''
return { status: 'running', label: 'Creating PDF', body: fp ? basename(fp) : undefined, bodyMono: !!fp }
},
result: (i, o, s) => {
- const fp = strField(o, 'path') ?? strField(i, 'file_path') ?? ''
+ const fp = strField(o, 'path') ?? strField(i, 'output_path') ?? ''
const verb = s === 'completed' ? 'Created PDF' : s === 'error' ? 'PDF creation failed' : 'PDF creation cancelled'
return { status: s, label: verb, body: fp ? basename(fp) : undefined, bodyMono: !!fp }
},
@@ -490,11 +479,11 @@ const task_update_todos: MascotActionFormatter = {
const FORMATTER_REGISTRY: Record = {
// file ops
stream_edit,
- write_file,
read_file,
find_files,
list_folder,
- create_pdf,
+ convert_to_pdf: convertToPdf,
+ convert_from_pdf: convertToPdf,
read_pdf,
convert_to_markdown,
// code execution
diff --git a/app/ui_layer/browser/frontend/src/pages/Tasks/actionRenderers/renderers.tsx b/app/ui_layer/browser/frontend/src/pages/Tasks/actionRenderers/renderers.tsx
index f1401c4e..7200f26e 100644
--- a/app/ui_layer/browser/frontend/src/pages/Tasks/actionRenderers/renderers.tsx
+++ b/app/ui_layer/browser/frontend/src/pages/Tasks/actionRenderers/renderers.tsx
@@ -55,26 +55,6 @@ const StreamEditRenderer: ActionRenderer = ({ inputObj, onOpenFile }) => {
)
}
-const WriteFileRenderer: ActionRenderer = ({ inputObj, onOpenFile }) => {
- const filePath = strField(inputObj, 'file_path') ?? ''
- const content = strField(inputObj, 'content') ?? ''
-
- return (
- <>
-
- {filePath
- ?
- : }
-
-
- {content
- ?
- : }
-
-
- )
-}
-
const ReadFileRenderer: ActionRenderer = ({ inputObj, outputObj, onOpenFile }) => {
const filePath = strField(inputObj, 'file_path') ?? ''
const content = strField(outputObj, 'content')
@@ -165,10 +145,14 @@ const ListFolderRenderer: ActionRenderer = ({ inputObj, outputObj, onOpenFile })
)
}
-const CreatePdfRenderer: ActionRenderer = ({ inputObj, outputObj, onOpenFile }) => {
- const filePath = strField(inputObj, 'file_path') ?? ''
+// Renderer for convert_to_pdf — handles all source formats via one schema.
+const ConvertToPdfRenderer: ActionRenderer = ({ inputObj, outputObj, onOpenFile }) => {
+ const outPath = strField(outputObj, 'path') ?? strField(inputObj, 'output_path') ?? ''
const content = strField(inputObj, 'content') ?? ''
- const outPath = strField(outputObj, 'path') ?? filePath
+ const sourcePath = strField(inputObj, 'source_path') ?? ''
+ const url = strField(inputObj, 'url') ?? ''
+ const imagePaths = (arrField(inputObj, 'image_paths') ?? [])
+ .filter((p): p is string => typeof p === 'string')
return (
<>
@@ -180,7 +164,13 @@ const CreatePdfRenderer: ActionRenderer = ({ inputObj, outputObj, onOpenFile })
{content
?
- : }
+ : sourcePath
+ ?
+ : url
+ ?
+ : imagePaths.length
+ ?
+ : }
)
@@ -685,11 +675,11 @@ const TaskUpdateTodosRenderer: ActionRenderer = ({ inputObj }) => {
export const SUPPORTED_ACTION_NAMES = [
// file ops
'stream_edit',
- 'write_file',
'read_file',
'find_files',
'list_folder',
- 'create_pdf',
+ 'convert_to_pdf',
+ 'convert_from_pdf',
'read_pdf',
'convert_to_markdown',
// code execution
@@ -732,11 +722,11 @@ export function isSupportedActionName(name: string): name is SupportedActionName
const REGISTRY: Record = {
// file ops
stream_edit: StreamEditRenderer,
- write_file: WriteFileRenderer,
read_file: ReadFileRenderer,
find_files: FindFilesRenderer,
list_folder: ListFolderRenderer,
- create_pdf: CreatePdfRenderer,
+ convert_to_pdf: ConvertToPdfRenderer,
+ convert_from_pdf: ConvertToPdfRenderer,
read_pdf: ReadPdfRenderer,
convert_to_markdown: ConvertToMarkdownRenderer,
// code execution
diff --git a/app/usage/llm_call_storage.py b/app/usage/llm_call_storage.py
index a98cf576..1a409086 100644
--- a/app/usage/llm_call_storage.py
+++ b/app/usage/llm_call_storage.py
@@ -68,7 +68,9 @@ def __post_init__(self):
class LLMCallStorage:
"""SQLite-backed store of full LLM calls."""
- def __init__(self, db_path: Optional[str] = None, max_rows: int = DEFAULT_MAX_ROWS):
+ def __init__(
+ self, db_path: Optional[str] = None, max_rows: int = DEFAULT_MAX_ROWS
+ ):
if db_path is None:
from app.config import APP_DATA_PATH
@@ -109,7 +111,9 @@ def _init_db(self) -> None:
""")
# Migrate older DBs that predate a column.
existing = {r[1] for r in cursor.execute("PRAGMA table_info(llm_calls)")}
- for col, decl in (("cache_creation_tokens", "INTEGER NOT NULL DEFAULT 0"),):
+ for col, decl in (
+ ("cache_creation_tokens", "INTEGER NOT NULL DEFAULT 0"),
+ ):
if col not in existing:
cursor.execute(f"ALTER TABLE llm_calls ADD COLUMN {col} {decl}")
for col in ("timestamp", "prompt_name", "call_type", "task_id", "model"):
@@ -176,7 +180,9 @@ def recent(self, limit: int = 100) -> List[Dict[str, Any]]:
with sqlite3.connect(self._db_path) as conn:
conn.row_factory = sqlite3.Row
cursor = conn.cursor()
- cursor.execute("SELECT * FROM llm_calls ORDER BY id DESC LIMIT ?", (limit,))
+ cursor.execute(
+ "SELECT * FROM llm_calls ORDER BY id DESC LIMIT ?", (limit,)
+ )
return [dict(r) for r in cursor.fetchall()]
def count(self) -> int:
diff --git a/app/utils/pdf_convert.py b/app/utils/pdf_convert.py
new file mode 100644
index 00000000..36dac451
--- /dev/null
+++ b/app/utils/pdf_convert.py
@@ -0,0 +1,370 @@
+"""Native-engine PDF converters for the Phase-2 _to_pdf actions.
+
+ * convert_html() — static HTML/CSS via WeasyPrint (pure-Python, no browser).
+ * convert_url() — live URL via Playwright/Chromium, run in a SUBPROCESS so
+ it never collides with the host app's asyncio loop.
+ * convert_office() — docx/odt/rtf/pptx/xlsx via LibreOffice headless.
+
+Each returns {"status","path"/"message"} and fails gracefully with an actionable
+message when its engine isn't installed (these engines can't all be pip-installed
+— WeasyPrint needs system libs, Playwright needs a browser binary, LibreOffice is
+a system package). Heavy imports stay inside functions (action-loader constraint).
+
+Design: docs/design/multi-source-pdf-actions.md
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+from typing import Any, Dict, Optional
+
+
+# ── Web: page CSS from the common style knobs ──────────────────────────────
+def _landscape(style: Dict[str, Any]) -> bool:
+ return str((style or {}).get("orientation", "portrait")).lower().startswith("l")
+
+
+def _page_size(style: Dict[str, Any]) -> str:
+ s = str((style or {}).get("page_size", "A4"))
+ return s if s else "A4"
+
+
+def _margin_in(style: Dict[str, Any]) -> float:
+ try:
+ return float((style or {}).get("margin_in", 1.0))
+ except (TypeError, ValueError):
+ return 1.0
+
+
+def _page_css(style: Dict[str, Any]) -> str:
+ size = _page_size(style)
+ if _landscape(style):
+ size = f"{size} landscape"
+ return f"@page {{ size: {size}; margin: {_margin_in(style)}in; }}"
+
+
+# ── Web/HTML render via Playwright in a subprocess ─────────────────────────
+# The child uses the sync Playwright API in its own process, avoiding any
+# conflict with the host application's (nest_asyncio-patched) event loop.
+# Chromium works on Windows/Linux/macOS — unlike WeasyPrint, which needs GTK/
+# Pango/Cairo native libs and fails to import on a bare Windows box.
+_PLAYWRIGHT_CHILD = r'''
+import json, sys
+cfg = json.load(open(sys.argv[1], encoding="utf-8"))
+from playwright.sync_api import sync_playwright
+with sync_playwright() as p:
+ browser = p.chromium.launch()
+ page = browser.new_page()
+ page.goto(cfg["url"], wait_until=cfg.get("wait_until", "networkidle"), timeout=cfg["timeout_ms"])
+ if cfg.get("css"):
+ page.add_style_tag(content=cfg["css"])
+ kwargs = {"path": cfg["output_path"], "print_background": cfg.get("print_background", True)}
+ if cfg.get("prefer_css_page_size"):
+ kwargs["prefer_css_page_size"] = True
+ if cfg.get("page_size"):
+ kwargs["format"] = cfg["page_size"]
+ kwargs["landscape"] = cfg.get("landscape", False)
+ if cfg.get("margin"):
+ m = cfg["margin"]
+ kwargs["margin"] = {"top": m, "right": m, "bottom": m, "left": m}
+ page.pdf(**kwargs)
+ browser.close()
+'''
+
+
+def _run_playwright(cfg: Dict[str, Any], timeout_ms: int) -> Dict[str, Any]:
+ """Run the Playwright child to render cfg['url'] → cfg['output_path']."""
+ cfg_dir = tempfile.mkdtemp()
+ cfg_path = os.path.join(cfg_dir, "cfg.json")
+ with open(cfg_path, "w", encoding="utf-8") as f:
+ json.dump(cfg, f)
+ try:
+ proc = subprocess.run(
+ [sys.executable, "-c", _PLAYWRIGHT_CHILD, cfg_path],
+ capture_output=True,
+ text=True,
+ timeout=timeout_ms / 1000 + 60,
+ )
+ except subprocess.TimeoutExpired:
+ return {"status": "error", "message": "Render timed out."}
+ finally:
+ shutil.rmtree(cfg_dir, ignore_errors=True)
+ out = cfg["output_path"]
+ if proc.returncode != 0 or not os.path.isfile(out):
+ err = (proc.stderr or "").strip()
+ hint = ""
+ if "Executable doesn't exist" in err or "playwright install" in err:
+ hint = " Run `playwright install chromium` to install the browser."
+ elif "No module named 'playwright'" in err:
+ hint = " Install the 'playwright' package."
+ return {"status": "error", "message": f"Playwright render failed: {err[:400]}{hint}"}
+ return {"status": "success", "path": out, "size_bytes": os.path.getsize(out)}
+
+
+def convert_url(
+ url: str,
+ output_path: str,
+ style: Optional[Dict[str, Any]] = None,
+ timeout_ms: int = 60000,
+) -> Dict[str, Any]:
+ """Render a live URL to PDF via Playwright/Chromium."""
+ style = style or {}
+ abs_path = os.path.abspath(output_path)
+ os.makedirs(os.path.dirname(abs_path) or ".", exist_ok=True)
+ cfg = {
+ "url": url,
+ "output_path": abs_path,
+ "page_size": _page_size(style),
+ "landscape": _landscape(style),
+ "print_background": bool(style.get("print_background", True)),
+ "margin": f"{_margin_in(style)}in",
+ "css": str(style["css"]) if style.get("css") else "",
+ "timeout_ms": timeout_ms,
+ }
+ return _run_playwright(cfg, timeout_ms)
+
+
+def _render_html_weasyprint(
+ output_path: str, source_path: Optional[str], html_text: Optional[str], style: Dict[str, Any]
+) -> Dict[str, Any]:
+ """Fallback HTML→PDF via WeasyPrint. Its import can fail on Windows (no GTK/Pango/
+ Cairo) — caught here so it degrades gracefully rather than crashing the action."""
+ try:
+ from weasyprint import HTML, CSS
+ except Exception as exc: # noqa: BLE001 (import-time OSError on bare Windows)
+ return {"status": "error", "message": f"WeasyPrint unavailable ({type(exc).__name__}: {exc})."}
+ try:
+ sheets = []
+ if any(k in (style or {}) for k in ("page_size", "orientation", "margin_in")):
+ sheets.append(CSS(string=_page_css(style)))
+ if style.get("css"):
+ sheets.append(CSS(string=str(style["css"])))
+ doc = HTML(filename=source_path) if source_path else HTML(string=html_text or "", base_url=os.getcwd())
+ doc.write_pdf(output_path, stylesheets=sheets or None)
+ return {"status": "success", "path": output_path, "size_bytes": os.path.getsize(output_path)}
+ except Exception as exc: # noqa: BLE001
+ return {"status": "error", "message": f"WeasyPrint render failed: {type(exc).__name__}: {exc}"}
+
+
+def convert_html(
+ output_path: str,
+ source_path: Optional[str] = None,
+ html_text: Optional[str] = None,
+ style: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+ """Render HTML to PDF — Playwright/Chromium primary (cross-platform, incl. Windows),
+ WeasyPrint fallback. Only imposes page geometry when the user explicitly sets it;
+ otherwise honors the HTML's own @page (preserves a reconstructed PDF's original size).
+ `style.css` is injected last."""
+ from pathlib import Path
+
+ style = style or {}
+ abs_path = os.path.abspath(output_path)
+ os.makedirs(os.path.dirname(abs_path) or ".", exist_ok=True)
+
+ # Resolve HTML to a local file for file:// rendering.
+ tmp_dir = None
+ if source_path:
+ html_file = os.path.abspath(source_path)
+ else:
+ tmp_dir = tempfile.mkdtemp()
+ html_file = os.path.join(tmp_dir, "in.html")
+ with open(html_file, "w", encoding="utf-8") as f:
+ f.write(html_text or "")
+
+ explicit_page = any(k in style for k in ("page_size", "orientation", "margin_in"))
+ cfg = {
+ "url": Path(html_file).as_uri(),
+ "output_path": abs_path,
+ "print_background": bool(style.get("print_background", True)),
+ "css": str(style["css"]) if style.get("css") else "",
+ "wait_until": "load",
+ "timeout_ms": 60000,
+ }
+ if explicit_page:
+ cfg["page_size"] = _page_size(style)
+ cfg["landscape"] = _landscape(style)
+ cfg["margin"] = f"{_margin_in(style)}in"
+ else:
+ cfg["prefer_css_page_size"] = True
+
+ try:
+ res = _run_playwright(cfg, 60000)
+ finally:
+ if tmp_dir:
+ shutil.rmtree(tmp_dir, ignore_errors=True)
+ if res["status"] == "success":
+ return res
+
+ # Playwright unavailable/failed → try WeasyPrint (gracefully).
+ fb = _render_html_weasyprint(abs_path, source_path, html_text, style)
+ if fb["status"] == "success":
+ return fb
+ return {
+ "status": "error",
+ "message": f"HTML render failed. Playwright: {res.get('message', '')} | {fb.get('message', '')}",
+ }
+
+
+# ── Office: LibreOffice headless ───────────────────────────────────────────
+def _find_soffice() -> Optional[str]:
+ for name in ("soffice", "libreoffice"):
+ p = shutil.which(name)
+ if p:
+ return p
+ for cand in (
+ r"C:\Program Files\LibreOffice\program\soffice.exe",
+ r"C:\Program Files (x86)\LibreOffice\program\soffice.exe",
+ "/usr/bin/soffice",
+ "/usr/bin/libreoffice",
+ "/Applications/LibreOffice.app/Contents/MacOS/soffice",
+ ):
+ if os.path.isfile(cand):
+ return cand
+ return None
+
+
+def convert_office(source_path: str, output_path: str, timeout: int = 180) -> Dict[str, Any]:
+ """Convert an office document to PDF via LibreOffice headless (native fidelity)."""
+ soffice = _find_soffice()
+ if not soffice:
+ return {
+ "status": "error",
+ "message": (
+ "LibreOffice not found. Install LibreOffice and ensure `soffice` is on "
+ "PATH to convert office documents."
+ ),
+ }
+ abs_out = os.path.abspath(output_path)
+ out_dir = os.path.dirname(abs_out) or "."
+ os.makedirs(out_dir, exist_ok=True)
+ work = tempfile.mkdtemp()
+ try:
+ proc = subprocess.run(
+ [soffice, "--headless", "--convert-to", "pdf", "--outdir", work, os.path.abspath(source_path)],
+ capture_output=True,
+ text=True,
+ timeout=timeout,
+ )
+ except subprocess.TimeoutExpired:
+ shutil.rmtree(work, ignore_errors=True)
+ return {"status": "error", "message": "LibreOffice conversion timed out."}
+ produced = os.path.join(work, os.path.splitext(os.path.basename(source_path))[0] + ".pdf")
+ if proc.returncode != 0 or not os.path.isfile(produced):
+ shutil.rmtree(work, ignore_errors=True)
+ return {"status": "error", "message": f"LibreOffice conversion failed: {(proc.stderr or proc.stdout or '').strip()[:300]}"}
+ try:
+ shutil.move(produced, abs_out)
+ finally:
+ shutil.rmtree(work, ignore_errors=True)
+ return {"status": "success", "path": abs_out, "size_bytes": os.path.getsize(abs_out)}
+
+
+def convert_pdf_to_html(source_path: str, output_path: str, mode: str = "xhtml") -> Dict[str, Any]:
+ """Extract a layout-rich HTML reconstruction of a PDF via PyMuPDF.
+
+ The output HTML carries the original's fonts, sizes, colors, positions and
+ images, so the agent can edit its text with stream_edit and re-render with
+ convert_to_pdf (html format) while preserving the look — no editable source needed.
+ mode: 'xhtml' (flow-based, reflows on edits) or 'html' (absolute-positioned,
+ near-identical but rigid).
+ """
+ try:
+ import fitz # PyMuPDF
+ except Exception as exc: # noqa: BLE001
+ return {
+ "status": "error",
+ "message": f"PyMuPDF not available ({type(exc).__name__}: {exc}). Install pymupdf.",
+ }
+ if mode not in ("html", "xhtml"):
+ mode = "xhtml"
+ try:
+ doc = fitz.open(source_path)
+ bodies = []
+ page_w = page_h = None
+ for page in doc:
+ if page_w is None:
+ page_w, page_h = page.rect.width, page.rect.height
+ s = page.get_text(mode)
+ m = re.search(r"]*>(.*)
", s, re.DOTALL | re.IGNORECASE)
+ bodies.append(m.group(1) if m else s)
+ n = len(doc)
+ doc.close()
+ except Exception as exc: # noqa: BLE001
+ return {"status": "error", "message": f"PDF→HTML extraction failed: {type(exc).__name__}: {exc}"}
+
+ # Carry the source's page size into the HTML so re-rendering preserves geometry
+ # (convert_to_pdf html only overrides @page when the user explicitly passes page style).
+ page_css = (
+ f""
+ if page_w
+ else ""
+ )
+ sep = '\n\n'
+ html = (
+ f'\n{page_css}