Agent Zero AI framework
Add built-in goal management plugin
Alessandro84c13dab01cc
diff --git a/plugins/AGENTS.md b/plugins/AGENTS.mdindex c913b12f1..0d42f9124 100644--- a/plugins/AGENTS.md+++ b/plugins/AGENTS.md@@ -78,6 +78,7 @@ Direct child DOX files:| [_editor/AGENTS.md](_editor/AGENTS.md) | Native Markdown editor surface and sessions. || [_email_integration/AGENTS.md](_email_integration/AGENTS.md) | IMAP/Exchange polling and SMTP reply integration. || [_error_retry/AGENTS.md](_error_retry/AGENTS.md) | Critical exception retry lifecycle hooks. |+| [_goal/AGENTS.md](_goal/AGENTS.md) | Built-in chat goal strip, `/goal` slash command, and agent-facing goal tools. || [_infection_check/AGENTS.md](_infection_check/AGENTS.md) | Prompt-injection safety analysis before tool execution. || [_kokoro_tts/AGENTS.md](_kokoro_tts/AGENTS.md) | Kokoro text-to-speech integration. || [_memory/AGENTS.md](_memory/AGENTS.md) | Optional persistent recall plugin, knowledge import, tools, and dashboard; do not assume it is enabled outside this plugin. |diff --git a/plugins/_commands/AGENTS.md b/plugins/_commands/AGENTS.mdindex 92b2a89e7..f9c0a0e61 100644--- a/plugins/_commands/AGENTS.md+++ b/plugins/_commands/AGENTS.md@@ -28,6 +28,7 @@- Commands contributed by enabled plugins live in their `commands/` directory and must not be rediscovered through the generic plugin-distributed path from `_commands` itself.- On startup, `_commands` copies legacy `usr/plugins/commands` command and skill files into `usr/plugins/_commands` without overwriting existing files, copies scoped legacy command folders to `_commands`, and disables the legacy `commands` plugin roots to prevent duplicate WebUI popovers.- Script commands must expose `run(payload)` and return a string or a dict with `text` and optional `effects`; `show_markdown` effects render as auto-dismissing toast notifications.+- Script commands may emit `send_message` with `text` to submit the rendered composer text immediately after command resolution.## Work Guidancediff --git a/plugins/_commands/webui/commands-slash-store.js b/plugins/_commands/webui/commands-slash-store.jsindex 0d43de546..9b1c2a207 100644--- a/plugins/_commands/webui/commands-slash-store.js+++ b/plugins/_commands/webui/commands-slash-store.js@@ -353,6 +353,7 @@ const model = {const effects = Array.isArray(result.effects) ? result.effects : [];let hadToast = false;let hadError = false;+ let shouldSend = false;for (const effect of effects) {if (!effect || typeof effect !== "object") continue;@@ -366,6 +367,11 @@ const model = {nextText = nextText ? `${nextText}\n${chunk}` : chunk;continue;}+ if (type === "send_message") {+ nextText = String(effect.text || nextText || "");+ shouldSend = true;+ continue;+ }if (type === "toast") {hadToast = true;const level = String(effect.level || "info").toLowerCase();@@ -413,6 +419,10 @@ const model = {);continue;}+ if (type === "goal_changed") {+ window.dispatchEvent(new CustomEvent("goal:changed", { detail: effect }));+ continue;+ }if (type === "open_plugin_config") {const pluginName = String(effect.plugin || "").trim();if (pluginName) {@@ -463,6 +473,9 @@ const model = {this.rawArguments = "";this.rawMessage = nextText;this.selectedIndex = 0;+ if (shouldSend && nextText.trim()) {+ await chatInputStore?.sendMessage?.();+ }return { hadToast, hadError };},diff --git a/plugins/_goal/AGENTS.md b/plugins/_goal/AGENTS.mdnew file mode 100644index 000000000..cd797adad--- /dev/null+++ b/plugins/_goal/AGENTS.md@@ -0,0 +1,41 @@+# Goal Plugin DOX++## Purpose++- Own the built-in chat goal strip, `/goal` slash command, goal state API, and agent-facing goal tools.+- Keep chat goals scoped to the active chat context and stored as user data outside tracked plugin code.++## Ownership++- `plugin.yaml` owns the always-enabled `_goal` plugin metadata.+- `helpers/goals.py` owns file-backed goal storage under `usr/plugins/_goal/goals/` and goal status normalization.+- `api/goal.py` owns the WebUI JSON API for reading, editing, pausing, resuming, and deleting goals.+- `commands/` owns the `/goal` slash command contributed to `_commands`.+- `webui/` and `extensions/webui/` own the composer goal strip and inline controls.+- `tools/` and `prompts/` own agent-facing goal inspection, creation, and status update behavior.+- `extensions/python/message_loop_prompts_after/` owns injecting the active goal into agent context.++## Local Contracts++- Goal status values are `active`, `paused`, `complete`, and `blocked`.+- Active goals are injected into agent extras; paused and blocked goals remain visible in the UI, while complete goals are hidden.+- Goal records track accumulated active time with `elapsed_seconds` and `active_since`; pausing freezes elapsed time until resume.+- User controls may pause, resume, edit, or delete a goal; destructive delete uses inline confirmation. Model tools may create goals and mark them complete or blocked.+- `/goal <objective>` creates the goal and sends the objective as the user message so the agent starts working immediately.+- `/goal auto` fills the composer with a prompt asking the agent to create and manage its own goal instead of silently sending a message.+- Goal UI feedback uses toast notifications and inline controls, not modal dialogs.++## Work Guidance++- Keep goal state in `usr/plugins/_goal/`; do not store runtime goal data in tracked files.+- Keep the goal strip mounted through WebUI extension points instead of modifying core composer templates.+- Keep `_commands` compatibility in mind: `/goal` is a plugin-contributed command and should remain read-only in the command manager.++## Verification++- Run `conda run -n a0 pytest plugins/_goal/tests` after changing `_goal` backend behavior.+- Run `_commands` discovery tests when changing the `/goal` command contribution contract.++## Child DOX Index++No child DOX files.diff --git a/plugins/_goal/__init__.py b/plugins/_goal/__init__.pynew file mode 100644index 000000000..8b1378917--- /dev/null+++ b/plugins/_goal/__init__.py@@ -0,0 +1 @@+diff --git a/plugins/_goal/api/__init__.py b/plugins/_goal/api/__init__.pynew file mode 100644index 000000000..8b1378917--- /dev/null+++ b/plugins/_goal/api/__init__.py@@ -0,0 +1 @@+diff --git a/plugins/_goal/api/goal.py b/plugins/_goal/api/goal.pynew file mode 100644index 000000000..7dd5a47ee--- /dev/null+++ b/plugins/_goal/api/goal.py@@ -0,0 +1,55 @@+from __future__ import annotations++from helpers.api import ApiHandler, Request, Response++from plugins._goal.helpers import goals+++class Goal(ApiHandler):+ async def process(self, input: dict, request: Request) -> dict | Response:+ action = str(input.get("action", "") or "").strip().lower()+ context_id = str(input.get("context_id", "") or "").strip()++ try:+ if action == "get":+ return {"ok": True, "goal": goals.public_goal(goals.get_goal(context_id))}+ if action in {"set", "create"}:+ return self._set(context_id, input)+ if action == "update":+ return self._update(context_id, input)+ if action == "pause":+ return self._status(context_id, "paused")+ if action == "resume":+ return self._status(context_id, "active")+ if action == "delete":+ goals.delete_goal(context_id)+ return {"ok": True, "goal": None}+ except FileNotFoundError:+ return Response(status=404, response="Goal not found")+ except ValueError as error:+ return Response(status=400, response=str(error))++ return Response(status=400, response=f"Unknown action: {action}")++ def _set(self, context_id: str, input: dict) -> dict:+ goal = goals.create_goal(+ context_id,+ str(input.get("objective") or ""),+ created_by=str(input.get("created_by") or "user"),+ token_budget=input.get("token_budget"),+ )+ return {"ok": True, "goal": goals.public_goal(goal)}++ def _update(self, context_id: str, input: dict) -> dict:+ goal = goals.update_goal(+ context_id,+ objective=input.get("objective") if "objective" in input else None,+ status=input.get("status") if "status" in input else None,+ note=input.get("note") if "note" in input else None,+ token_budget=input.get("token_budget") if "token_budget" in input else None,+ )+ return {"ok": True, "goal": goals.public_goal(goal)}++ def _status(self, context_id: str, status: str) -> dict:+ goal = goals.update_goal(context_id, status=status)+ return {"ok": True, "goal": goals.public_goal(goal)}diff --git a/plugins/_goal/commands/goal.command.yaml b/plugins/_goal/commands/goal.command.yamlnew file mode 100644index 000000000..34bf24a34--- /dev/null+++ b/plugins/_goal/commands/goal.command.yaml@@ -0,0 +1,5 @@+name: goal+description: Create, inspect, pause, resume, edit, or delete this chat goal.+argument_hint: "[objective|status|pause|resume|edit <goal>|delete|auto]"+type: script+script_path: goal_command.pydiff --git a/plugins/_goal/commands/goal_command.py b/plugins/_goal/commands/goal_command.pynew file mode 100644index 000000000..26bd58a64--- /dev/null+++ b/plugins/_goal/commands/goal_command.py@@ -0,0 +1,82 @@+from __future__ import annotations++from typing import Any++from plugins._goal.helpers import goals+++def run(payload: dict[str, Any]) -> dict[str, Any]:+ invocation = payload.get("invocation") or {}+ raw_args = str(invocation.get("raw_arguments") or "").strip()+ tokens = ((invocation.get("arguments") or {}).get("tokens") or [])+ context_id = str((payload.get("context") or {}).get("context_id") or "").strip()++ if not context_id:+ return _effects(_toast("Open or create a chat context first.", level="error"))++ action = str(tokens[0] if tokens else "").strip().lower()++ try:+ if action in {"", "status", "show"}:+ return _show_markdown("Goal", goals.summarize_goal(goals.get_goal(context_id)))+ if action in {"pause", "paused"}:+ goal = goals.update_goal(context_id, status="paused")+ return _changed("Goal paused.", goal)+ if action in {"resume", "start", "active"}:+ goal = goals.update_goal(context_id, status="active")+ return _changed("Goal resumed.", goal)+ if action in {"delete", "clear", "remove"}:+ goals.delete_goal(context_id)+ return _changed("Goal deleted.", None)+ if action in {"complete", "done"}:+ goal = goals.update_goal(context_id, status="complete")+ return _changed("Goal marked complete.", goal)+ if action == "blocked":+ note = raw_args.split(None, 1)[1].strip() if len(tokens) > 1 else ""+ goal = goals.update_goal(context_id, status="blocked", note=note)+ return _changed("Goal marked blocked.", goal)+ if action == "edit":+ objective = raw_args.split(None, 1)[1].strip() if len(tokens) > 1 else ""+ goal = goals.update_goal(context_id, objective=objective, status="active")+ return _changed("Goal updated.", goal)+ if action in {"auto", "ask", "model"}:+ hint = raw_args.split(None, 1)[1].strip() if len(tokens) > 1 else ""+ return _auto_prompt(hint)++ goal = goals.create_goal(context_id, raw_args, created_by="user")+ return _changed("Goal set.", goal, send_text=raw_args)+ except FileNotFoundError:+ return _effects(_toast("No goal is set for this chat.", level="error"))+ except ValueError as error:+ return _effects(_toast(str(error), level="error"))+++def _auto_prompt(hint: str) -> dict[str, Any]:+ prompt = (+ "Please create and manage a goal for this chat. Use the goal tools to inspect "+ "any current goal, create a concise goal objective, and update it when the work "+ "is complete or genuinely blocked."+ )+ if hint:+ prompt += f"\n\nUser hint: {hint}"+ return {"text": prompt, "effects": []}+++def _changed(message: str, goal: dict[str, Any] | None, *, send_text: str = "") -> dict[str, Any]:+ return _effects(+ _toast(message),+ {"type": "goal_changed", "goal": goals.public_goal(goal)},+ {"type": "send_message", "text": send_text} if send_text else {},+ )+++def _effects(*effects: dict[str, Any]) -> dict[str, Any]:+ return {"text": "", "effects": [effect for effect in effects if effect]}+++def _toast(message: str, *, level: str = "success") -> dict[str, Any]:+ return {"type": "toast", "message": message, "level": level}+++def _show_markdown(title: str, content: str) -> dict[str, Any]:+ return _effects({"type": "show_markdown", "title": title, "content": content})diff --git a/plugins/_goal/extensions/python/message_loop_prompts_after/_50_include_goal.py b/plugins/_goal/extensions/python/message_loop_prompts_after/_50_include_goal.pynew file mode 100644index 000000000..e18ac7080--- /dev/null+++ b/plugins/_goal/extensions/python/message_loop_prompts_after/_50_include_goal.py@@ -0,0 +1,28 @@+from __future__ import annotations++from agent import LoopData+from helpers.extension import Extension+from plugins._goal.helpers import goals+++class IncludeGoal(Extension):+ async def execute(self, loop_data: LoopData = LoopData(), **kwargs):+ if not self.agent:+ return++ try:+ goal = goals.get_goal(self.agent.context.id)+ except ValueError:+ goal = None++ if not goal or goal.get("status") != "active":+ loop_data.extras_temporary.pop("current_goal", None)+ return++ loop_data.extras_temporary["current_goal"] = self.agent.read_prompt(+ "agent.extras.goal.md",+ status=goal.get("status", ""),+ objective=goal.get("objective", ""),+ created_by=goal.get("created_by", ""),+ updated_at=goal.get("updated_at", ""),+ )diff --git a/plugins/_goal/extensions/webui/chat-input-progress-start/goal-strip.html b/plugins/_goal/extensions/webui/chat-input-progress-start/goal-strip.htmlnew file mode 100644index 000000000..ffb19f19d--- /dev/null+++ b/plugins/_goal/extensions/webui/chat-input-progress-start/goal-strip.html@@ -0,0 +1,207 @@+<script type="module">+ import { store } from "/plugins/_goal/webui/goal-store.js";+</script>++<div x-data+ class="goal-strip-root"+ x-create="$store.goalBar.onMount()"+ x-init="$watch('$store.chats.selected', () => $store.goalBar.refresh(true))"+ x-destroy="$store.goalBar.cleanup()">+ <template x-if="$store.goalBar && $store.goalBar.visible">+ <div class="goal-strip" :class="`is-${$store.goalBar.goal?.status || 'active'}`">+ <span class="material-symbols-outlined goal-strip-icon" x-text="$store.goalBar.statusIcon" aria-hidden="true"></span>++ <template x-if="!$store.goalBar.editing">+ <div class="goal-strip-copy">+ <span class="goal-strip-status" x-text="$store.goalBar.statusLabel"></span>+ <span class="goal-strip-objective" x-text="$store.goalBar.goal?.objective || ''"></span>+ <span class="goal-strip-time" x-text="`• ${$store.goalBar.elapsedLabel}`"></span>+ </div>+ </template>++ <template x-if="$store.goalBar.editing">+ <div class="goal-strip-edit">+ <input class="goal-strip-input"+ type="text"+ x-model="$store.goalBar.draft"+ @keydown.enter.prevent="$store.goalBar.saveEdit()"+ @keydown.escape.prevent="$store.goalBar.cancelEdit()"+ aria-label="Goal objective" />+ <button type="button" class="goal-strip-action" title="Save goal" @click="$store.goalBar.saveEdit()" :disabled="$store.goalBar.saving">+ <span class="material-symbols-outlined" aria-hidden="true">check</span>+ </button>+ <button type="button" class="goal-strip-action" title="Cancel" @click="$store.goalBar.cancelEdit()" :disabled="$store.goalBar.saving">+ <span class="material-symbols-outlined" aria-hidden="true">close</span>+ </button>+ </div>+ </template>++ <div class="goal-strip-actions" x-show="!$store.goalBar.editing">+ <button type="button" class="goal-strip-action" title="Edit goal" @click="$store.goalBar.startEdit()" :disabled="$store.goalBar.saving">+ <span class="material-symbols-outlined" aria-hidden="true">edit</span>+ </button>+ <button type="button" class="goal-strip-action"+ :title="$store.goalBar.goal?.status === 'active' ? 'Pause goal' : 'Resume goal'"+ @click="$store.goalBar.pauseOrResume()"+ :disabled="$store.goalBar.saving">+ <span class="material-symbols-outlined" aria-hidden="true" x-text="$store.goalBar.goal?.status === 'active' ? 'pause_circle' : 'play_circle'"></span>+ </button>+ <button type="button" class="goal-strip-action" title="Delete goal" @click="$confirmClick($event, () => $store.goalBar.deleteGoal())" :disabled="$store.goalBar.saving">+ <span class="material-symbols-outlined" aria-hidden="true">delete</span>+ </button>+ </div>+ </div>+ </template>+</div>++<style>+ #progress-bar-box.has-goal-bar {+ flex-wrap: wrap;+ row-gap: var(--spacing-xs);+ }++ #progress-bar-box.has-goal-bar .goal-strip-root {+ flex: 0 0 100%;+ min-width: 0;+ display: flex;+ width: 100%;+ }++ .goal-strip {+ width: 100%;+ min-height: 2rem;+ display: flex;+ align-items: center;+ gap: 0.42rem;+ padding: 0.18rem var(--spacing-sm);+ color: var(--color-text);+ background: transparent;+ border: none;+ border-radius: 0;+ box-shadow: none;+ }++ .goal-strip-icon {+ flex: 0 0 auto;+ font-size: 1rem;+ opacity: 0.75;+ }++ .goal-strip-copy {+ min-width: 0;+ display: flex;+ align-items: baseline;+ gap: 0.3rem;+ flex: 1 1 auto;+ overflow: hidden;+ }++ .goal-strip-status {+ flex: 0 0 auto;+ font-size: 0.76rem;+ font-weight: 600;+ }++ .goal-strip-objective {+ min-width: 0;+ overflow: hidden;+ text-overflow: ellipsis;+ white-space: nowrap;+ color: color-mix(in srgb, var(--color-text) 64%, transparent);+ font-size: 0.76rem;+ }++ .goal-strip-time {+ flex: 0 0 auto;+ color: color-mix(in srgb, var(--color-text) 44%, transparent);+ font-size: 0.76rem;+ white-space: nowrap;+ }++ .goal-strip-actions,+ .goal-strip-edit {+ display: flex;+ align-items: center;+ gap: 0.18rem;+ min-width: 0;+ }++ .goal-strip-edit {+ flex: 1 1 auto;+ }++ .goal-strip-input {+ flex: 1 1 auto;+ min-width: 8rem;+ height: 1.55rem;+ padding: 0 0.35rem;+ border: 1px solid color-mix(in srgb, var(--color-border) 82%, transparent);+ border-radius: 6px;+ background: color-mix(in srgb, var(--color-background) 80%, transparent);+ color: var(--color-text);+ font-family: var(--font-family-main, "Rubik", Arial, Helvetica, sans-serif);+ font-size: 0.76rem;+ outline: none;+ }++ .goal-strip-input:focus {+ border-color: color-mix(in srgb, var(--color-text) 28%, var(--color-border));+ }++ .goal-strip-action {+ width: 1.55rem;+ height: 1.55rem;+ display: inline-flex;+ align-items: center;+ justify-content: center;+ padding: 0;+ border: none;+ border-radius: 6px;+ background: transparent;+ color: var(--color-text);+ opacity: 0.68;+ cursor: pointer;+ }++ .goal-strip-action:hover:not(:disabled) {+ opacity: 1;+ background: color-mix(in srgb, var(--color-border) 34%, transparent);+ }++ .goal-strip-action.confirming:not(:disabled) {+ opacity: 1;+ color: var(--color-warning, var(--color-text));+ background: color-mix(in srgb, var(--color-warning, var(--color-text)) 16%, transparent);+ }++ .goal-strip-action:disabled {+ opacity: 0.35;+ cursor: not-allowed;+ }++ .goal-strip-action .material-symbols-outlined {+ font-size: 1rem;+ }++ .goal-strip.is-paused .goal-strip-icon,+ .goal-strip.is-blocked .goal-strip-icon {+ color: var(--color-warning, var(--color-text));+ }++ .goal-strip.is-complete .goal-strip-icon {+ color: var(--color-success, var(--color-text));+ }++ @media (max-width: 768px) {+ .goal-strip {+ width: 100%;+ }++ .goal-strip-status,+ .goal-strip-objective,+ .goal-strip-time,+ .goal-strip-input {+ font-size: 0.72rem;+ }+ }+</style>diff --git a/plugins/_goal/helpers/__init__.py b/plugins/_goal/helpers/__init__.pynew file mode 100644index 000000000..8b1378917--- /dev/null+++ b/plugins/_goal/helpers/__init__.py@@ -0,0 +1 @@+diff --git a/plugins/_goal/helpers/goals.py b/plugins/_goal/helpers/goals.pynew file mode 100644index 000000000..840358de8--- /dev/null+++ b/plugins/_goal/helpers/goals.py@@ -0,0 +1,304 @@+from __future__ import annotations++import json+import re+from datetime import datetime, timezone+from pathlib import Path+from typing import Any++from helpers import files+++PLUGIN_NAME = "_goal"+GOALS_DIR = "goals"+ACTIVE_STATUSES = {"active", "paused"}+FINAL_STATUSES = {"complete", "blocked"}+VALID_STATUSES = ACTIVE_STATUSES | FINAL_STATUSES+++def get_goal(context_id: str) -> dict[str, Any] | None:+ context_id = _require_context_id(context_id)+ path = _goal_path(context_id)+ if not Path(path).is_file():+ return None++ try:+ raw = json.loads(files.read_file(path))+ except (OSError, json.JSONDecodeError):+ return None+ if not isinstance(raw, dict):+ return None++ goal = _normalize_goal(raw, context_id=context_id)+ if not goal.get("objective"):+ return None+ return goal+++def list_goals() -> list[dict[str, Any]]:+ directory = _goals_dir()+ if not Path(directory).is_dir():+ return []++ goals: list[dict[str, Any]] = []+ for goal_file in sorted(Path(directory).glob("*.json")):+ try:+ raw = json.loads(files.read_file(str(goal_file)))+ except (OSError, json.JSONDecodeError):+ continue+ if not isinstance(raw, dict):+ continue+ context_id = str(raw.get("context_id") or "").strip()+ if not context_id:+ continue+ goal = _normalize_goal(raw, context_id=context_id)+ if goal.get("objective"):+ goals.append(goal)+ return goals+++def create_goal(+ context_id: str,+ objective: str,+ *,+ created_by: str = "user",+ token_budget: int | None = None,+) -> dict[str, Any]:+ context_id = _require_context_id(context_id)+ objective = _clean_objective(objective)+ if not objective:+ raise ValueError("Goal objective is required")++ now = _now()+ existing = get_goal(context_id)+ goal = {+ "context_id": context_id,+ "objective": objective,+ "status": "active",+ "created_by": _clean_created_by(created_by),+ "token_budget": _clean_token_budget(token_budget),+ "created_at": existing.get("created_at") if existing else now,+ "active_since": now,+ "elapsed_seconds": 0,+ "updated_at": now,+ "note": "",+ }+ _write_goal(goal)+ return goal+++def update_goal(+ context_id: str,+ *,+ objective: str | None = None,+ status: str | None = None,+ note: str | None = None,+ token_budget: int | None = None,+) -> dict[str, Any]:+ context_id = _require_context_id(context_id)+ goal = get_goal(context_id)+ if not goal:+ raise FileNotFoundError("Goal not found")++ if objective is not None:+ cleaned_objective = _clean_objective(objective)+ if not cleaned_objective:+ raise ValueError("Goal objective is required")+ goal["objective"] = cleaned_objective++ if status is not None:+ _apply_status(goal, _normalize_status(status))++ if note is not None:+ goal["note"] = str(note or "").strip()++ if token_budget is not None:+ goal["token_budget"] = _clean_token_budget(token_budget)++ goal["updated_at"] = _now()+ _write_goal(goal)+ return goal+++def delete_goal(context_id: str) -> None:+ context_id = _require_context_id(context_id)+ files.delete_file(_goal_path(context_id))+++def public_goal(goal: dict[str, Any] | None) -> dict[str, Any] | None:+ if not goal:+ return None+ return {+ "context_id": str(goal.get("context_id") or ""),+ "objective": str(goal.get("objective") or ""),+ "status": str(goal.get("status") or "active"),+ "created_by": str(goal.get("created_by") or "user"),+ "token_budget": goal.get("token_budget"),+ "created_at": str(goal.get("created_at") or ""),+ "active_since": str(goal.get("active_since") or ""),+ "elapsed_seconds": _clean_elapsed_seconds(goal.get("elapsed_seconds")),+ "updated_at": str(goal.get("updated_at") or ""),+ "note": str(goal.get("note") or ""),+ }+++def summarize_goal(goal: dict[str, Any] | None) -> str:+ if not goal:+ return "No goal is set for this chat."++ status = str(goal.get("status") or "active")+ objective = str(goal.get("objective") or "").strip()+ elapsed = _format_elapsed(_elapsed_seconds(goal))+ updated = str(goal.get("updated_at") or "").strip()+ lines = [f"Status: {status}", f"Goal: {objective}", f"Active time: {elapsed}"]+ if updated:+ lines.append(f"Updated: {updated}")+ note = str(goal.get("note") or "").strip()+ if note:+ lines.append(f"Note: {note}")+ return "\n".join(lines)+++def _write_goal(goal: dict[str, Any]) -> None:+ files.write_file(+ _goal_path(str(goal["context_id"])),+ json.dumps(public_goal(goal), indent=2, ensure_ascii=False) + "\n",+ )+++def _normalize_goal(raw: dict[str, Any], *, context_id: str) -> dict[str, Any]:+ status = str(raw.get("status") or "active").strip().lower()+ if status not in VALID_STATUSES:+ status = "active"++ created_at = str(raw.get("created_at") or "")+ updated_at = str(raw.get("updated_at") or "")+ active_since = str(raw.get("active_since") or "")+ elapsed_seconds = _clean_elapsed_seconds(raw.get("elapsed_seconds"))+ if "elapsed_seconds" not in raw and status != "active":+ elapsed_seconds = _seconds_between(created_at, updated_at)+ if status == "active" and not active_since:+ active_since = created_at or updated_at++ return {+ "context_id": context_id,+ "objective": _clean_objective(str(raw.get("objective") or "")),+ "status": status,+ "created_by": _clean_created_by(str(raw.get("created_by") or "user")),+ "token_budget": _clean_token_budget(raw.get("token_budget")),+ "created_at": created_at,+ "active_since": active_since,+ "elapsed_seconds": elapsed_seconds,+ "updated_at": updated_at,+ "note": str(raw.get("note") or "").strip(),+ }+++def _goals_dir() -> str:+ return files.get_abs_path(files.USER_DIR, files.PLUGINS_DIR, PLUGIN_NAME, GOALS_DIR)+++def _goal_path(context_id: str) -> str:+ return files.get_abs_path(_goals_dir(), f"{_safe_context_id(context_id)}.json")+++def _require_context_id(context_id: str) -> str:+ context_id = str(context_id or "").strip()+ if not context_id:+ raise ValueError("A chat context is required")+ return context_id+++def _safe_context_id(context_id: str) -> str:+ safe = re.sub(r"[^A-Za-z0-9_.-]+", "_", context_id).strip("._")+ if not safe:+ raise ValueError("A chat context is required")+ return safe[:180]+++def _clean_objective(objective: str) -> str:+ return re.sub(r"\s+", " ", str(objective or "")).strip()+++def _normalize_status(status: str) -> str:+ cleaned = str(status or "").strip().lower()+ if cleaned not in VALID_STATUSES:+ raise ValueError("Goal status must be active, paused, complete, or blocked")+ return cleaned+++def _clean_created_by(created_by: str) -> str:+ cleaned = str(created_by or "").strip().lower()+ return cleaned if cleaned in {"user", "model"} else "user"+++def _clean_token_budget(token_budget: Any) -> int | None:+ if token_budget in (None, ""):+ return None+ try:+ value = int(token_budget)+ except (TypeError, ValueError):+ return None+ return value if value > 0 else None+++def _apply_status(goal: dict[str, Any], status: str) -> None:+ current = str(goal.get("status") or "active")+ if current == "active" and status != "active":+ goal["elapsed_seconds"] = _elapsed_seconds(goal)+ goal["active_since"] = ""+ elif current != "active" and status == "active":+ goal["active_since"] = _now()+ goal["status"] = status+++def _elapsed_seconds(goal: dict[str, Any]) -> int:+ seconds = _clean_elapsed_seconds(goal.get("elapsed_seconds"))+ if str(goal.get("status") or "active") == "active":+ seconds += _seconds_between(str(goal.get("active_since") or ""), _now())+ return seconds+++def _clean_elapsed_seconds(value: Any) -> int:+ try:+ seconds = int(value)+ except (TypeError, ValueError):+ return 0+ return max(0, seconds)+++def _seconds_between(start: str, end: str) -> int:+ start_dt = _parse_time(start)+ end_dt = _parse_time(end)+ if not start_dt or not end_dt:+ return 0+ return max(0, int((end_dt - start_dt).total_seconds()))+++def _parse_time(value: str) -> datetime | None:+ text = str(value or "").strip()+ if not text:+ return None+ if text.endswith("Z"):+ text = f"{text[:-1]}+00:00"+ try:+ parsed = datetime.fromisoformat(text)+ except ValueError:+ return None+ if parsed.tzinfo is None:+ parsed = parsed.replace(tzinfo=timezone.utc)+ return parsed.astimezone(timezone.utc)+++def _format_elapsed(seconds: int) -> str:+ hours, remainder = divmod(max(0, int(seconds)), 3600)+ minutes, seconds = divmod(remainder, 60)+ if hours:+ return f"{hours}h {minutes}m"+ if minutes:+ return f"{minutes}m {seconds}s"+ return f"{seconds}s"+++def _now() -> str:+ return datetime.now(timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z")diff --git a/plugins/_goal/plugin.yaml b/plugins/_goal/plugin.yamlnew file mode 100644index 000000000..68ef170bc--- /dev/null+++ b/plugins/_goal/plugin.yaml@@ -0,0 +1,5 @@+name: _goal+title: Goal+description: Built-in chat goal tracking and goal tools.+version: 0.1.0+always_enabled: truediff --git a/plugins/_goal/prompts/agent.extras.goal.md b/plugins/_goal/prompts/agent.extras.goal.mdnew file mode 100644index 000000000..d1c0f88a7--- /dev/null+++ b/plugins/_goal/prompts/agent.extras.goal.md@@ -0,0 +1,7 @@+## current goal+status: {{status}}+objective: {{objective}}+created by: {{created_by}}+updated: {{updated_at}}++Follow this goal while it is active. When the work is complete, call `update_goal` with `status="complete"` before your final answer. If progress is genuinely blocked, call `update_goal` with `status="blocked"` and explain what is missing.diff --git a/plugins/_goal/prompts/agent.system.tool.create_goal.md b/plugins/_goal/prompts/agent.system.tool.create_goal.mdnew file mode 100644index 000000000..38919d228--- /dev/null+++ b/plugins/_goal/prompts/agent.system.tool.create_goal.md@@ -0,0 +1,23 @@+### create_goal+Create or replace the current chat goal.++Use only when the user asks for a goal, asks you to manage a goal, or `/goal auto` asks you to create one.++Args: `objective`, optional `token_budget`.++Rules:+- Create one concise objective that describes the current work, not a generic plan.+- The new goal becomes active.+- Do not create goals for casual replies or ordinary one-shot answers.++Example:+~~~json+{+ "thoughts": ["The user asked me to manage this task as a goal."],+ "headline": "Creating goal",+ "tool_name": "create_goal",+ "tool_args": {+ "objective": "Add the built-in goal plugin with a Web UI strip and slash command"+ }+}+~~~diff --git a/plugins/_goal/prompts/agent.system.tool.get_goal.md b/plugins/_goal/prompts/agent.system.tool.get_goal.mdnew file mode 100644index 000000000..e178111af--- /dev/null+++ b/plugins/_goal/prompts/agent.system.tool.get_goal.md@@ -0,0 +1,10 @@+### get_goal+Inspect the current chat goal.++Use this when the user asks about the goal, asks you to manage a goal, or you need to check whether a goal already exists before creating one.++Args: none.++Rules:+- Do not invent a goal if none exists.+- If a goal is paused, complete, or blocked, treat it as state to report unless the user asks you to resume or replace it.diff --git a/plugins/_goal/prompts/agent.system.tool.update_goal.md b/plugins/_goal/prompts/agent.system.tool.update_goal.mdnew file mode 100644index 000000000..60c25deef--- /dev/null+++ b/plugins/_goal/prompts/agent.system.tool.update_goal.md@@ -0,0 +1,11 @@+### update_goal+Mark the current chat goal complete or blocked.++Use when the active goal is actually achieved, or when progress is genuinely blocked by missing user input or an external-state change.++Args: `status` (`complete` or `blocked`), optional `objective`, optional `note`.++Rules:+- Mark `complete` only when the objective has been achieved.+- Mark `blocked` only when meaningful progress cannot continue without user input or an external-state change.+- Pause, resume, edit, and delete are user controls; do not claim to perform them with this tool.diff --git a/plugins/_goal/tests/conftest.py b/plugins/_goal/tests/conftest.pynew file mode 100644index 000000000..820354eaf--- /dev/null+++ b/plugins/_goal/tests/conftest.py@@ -0,0 +1,8 @@+import sys+from pathlib import Path+++a0_root = str(Path(__file__).resolve().parents[3])+while a0_root in sys.path:+ sys.path.remove(a0_root)+sys.path.insert(0, a0_root)diff --git a/plugins/_goal/tests/test_goal_plugin.py b/plugins/_goal/tests/test_goal_plugin.pynew file mode 100644index 000000000..6754f2974--- /dev/null+++ b/plugins/_goal/tests/test_goal_plugin.py@@ -0,0 +1,124 @@+from __future__ import annotations++import uuid+from types import SimpleNamespace++import pytest++from helpers import files+from plugins._goal.api.goal import Goal+from plugins._goal.commands import goal_command+from plugins._goal.helpers import goals+from plugins._goal.tools.create_goal import CreateGoal+from plugins._goal.tools.get_goal import GetGoal+from plugins._goal.tools.update_goal import UpdateGoal+++def context_id():+ context_id = f"goal-test-{uuid.uuid4().hex}"+ yield context_id+ goals.delete_goal(context_id)+++def _payload(context_id: str, command_text: str) -> dict:+ from plugins._commands.helpers.commands import parse_slash_invocation++ return {+ "invocation": parse_slash_invocation(command_text),+ "context": {"context_id": context_id},+ }+++def test_goal_storage_round_trip(context_id: str):+ goal = goals.create_goal(context_id, "Ship the goal plugin", token_budget=1200)++ loaded = goals.get_goal(context_id)+ assert loaded == goal+ assert loaded["status"] == "active"+ assert loaded["token_budget"] == 1200+ assert loaded["active_since"]+ assert loaded["elapsed_seconds"] == 0++ updated = goals.update_goal(context_id, status="paused", objective="Polish the goal strip")+ assert updated["status"] == "paused"+ assert updated["objective"] == "Polish the goal strip"+ assert updated["active_since"] == ""+ paused_seconds = updated["elapsed_seconds"]++ resumed = goals.update_goal(context_id, status="active")+ assert resumed["status"] == "active"+ assert resumed["active_since"]+ assert resumed["elapsed_seconds"] == paused_seconds++ goals.delete_goal(context_id)+ assert goals.get_goal(context_id) is None+++def test_goal_command_sets_pauses_resumes_and_deletes(context_id: str):+ created = goal_command.run(_payload(context_id, "/goal Add current goal support"))+ assert created["effects"][0]["message"] == "Goal set."+ assert created["effects"][2] == {"type": "send_message", "text": "Add current goal support"}+ assert goals.get_goal(context_id)["objective"] == "Add current goal support"++ paused = goal_command.run(_payload(context_id, "/goal pause"))+ assert paused["effects"][0]["message"] == "Goal paused."+ assert goals.get_goal(context_id)["status"] == "paused"++ resumed = goal_command.run(_payload(context_id, "/goal resume"))+ assert resumed["effects"][0]["message"] == "Goal resumed."+ assert goals.get_goal(context_id)["status"] == "active"++ deleted = goal_command.run(_payload(context_id, "/goal delete"))+ assert deleted["effects"][0]["message"] == "Goal deleted."+ assert goals.get_goal(context_id) is None+++def test_goal_auto_fills_prompt(context_id: str):+ result = goal_command.run(_payload(context_id, "/goal auto keep this tight"))++ assert "Please create and manage a goal" in result["text"]+ assert "User hint: keep this tight" in result["text"]+ assert result["effects"] == []+++def test_goal_files_stay_under_user_plugin_state(context_id: str):+ goals.create_goal(context_id, "Keep state in usr")+ goal_path = files.get_abs_path(+ files.USER_DIR,+ files.PLUGINS_DIR,+ goals.PLUGIN_NAME,+ goals.GOALS_DIR,+ f"{context_id}.json",+ )++ assert files.exists(goal_path)+++async def test_goal_api_and_agent_tools(context_id: str):+ handler = object.__new__(Goal)+ created = await handler.process(+ {+ "action": "set",+ "context_id": context_id,+ "objective": "Exercise API path",+ },+ None,+ )+ assert created["ok"] is True+ assert created["goal"]["objective"] == "Exercise API path"++ fake_agent = SimpleNamespace(context=SimpleNamespace(id=context_id))+ get_tool = GetGoal(fake_agent, "get_goal", None, {}, "", None)+ get_response = await get_tool.execute()+ assert "Exercise API path" in get_response.message++ update_tool = UpdateGoal(fake_agent, "update_goal", None, {}, "", None)+ update_response = await update_tool.execute(status="complete")+ assert "Status: complete" in update_response.message++ create_tool = CreateGoal(fake_agent, "create_goal", None, {}, "", None)+ create_response = await create_tool.execute(objective="Exercise tool path")+ assert "Goal created: Exercise tool path" == create_response.message+ assert goals.get_goal(context_id)["created_by"] == "model"diff --git a/plugins/_goal/tools/__init__.py b/plugins/_goal/tools/__init__.pynew file mode 100644index 000000000..8b1378917--- /dev/null+++ b/plugins/_goal/tools/__init__.py@@ -0,0 +1 @@+diff --git a/plugins/_goal/tools/create_goal.py b/plugins/_goal/tools/create_goal.pynew file mode 100644index 000000000..4853ce4fc--- /dev/null+++ b/plugins/_goal/tools/create_goal.py@@ -0,0 +1,23 @@+from __future__ import annotations++from helpers.tool import Response, Tool+from plugins._goal.helpers import goals+++class CreateGoal(Tool):+ async def execute(+ self,+ objective: str = "",+ token_budget: int | None = None,+ **kwargs,+ ) -> Response:+ goal = goals.create_goal(+ self.agent.context.id,+ objective,+ created_by="model",+ token_budget=token_budget,+ )+ return Response(+ message=f"Goal created: {goal['objective']}",+ break_loop=False,+ )diff --git a/plugins/_goal/tools/get_goal.py b/plugins/_goal/tools/get_goal.pynew file mode 100644index 000000000..8c81f0236--- /dev/null+++ b/plugins/_goal/tools/get_goal.py@@ -0,0 +1,10 @@+from __future__ import annotations++from helpers.tool import Response, Tool+from plugins._goal.helpers import goals+++class GetGoal(Tool):+ async def execute(self, **kwargs) -> Response:+ goal = goals.get_goal(self.agent.context.id)+ return Response(message=goals.summarize_goal(goal), break_loop=False)diff --git a/plugins/_goal/tools/update_goal.py b/plugins/_goal/tools/update_goal.pynew file mode 100644index 000000000..7caac0b5c--- /dev/null+++ b/plugins/_goal/tools/update_goal.py@@ -0,0 +1,31 @@+from __future__ import annotations++from helpers.tool import Response, Tool+from plugins._goal.helpers import goals+++class UpdateGoal(Tool):+ async def execute(+ self,+ status: str = "",+ objective: str = "",+ note: str = "",+ **kwargs,+ ) -> Response:+ normalized_status = str(status or "").strip().lower()+ if normalized_status not in {"complete", "blocked"}:+ return Response(+ message="Model-managed goal updates may only mark goals complete or blocked.",+ break_loop=False,+ )++ goal = goals.update_goal(+ self.agent.context.id,+ status=normalized_status,+ objective=objective if objective else None,+ note=note if note else None,+ )+ return Response(+ message=goals.summarize_goal(goal),+ break_loop=False,+ )diff --git a/plugins/_goal/webui/goal-store.js b/plugins/_goal/webui/goal-store.jsnew file mode 100644index 000000000..348f5f998--- /dev/null+++ b/plugins/_goal/webui/goal-store.js@@ -0,0 +1,206 @@+import { createStore } from "/js/AlpineStore.js";+import { callJsonApi } from "/js/api.js";+import { store as chatsStore } from "/components/sidebar/chats/chats-store.js";+import {+ toastFrontendError,+ toastFrontendSuccess,+} from "/components/notifications/notification-store.js";++const GOAL_API_PATH = "/plugins/_goal/goal";++const model = {+ goal: null,+ loading: false,+ saving: false,+ editing: false,+ draft: "",+ lastContextId: "",+ intervalId: null,+ clockIntervalId: null,+ goalChangedHandler: null,+ now: Date.now(),++ get visible() {+ return Boolean(this.goal?.objective && this.goal.status !== "complete");+ },++ get contextId() {+ return chatsStore?.getSelectedChatId?.() || globalThis.getContext?.() || "";+ },++ get statusLabel() {+ const status = this.goal?.status || "active";+ if (status === "paused") return "Goal paused";+ if (status === "complete") return "Goal complete";+ if (status === "blocked") return "Goal blocked";+ return "Pursuing goal";+ },++ get statusIcon() {+ const status = this.goal?.status || "active";+ if (status === "paused") return "pause_circle";+ if (status === "complete") return "check_circle";+ if (status === "blocked") return "error";+ return "track_changes";+ },++ get elapsedSeconds() {+ if (!this.goal) return 0;+ const status = this.goal.status || "active";+ const storedSeconds = Number.parseInt(this.goal.elapsed_seconds, 10);+ let seconds = Number.isNaN(storedSeconds) ? 0 : storedSeconds;+ if (Number.isNaN(storedSeconds) && status !== "active") {+ seconds = this.secondsBetween(this.goal.created_at, this.goal.updated_at);+ }+ if (status === "active") {+ seconds += this.secondsBetween(+ this.goal.active_since || this.goal.created_at || this.goal.updated_at,+ this.now,+ );+ }+ return Math.max(0, seconds);+ },++ secondsBetween(start, end) {+ const startMs = Date.parse(start || "");+ const endMs = typeof end === "number" ? end : Date.parse(end || "");+ if (Number.isNaN(startMs) || Number.isNaN(endMs)) return 0;+ return Math.max(0, Math.floor((endMs - startMs) / 1000));+ },++ get elapsedLabel() {+ const seconds = this.elapsedSeconds;+ const hours = Math.floor(seconds / 3600);+ const minutes = Math.floor((seconds % 3600) / 60);+ const remainingSeconds = seconds % 60;+ if (hours) return `${hours}h ${minutes}m`;+ if (minutes) return `${minutes}m ${remainingSeconds}s`;+ return `${remainingSeconds}s`;+ },++ onMount() {+ document.getElementById("progress-bar-box")?.classList.add("has-goal-bar");+ this.goalChangedHandler = (event) => {+ const detail = event?.detail || {};+ if (detail.goal === null) {+ this.goal = null;+ }+ void this.refresh(true);+ };+ window.addEventListener("goal:changed", this.goalChangedHandler);+ this.clockIntervalId = window.setInterval(() => {+ this.now = Date.now();+ }, 1000);+ this.intervalId = window.setInterval(() => this.refresh(), 3000);+ void this.refresh(true);+ },++ cleanup() {+ document.getElementById("progress-bar-box")?.classList.remove("has-goal-bar");+ if (this.goalChangedHandler) {+ window.removeEventListener("goal:changed", this.goalChangedHandler);+ }+ if (this.intervalId) {+ window.clearInterval(this.intervalId);+ }+ if (this.clockIntervalId) {+ window.clearInterval(this.clockIntervalId);+ }+ this.goalChangedHandler = null;+ this.intervalId = null;+ this.clockIntervalId = null;+ },++ async refresh(force = false) {+ const contextId = this.contextId;+ if (!contextId) {+ this.goal = null;+ this.lastContextId = "";+ return;+ }+ if (!force && this.loading) return;++ this.loading = true;+ try {+ const response = await callJsonApi(GOAL_API_PATH, {+ action: "get",+ context_id: contextId,+ });+ this.goal = response?.goal || null;+ this.now = Date.now();+ this.lastContextId = contextId;+ if (!this.goal) this.editing = false;+ } catch (error) {+ console.error("Failed to load goal:", error);+ this.goal = null;+ this.lastContextId = contextId;+ } finally {+ this.loading = false;+ }+ },++ startEdit() {+ if (!this.goal) return;+ this.draft = this.goal.objective || "";+ this.editing = true;+ requestAnimationFrame(() => {+ document.querySelector(".goal-strip-input")?.focus?.();+ document.querySelector(".goal-strip-input")?.select?.();+ });+ },++ cancelEdit() {+ this.editing = false;+ this.draft = "";+ },++ async saveEdit() {+ const objective = (this.draft || "").trim();+ if (!objective) {+ void toastFrontendError("Goal objective is required.", "Goal");+ return;+ }+ await this.update({ action: "update", objective, status: "active" }, "Goal updated.");+ this.editing = false;+ },++ async pauseOrResume() {+ if (!this.goal) return;+ const action = this.goal.status === "active" ? "pause" : "resume";+ await this.update(+ { action },+ action === "pause" ? "Goal paused." : "Goal resumed.",+ );+ },++ async deleteGoal() {+ await this.update({ action: "delete" }, "Goal deleted.");+ },++ async update(payload, successMessage) {+ const contextId = this.contextId;+ if (!contextId || this.saving) return;++ this.saving = true;+ try {+ const response = await callJsonApi(GOAL_API_PATH, {+ ...payload,+ context_id: contextId,+ });+ this.goal = response?.goal || null;+ this.now = Date.now();+ this.lastContextId = contextId;+ window.dispatchEvent(new CustomEvent("goal:changed", {+ detail: { goal: this.goal, context_id: contextId },+ }));+ void toastFrontendSuccess(successMessage, "Goal");+ } catch (error) {+ console.error("Failed to update goal:", error);+ void toastFrontendError(error?.message || "Failed to update goal.", "Goal");+ } finally {+ this.saving = false;+ }+ },+};++export const store = createStore("goalBar", model);diff --git a/plugins/_goal/webui/thumbnail.png b/plugins/_goal/webui/thumbnail.pngnew file mode 100644index 000000000..4d886a818Binary files /dev/null and b/plugins/_goal/webui/thumbnail.png differ