208 Commits

Author	SHA1	Message	Date
Hyeonsang Cho	9c00fd839a	fix(frontend): return SSO sign-ins to their next path (#7467) ... * fix(frontend): return SSO sign-ins to their next path The (auth) layout redirected every signed-in request to /workspace. The Gateway sets the session cookie on the same redirect that lands on /auth/callback?next=..., so the callback page never rendered and every SSO sign-in landed on the workspace instead of the page that asked for it. A signed-in visit to /login?next=... lost its target the same way. Layouts cannot read searchParams, so the layout now renders the page for a signed-in session and each page sends the user on: the callback and login to the validated next path, setup to the workspace. The login page shows a short wait message instead of the form while it redirects, and uses router.replace so Back does not return to it. * docs(changelog): reference #7467 for the SSO next-path fix * fix(auth): reject control characters in the next redirect path Browsers delete tab, LF and CR from a URL before parsing it, so a next of "/\n//evil.example" passed both validators' "//" check and then navigated to //evil.example. The login page's post-sign-in push already followed it, and the signed-in login and SSO callback redirects reach it too. validateAuthNextPath and validate_next_param now reject every C0 control character and DEL. Percent-encoded forms are left alone: URL parsers do not decode them, so they stay on the local origin. --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-26 19:24:35 +08:00
ShaoLOWu	21fb080530	fix(frontend): allow non-ASCII local parts in auth password forms (#7488) (#7498) ... * fix(frontend): allow non-ASCII local parts in auth password forms (#7488) The sign-in, register, admin-setup and change-password forms relied on the browser's type="email" constraint validation, which rejects any non-ASCII local part before the submit handler runs. The backend identity schema deliberately accepts such addresses (see emailSchema in @/core/auth/types), so an account created via the API, an administrator or OIDC could never sign in through the password form. Forms are now noValidate, and the permissive isValidEmail helper (one @, non-empty local part and domain, no whitespace) runs in the handlers instead, staying strictly weaker than what the backend accepts. * fix(auth): normalize emails and restore form password checks --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-25 22:09:58 +08:00
Agustin M.	66f00e7b86	fix(frontend): make docs search work on desktop and mobile (#6715) ... * fix(frontend): make docs search work on desktop and mobile Docs search on deerflow.tech was broken twice over: no build step ever generated the Pagefind index that Nextra's <Search> loads, and the custom docs header that replaces Nextra's navbar never rendered a search box. - `pnpm build` now runs `search:index` (pagefind 1.5.2, pinned) to write public/_pagefind/ (gitignored). - The landing Header and its mobile sheet take an optional `search` slot; only the docs layout fills it, with localized labels and an aria-label. - Each docs page carries a Pagefind `lang` filter and queries are scoped to it, since the root <html lang> is fixed and would mix en/zh results. - globals.css restyles the results panel with app tokens because Nextra's <Head> variables are unset, lifts it above the mobile sheet, and keeps it tappable; the sheet no longer closes before a result navigates and closes after navigation. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(frontend): add DESIGN.md describing the shipped design system Records the existing tokens, typography, components, docs (Nextra) overrides, motion, accessibility and copy rules, plus the landing-only decorative exceptions, so UI changes have something to be checked against. Linked from frontend/AGENTS.md. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(frontend): address Codex review of docs search - Chinese search: the root <html lang> is fixed, so Pagefind indexed zh pages with the English tokenizer and multi-character words (e.g. 偏好) never matched. scripts/build-search-index.mjs now sets each page's lang from its route before indexing, producing separate en-US and zh-CN indexes, and DocsHtmlLang syncs <html lang> at runtime (resetting Pagefind on a language switch) so queries hit the right index. - Mobile menu: reset the open state when the route changes instead of comparing against the saved path, so Back no longer reopens the sheet. - Shortcut: stop mounting a second <Search> in Nextra's unused mobile menu, which captured Cmd/Ctrl+K and focused an offscreen input at 640-767px. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * docs(frontend): keep guidance within size budget * fix(frontend): address docs search review feedback Keep Nextra results within the mobile sheet scroll boundary and dismiss same-hash selections by pointer or keyboard. Rebuild Pagefind output without stale fragments and replace UI source-string checks with behavioral coverage. --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-25 21:31:11 +08:00
一片一片	6213fee192	fix(frontend): bound notification bodies by code points (#7474) ... Both chat pages capped the "conversation finished" notification body with String#length / substring, which count UTF-16 code units: a cut inside an astral character's surrogate pair rendered U+FFFD, and a body that fits 200 code points was shortened early. Extract notificationBody() so both pages share the code-point bound and the "Conversation finished" fallback, and add boundary regressions. Co-authored-by: 一片一片 <192845873+gdut4140@users.noreply.github.com>	2026-10-25 15:13:16 +08:00
ShallAbby	c11ba84708	fix(frontend): keep collapsed sidebar navigation visible on mobile (#7198) ... * fix(frontend): keep collapsed sidebar navigation visible on mobile * fix(frontend): address mobile sidebar review feedback * fix(ci): keep frontend agent guidance within size budget * fix(frontend): align mobile sidebar focus and trigger state * fix(frontend): keep Agents header actions within mobile viewport --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-22 15:13:01 +08:00
Totoro	0baa99ca90	feat(models): add scoped model controls to Web chats (#7249) ... * test: stabilize reporter evidence and guard missing chat nodes * feat(models): scope Web model choices to tasks, turns and conversations * test(e2e): mock model-control preview for ordinary chat submissions * fix(models): harden scoped choices and stale Agent submissions --------- Co-authored-by: Totoro-qaq <279883115+Totoro-qaq@users.noreply.github.com>	2026-10-22 08:08:23 +08:00
PeaceMaker-best	dbebd18dd7	fix(deer-flow): retry failed agent setup saves (#6628) ... * fix(deer-flow): retry failed agent setup saves Signed-off-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com> * fix(frontend): fence superseded agent save callbacks --------- Signed-off-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com> Co-authored-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-19 10:55:50 +08:00
Lucien	c5fd453c37	fix(artifacts): preserve account-scoped drafts across navigation (#6700) ... * fix(artifacts): preserve account-scoped drafts across navigation * docs(artifacts): keep draft lifecycle guidance within its budget * fix(artifacts): retain drafts through unknown auth and isolate typing updates * fix(artifacts): preserve drafts when visiting public showcases * fix(artifacts): preserve edits after pending save	2026-10-13 15:44:20 +08:00
Hyeonsang Cho	3f71b2e13f	fix(frontend): return to the opened workspace page after signing in (#6681) ... * fix(frontend): return to the opened workspace page after signing in Opening a workspace page without a valid session sent the user to a bare /login: the workspace layout called redirect("/login"), and a layout cannot read the request URL, so the path and query were both lost. A scheduled-task notification link (/workspace/scheduled-tasks?task_id=X) opened after the session expired therefore landed on the default workspace after sign-in. For an unauthenticated verdict the layout now renders WorkspaceLoginRedirect, which replaces the page with /login?next=<path+query> from the browser. It renders nothing else, so the workspace pages under it never mount. AuthProvider.refreshUser and useRequireAuth kept the path but dropped the query. They now share currentReturnPath() with the fetcher, which already kept both. * docs(changelog): reference #6681 * fix(frontend): keep the fragment in the sign-in return path currentReturnPath() kept the path and query but not location.hash, so an anchored deep link (/workspace/chats/x#section) lost its anchor across the login round trip. It is now the single source for all four bounce sites, so include the fragment. The server never receives the fragment, so only the browser-side bounce can keep it. validateAuthNextPath, the backend's validate_next_param and its quote() into /auth/callback all carry a '#' through unchanged. The models API test stubbed window.location without hash; a real Location always has one, so the stub now carries it. --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-11 19:05:03 +08:00
hataa	2f4f4d4b6c	feat(authz): admin user-management UI and disabled-account copy (#4063 gap 3) (#6641) ... * feat(authz): admin user-management UI and disabled-account copy (#4063 gap 3) Frontend slice of the account lifecycle backend (#6566): - Settings gains an admin-only Users page (core/auth/admin-users.ts -> GET/PATCH /api/v1/admin/users): email, read-only role, disabled state, and a suspend/restore toggle per row; the Gateway's rejection detail (last-active-admin 409) renders verbatim. The nav entry is hidden for non-admins and the page guards independently; ?settings=users joins the deep-link whitelist (now an exhaustive Record over SettingsSection). - A session that turns out disabled maps account_disabled to a login redirect that states the reason on all three surfaces: the SSR AuthResult tag (consumed exhaustively by the workspace/artifacts/auth layouts), the shared fetcher's 401 interception, and AuthProvider.refreshUser. No next target is preserved - a disabled account cannot sign back in. Login failures surface the localized account_disabled copy when the code is present. - userSchema stays disabled-optional (absent = not disabled); zh/en locales and docs updated in the same change. * fix(authz): address review on admin user UI and disabled copy (#4063 gap 3) Review follow-ups on PR #6641: - Direct /login visits with a suspended session now surface the SSR account_disabled verdict through AuthDisabledContext instead of discarding it (willem-bd): the auth layout wraps pages with the provider and the login form seeds its reason from it — no redirect, so no loop. Regression tests cover both verdict states. - admin-users.ts parses both endpoints against userSchema / z.array(userSchema) (zhfeng): malformed payloads fail the load instead of rendering phantom rows; toggle error copy is scoped to GatewayApiError with a localized fallback for anything else. - The localized account_disabled copy is login-only (zhfeng): sign-up keeps the backend message verbatim so a suspended account's email cannot be probed through the register surface. - Settings page folds the load banner and toggle error into a single alert region (zhfeng); adds coded-envelope 409, malformed-row, and load-failure tests; fetcher.ts documents the 401 body-consumption contract. - prettier across touched files (CI format gate). The admin-users query key keeps user?.id, matching the model-settings-page precedent (converge later per review).	2026-10-11 12:54:51 +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	35cdcab1c5	feat(scheduled-tasks): signals, honest notices and fair queueing for server-started runs (RFC #6340, 2/2) (#6393) ... * 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(gateway): no-transform on SSE responses All four text/event-stream responses (thread run create stream, join, existing-run GET/POST stream, stateless create stream) now take their headers from app/gateway/sse_headers.py and send Cache-Control: no-cache, no-transform, so compressing proxies such as Next's rewrite proxy stop buffering streams. Content-Location and X-Accel-Buffering are unchanged; scheduled and MCP-notification runs keep stream_mode=None. Tests pin the headers on every SSE route and fail on a literal no-cache header left in routers. Docs: API.md SSE headers note, CHANGELOGs. * feat(scheduler): per-owner run cap and fair queue selection New scheduler.max_concurrent_runs_per_user (default 2, 0 = off, effective min(cap, max_concurrent_runs)) caps launching/running scheduled runs per task owner. claim_queued_run checks it right after the global count under the same budget lock, so it is atomic across workers and Pods. list_queued_runs ranks same-thread FIFO heads per owner with ROW_NUMBER() OVER (PARTITION BY owner) and orders the batch by that rank, so the drain is owner-fair even with the cap off; owners at their cap drop out before the batch limit. Orphan rows (task deleted while queued) are never held back by the cap. Gateway lifespan passes the startup value; the service constructor default stays 0. Docs: config.example.yaml (config_version 54), CONFIGURATION.md, the six READMEs, backend AGENTS.md, CHANGELOGs (behavior change flagged). The live-task quota is untouched. * feat(scheduler): durable lifecycle events for the originating chat When a chat-created schedule is paused by the agent, auto-paused or finishes, finalization now reports task_stopped / task_paused / task_finished, only on a live -> paused/finished transition. The new finish_task_at_end_condition replaces the three inline "mark completed" blocks (admission rejected as ended, claim-time skip, complete_if_ended), so every site emits exactly once. The scheduler's finalization observer is always installed. It writes scheduled_task_events rows for the originating chat in the same transaction as the state change, deduplicated on (task_id, anchor, event), with a title snapshot, stop condition, run number, last run outcome and the chat's newest run as placement anchor. Lookups fall back on bad stored data; only database errors propagate. Manual trials drop only run_* events. The IM step keeps PR1's selection until B4. New GET /api/threads/{thread_id}/scheduled-task-events (owner check, caller's rows, oldest first); rows survive task deletion and go with the chat. Migration 0032_activity_and_task_events adds the events table plus the run-origin column/index and read-state tables used later, each object guarded on its own. Contract scheduled_goal_notes v3 pins the lifecycle vocabulary. Docs: API.md, migrations chain, backend AGENTS.md, six READMEs, CHANGELOGs. * feat(scheduler): honest, localized and self-contained IM notices Every scheduled-task IM notice is now enqueued by the finalization observer in the transaction that records the outcome, one message per occurrence (task_stopped > task_paused > task_finished > run_failed > run_unmet > run_completed; a once task sends only its run event). The merged auto-pause replaces the separate unmet + pause messages, agent stops and finishes now notify, and recovery-finalized runs notify exactly once. Idle finishes use a deterministic idle: key derived from the lifecycle anchor. The old non-transactional enqueue in handle_run_completion is removed. New app/channels/capabilities.py holds CHANNEL_CAPABILITIES with a proactive_notifications flag (adds the missing qq entry); only push-capable providers (WeCom) get rows, /api/channels/providers returns the flag, and the worker ends legacy rows for other providers as terminal failed. New app/scheduler/notification_text.py renders en-US/zh-CN text: title, what happened (plus the last run's outcome), the tasks page's one-line run summary (redacted) when the agent replied, and a closing line. No IDs, no links, no public_base_url. Locale is the owner's new `locale` preference, else the new channel_connections.notification_locale (default en-US). Docs: config.example.yaml (config_version 55), CONFIGURATION.md, API.md, channels AGENTS.md, six READMEs, CHANGELOGs (behavior change flagged). * feat(gateway): thread origin, activity feed and read markers for server-created threads Runs started by the server for a user (scheduler, IM channels, GitHub agents, extension handles, MCP notifications) now carry a server-owned metadata.deerflow_origin {kind, provider?, namespace?} (new harness module deerflow.runtime.run_origin, pinned by contracts/thread_origin_contract.json). It is stamped only from request.state.run_origin or by the internal channel caller; run admission drops client copies from both metadata and config.metadata, and thread create/patch strip it. RunRepository derives runs.origin_kind on put and on create_thread_operation_atomic (agent runs only), and gains latest_change(). New ThreadReadRepository keeps a per-user, never-decreasing read position (thread_read_markers) and a per-user read clock (thread_read_versions). POST /api/threads/{id}/read marks a thread read, thread search items carry unread, and thread delete removes the markers. GET /api/thread-activity pages the caller's run changes over the run-change clock, returns only threads changed by server-originated runs plus read_version, and 503s without SQL; /api/features reports thread_activity.available. Docs: API.md, gateway AGENTS.md (condensed to stay under its budget), CHANGELOGs. * fix(scheduler): adapt PR2 to PR1 follow-ups PR1 moved the scheduled-task lifecycle rules out of backend/AGENTS.md into the persistence guide and grew the sandbox AGENTS.md chain to within 267 bytes of its hard limit. The per-owner queue-fairness detail now lives in the persistence guide next to the lifecycle rules (backend/AGENTS.md keeps the cap and a link), so check_agent_guidance passes again. PR1's goal-outcome unit test pinned scheduled_goal_notes_contract version 2; PR2 bumps it to 3 (lifecycle vocabulary only, the v2 keys are unchanged). * 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. * feat(frontend): thread origin, activity polling, read markers and task events core Frontend core for server-created threads and schedule lifecycle events (PR2 F1); the sidebar markers (F2) and the chat event line (F3) build on it. - core/threads/origin.ts: threadOriginOf reads metadata.deerflow_origin, then channel_source (github -> GitHub origin), then a legacy scheduled_task_id; key and kinds pinned to contracts/thread_origin_contract.json. labelOfThreadOrigin and the now exported labelOfChannelProvider(provider, t) use the new localized threads.origin.providers names (飞书, 企业微信, ...), with the English map (gaining GitHub) only as the fallback. - core/threads/activity.ts: useThreadActivity polls /api/thread-activity every 15 s (focus refetch, never in the background, off unless features.thread_activity.available). The first response only seeds the cursor; server-origin threads, a truncated page or a higher read_version invalidate the thread lists, a scheduled thread also ["scheduled-tasks"]; an invalid cursor re-seeds. useMarkThreadRead debounces POST /read by 1 s, skips a thread whose cached unread is false, patches the search and infinite caches optimistically and stores the returned read_version so a tab's own read does not refetch its lists. AgentThread gains unread. - core/scheduled-tasks/events.ts: ScheduledTaskEvent, the events query (["scheduled-tasks","thread-events",id], one fetch per saved chat, not gated on the task list so a deleted task's lines stay, refetched when a task of the chat changes status or finishes a run), describeTaskEvent (en/zh copy, title and condition as segments, last-run suffix, See that run / Open task) and placeTaskEvents (end of the after_run_id turn, else the tail, ordered by created_at); lifecycle names pinned to contract v3. - features: thread_activity (default unavailable); channels: proactive_notifications on providers. - Locale sync: the I18nProvider reports the UI language and a signed-in preference session saves it as the new `locale` preference when the account's differs (and on every switch), so IM notices follow the UI language; nothing is written with auth disabled. - i18n: threads.* (unread, origin labels, provider names), scheduledTasks.events.*, history.waitingForSlot (now shown for queued run rows), channels.scheduledUpdates.*. - e2e mocks: thread activity feed and controller, POST /read, the events route, providers with proactive_notifications, search unread, features thread_activity (off by default). Preference e2e mocks return the UI locale so they keep asserting only their own edits. - Docs: frontend AGENTS.md, CHANGELOGs. * 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". * feat(frontend): origin markers and unread state in the thread lists Server-created threads (PR2 F2) now say who created them and whether they are new, in the sidebar and on the Chats page, and reach an open sidebar without a reload. - ThreadOriginIcon (thread-channel-source.tsx): clock for a scheduled run, the provider mark for IM threads, the GitHub mark (new in ChannelProviderIcon) for GitHub threads, a puzzle piece for extensions; the localized "Scheduled run" / "From Feishu" / "From GitHub" / "From an extension" label is its accessible name and tooltip. ThreadChannelIcon stays exported as a wrapper, and the provider chip tooltip is localized (no more "Feishu channel"). - Unread dot after the title (aria-hidden dot plus sr-only "Unread"); the row aria-label becomes "{title}, unread" / "{title}，未读". Never shown for the open thread. - WorkspaceSidebar mounts useThreadActivity once. - useMarkOpenThreadRead (components/workspace/chats): the default and custom-agent chat pages mark the thread read once its metadata has loaded, when its cached unread flips to true while open, when the tab becomes visible, and from onFinish (a send or a joined run ended). Each trigger goes through useMarkThreadRead, so it is debounced and a no-op while the cached unread is false. - Tests: thread-origin-icon and recent-chat-list DOM tests (en/zh, active row, no raw identifiers), use-mark-open-thread-read DOM tests, e2e thread-activity.spec.ts (new scheduled run appears unread within one fake-clock poll without a reload, opening it posts /read and clears the dot, a read on another device clears it, IM and GitHub markers, zh labels, the Chats page, no polling when unavailable); thread-history.spec.ts now finds the localized origin icon. - Docs: frontend AGENTS.md, CHANGELOGs. * feat(frontend): schedule event line in the originating chat and channel notice support The chat that created a schedule now says when the schedule paused or ended, and the channel cards say which apps receive scheduled task updates (PR2 F3). - ScheduledTaskEventLine (mockup m2, marker 4): a dashed, muted row with the describeTaskEvent text (title in <strong>, stop condition clamped to one line with the full text in its tooltip, last-run suffix), the time via formatTaskTime and a right-aligned "See that run" (run chat) or "Open task" link. PauseCircle for paused, CircleCheck for finished and once-done, CircleX for once-failed. role="note", aria-label "Scheduled task update" / "定时任务通知", data-task-id and data-event-id only. - MessageList takes scheduledTaskEvents and renders placeTaskEvents output through a new VirtualMessageList.renderAfterGroup, so each line sits at the end of its after_run_id turn inside the group's measured row (also when the list virtualizes); lines with nowhere to go render at the tail. - Both chat pages load useThreadScheduledTaskEvents (not gated on the task list, so the lines stay after a task is deleted). The custom-agent page passes its agent so "See that run" opens the run on that agent's route. - ChannelScheduledUpdates: "Scheduled task updates: sent here" / "... not available for this app yet" (定时任务通知：会发送到这里 / 此应用暂不支持) on the Settings provider cards and under each sidebar channel row; nothing when an older backend does not report proactive_notifications. - e2e mock controller: setScheduledTasks. - Tests: scheduled-task-event-line and channel-scheduled-updates DOM tests (every kind in en and zh, hrefs, clamp, no raw identifiers, Chinese title), MessageList placement DOM tests; e2e scheduled-task-chat-events.spec.ts (the line appears with the card's "Paused by agent" without a reload, See that run opens the run chat, anchored vs tail placement, two events in time order, the line survives task deletion and Open task shows the task is gone; en-3 and zh-1) and channels.spec.ts (WeCom sent here, Feishu not yet; en and zh). - Docs: frontend AGENTS.md, CHANGELOGs. * 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(scheduler): address PR2 review findings - Event lines: hold an event whose anchor run is on an unloaded history page instead of placing it at the bottom (hasMoreHistory); tail fallback only for fully loaded (branched/pruned) history or no anchor. - Idle-finish anchor follows its reason: end:<iso> only for an end_at finish, seq:<n> otherwise, so a later end-time finish is not deduplicated away by an earlier max_runs finish. - Observer takes FOR SHARE on the originating threads_meta row, so a racing thread delete cannot leave an orphan event line. - One taskPagePath (core), re-exported by the card. - Notification locales derived from NotificationLocale; /preferences uses it. - IM notices drop generic reasons (goal_not_met_yet, unknown) instead of repeating the sentence. - Localized provider names on Settings cards, sidebar rows and setup dialog. - zh event lines: no space after a Chinese title (Latin-aware gap). - Unread row label keeps the origin marker; chats page keeps the time as a description. - Sidebar shows the scheduled-updates line only for connected apps; Settings says "available after you connect" for unconnected push apps. - Event line keeps a real space before the time. * 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". * test(scheduler): consolidate PR2 backend test setup - Fold the repeated task, origin-chat and observer setup of the lifecycle-event repository tests into one lifecycle_task builder. - Build the per-owner-cap services through one _capped_service builder that keeps every cap explicit at the call site. - Table the five SSE route header checks into one parametrized test with the same routes, bodies and Content-Location expectations. - Reuse bind_wecom and hoist repeated local imports in the event tests. Every case and assertion is kept; collected cases are unchanged. * test(frontend): consolidate PR2 thread activity and origin test setup Extract shared builders and helpers in the frontend tests PR2 adds, with every case, input and assertion kept: - activity.test.ts: seededClient/apply helpers and one LIST_KEYS constant replace the per-test seed, spy and apply boilerplate. - mark-read.dom.test.tsx: newClient() and advance() replace the repeated QueryClient wrapper and fake-timer act blocks. - origin.test.ts: the English and Chinese label checks become tables; the no-English-name check now runs on every Chinese row. - thread-activity.spec.ts: a scheduledRun() builder replaces four inline copies of the scheduled run thread. - channels.spec.ts: the PR2 block uses setLocaleCookie and one card helper. Collected cases are unchanged (unit 211, e2e 60); no test was removed. * 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. * fix(scheduler): two gaps found in live acceptance - A fresh scheduled run thread is named when it launches. The worker copied the title to the thread list only when the run ended, so the sidebar, which now shows the new run thread at once, listed it as untitled while it ran. - A task capped at one run finishes with "its one run is done" / "唯一一次运行已完成" in the chat event line and the IM notice, instead of "all 1 runs are done". * 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. * test(scheduler): expect the one-run finish copy in service notices * fix(gateway): create a scheduled run thread with its title Pre-setting the name after start_run raced the thread row, which the run worker creates asynchronously: live, one of two run threads still reached the sidebar untitled. Run admission now creates a new thread with the title its run input carries, which the worker would copy only at run end. * docs(changelog): reference #6393 for the scheduled-task signal entries * fix(scheduled-tasks): route event-line run links by the agent that ran them The originating chat's agent was used for "See that run", but a task's agent can change after the chat created it, so the link could open the run chat on another agent's route. Lifecycle events now record run_agent_name, the task's agent when the run finished (edits are refused while a run is active), and the line routes by it. * fix(scheduled-tasks): load up to the route's maximum of chat event lines The chat loads its lifecycle events once, and the route's default of 50 would silently drop the oldest lines of a chat with many schedules. Ask for the maximum, 200. * fix(threads): keep activity reads and the first cursor in step with the lists - Accepting the first activity cursor refreshes the thread lists once. The lists load on their own, possibly before a run the seed already counts, and later polls start after it, so such a thread never appeared. - A local read whose returned read clock jumps past that one read also covers reads on other devices; the lists are refreshed instead of the clock silently skipping those threads' stale unread dots. - An invalid cursor re-seeds through the same path, so it refreshes once. * docs(agents): bring the middlewares guidance chain back under the hard limit #6378 and #6363 each fit the budget, but together the middlewares AGENTS.md chain on main is 98,425 bytes, 121 over the 98,304 hard limit, so Lint Check fails on main. Move the scheduled-task recovery, launch-update and queue-timeout rules from backend/AGENTS.md into the persistence guide's lifecycle section, which backend/AGENTS.md already points to. The chain is now 98,067 bytes. * fix(helm): bump the chart's config_version to 55 config.example.yaml moved to 55 in this PR, so the Helm chart's validate-chart drift check failed. The chart's embedded config needs no field changes: the new scheduler and channel keys have defaults. --------- Co-authored-by: Totoro-qaq <279883115+Totoro-qaq@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-07 10:22:15 +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
Totoro	cdbcc0d9e9	feat(scheduled-tasks): show goal outcomes and end conditions in run history (#6326) ... * docs(scheduler): document tool_enabled, goal notices and goal-evaluation change Follow-up to #6229: - CONFIGURATION.md: add scheduler.tool_enabled to the example and notes. - CONFIGURATION.md, README (en/zh/pt): unmet goal runs send a goal-unmet notice instead of a completion notice, and three unmet runs add an auto-pause notice; the docs still said only success/failed notify. - CHANGELOG (en/zh): the #6229 entry now states the default-on goal evaluation change for scheduled/webhook/autonomous goal runs and that evaluator usage counts toward run usage. * feat(scheduled-tasks): show goal outcomes and end conditions in run history Follow-up to #6229. The API already returns these fields; the tasks page did not show them, so a met goal read as plain "Success", an unmet reason code rendered as a red execution error, and the goal-unmet IM notice pointed to a workspace showing neither objective nor verdict. - Task detail shows the per-run goal, max automatic runs and end time when a conversation-created task has them. - Goal runs show "Goal met" (or met relying on stated assumptions); unmet runs show a localized reason plus the host code in neutral styling. The run whose agent asked to stop the schedule is marked. - Runs without a goal, and failed runs, render as before. Read-only and frontend-only: no API change. * docs(changelog): add #6326 scheduled-task goal outcome entry * fix(scheduled-tasks): show readable unmet reasons instead of raw codes Unmet runs now show only the localized reason; the host code moves to the tooltip so it can still be matched with the IM notice. Codes without a label are still shown verbatim. * fix(scheduler): show readable goal reasons instead of internal codes Task detail now localizes the host-written last_error values from goal and stop finalization (agent stop, automatic pause, unmet reason codes) under a matching label, and Chinese copy is tightened. Goal-unmet and auto-pause IM notices state the reason in words instead of printing the raw code; unknown codes are still not forwarded. * docs(changelog): describe readable goal reasons in #6326 entry * test(scheduler): pin host goal strings with a cross-language contract Address review on #6326: - Add contracts/scheduled_goal_notes_contract.json listing the task last_error strings and unmet reason codes the tasks page and IM notices translate. A backend test checks finalization constants, blocker and stand-down codes against it; a frontend test checks every listed value has a label. - Move the two last_error strings in finalization.py into constants. - Frontend reason lookup strips the blocked: prefix like the IM map and now covers goal_not_met_yet, with en/zh labels. --------- Co-authored-by: Totoro-qaq <279883115+Totoro-qaq@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-10-05 21:56:04 +08:00
Wenchao An	4c05e88c52	feat: add inline @ references with multiple skill activation (#6063) ... * feat(frontend): unify composer references with an @ picker * feat: edit references inline and activate multiple skills * docs: describe inline references and multiple skill selection * fix: prevent sent drafts from returning and repair CI checks * fix: reconcile inline references and address review feedback * fix: preserve references through discovery errors and polish	2026-09-30 23:09:05 +08:00
PeaceMaker-best	b73a4e79bf	feat(memory): scope management API by agent (#5565) ... * feat(memory): scope management API by agent Signed-off-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com> * fix(memory): preserve scoped management isolation Signed-off-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com> --------- Signed-off-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com> Co-authored-by: PeaceMaker-best <221849497+PeaceMaker-best@users.noreply.github.com>	2026-09-30 16:50:07 +08:00
Storm	1b691689da	fix(integrations): keep Lark runtime status consistent (#5994) ... * fix(integrations): keep Lark runtime status consistent Probe sandbox runtime readiness for every Lark mutation response outside the credential lock. Expose explicit sandbox_runtime_probed state so the frontend can distinguish conservative fallbacks without inferring semantics from runtime detail text, while cancelling stale reads before updating the cache. * style(frontend): format Lark cache test * fix(integrations): snapshot Lark credential status under the lock Why this change is needed: PR #5994 moved the post-mutation status read outside the per-user credential lock so the new sandbox runtime probe would not extend the critical section. As flagged in review, that lets a concurrent app switch or auth flow land between the committed mutation and the status read; in remote-provisioner mode the runtime probe can spend seconds before probe_lark_auth runs, so the raced switch can clear the new tokens and make a completed login report success=false, or mix an old app_id with a newer auth state. What changed: - add _LarkCredentialSnapshot (app config + auth probe) and capture it in the same _lark_credential_lock section that commits the mutation - thread the snapshot through _get_lark_mutation_status into get_lark_integration_status(credential_snapshot=...); only the credential-independent runtime probe still runs after the lock - apply to complete_lark_auth, complete_lark_config, and set_lark_app_credentials; install keeps the one-shot status build Problem solved: Mutation responses stay tied to the just-committed credential generation: a raced app switch can no longer flip a completed device-code login to success=false or blend a stale app_id with newer auth state, while the runtime probe stays off the lock. * fix(integrations): address Lark status review follow-ups - install_lark_integration: snapshot credential-derived status fields under _lark_credential_lock so the install response cannot mix newer credential state read across the unlocked runtime probe - useInstallLarkIntegration: route the cache write through cacheLarkMutationStatus so install cancels in-flight reads and keeps probed runtime fields under frontend/backend version skew - README: soften the UI claim - the status API exposes sandbox_runtime_probed and the mutation cache honors it * test(integrations): tighten Lark status fixtures and guidance docs - cache.test: use a distinct mutation runtime mode in the unprobed-merge case so the assertions prove the cached runtime fields win - e2e mock: include broker in the sandbox_runtime_mode union cast so the fixture cannot drift from LarkSandboxRuntimeMode - AGENTS.md (gateway + skills): mention sandbox_runtime_probed alongside the existing runtime readiness fields, keeping the gateway guidance file under its byte budget * fix(integrations): harden Lark mutation cache against skew and races - cacheLarkMutationStatus: await cancelQueries before writing so an in-flight GET whose fetch already resolved cannot clobber the fresher mutation status, matching the existing threads/archive pattern - self-heal version skew: an unprobed (pre-field backend) mutation response now triggers a status refetch instead of risking the conservative runtime fallback lingering until the next focus/remount - api: normalize a missing sandbox_runtime_probed to false at the boundary so the declared-non-optional type matches skewed runtimes - tests: pin the skew contract (missing-field cases for cache and api) and add a useInstallLarkIntegration regression test proving the install cache write goes through cacheLarkMutationStatus - README: describe the probed flag as cross-version semantics instead of claiming the same-version API surfaces both states - lark_cli: note that install's credential snapshot runs the auth probe subprocess while holding the credential lock * refactor(integrations): derive sandbox_runtime_probed inside the resolver _resolve_sandbox_runtime_readiness now returns a fourth probed element next to the branch that produces the unevaluated remote fallback, so the 'was readiness actually evaluated' invariant can no longer drift from the fallback logic it mirrors. Callers and resolver-level tests updated to pin probed per branch.	2026-09-29 17:23:36 +08:00
Wenchao An	e2f19d8335	feat(plugins): full-stack plugin APIs and bookmarks (#5647) ... * feat(plugins): add full-stack contributions and bookmarks example * ci(plugins): provision bookmark gateway for browser tests * fix(plugins): authenticate module downloads through configured backend * fix(plugins): isolate contributions and localize extension UI * fix(plugins): preserve bookmark agent routing and contain async callbacks * fix(plugins): pin durable batch workers to app extension snapshots	2026-09-22 11:18:57 +08:00
hataa	71087f2f8e	feat(authz): gate composer send on runs:create (Phase 4 follow-up, #4063) (#5528) ... * feat(authz): gate composer send on runs:create (Phase 4 follow-up, #4063) Mirrors #5294's stop gating on the send side: both chat routes pass canCreateRuns (from PERMISSIONS.RUNS_CREATE, lockstep with the backend enum) into the shared composer. The gate sits at the top of submitThreadMessage — the single choke point every composer entry (submit button, Enter, goal-set-triggered run) funnels through — and denies with a toast plus a rejected promise so PromptInput keeps the text. The idle submit button is disabled and explains the boundary via conditionally-spread aria-label/title (startTurnUnavailable, en/zh); while streaming the button stays the runs:cancel stop affordance. Also removes the unreachable kind === "stop" branch in handleSubmit (flagged during #5294's review): the Enter path early-returns with the streaming toast before the classifier runs. * fix(frontend): reject denied goal starts before saving state --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-09-20 17:45:03 +08:00
Wenchao An	1f437f86c6	feat(agents): persist default knowledge scopes for custom agents (#5579) ... * feat(agents): persist default knowledge scopes for custom agents * style: format agent knowledge guidance * fix(i18n): clarify default knowledge reset hint * fix(knowledge): preserve retries for initially unbound agents	2026-09-20 16:31:35 +08:00
zhangwei-way	b6503e9a35	feat(knowledge): add per-message RAGFlow retrieval scope (#5238) ... * feat(knowledge): integrate RAGFlow retrieval and management * test(knowledge): cover merged listing tool * feat(knowledge): add per-message retrieval scope * chore(docs): remove unrelated document * docs(knowledge): add interaction screenshots * feat(knowledge): simplify scope selector trigger * docs(knowledge): refresh selector screenshot * feat(knowledge): defer standalone management * docs(knowledge): show chat-only scope UI * fix(knowledge): honor scope on clarification replies * fix(knowledge): harden scoped replay validation * docs(knowledge): clarify replay scope precedence * fix(knowledge): keep provider settings on tools * fix(config): preserve tools-only knowledge settings * fix(knowledge): submit custom assistant identity * refactor(knowledge): trim PR scope changes * fix(knowledge): sanitize document scope display * feat(knowledge): enable scope selection in main chat * fix(knowledge): emphasize active scope icon without button frame * fix(knowledge): close context scrubbing and refresh e2e checks * fix(knowledge): preserve idempotent canonical retries * fix(knowledge): accept promptless conversation runs * style(knowledge): format backend regression tests * chore(knowledge): trim PR scope and fix frontend format * fix(knowledge): remove shared-scope notice * fix(knowledge): remove scope persistence notice * docs(knowledge): include main chat in catalog scope * fix(knowledge): preserve scope recovery and upgrades * fix(config): preserve LightRAG knowledge upgrades --------- Co-authored-by: foreleven <for-eleven@hotmail.com>	2026-09-18 16:59:31 +08:00
tiammomo	d8db4e1bf4	feat(scheduled-tasks): search task titles and prompts (#5355) ... * feat(scheduled-tasks): search task titles and prompts Signed-off-by: tiammomo <26957354+tiammomo@users.noreply.github.com> * docs(scheduled-tasks): separate search from time validation notes Signed-off-by: tiammomo <26957354+tiammomo@users.noreply.github.com> * fix(frontend): order scheduled-task imports --------- Signed-off-by: tiammomo <26957354+tiammomo@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-09-18 09:25:32 +08:00
tiammomo	73590a626d	fix(scheduled-tasks): reject nonexistent local execution times (#5348) ... * fix(scheduled-tasks): reject nonexistent local execution times Signed-off-by: tiammomo <26957354+tiammomo@users.noreply.github.com> * test(scheduled-tasks): align valid-time fixture with instant preservation Signed-off-by: tiammomo <26957354+tiammomo@users.noreply.github.com> --------- Signed-off-by: tiammomo <26957354+tiammomo@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-09-18 09:07:25 +08:00
tiammomo	6d725f1ccb	fix(scheduled-tasks): preserve unchanged one-time execution instants (#5330) ... * fix(scheduled-tasks): preserve unchanged one-time execution instants Signed-off-by: tiammomo <26957354+tiammomo@users.noreply.github.com> * fix(scheduled-tasks): reset edit state before task remounts Signed-off-by: tiammomo <26957354+tiammomo@users.noreply.github.com> * test(scheduled-tasks): exercise timezone fallback on UTC runners Signed-off-by: tiammomo <26957354+tiammomo@users.noreply.github.com> --------- Signed-off-by: tiammomo <26957354+tiammomo@users.noreply.github.com>	2026-09-18 08:06:31 +08:00
FanouZeng-TT	a022be195a	fix(frontend): scope skill suggestions by agent (#5451) ... * fix(frontend): scope skill suggestions by agent Filter composer slash-skill suggestions through the active custom agent allowlist so restricted agents do not offer unavailable skills. Co-Authored-By: Claude Code <noreply@anthropic.com> * fix(frontend): wait for agent scope before draft hydration Keep agent loading distinct from explicit empty and inherited skill scopes so saved skill chips are restored only after the active scope settles. Co-Authored-By: Claude Code <noreply@anthropic.com> --------- Co-authored-by: Claude Code <noreply@anthropic.com>	2026-09-16 23:13:44 +08:00
Zeren Wang	a58ab484a6	feat(projects): Projects MVP Phase 2 — instructions, document shelf, promotion, trash (#5443) ... * feat(projects): Projects MVP Phase 2 — instructions, document shelf, promotion, trash Implements docs/superpowers/specs/2026-09-12-projects-mvp-phase2-design.md (issue #5160, tracker #5129) in the slice order of the spec's §16. Slices: - A: ProjectsConfig + write-time 422 UTF-8 byte cap; PROJECT_CONTEXT_KEY admission pinning (both server-owned sets + worker hoist); latest-only request-scoped <project> block via DynamicContextMiddleware wrap_model_call/awrap_model_call (idempotent reassembly, reserved ID prefix + marker + provenance, never persisted); journal audit fingerprints; Instructions tab. - B: ProjectDocumentRow + migration 0023; ProjectDocumentRepository with locked check-and-set; hash-qualified immutable shelf storage with Paths helpers; upload/list/content/delete-to-trash routes; project delete trashes the shelf in-transaction; request-scoped bounded <documents> index with honest count/shown + actionable overflow note; list_project_documents/read_project_document tools registered only on pinned runs; PAT allowlist + drift guards; blocking-IO anchors. - C: shared thread-upload ingestion service (uploads router refactored to parity); POST from-thread with provenance; attach-to-thread with lock-staged copy (archived source allowed); read-only thread-files view with per-group truncation reporting. - D: restore (restored/merged/not_found/no_target/content_missing; no file moves), purge (continuous row lock across unlink/delete/commit, retryable on FS errors), retention sweep (lazy + startup, 24h orphan guard, row-side reconciliation never deletes). - E: Documents tab (shelf + conversation-files browser, provenance, archived banner, content-missing rows), /workspace/trash route, sidebar entry, composer attach handoff, i18n (en-US/zh-CN), e2e mocks + specs. Review hardening folded in (10 rounds, all with tests): - force active shelf content (HTML/XML family) to download; nosniff on artifact + content responses; unified unsandboxed-iframe PDF preview (fixes the pre-existing Chromium sandbox blank in the artifact viewer) - scope document trash to the URL project under the document lock - atomic no-overwrite filename reservation for ALL ingestion (seeded claims + os.link commit with suffix retry; same-name re-upload now unique-names instead of replacing); hidden staging only, no visible placeholders; lease cleanup on setup failure - serialize conversion under the document lock with post-lock active revalidation; drain locked filesystem work on cancellation; preserve bytes when an insert's commit state is uncertain (including trashed rows) - original-integrity checks before serving text or cached conversions; content_missing surfaced in list responses (UI reads the flag, no 409-probe); downloads always serve original bytes - bounded streaming document reads with cached char counts; shelf limits declared in middleware release identity - thread-root confinement for from-thread sources; config fallback rejects fractional/infinite values; composer counts staged attachments; pending attachments persist until submission or removal; in-flight instruction/rename edits survive save refetches; shelf and trash pagination; conversation-file and thread-files pages stay subscribed to refetches Docs: README/README_zh, backend API.md/ARCHITECTURE.md, AGENTS.md contracts, config.example.yaml projects block. Review follow-ups (head b4807477 → this revision): - The trash retention sweep is split so repeated lazy triggers stay bounded: the indexed expiry purge still runs on every trigger (GET /api/trash/documents, POST /api/trash/purge) while the O(all rows + all files) reconciliation is throttled to one run per user per 15 minutes (process-local, per-user window). The startup sweep now runs as a background task instead of blocking gateway readiness, and shutdown awaits it (bounded). - The export scrub (stripInternalMarkers) is fence- and indentation-aware like the render path, so a pasted, fenced <project>/<documents> snippet survives markdown export while real injected blocks (never fenced) are still removed. Fence regexes moved to a dependency-free leaf module to avoid the messages↔streamdown import cycle. - The artifact viewer's PDF iframe no longer carries an added title attribute (the upstream e2e contract locates it via :not([title])), and the upstream artifact-preview spec now pins the new contract: PDFs render unsandboxed, images keep sandbox="". * fix(projects): round-2 review — cancel an overrun trash sweep, restore the PDF frame title - Shutdown cancelled only the shield around the background startup sweep, so an all-users reconciliation that outlived the 5s budget kept walking rows and files while the document repo and DB engine were disposed underneath it. The wait now lives in `_shutdown_startup_trash_sweep`, which cancels the task and drains it before worker exit: the shield keeps the wait bounded, the cancel makes it final (CancelledError lands at the sweep's next await, and `_run_startup_trash_sweep` only catches `Exception`, so nothing swallows it). - The browser-preview iframe lost `title={getFileName(filepath)}` in the previous fix round, leaving the PDF frame without an accessible name while its siblings keep theirs. Restore it (WCAG frame titles), assert it in the DOM test, and anchor the e2e on `iframe[title="report.pdf"]` instead of `iframe:not([title])`. * fix(projects): round-3 review — report the sweep's late finish, not a phantom cancel `Task.cancel()` returns False when the sweep already finished inside the window between the deadline firing and the cancel, so the shutdown log claimed a cancellation that never happened. Branch on that outcome: the warning stays for a real cancel, a late finish is logged at info, and both paths still reap the task before worker exit. * fix(projects): round-4 review — make Empty trash delete what it confirms `POST /api/trash/purge` only ran the retention sweep, and the sweep's candidate selection is age-gated, so a freshly trashed document survived "Empty trash" even though the confirmation promises that every listed document is permanently deleted. With one trashed row the route answered `{"purged": 0}` and left it in place; `GET /api/trash/documents` sweeps expired rows before listing, so the visible rows were normally ineligible for the action by construction. Empty trash now drives `purge_all_trashed`: the caller's trashed rows (`list_all_trashed`, no age filter) each go through the same guarded, row-locked `purge` as the single-document delete — bytes first, then the row, in one transaction — so a row restored mid-flight is skipped instead of force-deleted, and an unlink failure rolls that row back and answers 500 with a retryable message. Retention expiry stays where it was: the sweep's `purge_candidates` is now the only age-gated selection, and the lazy retention sweep still runs on the listing and at startup. Tests: the router suite replaces the retention-gated expectation with the reviewer's repro (fresh row purged, bytes unlinked, shelf and other users' trash untouched, a failing unlink stays retryable and 500); a blocking-I/O anchor drives the new entry point through the offload; the mocked e2e covers the action end to end; a new real-backend spec performs it against the real gateway and re-reads `GET /api/trash/documents`. README, API, ARCHITECTURE and the phase-2 design docs (en+zh) state the age-independent contract.	2026-09-16 18:46:18 +08:00
Wenchao An	a246c928e9	feat(frontend): move capability management out of Settings (#5468) ... * feat(frontend): move capability management out of settings * fix(frontend): address capability center review feedback	2026-09-16 18:39:24 +08:00
yang rui	7513f16e0e	feat(settings): persist account preferences across browsers (#5397) ... * feat(settings): persist account preferences across browsers * docs(settings): scope preference guidance to user persistence * fix(settings): preserve SSR and fence custom-agent defaults * test: include user persistence in scoped guidance inventory * fix(settings): sync explicit edits and preserve local tab updates	2026-09-14 07:25:41 +08:00
tiammomo	4501c76b0f	feat(scheduled-tasks): browse paginated run history (#5363) ... Signed-off-by: tiammomo <26957354+tiammomo@users.noreply.github.com>	2026-09-12 12:59:52 +08:00
yang rui	ac2b6415ea	feat(agents): support Unicode display names for custom agents (#5324) ... * feat(agents): support Unicode display names for custom agents * fix(agents): preserve and validate Unicode display names * fix(agents): tolerate invalid stored labels and reject invisible names * fix(agents): identify agent in invalid display name warning * style(frontend): format agent display name fallback --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-09-12 11:09:41 +08:00
hataa	ec0ac474c4	feat(authz): gate thread-delete and run-cancel UI on effective permissions (Phase 4, #4063) (#5294) ... * feat(authz): gate thread-delete and run-cancel UI on effective permissions (Phase 4, #4063) Consume the effective route permissions surfaced by #5228 so the UI hides actions the caller's role cannot perform: - threads:delete hides the sidebar thread-row Delete menu item and the sidecar panel delete button (every useDeleteThread consumer) - runs:cancel disables the composer stop affordance; all three stop entry points converge on one check inside handleStopStreaming hasPermission treats an absent/null/unresolved permission list as permissive, so a mixed old-backend/new-frontend deploy never hides actions the caller can still perform. The Gateway @require_permission guards remain the single enforcement point. * fix(authz): review follow-ups for stop gating (comment accuracy, a11y, tests) - Correct the defense-in-depth comment: the submit-button click is the only live entry into handleStopStreaming (handleSubmit returns early with the pleaseWaitStreaming toast while streaming, so the kind==="stop" branch is unreachable); the handler gate stays as future-proofing. - Explain the disabled stop affordance with aria-label + title (Radix tooltips don't fire on disabled buttons), with en-US/zh-CN strings. - Add the composer stop-gating DOM tests (disabled + onStop never fires + permissive default) and the sidebar delete-menu gating tests, so all gated surfaces carry wiring tests. * fix(authz): stop conditional aria-label from stripping the submit name The stop-gating follow-up (1612855b) explained the disabled stop affordance with aria-label/title but passed explicitly-undefined values in the non-denied case. PromptInputSubmit declares its default aria-label="Submit" before {...props}, so the undefined key landed in the spread and clobbered the default: React omits the attribute entirely and the submit control lost its accessible name in every state, which broke the sidecar e2e layout helper (it locates the button by its "Submit" label). Spread the attributes conditionally so they only attach when stopDenied, and lock the invariant with a DOM test asserting the base "Submit" name survives when stop is not denied (mutation-verified: reverting the conditional spread turns the new test red). * test(authz): drop unused rerenderWith helper, guard accessible name by role query Address the review nit on the stop-gating DOM tests: the rerenderWith helper was never called, and a second render() would append a composer instead of updating the first one anyway — drop it (the sidecar-delete-gating tests already demonstrate the correct rerender pattern if a granted->denied flip test is ever needed). Also resolve the accessible-name regression guard through getByRole("button", { name: "Submit" }) so it fails exactly the way e2e and assistive tech consume the control (mutation-verified: the explicitly-undefined aria-label form turns it red). --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-09-12 10:40:54 +08:00
Undermoon1412	c9c7076ba7	fix: localize Chinese docs links (#5275) ... * fix: localize Chinese docs links * fix(docs): correct layout import order * test(docs): narrow localized link e2e locator Signed-off-by: Undermoon1412 <80385295+Undermoon1412@users.noreply.github.com> --------- Signed-off-by: Undermoon1412 <80385295+Undermoon1412@users.noreply.github.com> Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-09-10 21:29:21 +08:00
wutongyuonce	48a8978b7b	feat(scheduler): add interval schedule type (#5291) ... * feat(scheduler): add interval schedule type Allow scheduled tasks to fire every N seconds from last dispatch, not only wall-clock cron or a single run_at. Cadence is UTC now+N with no missed-beat catch-up, bounded by min_once_delay_seconds and 30 days. * fix(scheduler): let interval tasks create, edit, and keep next run Create/edit now keep every_seconds. Unchanged interval spec no longer resets next_run_at, including timezone-only PATCH. * fix(scheduler): keep non-minute intervals on edit Stop rounding every_seconds to whole minutes in the form. Values that are not whole minutes or hours now use a seconds unit so edit/duplicate round-trips the stored cadence instead of rewriting it and resetting next_run_at. Document that min_once_delay_seconds is also the interval floor. * fix(scheduler): clamp interval seconds to the default 60s floor The new seconds unit allowed 1–59, which the API rejects under the default min_once_delay_seconds. Clamp the form to >= 60 and show the floor next to the preview. Also mention interval in the scheduler field_doc, matching config.example.yaml. * fix(scheduler): do not clamp interval amount while typing Keystroke clamp made 90 become 9 -> 60, then 600, and backspace could not leave 60. Keep the raw field text and apply the 60s floor on blur and emit only. * test(scheduler): cover interval input editing * fix(frontend): preserve saved interval cadence until edited * style(tests): format scheduled task router tests --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-09-10 16:46:01 +08:00
wutongyuonce	69f0f483eb	feat(scheduler): let scheduled tasks pin a custom agent (#5288) ... * feat(scheduler): let scheduled tasks pin a custom agent Create and update accept optional assistant_id, defaulting to lead_agent. Custom names are normalized and must already exist for the task owner. The workspace form exposes the same choice, and duplicate copies it. Fixes #5286 * fix(scheduler): keep assistant-id PR free of interval tests Drop the six interval tests that belonged to the interval schedule PR and fail here because this tree still only accepts once/cron. Treat lead_agent case-insensitively so LEAD_AGENT / lead-agent store as the default. Omit unchanged assistant_id on edit so a deleted custom agent does not 422 unrelated PATCH (rename, reschedule). * fix(scheduler): format task page and browser tests --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-09-10 15:36:49 +08:00
JeffJiang	dfaeef3772	fix(frontend): support standalone demo APIs and runtime GitHub stars (#5302) ... * fix(frontend): support standalone demo APIs and runtime GitHub stars * Update API origin URL to use environment variables Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> * test(frontend): align static demo tests with runtime origin --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com> Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>	2026-09-09 00:00:56 +08:00
Zeren Wang	5951c89b5b	feat(projects): project workspaces with scoped chats and thread membership (#5265) ... * feat(projects): project workspaces with scoped chats and thread membership Backend: - projects table model and migration; fail-closed ProjectRepository with ownership checks, CRUD/archive/restore/delete router, and atomic thread move between projects - threads_meta.project_id column exposed as reserved deerflow_project_id metadata; project-aware thread create/search with pagination bounds and membership echoed in create responses - first-run admission assigns the project only at genuine first run, seeded at write time and dropped when invalid; serialized against project deletion and thread assignment - branch creation inherits the source thread's project membership (an archived/deleted project degrades the branch to unassigned instead of failing the request) Frontend: - projects data layer, thread move API, and sidebar projects section with flat/grouped modes, archived-project threads, and stable virtual-list offsets - project detail page with project-scoped new chat (/workspace/chats/new?project=) and paginated thread list - move-to-project thread menu, new-project dialog, archived-project gates - project-scoped new chats pre-create the thread with membership before the first submit or /goal set, so runs never proceed outside the project - goal-set preparation is fenced against conversation switches: a stale continuation is dropped instead of saving the goal or launching the abandoned submission on the newly opened conversation - project thread lists join thread lifecycle invalidations (stop, pin) so an open project page never keeps stale titles, recency, or pagination * fix(chats): keep archive undo toast when the sidebar row unmounts The archive success toast was fired from per-mutate callbacks passed to mutation.mutate. React Query drops those handlers when the observer component unmounts before the mutation settles; archiving the open chat removes its sidebar row mid-flight, so the undo toast never appeared and the e2e archive-undo test timed out waiting for it. Move the success/error handlers to the mutation level (useArchiveThread options, same pattern as useMoveThreadToProject) where callbacks are delivered even after the originating row unmounts. * fix(projects): pin project thread listing contract and exclude archived chats GET /api/projects/{id}/threads returned the thread store row verbatim (list[dict], no response_model): user_id/assistant_id leaked, any future ThreadMetaRow column would auto-leak, and the OpenAPI schema was empty. Return a narrow ProjectThreadResponse (the exact fields ProjectThread declares) with the same metadata secret redaction the surrounding thread endpoints get from _MetadataRedactingResponse. The listing also ran search() without the archived filter, so a retired chat rendered as a normal row on the project page while the sidebar hid it. Search archived=False to mirror the sidebar's archived:false lists; restore stays on the global Archived tab. Both regressions pinned by new router tests: wire-shape allowlist and archived-member exclusion. * docs(migrations): record the 0019/0020 chain against the bootstrap reservation The tree now chains 0018 -> 0019_projects -> 0020_threads_meta_project_id, so migrations/AGENTS.md was stale twice over: the revision index stopped at 0018 and the rolling-forward section still claimed the tree 'deliberately remains at 0018'. Document the new head and record the intentional numeric-prefix reuse of 0019: 0019_projects is in-chain while 0019_thread_incarnations stays the reserved, allowlisted out-of-tree rollout id. The owning rollout revision must re-parent onto this tree's head when it merges so alembic never sees two heads off 0018; bootstrap.py now cross-references that note next to _FORWARD_COMPATIBLE_REVISION. * fix(chats): invalidate project thread lists on archive/restore useArchiveThread refreshed the infinite sidebar cache, threads/search and the per-thread metadata cache but not the project-scoped list ([...PROJECTS_QUERY_KEY, 'threads', id]) this PR adds — the one thread mutation not wired to that key, after usePinThread, useRenameThread, useDeleteThread, useMoveThreadToProject and invalidateStoppedThreadCaches. An archive from a sidebar row while a project page is open therefore left the archived chat rendered as a normal row until remount (and undo left it missing). Invalidate the prefix in the mutation-level success handler. Regression test asserts the project-list prefix is invalidated on success. * fix(projects): fetch project discovery only in grouped sidebar mode RecentChatList mounted two useProjects queries per sidebar render, but knownProjectIds is consumed only by the grouped-mode exclusion filter; in the default flat mode every page load paid two GET /api/projects?status= round trips for data nothing read. Gate both queries on grouped mode — GroupedProjectList fetches the same keys when the toggle is on and TanStack dedupes the observers. Also set retry: false on useProject: a deleted or foreign project 404s deterministically, and the page renders a dedicated not-found state for it, so the default 1s/2s/4s retry backoff kept deep links in 'loading' for ~7s before that state appeared. Matches useThreadMetadata / useThreadTokenUsage. * fix(threads): fail closed on project-scoped create in memory mode MemoryThreadMetaStore.create accepted project_id and silently ignored it, making memory mode the one membership path that fails open: POST /api/threads with a project id returned 200 and the run started unassigned, violating the invariant that a run never proceeds outside the selected project (the SQL store raises ProjectNotAssignableError inside the insert transaction for the same request). Raise ProjectNotAssignableError whenever project_id is present so the router's existing 404 mapping applies, the frontend keeps the composer text for a retry, and memory mode behaves exactly like SQL mode. set_project already reports rejection; create now matches it. Store-level test (raises, nothing persisted, project filter stays empty, unscoped creates still work) plus a router-level test asserting the 404 and that no row is left behind. * fix(projects): window the project page thread list ProjectThreadsSection rendered every loaded page as a plain Link row, so a long-lived project accumulated unbounded DOM on the page's scroll surface: each load-more appended another 100 rows and every formatTimeAgo tick re-rendered the whole list. Reuse VirtualThreadList (now generic over any row shape with a thread_id), pointing its scroll parent at this page's ScrollArea viewport via the shared [data-slot="scroll-area-viewport"] selector used by /workspace/chats; under the 60-row threshold it falls back to the plain render, so small projects are unchanged. * fix(projects): restore row dividers and pin them with a render test The row class template literal concatenated transition-colors directly with the conditional border-b token, so non-final rows rendered the invalid class 'transition-colorsborder-b' and lost both the divider and the transition. Compose the row classes with cn() and a boolean guard instead. The section moved out of page.tsx into a testable component so the row markup finally has coverage: a DOM test asserts every row except the final data row carries border-b (index-based, not last: — correct under virtualization where the last mounted row is not the last data row), and the untitled fallback plus load-more button render for a partial page. * fix(projects): validate forward schemas and fence membership reads	2026-09-08 17:00:26 +08:00
Ryker_Feng	98b8e4657e	feat(chats): add archive and restore (#5236) ... * feat(chats): add archive and restore * test(chats): observe archive search requests in pagination e2e * docs(gateway): move thread lifecycle details out of inherited guidance * docs(chats): add concise archive and restore RFC * docs(chats): move archive RFC discussion to issue 5237	2026-09-06 22:30:26 +08:00
ChaseMoon	c139ba108f	fix(frontend): keep mobile sidebar trigger clickable (#5149) ... Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-09-03 09:24:49 +08:00
jiaqiang0000	91c7ed4cf5	fix(frontend): keep renamed thread titles in sync (#5045) ... * fix(frontend): 同步会话重命名后的标题状态 * chore: 重新触发 PR 自动分流检查 * fix(frontend): address thread title sync review feedback Signed-off-by: 橘猫 <2622045569@qq.com> * fix(frontend): fall back when canonical thread title is empty Signed-off-by: 橘猫 <2622045569@qq.com> * fix(frontend): fence stale metadata after thread rename Signed-off-by: 橘猫 <2622045569@qq.com> * fix(frontend): fence stale thread list responses after rename Signed-off-by: 橘猫 <2622045569@qq.com> --------- Signed-off-by: 橘猫 <2622045569@qq.com>	2026-09-01 23:10:54 +08:00
Ryker_Feng	8d8ca506ba	feat(artifacts): download run files as zip (#5117) ... * feat(artifacts): download run files as zip * fix(artifacts): address archive review feedback * fix(artifacts): gate unavailable archive downloads * fix(artifacts): verify archive availability * fix(artifacts): harden archive consistency * fix(artifacts): reject archive path aliases	2026-09-01 22:01:21 +08:00
Nan Gao	73e3699347	feat(frontend): render markdown artifacts in the "open in new window" view (#5056) ... * feat(frontend): render markdown artifacts in the new window The artifacts panel's "open in new window" action handed the browser the raw Gateway response. For markdown that is a `text/markdown` body the browser can only show as source, so the new window was a text dump rather than a reader. Route markdown artifacts to a new `/artifacts/view` page that renders them with the same components the panel uses (SafeStreamdown + the artifact rehype chain + citation links/panel), including the truncated-preview banner and its "load full file" action. Everything else keeps the raw Gateway URL — notably HTML/SVG, which the Gateway deliberately serves as a download so active content never executes in the application origin. - `core/artifacts/viewer.ts` centralizes which stored artifacts are markdown (`.skill` archives included, since they hold a SKILL.md), so the panel and the viewer route cannot drift. - `ArtifactFilePreview` and its siblings move out of `artifact-file-detail.tsx` into `artifact-file-preview.tsx`; otherwise the standalone route would pull the CodeMirror editor into its bundle. - The window title comes from the route's `generateMetadata`, not `document.title`, which the App Router overwrites after hydration. - The viewer reads content through `useStandaloneArtifactContent`, which shares `useArtifactContent`'s query key but not its `useThread` dependency, since a detached window has no thread context. Claude-Session: https://claude.ai/code/session_013AiCrC5SBc3HdFYNxsp1EC * fix(frontend): keep the artifact target across re-authentication Review found the standalone viewer unrecoverable from an expired session. The window's target lives entirely in `?path=...&thread_id=...`, and both auth paths dropped it: - The layout guard redirected to `/login` with no `next` at all. A layout cannot read `searchParams`, so the guard moves into the page, which can — and rebuilds the full viewer address for `next`. The layout loses its AuthProvider along the way: nothing under this route reads `useAuth`, and the guard now makes a single `getServerSideUser` call per request. - The shared fetch wrapper built `next` from `window.location.pathname`, which silently truncated the query string. It now carries `search` too, so any route holding state in the query survives a 401, not just this one. `validateAuthNextPath` already accepts a query string. `buildArtifactViewerURL` is split out of `resolveArtifactOpenURL`: the guard needs the route itself, never the Gateway fallback that the latter takes for non-markdown targets. Tests: the login round trip (unit — the rebuilt URL survives `validateAuthNextPath` and parses back to the same target), the fetch wrapper preserving the query on 401 (unit), and the expired-session window reaching `/login` with the artifact intact (E2E). The E2E asserts on the popup's navigation *requests*, since `(auth)/layout` answers `/login` with a server redirect under DEER_FLOW_AUTH_DISABLED and no navigation commits. `tests/unit/core/models/api.test.ts` stubbed `window.location` without `search`; a real Location always has it. Claude-Session: https://claude.ai/code/session_013AiCrC5SBc3HdFYNxsp1EC * fix(frontend): keep public showcase artifacts out of the auth gate Review found that the viewer's access check regressed `/showcase`. Those pages render with `isMock`, their artifacts are served by the unauthenticated demo route, and the raw artifact URL this window replaced stayed public — so gating the window unconditionally bounced every logged-out showcase visitor to /login for a document that is already public. `requiresAuthenticatedViewer` exempts a mock target only when `resolveStaticDemoArtifact` would actually serve it. The allowlist is the authority rather than the flag: `mock=true` is caller-supplied, so a target the demo route answers with 404 — a non-allowlisted path, or a thread that is not a demo thread — still needs a session. Covered in `tests/e2e-auth/`, since the default E2E config disables auth and cannot see this: a public showcase artifact renders without a session, while a non-allowlisted path and a missing mock flag both land on /login. Verified the positive case goes red without the exemption. Claude-Session: https://claude.ai/code/session_013AiCrC5SBc3HdFYNxsp1EC	2026-08-29 11:07:16 +08:00
Syt3s	6e5a41fd9a	feat(frontend): add conversation outline navigation for long chats (#5025) ... * feat(frontend): add conversation outline navigation for long chats * fix(frontend): escape bottom lock before outline navigation	2026-08-29 08:00:55 +08:00
Ryker_Feng	848eea289c	feat(frontend): duplicate scheduled tasks (#5064) ... * docs: design scheduled task duplication * docs: plan scheduled task duplication * feat(frontend): build scheduled task duplicate drafts * feat(frontend): duplicate scheduled tasks into create form * docs: document scheduled task duplication * test(frontend): verify duplicate schedule preview * refactor(frontend): simplify scheduled task duplication	2026-08-27 22:22:50 +08:00
Aari	ff0a6768c2	feat(subagents): add unified capacity and durable batch execution (#4998) ... * feat(subagents): add capacity controls and durable batches * fix(helm): sync subagent config schema version * fix(subagents): preserve batch history without worker * fix(subagents): support explicit factory runtimes * fix: address durable batch review findings	2026-08-25 07:49:38 +08:00
Aari	645ca08f16	fix(scheduler): enqueue busy scheduled task runs (#4918) ... * fix(frontend): clarify reuse-thread scheduling behavior * fix(scheduler): enqueue overlapping scheduled runs * fix(scheduler): preserve queue lease fencing * fix(scheduler): close queue concurrency races * fix(scheduler): harden queue timeout bookkeeping * fix(scheduler): preserve manual failure schedule --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-08-24 15:38:32 +08:00
Aari	5ffc2d3e27	feat(mcp): complete durable task notifications and chat UI (#4833) ... * feat(mcp): add reliable task notifications and cancellation * feat(mcp): add background task chat UI * fix(mcp): hide and sanitize task notification prompts * fix(mcp): sanitize projected task names * fix(mcp): harden task notifications and details * fix(mcp): harden task lifecycle recovery * fix(mcp): gate task UI and isolate cancellations * test: scope plain-text response locator * fix(mcp): align task notification boundaries * fix(mcp): bound task delivery retries * fix background task notification races	2026-08-22 16:53:32 +08:00
starslittle	7e4996eef3	fix(frontend): surface model loading failures (#4840) ... * fix(frontend): surface model loading failures * refactor(frontend): reuse model error UI primitives * fix(frontend): address model banner review feedback * refactor(frontend): remove unused model fetch state	2026-08-17 08:23:07 +08:00
Daoyuan Li	e23dd8f88b	refactor(frontend): share showcase chat page (#4765)	2026-08-12 09:16:58 +08:00
Ryker_Feng	e401ae2d7b	feat(integrations): support switching Lark app credentials (#4703) ... * feat(integrations): support switching Lark app credentials * fix(integrations): harden Lark app switching * refactor(integrations): simplify Lark switch flow * fix(integrations): reject superseded Lark flows * test(integrations): pass Lark flow generation * fix(integrations): preserve pending Lark flows --------- Co-authored-by: Willem Jiang <willem.jiang@gmail.com>	2026-08-10 07:19:19 +08:00
Aari	e5c62cab5a	feat(frontend): add Browser Live to Custom Agent chats (#4719) ... * feat(frontend): add Browser Live to Custom Agent chats * test(frontend): cover mock Custom Agent Browser Live	2026-08-07 21:38:27 +08:00