4 Commits

Author	SHA1	Message	Date
dependabot[bot]	916e647a75	chore(deps-dev): bump happy-dom from 20.11.1 to 21.0.4 in /frontend (#7391) ... * chore(deps-dev): bump happy-dom from 20.11.1 to 21.0.4 in /frontend Bumps [happy-dom](https://github.com/capricorn86/happy-dom) from 20.11.1 to 21.0.4. - [Release notes](https://github.com/capricorn86/happy-dom/releases) - [Commits](https://github.com/capricorn86/happy-dom/compare/v20.11.1...v21.0.4) --- updated-dependencies: - dependency-name: happy-dom dependency-version: 21.0.4 dependency-type: direct:development ... Signed-off-by: dependabot[bot] <support@github.com> * test(frontend): isolate FlipDisplay animations in DOM suites --------- Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-24 10:45:01 +08:00
Totoro	059758f321	fix(runtime): stop Goal continuations after loop hard stops (#7167) ... * fix(runtime): stop Goal continuations after loop hard stops * chore: remove redundant SVG sources from Goal fix * test(goal): remove PR-only screenshot generation --------- Co-authored-by: Totoro-qaq <279883115+Totoro-qaq@users.noreply.github.com>	2026-10-20 16:55:13 +08:00
Totoro	0fe6e63a68	feat(goal): show why a chat goal stopped and when it was met, and redact the goal evaluator and continuation input (#6556) ... * feat(goal): record the met goal and keep goal state on the history head - Add a goal_outcome LastValue channel (GoalOutcomeState). Only the guarded clear of a satisfied ordinary goal writes it, in the same checkpoint as the clear; the reply anchor is the latest visible AI message with text, the reply the visible signature keys on. A goal stored without created_at still clears and gets a record. - write_thread_goal removes the record on every other goal write and lists it in channel_versions, new_versions and metadata writes when it changes. Threads that never had a record keep their checkpoint shape. The sync-only SqliteSaver and CachedHistorySaver, which take the #6448 sync fallback, store and drop it the same way. - goal_outcome is server-owned: POST /state and non-internal run input that carry it get 400. A POST /state goal write, or a goal in external run input, clears it. - A branch head written onto its replay base resets the channels the head lacks, so a goal or record that write_thread_goal removed does not come back. Branching from the met turn keeps the record without the met goal. - The POST /history head now carries an active goal and an achieved goal_outcome, also before any message exists, so the post-run history refetch keeps them. Older entries stay title/thread_data. - contracts/thread_goal_contract.json pins the chat stand-down and check-failure codes, the record shape and status, the head keys and the host-written reasons. * feat(frontend): show why a goal stopped and when it was met - The goal bar derives its state from the active goal, the goal_outcome record and the messages: set, in progress, continuing, stopped (limit, auto-continue off, no progress, token budget, missing evidence, failed run, unknown code), waiting for you, waiting, couldn't check the goal, paused and goal met. An 8/8 stand-down now reads "Stopped" with the next step instead of "Continuing 8/8", and a count-0 stand-down no longer looks like a fresh goal. - "Goal met" shows while its anchor reply is the latest visible message (a visible human message, or a visible AI message with text, moves the chat on), so a reload agrees with the live view. An active goal wins over the record, and this tab's /goal set or clear hides it. - useActiveGoal drops the optimistic goal when the record of that same goal arrives, which fixes the bar that stayed after a goal met on the first run (the clear frame has no goal key), also for a goal stored without created_at. Server goal values pass through isGoalState; a /goal status read uses the backend's own active check, so the bar, the toast and the edit lock agree with the server. - Row 2 gives the reason and what to do next; Details holds the full goal, the checker's own note (never host-written text, a check failure or a paused goal's older check), the assumption note and an unknown code, and starts collapsed in each new state. The bar is a labelled section with a live region that announces state changes only (another goal's same state counts) and re-reads its text after a language switch. - The edit pencil on the latest turn is shown disabled with "Editing is off while a goal is set" instead of hidden; the message toolbar shows on focus-within, so keyboard users can reach it. - A /goal set or clear rejected with 409 keeps the draft and says a run is still going; other failures keep the server's message and the draft. A /goal request replaced by a newer one leaves the composer alone, so a double submit no longer empties it before the second one fails. - Copy lives in inputBox.goalBar (en-US, zh-CN); a contract test reads contracts/thread_goal_contract.json, and the raw-identifier guard now catches stand-down codes and goal field names. * test(frontend): cover the goal bar on both chat pages - tests/e2e/goal-status.spec.ts runs every case on the chat page and the agent chat page, since each wires the goal bar and the edit lock itself: a goal stopped at 8/8, one waiting for details and one waiting on an open question card show their reason and next step, also after a reload; the locked edit pencil gets keyboard focus, shows its toolbar and tooltip, does not open the editor, and hides while a file uploads; Goal met after one automatic follow-up (In progress, Continuing 1/8, then "Auto-continued once") survives a reload and hides after the next visible message; a goal met on the first run of a new chat replaces the set bar and frees the pencil, and a new /goal replaces Goal met while its own run goes on; a /goal set or clear refused with 409 keeps the draft for the retry and shows its own busy toast. - The mock POST /history head carries only the contract's history_head_keys, with goal only while active and goal_outcome only when achieved; thread state and run values omit an unset goal instead of sending goal: null. PUT and DELETE /goal drop the met record, setGoalWritesBusy returns the Gateway's 409, and a repeat create of a requested thread id returns the thread as is, like the Gateway. - The raw-identifier guard also catches checker blockers and the met record's field names. - frontend/src/AGENTS.md: the GoalStatus sentence now names goal, goal_outcome and useActiveGoal, reworded in place. * test(frontend): keep the draft through a failed upload and a busy /goal #6412 fires onSent only once a send is dispatched, so a failed upload keeps the text, files and stored draft. A /goal the Gateway refuses with 409 never reaches sendMessage, and the composer rejects it so PromptInput keeps the text. Drive both through the real sendMessage in one composer: a failed upload keeps "summarize it" stored, a busy /goal keeps its text and stored draft with no run, and the retry saves the goal and starts one run with the objective, not the "/goal" text. After that run the composer is empty and no stored draft comes back. * fix(frontend): drop the stop condition's closing period before the pause clause A stored stop condition often ends with a period, so the schedule card read "…remain)., pauses itself" (and "…。，满足后自动暂停" in Chinese). Trim the condition's closing sentence punctuation before the clause that follows it. The event line, where the condition ends the sentence, is unchanged. * fix(frontend): point "evidence missing" at the agent, not a user reply "Evidence missing" asked the user to reply with what's left, which is the push a goal is meant to save. It now asks the agent to show the result or explain what's missing, and offers /goal clear only for a goal that no longer applies: clearing drops the met record, so work that is right would never show "Goal met". zh-CN follows. Copy only: no key, state or mapping changes, and the scheduled page's reason labels are untouched. tests/unit/components/workspace/goal-status-next-steps.test.ts checks the row in en-US and zh-CN, and that no stop row offers /goal clear without that condition. goal-status.dom.test.tsx and goal-stream.dom.test.tsx now expect the new copy. * fix(frontend): say "Couldn't check the goal" once in the goal bar After a goal check that could not run, the bar's second line borrowed the scheduled page's whole reason, so it repeated the chip: "Couldn't check the goal · Couldn't check the goal; the run itself may be fine. It's checked again after your next message." Chinese had the same repeat. The line now gives only why the check failed ("The run itself may be fine", "No final reply was saved" or "The chat changed during the check"), then when it is checked again. The screen-reader announcement follows. The chip and the scheduled page's reason labels are unchanged. tests/unit/components/workspace/goal-status-unchecked.test.ts checks every check-failure code in en-US and zh-CN: the label appears once, and the line still says why the check failed. * feat(goal): redact the evaluator input when pii_redaction is enabled The goal evaluator calls its model directly, outside PiiRedactionMiddleware, so it sent raw user lines, tool arguments, tool results and Human Input Card answers even with pii_redaction enabled. With pii_redaction enabled: - the messages in the evidence window are redacted whole before the evidence caps can cut an identifier in two, as TitleMiddleware does. This reuses redact_queued_messages, which already covers content, call arguments and card answers. Earlier messages are left alone: the evaluator never sees them, and the pass is synchronous work on the event loop (0.84 s for an 800-message, 4 MB thread, 0.06 s for its window); - the assembled input, the goal objective included, is redacted again. A redaction error fails the check with evaluator_failed; raw text is never sent instead. When redaction is off, the input is byte-identical. Thread state keeps the raw text. README.md, config.example.yaml and the middleware docstring list the evaluator with the other redacted inputs. tests/test_goal_pii.py puts an address where the evidence caps cut a tool argument, a tool result and a card answer, and checks the objective, the unchanged input when redaction is off, that only the evidence window reaches the redactor and gives the same evidence as redacting the whole thread, that a redaction error stands down with evaluator_failed before the model is called, and the worker path. * fix(goal): redact the hidden continuation when pii_redaction is enabled The hidden /goal continuation repeats the goal objective and the evaluator's reason and evidence summary. PiiRedactionMiddleware skips it, since it is a framework message and not a user message, so with pii_redaction enabled each continuation turn sent them raw to the agent's model, and the message stayed in the thread for later model calls. The durable-context block and the evaluator input already redact the objective. With pii_redaction enabled, make_goal_continuation_message now redacts the objective, the reason and the evidence summary with redact_text before the message is built. The thread keeps the redacted message, which the UI hides; the goal state keeps the raw objective. The worker builds the message before it counts the continuation. A redaction error fails the check the way an evaluator redaction error does: run_failed with stand_down_reason evaluator_failed, the goal stays active, nothing is sent and the continuation budget is not spent. Only the exception type is stored. With redaction off, the message is byte-identical. README.md, config.example.yaml and the middleware docstring list the continuation with the other redacted inputs. tests/test_goal_continuation_pii.py checks the redacted objective, reason and evidence summary against the tokens redact_text gives, the unchanged message with redaction off or no config, the worker path under the run config, and a redaction error. * docs(changelog): link the goal outcome entries to #6556 Fill the four ([#PR]) placeholders in CHANGELOG.md and CHANGELOG_zh.md with this PR's number and add the matching link references. * fix(frontend): keep an active goal stored without timestamps visible POST /threads/{id}/state and run input can store an active goal without created_at or updated_at. The backend still evaluates it and rejects an edit with 409 (is_active_goal checks only status "active"), but isGoalState required both timestamps, so history and live values dropped it: both chat pages hid the goal bar and unlocked the last-turn pencil, and only a /goal status read, which used a looser predicate, brought them back. isGoalState now accepts any record with a string objective and status "active", and normalizeGoalStatusRead uses it, so thread values, live updates and status reads share one rule. Malformed or inactive values are still dropped. Tests cover a sparse active goal from the history head and from a live update before the post-run refetch (bar shown, hasGoal true), and a malformed goal that stays hidden. * test(goal): check the outcome write metadata the same way on every saver PostgresSaver stores checkpoint metadata through get_serializable_checkpoint_metadata, which drops "writes", so the [postgres] case of test_goal_outcome_round_trips_through_the_sync_fallback failed with KeyError: 'writes' when CI ran it against a live database. The test now records the metadata write_thread_goal passes to put and asserts the clear's and the next goal's "writes" there, for every saver. The stored channel values are checked as before, and on sqlite and cached-sqlite the stored "writes" must still equal what was passed. * docs(agents): keep goal_outcome out of the agents guidance chain The middlewares AGENTS.md chain is already over the 98,304-byte AG002 hard limit on main, and the PR-mode check fails any chain a PR touches, so adding goal_outcome to the ThreadState field list in deerflow/agents/AGENTS.md failed the agent-guidance job. goal_outcome stays documented in runtime/AGENTS.md and backend/app/gateway/AGENTS.md, which are outside that chain. * refactor(goal): read the evaluator's evidence and redaction from one window format_visible_conversation recomputed the window start that the redaction pass takes from _evidence_window. Both now use _evidence_window, so a later change to the cap or to what counts as visible moves both. The window test now fills the window with tool-only replies and tool results. Before, it caught a cap change in one copy but not a change to what counts as visible. --------- Co-authored-by: Totoro-qaq <279883115+Totoro-qaq@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-10 00:20:45 +08:00
Totoro	2dd2e5415c	feat(scheduled-tasks): finish the user-facing side of conversation schedules (RFC #6340, 1/2) (#6378) ... * feat(scheduler): lifecycle rules, goal/limit parity and coded errors for scheduled tasks - Migration 0031: nullable scheduled_tasks.unmet_streak_after_seq (internal streak boundary) and stop_condition (the user's stop rule, own column). - Stop rule is normalized (stop_rule.py) and appended only at launch; the stored prompt never contains it. Wording adapts when scheduler.tool_enabled is off. - Willem 1: page-created tasks get goal evaluation, <standing_notes>, the previous-run reference and own-schedule stop; request_stop and the scheduled capability no longer require an origin conversation. - Repository: single reactivation choke point raising ScheduledTaskLimitsExhausted; streak boundary moves on goal/prompt/stop condition/note changes (not on resume); goal-check failures neither count nor reset the streak; pause of a finished task returns "finished"; trials on a paused task keep the host pause marker. - New repository reads: automatic_runs_used_for, active_run_status_for, list_manageable_from_thread, thread_relation/thread_run on thread tasks, task_ids_for_thread, run_number, and run_number/total_tokens/summary on run history rows. - REST: goal/max_runs/end_at/stop_condition on create and PATCH (null clears, naive end_at = task timezone), resume recomputes from now with an optional renewal body, once_time_passed, task_finished, limits_exhausted, scheduler_not_running on create, trigger returns outcome/existing/thread_id, task responses add automatic_runs_used and active_run_status. - Coded errors {code, message, params} for routes, shared validation and the chat capability (scheduled_task_errors.py), pinned by contracts/scheduled_task_errors_contract.json; goal notes contract v2 with check_failure_codes, scheduled_origin_key and host_run_errors (host_notes.py). - /api/features adds scheduled_tasks {available, running, tool_enabled, min_interval_seconds}; ScheduledTaskService.is_running. - Docs: six README scheduler sections, API.md scheduled tasks section (breaking error shape), CONFIGURATION.md, AGENTS notes, CHANGELOGs. - Tests: migration 0031, stop rule, error contract, run listing, lifecycle over HTTP, repository, service and capability cases; updated tests for the new error shape, finished-task pause and head revision. * feat(scheduler): conversation update/resume, run-conversation authority and readable launches - schedule_task: update and resume actions, stop_condition and clear_fields parameters, plain parameter types (value rules come back as coded results), rewritten docstrings for schedule_task and stop_scheduled_task. - Capability: update/resume share the REST validation and error codes; interactive turns in a task's run conversation may manage that task; scheduled runs keep only own-stop; grants require a running scheduler. - Results: compact JSON-safe task views with local times, display card/text, last run in list, timezone_source/browser_timezone, now_local; no ISO, user, lease or origin fields; stop_instructions removed. - Timezone: explicit > browser (context.client_timezone, validated in start_run and never forwarded to the run config) > not needed for intervals and offset run_at > timezone_required. - Trial gate accepts natural direct requests after acknowledgements and particles; trial results report thread_id and existing. - Scheduled launches: stable message id scheduled-<task_run_id>, server-owned deerflow_scheduled_origin metadata with the user-language parts, run thread title for fresh-thread tasks. - Worker records goal continuations in the verdict; lead prompt language rule covers stored task text and scheduled runs. - Docs: six READMEs, CONFIGURATION, API, runtime/tools AGENTS, CHANGELOGs. * feat(frontend): scheduled-task core types, formatting, errors and glossary - throwGatewayApiError now throws GatewayApiError (status, code, params, rawMessage); message stays the string detail or detail.message - scheduled-task types gain stop_condition, automatic_runs_used, active_run_status, origin/notes, run_number/total_tokens/summary, thread relation, trigger result, renewal and scheduled origin; isTaskBusy and hasActiveRun helpers - api: fetchScheduledTask, resume with optional renewal body, typed trigger result and update payload with null clears - hooks: polling at 3 s while a run is active (list, thread list, run history), useScheduledTask with live gating and final 404, useInView, localized error toasts; run history refreshes tasks when a run finishes - new pure modules: errors.ts (contract code to localized copy), format.ts (relative task times, viewer time, display zone), status.ts, actions.ts, run-error.ts; describeTaskSchedule in cron.ts; goal-outcome adds unchecked goal checks, describeTaskOutcome and parseStopRunId - features: scheduled_tasks block with defaults when missing - buildRunContext sends client_timezone - titleOfThread takes a localized untitled label; breadcrumb names scheduled tasks and agents; reference chips use the localized untitled label - schedule input: shared browserTimeZone, labelled selects, aria-pressed type toggles, interval minimum from the hint template - i18n: all PR1 scheduled-task keys in en-US and zh-CN, glossary fixes, recipe instructions moved into i18n - e2e mocks follow the new task, trigger, resume, thread-task and features shapes; expectNoRawIdentifiers helpers for e2e and DOM tests - tests for errors, format, cron, status, actions, goal outcome, run errors, hooks, run context, thread titles and features; scheduled e2e copy updated * feat(frontend): list-first scheduled tasks page with outcomes and editable goals - page.tsx is now a thin composition of components/workspace/scheduled-tasks: status tabs (All/Active/Paused/Finished) and search over the task list, ?task_id= deep link with router.replace on selection, ?thread_id= chip with Show all, empty state, scheduler-off notice and unavailable state - task list rows show the schedule in words and one status line (next run, running now, paused by agent, auto-paused, finished by its cap) - task detail: status badge, actions from availableActions with reasons, More actions menu (Duplicate, Copy task ID, Delete), outcome notice, Runs / Stops when / Each run's goal / Does / Notes from chat / History, origin chat link; success toasts for every action - run rows: run number or Trial run, summary, goal and assumption badges, continuations, tokens, Open chat link; raw errors and the evaluator reason only behind Details - create/edit/duplicate dialog with goal, stop condition, safety caps and advanced agent/context options; PATCH sends only changed fields, null clears a cap - renew dialog raises or removes caps and resumes in one request; a limits_exhausted Resume opens it - removed i18n keys the old page used; added feedback.resumedNoTime - recorded en-3 and zh-1 page fixtures; scheduled e2e specs rewritten for the new page; DOM tests for the detail and the form dialog - CHANGELOG entries and the frontend AGENTS.md scheduled-task note * feat(frontend): live schedule card, run conversation provenance and header entry - schedule_task results (create, update, pause, resume, trial, delete) become an assistant:scheduled-task message group rendered as a live card: schedule, next run, stop condition with the safety cap, goal, where results go, Run once now, Pause/Resume and Open task; the card polls the task only while it is on screen and shows deleted, scheduler-off and limits-exhausted states - one card per task per assistant turn; the card group is not a turn boundary for usage, branching, editing, outline or skill attribution - a human message with deerflow_scheduled_origin stays a human group with scheduledOrigin and renders as a "Scheduled run / Trial run" block with the task instructions, stop condition and notes collapsed; the launched text is never shown and the message is not editable - readable step labels for schedule_task actions and stop_scheduled_task - ThreadScheduledTasksButton replaces the header link: hidden without tasks, shows the count, links to the task (or the chat filter), and a run's chat links to its task - recorded en-3 / zh-1 chat and run-thread fixtures; chat-card and run-thread e2e specs; unit and DOM tests for parsing, grouping, turn boundaries, card, run block, header button, step labels and reconnect hydration - i18n: header.countLabelOne added, unused card.next removed; CHANGELOG and frontend AGENTS.md notes * fix(scheduler): address verification findings Move the scheduled-task lifecycle guidance from backend/AGENTS.md into the persistence guide and leave a one-line pointer, so the effective AGENTS.md chains for agents/middlewares, sandbox and subagents stay under the 98304-byte hard limit enforced by scripts/check_agent_guidance.py in lint-check. * fix(scheduler): address review findings * fix(scheduled-tasks): polish from live acceptance - zh schedule wording: an interval of one unit reads 每分钟 / 每小时 / 每秒, and a saved interval of whole days reads 每天 / 每 2 天 (Every day / Every 2 days) instead of 每 1 分钟 or 每 24 小时; several units keep the number - zh spacing: 已于{time} 满足 and 在{time} 的运行中 now leave a space between the interpolated time and the Chinese after it; a copy test guards every scheduled-task zh string against a placeholder glued to Chinese - run summary: when the first line of the final reply only leads in to a list (ends with ":" or "："), the list items follow it as plain text (bullets, numbering, checkboxes, bold, code and links stripped), joined with "；" for CJK text and "; " otherwise, within the 160-character cap - a schedule_task result (create, update, pause, resume, trial, delete) that arrives in a chat invalidates that chat's task list, the tasks list and the named task, so the header button and cards update without waiting for the idle poll; results already in the loaded history do not refetch - e2e and unit fixtures are now the live acceptance recordings (DeepSeek Flash, demo data, fictional names): live-weekday.json (create, trial, edit, pause, resume in one zh chat) and live-minute.json (per-minute chat, run 1 and run 2, paused by the agent), fetched with GET from the demo Gateway and trimmed; the hand-shaped en-3 / zh-1 fixtures are removed and the chat-card, run-thread and tasks-page specs run in both locales over the recorded data * docs(changelog): reference #6378 for the scheduled-tasks entries * docs(agents): shorten the scheduled-task pointer to stay under the guidance limit * test(scheduled-tasks): pin the live takes to their recorded time zone The live fixtures were recorded in Asia/Shanghai, and an interval task reads in the viewer's zone, so the 16:48 assertions failed on UTC CI runners. Pin the browser zone in the two live-take e2e specs and the zh live-take unit test. * fix(scheduled-tasks): keep untouched end times and drop a chat filter the new task is not in - The edit, duplicate and renew dialogs keep a stored end time's instant while its field still shows it. A minute-precision wall value cannot keep seconds or name the later 01:30 of a DST fall-back, so a title-only edit moved the cap an hour earlier, and raising the run limit re-sent the end time without its seconds. - Creating or duplicating a task from a chat's task view drops the chat filter when the new task does not belong to that chat, instead of showing "This task isn't one of this chat's tasks". * fix(scheduled-tasks): tie pause notices to the pause they describe - Paused by agent links and times only the run named in last_error. When that run is not loaded, the notice shows no link and the task's own time instead of an earlier run that also asked to stop. - The outcome notice reads the latest history page whichever page is shown, so browsing older runs no longer swaps the auto-pause reason and "Open latest run" to an earlier miss. It shares that page's request. * fix(scheduled-tasks): three lifecycle gaps found while re-checking review classes - The edit form compares a cron in the form its schedule input emits, so an untouched "0 09 * * 0,6" is not re-sent as "0 9 * * 6,0" and a title-only edit no longer re-arms or refuses a finished task. - Chat resume asks for a timezone, as update does, when a naive end_at would land in the UTC placeholder of a zone-free task. - Re-arming a task clears a host pause marker, as resume does, so a later manual pause no longer reads as "Paused by agent". * fix(scheduled-tasks): keep the notice's latest-runs query from refreshing older pages useLatestScheduledTaskRuns kept React Query's default refetch on mount, focus and reconnect, so going offline and back while an older history page was shown fetched the latest page again. Refreshing stays with the history, which refreshes the latest page only while it is shown. * test(scheduled-tasks): let the viewer's time carry its own day label Between 16:00 and 24:00 UTC, UTC and Asia/Shanghai are on different days, so the run prompt shows "Tomorrow 01:00 · Today 09:00 your time" and the fixed "01:00 · 09:00 your time" assertion failed depending on the hour. --------- Co-authored-by: Totoro-qaq <279883115+Totoro-qaq@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-07 07:47:32 +08:00