MetaList 0.12.0__tar.gz → 0.14.0__tar.gz

{metalist-0.12.0/metalist.egg-info → metalist-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metalist
-Version: 0.12.0
+Version: 0.14.0
 Summary: A minimalist single-user note-taking app with SSR, fast in-memory tree operations, and efficient sync.
 Project-URL: Homepage, https://github.com/evolvingstuff/metalist
 Project-URL: Repository, https://github.com/evolvingstuff/metalist
@@ -23,6 +23,7 @@ Requires-Dist: pydantic==2.13.4
 Requires-Dist: pypdf==6.19.0
 Requires-Dist: python-dotenv==1.2.2
 Requires-Dist: python-multipart==0.0.32
+Requires-Dist: rich==14.3.4
 Requires-Dist: starlette==1.3.1
 Requires-Dist: tqdm==4.70.0
 Requires-Dist: tree-sitter==0.25.2
@@ -49,6 +50,23 @@ A minimalist single-user note-taking app focused on server-side rendering (SSR),
 - Multi-tab search contexts with server-persisted scroll/search state (survives browser restarts)
 - Manual namespace backups/restores to a user-selected backup folder with retention controls
 
+## Changes in 0.14.0
+
+- A new login screen: one dark screen with the MetaList logo. The namespace, password and OK fade in together; once the password is accepted, the loading progress slides in with the current step and the seconds elapsed. When the first login after an update backs up and upgrades the namespace, a note under OK says so. The Session locked page has the same look, and there is no white flash between them.
+- Web link titles: links to Reddit (including share links), YouTube, Vimeo, TikTok, Spotify and SoundCloud get their real titles. Lookups are paced per site, so a note full of links no longer trips a site's rate limit. Login, consent and site-name-only titles ("Sign in", "Reddit") show the link instead. The new command palette action Retry failed link titles asks every failed link again, with a progress dialog.
+- Quoted search also matches link titles and the URLs hidden behind link labels, and the AI sees those URLs too. Pasting into a quoted search inserts the text as copied.
+- `[[note id]]` is always a link, even in a note with a `[[ ]]` formatting tag.
+- The startup output in the terminal is easier to read: the version, a check mark per check, and each namespace's URLs lined up.
+- Fixed: clicking the AI chat's $ or eye button twice quickly crashed with "Redundant state change".
+
+## Changes in 0.13.0
+
+- Dictation: text from speech-to-text tools such as Superwhisper, pasted into the search bar or any tag field, becomes your existing tags ("neural network" gives `neural-network`). Say "quote … end quote" for text, "minus" to exclude, "at" before meta tags such as `@todo`. In a note, the words after "start tags" go to its tag bar. The phrases are set in Dictation Settings, and one undo restores what was pasted.
+- A quoted search with a space at its edge matches whole words: `" fat"` no longer finds "father".
+- The AI keeps a record of what it did for each answer (notes read, searches, web pages opened), so questions like "did you search the web for that?" are answered from what actually happened.
+- Dropping a `.txt`, `.md`, `.csv` or `.json` file stores it as before and adds its text as a child note, shown as Markdown, a table or formatted JSON. File pills show the extension (`.MD`, `.CSV`, …), and hovering a pill says that clicking downloads the file.
+- Typing one letter in the tag bar now narrows the suggestions you were already shown instead of reordering them, so the tag you want is in the top five far more often.
+
 ## Changes in 0.12.0
 
 - AI chat is now a tool-using agent: in one answer it can look up MetaList help, read and search the notes in your view, open web pages, and open menus, instead of picking a single route up front. Answers cite notes and web pages with clickable references, including each item listed from a web page.

{metalist-0.12.0 → metalist-0.14.0}/README.md

@@ -12,6 +12,23 @@ A minimalist single-user note-taking app focused on server-side rendering (SSR),
 - Multi-tab search contexts with server-persisted scroll/search state (survives browser restarts)
 - Manual namespace backups/restores to a user-selected backup folder with retention controls
 
+## Changes in 0.14.0
+
+- A new login screen: one dark screen with the MetaList logo. The namespace, password and OK fade in together; once the password is accepted, the loading progress slides in with the current step and the seconds elapsed. When the first login after an update backs up and upgrades the namespace, a note under OK says so. The Session locked page has the same look, and there is no white flash between them.
+- Web link titles: links to Reddit (including share links), YouTube, Vimeo, TikTok, Spotify and SoundCloud get their real titles. Lookups are paced per site, so a note full of links no longer trips a site's rate limit. Login, consent and site-name-only titles ("Sign in", "Reddit") show the link instead. The new command palette action Retry failed link titles asks every failed link again, with a progress dialog.
+- Quoted search also matches link titles and the URLs hidden behind link labels, and the AI sees those URLs too. Pasting into a quoted search inserts the text as copied.
+- `[[note id]]` is always a link, even in a note with a `[[ ]]` formatting tag.
+- The startup output in the terminal is easier to read: the version, a check mark per check, and each namespace's URLs lined up.
+- Fixed: clicking the AI chat's $ or eye button twice quickly crashed with "Redundant state change".
+
+## Changes in 0.13.0
+
+- Dictation: text from speech-to-text tools such as Superwhisper, pasted into the search bar or any tag field, becomes your existing tags ("neural network" gives `neural-network`). Say "quote … end quote" for text, "minus" to exclude, "at" before meta tags such as `@todo`. In a note, the words after "start tags" go to its tag bar. The phrases are set in Dictation Settings, and one undo restores what was pasted.
+- A quoted search with a space at its edge matches whole words: `" fat"` no longer finds "father".
+- The AI keeps a record of what it did for each answer (notes read, searches, web pages opened), so questions like "did you search the web for that?" are answered from what actually happened.
+- Dropping a `.txt`, `.md`, `.csv` or `.json` file stores it as before and adds its text as a child note, shown as Markdown, a table or formatted JSON. File pills show the extension (`.MD`, `.CSV`, …), and hovering a pill says that clicking downloads the file.
+- Typing one letter in the tag bar now narrows the suggestions you were already shown instead of reordering them, so the tag you want is in the top five far more often.
+
 ## Changes in 0.12.0
 
 - AI chat is now a tool-using agent: in one answer it can look up MetaList help, read and search the notes in your view, open web pages, and open menus, instead of picking a single route up front. Answers cite notes and web pages with clickable references, including each item listed from a web page.

{metalist-0.12.0 → metalist-0.14.0}/app/api/middleware/auth.py

@@ -41,6 +41,7 @@ class AuthMiddleware(BaseHTTPMiddleware):
     NO_TOKEN_REFRESH_PATHS = [
         f"{API_PREFIX}/auth/status",  # Polling service pings this for connectivity
         f"{API_PREFIX}/reminders/evaluate",  # Reminder polling is not user-initiated activity
+        f"{API_PREFIX}/notes/link-titles/retry",  # The retry dialog polls its progress
     ]
     
     # Note: /api/notes/* paths are NOT in this list - they require auth when password is set

{metalist-0.12.0 → metalist-0.14.0}/app/api/note_requests.py

@@ -106,6 +106,18 @@ class SearchSuggestionInteractionRequest(TypedDict):
 class TabSearchInteractionRequest(TypedDict):
     searchQuery: Text
 
+@with_config(ConfigDict(strict=True))
+class DictationPasteRequest(TypedDict):
+    """Text pasted into the search bar or the tag bar, and the field's current value."""
+    text: Text
+    target: Literal["search", "tags", "tag", "condition"]
+    current_value: Text
+    # The spoken phrases around a quoted phrase (Dictation Settings).
+    quote_open: Identifier
+    quote_close: Identifier
+    # Spoken before a search term to exclude it (Dictation Settings).
+    negate_phrase: Identifier
+
 @with_config(ConfigDict(strict=True))
 class TagSuggestionsRequest(TypedDict):
     note_id: Identifier
@@ -136,6 +148,14 @@ class CreateChildRequest(TypedDict):
     undoContext: UndoContext
     viewport: Viewport
 
+@with_config(ConfigDict(strict=True))
+class CreateFilePreviewChildRequest(TypedDict):
+    fileId: Identifier
+    search_query: Text | None
+    clientId: Identifier
+    undoContext: UndoContext
+    viewport: Viewport
+
 @with_config(ConfigDict(strict=True))
 class UpdateNoteRequest(TypedDict):
     clientId: Identifier

{metalist-0.12.0 → metalist-0.14.0}/app/api/routes/ai.py

@@ -642,6 +642,7 @@ def stream_ai_chat(
         model=payload.model,
     )
     provider_messages = ai_chat_store.provider_messages(session_key=session_key)
+    earlier_actions = ai_chat_store.earlier_actions(session_key=session_key)
     initial_messages = agent_context_builder.build_initial_messages(
         canonical_messages=provider_messages,
         prompts=prompts,
@@ -654,7 +655,7 @@ def stream_ai_chat(
     events = _stream_runtime_events(payload=payload, openai_api_key=openai_api_key,
         session_key=session_key, provider_messages=provider_messages, prompts=prompts, skills=skills,
         retrieval_settings=retrieval_settings, frozen_scope=frozen_scope, tagging_run=tagging_run,
-        web_settings=web_settings,
+        web_settings=web_settings, earlier_actions=earlier_actions,
         initial_input_tokens=initial_approx_input_tokens)
 
     return StreamingResponse(
@@ -673,6 +674,7 @@ async def _stream_runtime_events(
     provider_messages: list[dict[str, str]], prompts: AgentPromptSet, skills: AgentSkillSet,
     retrieval_settings: AgentRetrievalSettings, frozen_scope: ScopedSearchSnapshot,
     tagging_run: TaggingRun, initial_input_tokens: int, web_settings: AgentWebSettings,
+    earlier_actions: list[dict[str, object]],
 ) -> AsyncIterator[dict[str, object]]:
     action, start_label = 'provider_runtime', 'Connecting to OpenAI API'
     ready_label = 'OpenAI API ready · 1,050,000-token context'
@@ -686,7 +688,7 @@ async def _stream_runtime_events(
             selected_model=payload.model, thinking_level=payload.thinking_level,
             canonical_messages=provider_messages, prompts=prompts, skills=skills,
             retrieval_settings=retrieval_settings, web_settings=web_settings,
-            frozen_scope=frozen_scope, tagging_run=tagging_run)
+            frozen_scope=frozen_scope, tagging_run=tagging_run, earlier_actions=earlier_actions)
     try:
         async for event in events:
             yield event

{metalist-0.12.0 → metalist-0.14.0}/app/api/routes/auth.py

@@ -97,6 +97,7 @@ from app.services.client_state_service import save_client_preferences
 from app.services.client_state_service import save_command_palette_usage
 from app.services.openai_credentials import openai_credential_store
 from app.services.input_errors import NamespaceInputRejected
+from app.services.link_title_retry import stop_link_title_retry
 
 
 router = APIRouter(prefix="/auth", tags=["auth2"])
@@ -595,6 +596,9 @@ def logout(
     openai_credential_store.clear_session(session_key=session_key)
     token_service.revoke_token(token)
     shell_session_service.reset()
+    # Lock and login end a retry through the runtime generation; a passwordless
+    # logout does not change it, so stop the retry here.
+    stop_link_title_retry()
     view_cache.clear()
     reset_all_undo_state()
     reset_sync_state()
@@ -712,6 +716,8 @@ def auth_status(
     return {
         "version": VERSION,
         "database_user_version": database_user_version,
+        # The next login backs up and upgrades this database (the login screen says so).
+        "database_upgrade_pending": database_user_version < CURRENT_DATABASE_VERSION,
         "authenticated": token is not None,
         # Same answer as AuthService.has_password(), from the row already read.
         "has_password": settings is not None and bool(settings.encryption_enabled),

{metalist-0.12.0 → metalist-0.14.0}/app/api/routes/notes.py

@@ -20,9 +20,11 @@ from app.api.note_requests import (
     SearchSuggestionInteractionRequest,
     TabSearchInteractionRequest,
     TagSuggestionsRequest,
+    DictationPasteRequest,
     CreateNoteTopRequest,
     CreateSiblingRequest,
     CreateChildRequest,
+    CreateFilePreviewChildRequest,
     UpdateNoteRequest,
     SaveNoteRequest,
     AddSelectedTextTagRequest,
@@ -61,9 +63,16 @@ from app.services.exception_capture import CapturedExceptionContext
 from app.usecases.create_note import CmdCreateNote
 from app.usecases.base import QueryCommand
 from app.usecases.create_sibling import CmdCreateSibling
+from app.services.file_registry import file_registry
 from app.usecases.create_child import CmdCreateChild
+from app.usecases.create_file_preview_child import CmdCreateFilePreviewChild
 from app.usecases.update_content import CmdUpdateContent
 from app.usecases.prefetch_link_titles import CmdPrefetchLinkTitles
+from app.services.link_title_retry import (
+    link_title_retry_snapshot,
+    start_link_title_retry,
+    stop_link_title_retry,
+)
 from app.usecases.add_selected_text_tag import CmdAddSelectedTextTag
 from app.usecases.tag_proposals import (
     CmdAcceptTagProposal,
@@ -127,6 +136,7 @@ from app.services.html_export import build_notes_export_filename
 from app.services.note_fullscreen import build_note_fullscreen_markup
 from app.services.link_titles import link_title_store
 from app.services.search_index import search_index
+from app.services.dictation_cleanup import clean_dictated_paste
 from app.services.tag_suggestions import suggest_tags_for_note
 from app.services.undo_state import reset_undo_stack
 from app.usecases.prioritize import list_prioritize_tag_suggestions
@@ -154,6 +164,26 @@ def prefetch_link_titles(request: Request, draft: LinkTitlePrefetchRequest) -> d
     return CmdPrefetchLinkTitles(content=draft.content, tags=draft.tags).execute()
 
 
+@router.get("/notes/link-titles/retry")
+def link_title_retry_progress(request: Request) -> dict[str, object]:
+    require_request_auth_token(request)
+    return link_title_retry_snapshot()
+
+
+@router.post("/notes/link-titles/retry")
+@transactional_route
+def start_link_title_retry_route(request: Request) -> dict[str, object]:
+    require_request_auth_token(request)
+    return start_link_title_retry()
+
+
+@router.post("/notes/link-titles/retry/stop")
+@transactional_route
+def stop_link_title_retry_route(request: Request) -> dict[str, object]:
+    require_request_auth_token(request)
+    return stop_link_title_retry()
+
+
 def _require_note_present(note_id: str, *, context: str) -> None:
     if not isinstance(context, str) or not context:
         raise ValueError("context must be a non-empty string")
@@ -551,6 +581,22 @@ def delete_tag_interactions(request: Request) -> Dict[str, object]:
     return {"deletedCount": deleted_count}
 
 
+@router.post("/notes/dictation-paste")
+@transactional_route
+def dictation_paste(payload: DictationPasteRequest) -> Dict[str, object]:
+    """Read-only: the cleaned-up text to insert for a paste (docs/ui/dictation-paste.md)."""
+    text = clean_dictated_paste(
+        text=payload["text"],
+        target=payload["target"],
+        existing_tag_frequencies=search_index.list_explicit_tag_frequencies(),
+        current_value=payload["current_value"],
+        quote_open=payload["quote_open"],
+        quote_close=payload["quote_close"],
+        negate_phrase=payload["negate_phrase"],
+    )
+    return {"text": text}
+
+
 @router.post("/notes/tag-suggestions")
 @transactional_route
 def tag_suggestions(payload: TagSuggestionsRequest) -> Dict[str, object]:
@@ -750,6 +796,27 @@ def create_child(request: Request, note_id: str, body: CreateChildRequest):
     return cmd.execute()
 
 
+@router.post("/notes/file-preview-child/{note_id}")
+@transactional_route
+def create_file_preview_child(request: Request, note_id: str, body: CreateFilePreviewChildRequest):
+    token = _require_bearer_token(request)
+    viewport = _require_viewport(body)
+    _require_note_present(note_id, context="notes.file-preview-child")
+    file_id = body["fileId"]
+    if not file_registry.has_file(file_id):
+        raise HTTPException(status_code=404, detail=f"File not found: {file_id}")
+    cmd = CmdCreateFilePreviewChild(
+        parent_note_id=note_id,
+        file_id=file_id,
+        search_query=body["search_query"],
+        token=token,
+        client_id=body["clientId"],
+        undo_context=body["undoContext"],
+        viewport=viewport,
+    )
+    return cmd.execute()
+
+
 @router.put("/notes/{note_id}")
 @transactional_route
 def update_note(request: Request, note_id: str, body: UpdateNoteRequest):

{metalist-0.12.0 → metalist-0.14.0}/app/config.py

@@ -45,7 +45,6 @@ def _env_int(name: str, default: int) -> int:
 CRASH_SERVER_ON_FAIL = _env_flag("CRASH_SERVER_ON_FAIL", True)
 DEV_ENFORCE_INTEGRITY_CHECKS = _env_flag("DEV_ENFORCE_INTEGRITY_CHECKS", False)
 DISABLE_UNDO_SNAPSHOT = _env_flag("DISABLE_UNDO_SNAPSHOT", True)
-STARTUP_ANIMATION_ENABLED = _env_flag("STARTUP_ANIMATION_ENABLED", False)
 
 # Tag suggestions
 TAG_SUGGESTION_CONNECTORS = "-_/."

{metalist-0.12.0 → metalist-0.14.0}/app/encryption_audit.py

@@ -94,6 +94,20 @@ class EncryptionAuditReport:
     def startup_allowed(self) -> bool:
         return self.namespace_count > 0 and len(self.fatal_findings) == 0
 
+    def namespace_statuses(self) -> list[tuple[str, str]]:
+        """(namespace, PASS | MIGRATION REQUIRED | FAIL | SKIPPED (not encrypted)) per namespace."""
+        statuses: list[tuple[str, str]] = []
+        for result in self.results:
+            result_status = "SKIPPED (not encrypted)"
+            if result.is_encrypted:
+                result_status = "PASS"
+                if result.findings:
+                    result_status = "MIGRATION REQUIRED"
+                    if any(not finding.is_migration_deferred for finding in result.findings):
+                        result_status = "FAIL"
+            statuses.append((result.namespace, result_status))
+        return statuses
+
     def render_text(self) -> str:
         status = "FAIL"
         if self.passed:
@@ -110,15 +124,8 @@ class EncryptionAuditReport:
             ),
             f"Sensitive payloads checked: {self.checked_payload_count}",
         ]
-        for result in self.results:
-            result_status = "SKIPPED (not encrypted)"
-            if result.is_encrypted:
-                result_status = "PASS"
-                if result.findings:
-                    result_status = "MIGRATION REQUIRED"
-                    if any(not finding.is_migration_deferred for finding in result.findings):
-                        result_status = "FAIL"
-            lines.append(f"- {result.namespace}: {result_status}")
+        for namespace, result_status in self.namespace_statuses():
+            lines.append(f"- {namespace}: {result_status}")
         if self.findings:
             lines.append("Findings:")
             for finding in self.findings:

{metalist-0.12.0 → metalist-0.14.0}/app/exception_boundaries.py

@@ -26,6 +26,8 @@ CAPTURE_BOUNDARIES = {
     'app/api/routes/app_updates.py:update_status:lookup': ('AppUpdateRejected', 'FileNotFoundError'),
     # Release smoke polls only its own disposable HTTP listeners during an actual update.
     'scripts/smoke_self_update.py:_has_updated_namespace:probe_capture': ('HTTPError',),
+    # Release smoke cleanup: on Windows an exiting process refuses termination; the wait then checks it stopped.
+    'scripts/smoke_installed_package.py:_terminate_on_windows:exit_capture': ('ProcessLookupError', 'PermissionError'),
     # A child can exit between poll and terminate; hung children must be killed and reaped.
     'app/services/namespace_switcher.py:_stop_failed_namespace_launch:terminate_capture': ('ProcessLookupError',),
     'app/services/namespace_switcher.py:_stop_failed_namespace_launch:wait_capture': ('TimeoutExpired',),
@@ -125,6 +127,12 @@ CAPTURE_BOUNDARIES = {
     # Handle expected external I/O, provider, image or LaTeX parsing failure.
     'app/services/link_titles.py:fetch_link_title:target_capture': ('PublicHttpTargetRejected',),
     # Handle expected external I/O, provider, image or LaTeX parsing failure.
+    'app/services/link_titles.py:_fetch_oembed_title:target_capture': ('PublicHttpTargetRejected',),
+    # Handle expected external I/O, provider, image or LaTeX parsing failure.
+    'app/services/link_titles.py:_fetch_oembed_title:json_capture': ('JSONDecodeError', 'UnicodeDecodeError'),
+    # Handle expected external I/O, provider, image or LaTeX parsing failure.
+    'app/services/link_titles.py:_download_oembed:capture': ('TimeoutException', 'NetworkError', 'HTTPError', 'TimeoutException', 'NetworkError', 'ProtocolError'),
+    # Handle expected external I/O, provider, image or LaTeX parsing failure.
     'app/services/namespace_deletion_worker.py:_is_process_running:kill_capture': ('ProcessLookupError', 'PermissionError'),
     # Handle expected external I/O, provider, image or LaTeX parsing failure.
     'app/services/namespace_deletion_worker.py:_send_signal_if_running:signal_capture': ('ProcessLookupError',),

{metalist-0.12.0 → metalist-0.14.0}/app/main.py

@@ -16,7 +16,7 @@ from app.api.upload_limits import UploadLimitMiddleware
 from app.presentation.templates import get_templates
 from .api import dev
 from .api.middleware.auth import AuthMiddleware
-from app.config import ACTIVE_NAMESPACE, STARTUP_ANIMATION_ENABLED, VERSION
+from app.config import ACTIVE_NAMESPACE, VERSION
 from .db.session import begin_writer, enable_read_guard
 from .db.schema import initialize_schema
 from .db.migrations import CURRENT_DATABASE_VERSION
@@ -61,6 +61,7 @@ from app.services.diagnostics import track_request
 from app.services.diagnostics import write_encrypted_exception_trace
 from app.security.sensitive_logging import traceback_frame_summary
 from app.api.request_auth import clear_auth_cookie
+from app.presentation.login_page import login_is_certainly_needed
 from app.api.routes.notes import router as api2_router
 from app.api.routes.auth import router as api2_auth_router
 from app.api.routes.app_updates import router as api2_app_updates_router
@@ -463,7 +464,7 @@ async def home(request: Request, db: Annotated[SafeSession, Depends(get_db)]):
             asset_version=ASSET_VERSION,
             page_title=_resolve_page_title(base_title="MetaList"),
             needs_auth=True,
-            startup_animation_enabled=STARTUP_ANIMATION_ENABLED,
+            shows_login_at_once=login_is_certainly_needed(request),
         )
     return template.render(
         request=request,
@@ -472,10 +473,11 @@ async def home(request: Request, db: Annotated[SafeSession, Depends(get_db)]):
         asset_version=ASSET_VERSION,
         page_title=_resolve_page_title(base_title="MetaList"),
         needs_auth=False,
-        startup_animation_enabled=STARTUP_ANIMATION_ENABLED,
+        shows_login_at_once=False,
     )
 
 
+
 @app.get("/maintenance", response_class=HTMLResponse)
 async def maintenance_page(request: Request):
     """Maintenance mode page shown during bulk operations."""

metalist-0.14.0/app/presentation/login_page.py

@@ -0,0 +1,18 @@
+"""Whether the page opens straight on the login screen (docs/AI-SUMMARY.md, Login screen)."""
+
+from __future__ import annotations
+
+from starlette.requests import Request
+
+from app.api.request_auth import AUTH_COOKIE_NAME
+
+
+def login_is_certainly_needed(request: Request) -> bool:
+    """Whether a password namespace's page can open on the login screen at once,
+    with no white page before the browser checks its session: a re-login was asked
+    for (the Session locked page's Go to Login), or the browser has no session."""
+    if not isinstance(request, Request):
+        raise TypeError("request must be a Request")
+    if request.query_params.get("force_reauth") == "1":
+        return True
+    return request.cookies.get(AUTH_COOKIE_NAME) is None

metalist-0.14.0/app/services/agent/action_log.py

@@ -0,0 +1,59 @@
+"""The agent's own record of what it did for an answer.
+
+Each tool call becomes one short entry: what was asked and what came of it,
+never the content a tool returned (page text and notes can be huge, and the
+model can read them again). The entries are kept with the answer for the rest of
+the chat and given to the model on later turns, so a question such as "did you
+search the web for that?" is answered from what actually happened. Only the
+model sees them.
+"""
+
+from __future__ import annotations
+
+import json
+
+
+_NOTE_READ_TOOLS = frozenset({"read_view_notes", "search_view_notes"})
+_OPERATION_TOOLS = frozenset({"summarize_view", "propose_tag_generation", "propose_tag_review"})
+_KNOWN_TOOLS = _NOTE_READ_TOOLS | _OPERATION_TOOLS | {
+    "lookup_metalist_help", "view_overview", "open_web_pages", "open_menu",
+}
+
+
+def describe_action(*, name: str, arguments: str, result_content: str, is_error: bool) -> dict[str, object]:
+    """One log entry for a tool call, from its JSON arguments and JSON result."""
+    # A rejected call may name a tool that does not exist: it is still recorded.
+    if is_error:
+        return {"tool": name, "rejected": True}
+    if name not in _KNOWN_TOOLS:
+        raise ValueError(f"No action log entry for unknown tool: {name!r}")
+    parsed_arguments = json.loads(arguments)
+    assert isinstance(parsed_arguments, dict), "Tool arguments are a JSON object"
+    if name in _OPERATION_TOOLS:
+        return {"tool": name, "arguments": parsed_arguments}
+    result = json.loads(result_content)
+    assert isinstance(result, dict), "Tool results are a JSON object"
+    if name == "lookup_metalist_help":
+        return {"tool": name, "topics": list(parsed_arguments["topics"])}
+    if name == "view_overview":
+        return {"tool": name, "notes_in_view": result["note_count"], "trees_in_view": result["tree_count"]}
+    if name == "open_menu":
+        return {"tool": name, "menu": result["label"], "status": result["status"]}
+    if name == "open_web_pages":
+        return {"tool": name, "pages": [_page_entry(page) for page in result["pages"]]}
+    entry: dict[str, object] = {"tool": name}
+    if name == "search_view_notes":
+        entry["query"] = parsed_arguments["query"]
+        entry["matching_notes"] = result["matching_note_count"]
+    entry["trees_read"] = len(result["trees"])
+    entry["trees_left_unread"] = len(result["unread_root_ids"])
+    entry["trees_too_large"] = len(result["too_large_root_ids"])
+    return entry
+
+
+def _page_entry(page: dict[str, object]) -> dict[str, object]:
+    """The address as asked, whether it opened, and its title when it did."""
+    title = ""
+    if page["status"] == "ok":
+        title = page["title"]
+    return {"url": page["requested_url"], "status": page["status"], "title": title}

{metalist-0.12.0 → metalist-0.14.0}/app/services/agent/agent_loop.py

@@ -52,6 +52,7 @@ from app.services.bulk_operation import bulk_operation_guard
 from app.services.agent.citation_tokens import ShortCitationTranslator
 from app.services.agent.note_aliases import NoteAliases
 from app.services.agent.execution_errors import AgentExecutionError
+from app.services.agent.action_log import describe_action
 
 
 MAX_AGENT_TURNS = 8
@@ -82,6 +83,8 @@ class AgentLoopState:
         self.web_evidence: list[WebPageEvidence] = []
         self.capabilities = capabilities
         self.content = ""
+        # What this answer did, for later turns (action_log.py).
+        self.actions: list[dict[str, object]] = []
         # Note text shown to the model, and full-mode addresses the user approved.
         self.note_text_parts: list[str] = [selected_note_text]
         self.approved_urls: set[str] = set()
@@ -129,14 +132,19 @@ class AgentLoopState:
                 "reference_note_ids": list(self.reference_note_ids),
                 "reference_web_ids": self.reference_web_ids()}
 
+    def record_action(self, *, call: dict[str, str], result_content: str, is_error: bool) -> None:
+        self.actions.append(describe_action(name=call["name"], arguments=call["arguments"],
+                                            result_content=result_content, is_error=is_error))
+
     def done_event(self) -> dict[str, object]:
         return {"type": "done", "reference_note_ids": list(self.reference_note_ids),
-                "reference_web_ids": self.reference_web_ids()}
+                "reference_web_ids": self.reference_web_ids(), "actions": list(self.actions)}
 
 
 class AgentLoopMixin:
     async def _run_agent_loop(
         self, *, run, canonical_messages: list[dict[str, str]], frozen_scope: ScopedSearchSnapshot, tagging_run,
+        earlier_actions: list[dict[str, object]],
     ) -> AsyncIterator[dict[str, object]]:
         if not isinstance(frozen_scope, ScopedSearchSnapshot):
             raise TypeError("frozen_scope must be ScopedSearchSnapshot")
@@ -167,6 +175,7 @@ class AgentLoopMixin:
         messages = self._context_builder.build_agent_messages(
             canonical_messages=canonical_messages, skills=run.skills, web_settings=run.web_settings,
             snapshot=snapshot, available_urls=capabilities.normalized_urls, note_aliases=note_aliases,
+            earlier_actions=earlier_actions,
         )
         self._trace_store.append_event(
             session_key=run.session_key, run_id=run.run_id, event_type="FROZEN_SCOPE",
@@ -238,16 +247,21 @@ class AgentLoopMixin:
                     result = tool_message_result({"summary": "not started",
                                                   "reason": "The current view has no notes to summarize."})
                     self._record_tool_call(run=run, call=operation, result_text=result.content)
+                    state.record_action(call=operation, result_content=result.content, is_error=False)
                     messages.append({"role": "tool", "tool_call_id": operation["id"], "name": operation["name"],
                                      "content": result.content})
                     answered_without_operation = True
                 elif not isinstance(parsed, ToolResult):
                     self._record_tool_call(run=run, call=operation, result_text="(operation started)")
+                    state.record_action(call=operation, result_content="{}", is_error=False)
                     async with aclosing(self._stream_agent_operation(
                         run=run, canonical_messages=canonical_messages, snapshot=snapshot,
                         tagging_run=tagging_run, arguments=parsed, state=state,
                     )) as operation_events:
                         async for event in operation_events:
+                            # The operation ends the answer: its completion carries the log.
+                            if event["type"] == "done":
+                                event = {**event, "actions": list(state.actions)}
                             yield event
                     return
             if answered_without_operation:
@@ -266,6 +280,7 @@ class AgentLoopMixin:
                 result = result_holder[0]
                 results.append(result)
                 state.add_tool_result(result)
+                state.record_action(call=call, result_content=result.content, is_error=result.is_error)
                 self._record_tool_call(run=run, call=call, result_text=result.content)
                 messages.append({"role": "tool", "tool_call_id": call["id"], "name": call["name"],
                                  "content": result.content})

{metalist-0.12.0 → metalist-0.14.0}/app/services/agent/context.py

@@ -78,7 +78,8 @@ class AgentContextBuilder:
             "none": (
                 "Web access is disabled. You cannot search or open pages. If the "
                 "request requires the web, state that limitation and tell the user "
-                "they can enable contextual or full web access in AI Agent Settings."
+                "they can enable contextual or full web access in AI Agent Settings. Label "
+                "anything you suggest from your own knowledge as not looked up."
             ),
             "contextual": (
                 "You may open only exact URLs in available_urls, plus addresses written in "
@@ -86,7 +87,11 @@ class AgentContextBuilder:
                 "A #fragment is ignored "
                 "when comparing, so https://a.example/page#part is the same address as "
                 "https://a.example/page. You cannot search, and links discovered inside "
-                "opened pages do not become available."
+                "opened pages do not become available. When a request needs a search (for "
+                "example newer or recent papers, releases or news), say plainly that this mode "
+                "only opens links already in the notes or chat, that 'Open any public web page' "
+                "in AI Agent Settings allows searching, and label anything you suggest from your "
+                "own knowledge as not looked up."
             ),
             "full": (
                 "You may open any direct public HTTP(S) page, including Google "
@@ -158,6 +163,7 @@ class AgentContextBuilder:
         snapshot: ScopedSearchSnapshot,
         available_urls: tuple[str, ...],
         note_aliases: NoteAliases,
+        earlier_actions: list[dict[str, object]],
     ) -> list[dict[str, object]]:
         """The tool-using agent's opening conversation.
 
@@ -189,6 +195,16 @@ class AgentContextBuilder:
             {"role": "user", "content": "SELECTED_NOTE_CONTEXT\n" + json.dumps(view_context, sort_keys=True, separators=(",", ":"))},
             *self.append_web_access_context(messages=[], settings=web_settings, available_urls=available_urls),
         ]
+        if earlier_actions:
+            context_messages.append({"role": "user", "content": "EARLIER_ACTIONS\n" + json.dumps({
+                "instruction": (
+                    "Your own record of what you did for each earlier answer in this chat, oldest first: "
+                    "the tools you called, what you asked for, and what came of them (page text and note "
+                    "content are not repeated here). Answer questions about how an earlier answer was made "
+                    "only from this record. If it does not show something, say you cannot tell."
+                ),
+                "answers": earlier_actions,
+            }, sort_keys=True, separators=(",", ":"))})
         return [
             *system_messages,
             *[dict(message) for message in canonical_messages[:-1]],

{metalist-0.12.0 → metalist-0.14.0}/app/services/agent/help_catalog.py

@@ -16,6 +16,7 @@ HELP_TOPICS = {
     'ai': ('AI and tag proposals', 'OpenAI settings, context limits, prompts/skills, history export, and AI tag proposals: generation, acceptance, rejection/removal and bulk undo limits. This topic alone covers proposal workflow explanations.'),
     'privacy': ('Privacy and security', 'Cloud disclosure, gray notes when hovering chat, password exclusion, encryption and credentials.'),
     'data': ('Namespaces and backups', 'Namespaces, backup/restore, HTML export, ports and updates.'),
+    'dictation': ('Dictation (speech to text)', 'Pasting dictated text from speech-to-text tools such as Superwhisper into the search bar, tag bar or a note: how words become tags, spoken dash/quote/or/not, "at to do" meta tags, the "start tags" phrase in notes, undo, and Dictation Settings.'),
     'releases': ('Release notes', 'What changed in each MetaList version (what is new, when a feature or fix arrived).'),
 }
 HelpTopic = Literal[tuple(HELP_TOPICS)]

{metalist-0.12.0 → metalist-0.14.0}/app/services/agent/prompts/agent.md

@@ -103,6 +103,13 @@ last tool call. Answer the user's exact current question. Use the conversation t
 resolve follow-ups such as "try again"; earlier answers are not evidence about the
 current view, and earlier citations must not be reused.
 
+`EARLIER_ACTIONS` is your own record of what you did for each earlier answer in
+this chat: the tools you called and what came of them. When asked how an earlier
+answer was made (did you search the web, which pages, did you read the notes),
+answer from that record, including the searches and pages it lists. If the record
+does not show something, say you cannot tell; never deny or claim an action
+otherwise.
+
 Notes are identified by short ids such as `n12`. Cite every claim drawn from a note
 with its id in double brackets, copying the `note_id` of the note whose
 `content_text` supports it (a child, not merely its root), directly after the