dominds 1.25.0 → 1.25.2

package/dist/tools/team_mgmt.js

@@ -3448,7 +3448,7 @@ function renderTeamManual(language) {
                 '`default_responder` 虽然不是技术必填项，但实践上强烈建议显式设置：否则会退回到实现内置的对话主理人选择逻辑（例如按可见成员/内置成员兜底），容易造成跨环境或跨轮次行为漂移。',
                 '每次修改 `.minds/team.yaml` 必须运行 `team_mgmt_validate_team_cfg({})`；若输出里还有“已解决但未清理的问题”，继续前可用 `team_mgmt_clear_problems({ source: "team", path: "team.yaml" })` 收尾，避免运行时状态与 Problems 历史脱节。',
                 '强烈建议为每个成员配置 `.minds/team/<id>/{persona,knowhow,pitfalls}.*.md` 三类资产，用来明确角色职责、工作边界、正向知识沉淀与负向避坑教训；同一个 `<id>` 必须在 `team.yaml` 的 `members` 里出现，且在 `.minds/team/<id>/` 下存在对应的 mind 文件。',
-                '这些 `.minds/team/<id>/*` 文件属于团队对该角色的长期定义资产，默认应保持稳定、稀疏、慢变；它们不是该成员自己的日常经验仓库。成员在工作中积累的日常经验、近期排障线索、短中期可复用笔记，默认应优先沉淀到 `personal_memory`；凡是推荐给成员配 `personal_memory` 的场景，也默认同时推荐配 `skills` 与 `resources` 工具集，让成员能维护个人技能指引并读取已登记资源。需要向全队同步的当前有效状态、关键决策、下一步与仍成立阻塞，应写入 Taskdoc `progress` 这一准实时任务公告牌；个人/当前对话短期工作集与临时 bridge 细节则留在 reminders。',
+                '这些 `.minds/team/<id>/*` 文件属于团队对该角色的长期定义资产，默认应保持稳定、稀疏、慢变；它们不是该成员自己的日常经验仓库。成员在工作中积累的日常经验、近期排障线索、短中期可复用笔记，默认应优先沉淀到 `personal_memory`；凡是推荐给成员配 `personal_memory` 的场景，也默认同时推荐配 `skills` 与 `resources` 工具集，让成员能维护个人技能指引并读取已登记资源。需要向全队同步的当前有效状态、关键决策、下一步与仍成立阻塞，应写入 Taskdoc `progress` 这一准实时任务公告牌；个人/当前对话短期手头工作与临时 bridge 细节则留在 reminders。',
                 '如果某成员承担团队管理职责（尤其获得 `team_mgmt`），其 `persona.*.md` 必须明确要求：执行任何团队管理操作前先查看 `man({ "toolsetId": "team_mgmt" })` 的相关章节，并按手册标准做法维护 `.minds/**` 下的团队心智资产（如 `team.yaml`、成员 mind 文件、skills、priming 等）。',
                 '“角色归属对象”不等于“写权限”：`.minds/team/<id>/*` 虽然对应某个成员角色，但是否能修改，取决于当前成员是否被授予 `team_mgmt` 或等效团队资产维护权限；“这是你自己的 persona/knowhow/pitfalls” 不等于你可以自己改写它。',
                 '典型内容示例（可直接作为起点，按团队语境改写）：\n- `.minds/team/coder/persona.zh.md`\n```markdown\n### 核心身份\n- 专业程序员，负责按规格完成代码开发。\n### 工作边界\n- 不负责需求分析或产品策略决策。\n- 只根据已确认的开发规格进行实现与重构。\n### 交付标准\n- 输出可运行代码，并附关键验证步骤。\n```\n- `.minds/team/coder/knowhow.zh.md`\n```markdown\n- 熟悉本仓库主要模块边界、构建命令与常用验证入口。\n- 优先沿调用链和数据流定位根因，再决定修改点。\n- 遇到接口、配置或契约变更时，要同步检查文档、类型和回归影响。\n```\n- `.minds/team/coder/pitfalls.zh.md`\n```markdown\n- 不要只在症状层打补丁；修改前先定位调用链与数据流。\n- 涉及权限/配置时，不要跳过对应校验工具；若只剩“已解决但未清理的问题”，再用 `team_mgmt_clear_problems(...)` 收尾。\n- 涉及高风险改动时，不要一口气铺开大改；先给最小可审查方案，再逐步扩展。\n- 涉及 agentic 能力规划或开发时，不要不自觉套用传统软件工程里“程序化完善 unhappy path 兜底”的思路。对有智能体在环的业务流程步骤，继续程序化追加 unhappy path 判断，默认应视为负面行为和设计退步，而不是加分项；它不同于仅软件在环的业务流程环节，很容易引入巨量技术债务，而且业务效果往往不理想。此时应优先安排截图视觉确认、语义把关等保留智能体在环特性的兜底路径。\n```\n迁移说明：rtws 成员文件现已优先读取 `knowhow/pitfalls`；只有在新文件名不存在时，才回退接受旧的 `knowledge/lessons`。一旦存在新文件名，就只注入新文件内容，旧文件内容会被忽略。builtin mind 只认 canonical 文件名，不读取旧别名。请尽快完成改名迁移；过渡期之后，未来版本将不再识别 `knowledge/lessons`。\n写法约束：`persona/knowhow/pitfalls` 文件里不要再写与系统提示模板重复的总标题。系统提示模板会自动添加：`## 角色设定` / `## 经验知识` / `## 避坑指南`（英文模板对应 `## Persona` / `## Know-How` / `## Pitfalls`）。',
@@ -3522,7 +3522,7 @@ function renderTeamManual(language) {
             'The team definition entrypoint is `.minds/team.yaml` (no `.minds/team.yml` alias today).',
             '`default_responder` is not technically required, but strongly recommended in practice: without it, runtime falls back to implementation-defined Dialog Responder selection (for example visible-member/built-in fallback), which can drift across environments/runs.',
             'Strongly recommended: for each member, configure `.minds/team/<id>/{persona,knowhow,pitfalls}.*.md` assets to define role ownership, work boundaries, positive knowledge accumulation, and negative lessons/traps. The same `<id>` must exist in `members.<id>` in `team.yaml`.',
-            'These `.minds/team/<id>/*` files are the team-defined long-lived assets for that role, and should usually stay stable, sparse, and slow-changing. They are not the member’s everyday experience warehouse. Day-to-day lessons, recent debugging clues, and medium-term reusable personal notes should usually go to `personal_memory`; whenever the handbook recommends granting `personal_memory` to a member, it also recommends granting the `skills` and `resources` toolsets so the member can maintain personal skill guidance and read registered resources. Current effective state, key decisions, next steps, and still-active blockers that the team must synchronize on belong in Taskdoc `progress`, the quasi-real-time task bulletin board; personal/current-dialog short-term working-set and bridge details belong in reminders.',
+            'These `.minds/team/<id>/*` files are the team-defined long-lived assets for that role, and should usually stay stable, sparse, and slow-changing. They are not the member’s everyday experience warehouse. Day-to-day lessons, recent debugging clues, and medium-term reusable personal notes should usually go to `personal_memory`; whenever the handbook recommends granting `personal_memory` to a member, it also recommends granting the `skills` and `resources` toolsets so the member can maintain personal skill guidance and read registered resources. Current effective state, key decisions, next steps, and still-active blockers that the team must synchronize on belong in Taskdoc `progress`, the quasi-real-time task bulletin board; personal/current-dialog short-term current-work and bridge details belong in reminders.',
             'Typical content examples (use as a starting point, then adapt to your team context):\n- `.minds/team/coder/persona.en.md`\n```markdown\n### Core Identity\n- Professional programmer responsible for implementing approved development specs.\n### Work Boundaries\n- Not responsible for requirement discovery or product strategy.\n- Implements/refactors only against confirmed specs.\n### Delivery Standard\n- Deliver runnable code plus key verification steps.\n```\n- `.minds/team/coder/knowhow.en.md`\n```markdown\n- Knows the repo\'s main module boundaries, build commands, and common validation entry points.\n- Prefers tracing call chains and data flow to root cause before choosing an edit point.\n- When interfaces, config, or contracts change, also checks docs, types, and regression impact.\n```\n- `.minds/team/coder/pitfalls.en.md`\n```markdown\n- Do not patch only the symptom layer; trace the call chain and data flow first.\n- After changing permissions/config, do not skip the corresponding validators; if only "Resolved But Not Yet Cleared" remains, finish with `team_mgmt_clear_problems(...)`.\n- For high-risk changes, do not fan out into a big rewrite immediately; start with a minimal reviewable plan before expansion.\n- When planning or building agentic functionality, do not unconsciously import the traditional software-engineering instinct to \"complete\" unhappy paths with more programmatic fallback logic. For agent-in-the-loop business-process steps, adding more procedural unhappy-path branches should be treated as a negative behavior and a design regression by default, not as extra credit; unlike software-only-in-the-loop business-process steps, it often creates large technical debt while still producing weak business outcomes. Prefer screenshot-based visual confirmation, semantic review, or similar fallback paths that preserve the agent-in-the-loop nature of the step instead.\n```\nMigration note: rtws member files now prefer `knowhow/pitfalls`; they only fall back to legacy `knowledge/lessons` when the new filenames do not exist. Once a new filename exists, only the new file content is injected and the legacy file is ignored. Builtin minds only recognize canonical filenames and do not read legacy aliases. Please rename promptly; after the transition period, a future release will stop recognizing `knowledge/lessons`.\nAuthoring rule: do not add top-level titles that duplicate the system prompt wrapper. The system prompt already adds: `## Persona` / `## Know-How` / `## Pitfalls` (zh template: `## 角色设定` / `## 经验知识` / `## 避坑指南`).',
             'The team mechanism default is long-lived agents (long-lived teammates): `members` is a stable roster of callable teammates, not “on-demand sub-roles”. This is a product mechanism, not a deployment preference.\nTo pick who acts, use `-m/--member <id>` in CLI/TUI.\n`members.<id>.gofor` is a positive routing card for other teammates/humans (≤ 5 lines): write when someone should ask this teammate, what kinds of asks fit, and what help/output to expect.\n`members.<id>.nogo` is an optional negative routing card: write what should not be routed to this teammate and what kind of teammate/path should take it instead. Both fields are external routing metadata; do not dump the member’s own operating rules, work mode, acceptance bar, or full role spec here. Those belong in `.minds/team/<id>/*` or `.minds/team/domains/*.md`.\nBoth fields support three shapes: string (single sentence), YAML list (plain bullets), and YAML object (structured labeled summary; object keys are fully freeform and values must be strings).\nExample (`gofor` / `nogo`):\n```yaml\nmembers:\n  qa_guard:\n    name: QA Guard\n    gofor:\n      - Go to this teammate for pre-release regression gating\n      - Ask this teammate to map high-risk changes and manual checks\n      - Expect a regression verdict, risk list, and recommended next actions\n    nogo:\n      - Do not route net-new feature implementation here\n      - For product copy or information architecture, ask the relevant implementer/designer instead\n```\nExample (object form; rendered in YAML key order, freeform keys):\n```yaml\nmembers:\n  coordinator:\n    name: Coordinator\n    gofor:\n      When: when you need cross-member coordination, task breakdown, or result convergence\n      Ask: route requests, split work, and integrate outcomes\n      Returns: an execution plan, delegation decisions, and acceptance conclusions\n    nogo:\n      Avoid: do not route concrete implementation, test-authoring, or doc-writing directly here\n      RouteTo: send those asks to the relevant specialist teammate instead\n      Note: put the member’s own operating rules in persona/knowhow/pitfalls instead\n```\nIf you write the same structured content as a YAML list like `- When: ...` / `- Ask: ...` or `- Avoid: ...` / `- RouteTo: ...`, it is still accepted, but `team_mgmt_validate_team_cfg({})` will warn and suggest YAML object form for readability.',
             'Per-role default models: set global defaults via `member_defaults.provider/model`, then override `members.<id>.provider/model` per member (e.g. use `gpt-5.2` by default, and `gpt-5.2-codex` for code-writing members).',
@@ -3635,7 +3635,7 @@ function renderMindsManual(language) {
                 '推荐实践（建议默认采用）：每个 `members.<id>` 同时维护 `persona.*.md` / `knowhow.*.md` / `pitfalls.*.md`，把角色设定、正向知识/经验沉淀、负向教训/避坑规则分层管理。',
                 '共同去向（按当前实现）：这三类文件会在每次对话开始时按工作语言读取，并分别拼进 system prompt 的 `## 角色设定` / `## 经验知识` / `## 避坑指南` 章节；它们是写给“当前成员智能体自己”看的长期提示，不是给团队管理者/人类旁观者读的人物简介。',
                 '硬边界：`persona.*.md` / `knowhow.*.md` / `pitfalls.*.md` 是角色级长期定义资产，更像“角色宪章”，不是成员自己的日常经验仓库。只有稳定职责、长期工作方法、高复用判断原则、持久有效的正反例，才适合写进这些文件。',
-                '推荐分流：角色职责/边界/长期方法论 -> `persona/knowhow/pitfalls`；成员个人长期可复用经验与个人工作索引 -> `personal_memory`（推荐配给时同步配 `skills` 与 `resources` 工具集）；需要向全队同步的当前有效状态、关键决策、下一步与仍成立阻塞 -> Taskdoc `progress`（准实时任务公告牌）；个人/当前对话短期工作集、接续包、临时 bridge 细节 -> reminders；团队共享长期约定/不变量 -> `team_memory`。',
+                '推荐分流：角色职责/边界/长期方法论 -> `persona/knowhow/pitfalls`；成员个人长期可复用经验与个人工作索引 -> `personal_memory`（推荐配给时同步配 `skills` 与 `resources` 工具集）；需要向全队同步的当前有效状态、关键决策、下一步与仍成立阻塞 -> Taskdoc `progress`（准实时任务公告牌）；个人/当前对话短期手头工作、接续包、临时 bridge 细节 -> reminders；团队共享长期约定/不变量 -> `team_memory`。',
                 '最小要求：每个 `members.<id>` 建议至少提供 `persona.*.md`。当前实现中，缺失 persona 时会回退到内置默认 persona 文案；缺失或空白的 knowhow/pitfalls 会在系统提示中以本地化的“无”占位显示。',
                 'persona.*.md：角色设定（稳定的工作方式与职责）。它会进入该成员的 `role=system` 提示，因此默认应直接写给该智能体本人，使用第二人称“你”来规定职责、边界与工作方式；不要把它写成第三人称人物简介，更不要使用“祂”这类旁白口吻。',
                 'knowhow.*.md：正向知识/经验沉淀。它会进入 `## 经验知识`，适合写“当前成员在该职责下反复要用到的稳定事实 / 索引 / 约定 / 判断依据 / 已验证有效的方法”；更偏向帮助该成员复用长期适用的做法，而不是把“最近一次排障过程”或“今天查到的某个链接”原样堆进去。只有当这类材料已经上升为长期适用的方法、索引或判断规则时，才值得写入。',
@@ -3679,7 +3679,7 @@ function renderMindsManual(language) {
             'Recommended default practice: for each `members.<id>`, maintain `persona.*.md` / `knowhow.*.md` / `pitfalls.*.md` together so persona, positive knowledge accumulation, and negative lessons/traps stay layered and maintainable.',
             'Shared destination (current implementation): these three files are read at every dialog start and are spliced into the system prompt as `## Persona` / `## Know-How` / `## Pitfalls`. They are long-lived prompt assets written for the current member agent itself, not operator-facing biographies for a team manager or human observer.',
             'Hard boundary: `persona.*.md` / `knowhow.*.md` / `pitfalls.*.md` are role-level long-lived definition assets, closer to a “role charter” than to a personal notebook. Only stable responsibilities, long-lived working methods, highly reusable judgment rules, and durable positive/negative examples belong here.',
-            'Recommended split: role responsibilities/boundaries/long-lived methodology -> `persona/knowhow/pitfalls`; a member’s own long-lived reusable experience and working index -> `personal_memory` (when recommended, grant `skills` and `resources` alongside it); current effective state, key decisions, next steps, and still-active blockers that the team must synchronize on -> Taskdoc `progress` (the quasi-real-time task bulletin board); personal/current-dialog short-term working set, continuation details, and temporary bridge notes -> reminders; team-shared long-lived conventions/invariants -> `team_memory`.',
+            'Recommended split: role responsibilities/boundaries/long-lived methodology -> `persona/knowhow/pitfalls`; a member’s own long-lived reusable experience and working index -> `personal_memory` (when recommended, grant `skills` and `resources` alongside it); current effective state, key decisions, next steps, and still-active blockers that the team must synchronize on -> Taskdoc `progress` (the quasi-real-time task bulletin board); personal/current-dialog short-term current work, continuation details, and temporary bridge notes -> reminders; team-shared long-lived conventions/invariants -> `team_memory`.',
             'Minimum: for each `members.<id>`, provide at least `persona.*.md`. In the current implementation, a missing persona falls back to built-in default persona text, while missing/blank knowhow and pitfalls render as the localized “none” placeholder.',
             'persona.*.md: persona and operating style. It is injected into that member\'s `role=system` prompt, so write it directly to the agent in second person ("you") when specifying responsibilities, boundaries, and working style; do not turn it into a third-person biography.',
             'knowhow.*.md: positive knowledge / proven know-how. It lands in `## Know-How`, so use it for stable facts, indexes, conventions, decision cues, and validated methods that the member repeatedly reuses in this responsibility. Do not dump raw “latest debugging notes” or a link you found today unless it has already been distilled into a long-lived method, index, or judgment rule.',
@@ -3882,7 +3882,7 @@ function renderPrimingManual(language) {
         return (fmtHeader('.minds/priming/*（启动脚本）') +
             fmtList([
                 '目录约定：个人脚本放在 `.minds/priming/individual/<member-id>/<slug>.md`；团队共享脚本放在 `.minds/priming/team_shared/<slug>.md`。',
-                '脚本语义（按当前实现）：创建对话时，frontmatter 里的 `reminders` 会先恢复为该对话的提醒状态；随后脚本 records 会被追加进持久化事件流，并尽可能回放成真正的对话历史消息。它不是 system prompt，也不是只读日志，而是可编辑的“起手历史/行为引导层”。',
+                '脚本语义（按当前实现）：创建对话时，frontmatter 里的 `reminders` 会按 `scope` 分流：`dialog` 恢复为该对话本地提醒，`task` 写入当前差遣牒任务的持久提醒，`agent` / `runtime` 写入该成员的全局提醒；随后脚本 records 会被追加进持久化事件流，并尽可能回放成真正的对话历史消息。它不是 system prompt，也不是只读日志，而是可编辑的“起手历史/行为引导层”。',
                 '推荐格式：`frontmatter + record 块`。每个 `### record <type>` 对应一个持久化事件（去掉 `ts`），可忠实复原 tool 记录与 call-id 等技术细节。',
                 '口吻规则取决于 record 类型，而不是统一写成一种旁白：`human_text_record` 会变成 `role=user` 的 prompting message，应写成“用户/诉请者正在对这个智能体说的话”；`agent_words_record` 会变成 `role=assistant` 的可见回复，应写成“这个智能体已经说出口的话”；`agent_thought_record` 会变成 thinking message，只适合非常克制地承载内部推理痕迹，不适合拿来写通用制度说明。',
                 '`func_call_record` / `func_result_record` / tellask 相关 records 属于技术回放层：如果要保留，就应写真实调用名、参数、结果与关联 id，而不是随手写一段 prose 摘要来冒充工具历史。',
@@ -3890,7 +3890,7 @@ function renderPrimingManual(language) {
                 '严格约束：不支持 `### user` / `### assistant` 旧写法。',
                 '`func_call_record` 使用三反引号 `json`；其余 record 建议使用 6 重反引号 markdown block（避免与正文三反引号冲突）。',
                 '建议在 frontmatter 里维护 `title`、`applicableMemberIds` 等元数据；`team_shared` 脚本可用 `applicableMemberIds` 控制适用成员。',
-                'frontmatter.reminders 的写法也要遵循 reminder 语义：内容应短小、像工作集提示，不要塞成长文手册；若省略 `scope`，当前实现默认是 `dialog`；只有明确希望后续对话也继续可见时，才使用 `personal` 或 `agent_shared`。',
+                'frontmatter.reminders 的写法也要遵循 reminder 语义：内容应短小、像手头工作提示，不要塞成长文手册；若省略 `scope`，当前实现默认是 `task`；只对当前对话有效时用 `dialog`；紧急、短期、全局刺眼提醒才用 `agent`；`runtime` 仅供系统维护的提醒使用。',
                 '维护原则：允许任意编辑/重写脚本内容，包括新增或改写 assistant 消息，以引导期望行为（而不是拘泥于历史实录）。',
                 '每次修改 `.minds/priming/**` 后，建议运行 `team_mgmt_validate_priming_scripts({})` 做格式/路径校验。',
                 'WebUI 支持把“当前 course 历史”直接导出为个人启动脚本；导出后应由团队管理者审阅并按团队规范再编辑。',
@@ -3931,7 +3931,7 @@ function renderPrimingManual(language) {
     return (fmtHeader('.minds/priming/* (startup scripts)') +
         fmtList([
             'Directory convention: individual scripts live at `.minds/priming/individual/<member-id>/<slug>.md`; team-shared scripts live at `.minds/priming/team_shared/<slug>.md`.',
-            'Script semantics (current implementation): at dialog creation, frontmatter `reminders` are restored into dialog reminder state first; then records are appended to the persisted event stream and replayed into dialog history when possible. A priming script is not system prompt text and not a read-only log; it is an editable “startup history / behavior-guidance” asset.',
+            "Script semantics (current implementation): at dialog creation, frontmatter `reminders` are routed by `scope`: `dialog` restores into dialog-local reminder state, `task` writes to the current task's persisted reminders, and `agent` / `runtime` write to the member-wide reminder set; then records are appended to the persisted event stream and replayed into dialog history when possible. A priming script is not system prompt text and not a read-only log; it is an editable “startup history / behavior-guidance” asset.",
             'Recommended format: `frontmatter + record blocks`. Each `### record <type>` maps to one persisted event (without `ts`) for faithful replay, including tool records and call-id links.',
             'Tone depends on record type, not on one narrator voice: `human_text_record` becomes a `role=user` prompting message, so write it as what the user is saying to the agent; `agent_words_record` becomes a visible `role=assistant` reply, so write it as words the agent has already said; `agent_thought_record` becomes a thinking message and should be used sparingly, not as a place for general policy prose.',
             '`func_call_record` / `func_result_record` / tellask-related records are technical replay artifacts. Keep real call names, arguments, results, and linked ids if you include them; do not replace them with loose prose summaries.',
@@ -3939,7 +3939,7 @@ function renderPrimingManual(language) {
             'Strict rule: legacy `### user` / `### assistant` sections are not supported.',
             '`func_call_record` uses triple-backtick `json`; other records should use six-backtick markdown blocks to avoid nested-fence collisions.',
             'Use frontmatter for metadata like `title` and `applicableMemberIds`; for `team_shared`, `applicableMemberIds` narrows applicability.',
-            'frontmatter.reminders should follow reminder semantics too: keep them short like working-set prompts rather than mini-manuals. If `scope` is omitted, the current implementation defaults it to `dialog`; use `personal` / `agent_shared` only when you intentionally want later dialogs to keep seeing the reminder.',
+            'frontmatter.reminders should follow reminder semantics too: keep them short like current-work prompts rather than mini-manuals. If `scope` is omitted, the current implementation defaults it to `task`; use `dialog` for truly dialog-local notes; use `agent` only for urgent, short-lived, globally visible cues; `runtime` is reserved for system-maintained reminders.',
             'Maintenance principle: freely edit or fully rewrite scripts, including assistant messages, to shape expected behavior.',
             'After each edit under `.minds/priming/**`, run `team_mgmt_validate_priming_scripts({})` for format/path validation.',
             'WebUI can export current-course history into an individual startup script; team managers should review and refine exported scripts.',

package/dist/tools/txt.d.ts

@@ -33,6 +33,40 @@ export declare const readFileTool: {
     argsValidation: "dominds";
     call: (dlg: import("../dialog").Dialog, caller: import("../team").Team.Member, args: ToolArguments) => Promise<ToolCallOutput>;
 };
+export declare const fsReadFileTool: {
+    type: "func";
+    name: string;
+    description: string;
+    descriptionI18n: {
+        en: string;
+        zh: string;
+    };
+    parameters: {
+        type: string;
+        additionalProperties: boolean;
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            range: {
+                type: string;
+                description: string;
+            };
+            max_lines: {
+                type: string;
+                description: string;
+            };
+            show_linenos: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    argsValidation: "dominds";
+    call: (_dlg: import("../dialog").Dialog, _caller: import("../team").Team.Member, args: ToolArguments) => Promise<ToolCallOutput>;
+};
 export declare const createNewFileTool: FuncTool;
 export declare const overwriteEntireFileTool: FuncTool;
 export declare const prepareFileRangeEditTool: FuncTool;

package/dist/tools/txt.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareFileAppendTool = exports.prepareFileBlockReplaceTool = exports.applyFileModificationTool = exports.prepareFileInsertBeforeTool = exports.prepareFileInsertAfterTool = exports.prepareFileRangeEditTool = exports.overwriteEntireFileTool = exports.createNewFileTool = exports.readFileTool = void 0;
+exports.prepareFileAppendTool = exports.prepareFileBlockReplaceTool = exports.applyFileModificationTool = exports.prepareFileInsertBeforeTool = exports.prepareFileInsertAfterTool = exports.prepareFileRangeEditTool = exports.overwriteEntireFileTool = exports.createNewFileTool = exports.fsReadFileTool = exports.readFileTool = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 const fs_1 = __importDefault(require("fs"));
 const promises_1 = __importDefault(require("fs/promises"));
@@ -25,6 +25,12 @@ function ensureInsideWorkspace(rel) {
     }
     return file;
 }
+function resolveLocalFilesystemPath(inputPath) {
+    return path_1.default.resolve(process.cwd(), inputPath);
+}
+function displayLocalFilesystemPath(inputPath, absPath) {
+    return path_1.default.isAbsolute(inputPath) ? absPath : inputPath;
+}
 function normalizeFileWriteBody(inputBody) {
     if (inputBody === '' || inputBody.endsWith('\n')) {
         return { normalizedBody: inputBody, addedTrailingNewlineToContent: false };
@@ -773,6 +779,220 @@ exports.readFileTool = {
         }
     },
 };
+exports.fsReadFileTool = {
+    type: 'func',
+    name: 'fs_read_file',
+    description: 'Read a bounded local filesystem text file without restricting paths to rtws (runtime workspace).',
+    descriptionI18n: {
+        en: 'Read a bounded local filesystem text file without restricting paths to rtws (runtime workspace).',
+        zh: '读取本机文件系统文本文件（有上限/可截断），不限制路径必须位于 rtws（运行时工作区）内。',
+    },
+    parameters: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            path: {
+                type: 'string',
+                description: 'File path. Absolute paths are accepted; relative paths resolve from the current process cwd.',
+            },
+            range: {
+                type: 'string',
+                description: "Optional line range string: '10~50' | '300~' | '~20' | '~' (1-based, inclusive).",
+            },
+            max_lines: { type: 'integer', description: 'Max lines to show (default: 500).' },
+            show_linenos: {
+                type: 'boolean',
+                description: 'Whether to show line numbers (default: true).',
+            },
+        },
+        required: ['path'],
+    },
+    argsValidation: 'dominds',
+    call: async (_dlg, _caller, args) => {
+        const language = (0, work_language_1.getWorkLanguage)();
+        const labels = language === 'zh'
+            ? {
+                formatError: '请使用正确的函数工具参数调用 `fs_read_file`。\n\n' +
+                    '**期望格式：** `fs_read_file({ path, range, max_lines, show_linenos })`\n\n' +
+                    '注意：`path` 可为绝对路径，或相对当前进程 cwd 的路径；可选字段可直接省略。若你显式传入“未指定/默认”，可使用：`range: ""`（不指定范围）、`max_lines: 0`（默认 500）。',
+                formatErrorWithReason: (msg) => `❌ **错误：** ${msg}\n\n请使用正确的函数工具参数调用 \`fs_read_file\`。`,
+                fileLabel: '文件',
+                warningTruncatedByMaxLines: (shown, maxLines) => `⚠️ **警告：** 输出已截断（最多显示 ${maxLines} 行，当前显示 ${shown} 行）\n\n`,
+                warningTruncatedByCharLimit: (shown, maxChars) => `⚠️ **警告：** 输出已截断（字符总数上限约 ${maxChars}，当前显示 ${shown} 行）\n\n`,
+                warningTruncatedByMaxLinesWithRange: (maxLines, rangeLines, used) => `⚠️ **警告：** 输出将被 \`max_lines\`（${maxLines}）截断：\`range\` 共 ${rangeLines} 行，仅返回前 ${used} 行。\n\n`,
+                hintUseRangeNext: (filePath, start, end) => `💡 **提示：** 可继续调用 \`fs_read_file\` 读取下一段，例如：\`fs_read_file({ "path": "${filePath}", "range": "${start}~${end}", "max_lines": 0, "show_linenos": true })\`\n\n`,
+                hintLargeFileStrategy: (filePath) => `💡 **大文件策略：** 建议分多程分析，每程读取一段并整理接续信息，再继续读取下一段（例如：\`fs_read_file({ "path": "${filePath}", "range": "1~500", "max_lines": 0, "show_linenos": true })\`）。\n\n`,
+                sizeLabel: '大小',
+                totalLinesLabel: '总行数',
+                emptyFileLabel: '<空文件>',
+                failedToRead: (msg) => `❌ **错误**\n\n读取文件失败：${msg}`,
+                invalidFormatMultiToolCalls: (toolName) => `INVALID_FORMAT：检测到疑似把多个工具调用文本混入了 \`fs_read_file\` 的输入（例如出现 \`${toolName}\`）。\n\n请把不同工具拆分为独立调用。`,
+            }
+            : {
+                formatError: 'Please call the function tool `fs_read_file` with valid arguments.\n\n' +
+                    '**Expected:** `fs_read_file({ path, range, max_lines, show_linenos })`\n\n' +
+                    'Note: `path` may be absolute or relative to the current process cwd. Optional fields can be omitted. If you explicitly pass “unset/default”, use `range: ""` (unset range) and `max_lines: 0` (default 500).',
+                formatErrorWithReason: (msg) => `❌ **Error:** ${msg}\n\nPlease call the function tool \`fs_read_file\` with valid arguments.`,
+                fileLabel: 'File',
+                warningTruncatedByMaxLines: (shown, maxLines) => `⚠️ **Warning:** Output was truncated (max ${maxLines} lines; showing ${shown})\n\n`,
+                warningTruncatedByCharLimit: (shown, maxChars) => `⚠️ **Warning:** Output was truncated (~${maxChars} character cap; showing ${shown} lines)\n\n`,
+                warningTruncatedByMaxLinesWithRange: (maxLines, rangeLines, used) => `⚠️ **Warning:** Output will be truncated by \`max_lines\` (${maxLines}): \`range\` has ${rangeLines} lines; returning only the first ${used}.\n\n`,
+                hintUseRangeNext: (filePath, start, end) => `💡 **Hint:** Call \`fs_read_file\` again to continue reading, e.g. \`fs_read_file({ "path": "${filePath}", "range": "${start}~${end}", "max_lines": 0, "show_linenos": true })\`\n\n`,
+                hintLargeFileStrategy: (filePath) => `💡 **Large file strategy:** Analyze in slices and continue with another \`fs_read_file\` range, e.g. \`fs_read_file({ "path": "${filePath}", "range": "1~500", "max_lines": 0, "show_linenos": true })\`.\n\n`,
+                sizeLabel: 'Size',
+                totalLinesLabel: 'Total lines',
+                emptyFileLabel: '<empty file>',
+                failedToRead: (msg) => `❌ **Error**\n\nFailed to read file: ${msg}`,
+                invalidFormatMultiToolCalls: (toolName) => `INVALID_FORMAT: Detected what looks like function tool call text mixed into \`fs_read_file\` input (e.g. \`${toolName}\`).\n\nSplit different tools into separate calls.`,
+            };
+        const errorMsg = (zh, en) => (language === 'zh' ? zh : en);
+        const pathValue = args['path'];
+        if (typeof pathValue !== 'string' || pathValue.trim() === '') {
+            return (0, tool_1.toolFailure)(labels.formatError);
+        }
+        const requestedPath = pathValue.trim();
+        const absPath = resolveLocalFilesystemPath(requestedPath);
+        const displayPath = displayLocalFilesystemPath(requestedPath, absPath);
+        const showLinenosValue = args['show_linenos'];
+        const showLinenos = showLinenosValue === undefined
+            ? true
+            : typeof showLinenosValue === 'boolean'
+                ? showLinenosValue
+                : null;
+        if (showLinenos === null) {
+            return (0, tool_1.toolFailure)(labels.formatErrorWithReason(errorMsg('`show_linenos` 必须是 boolean', '`show_linenos` must be a boolean')));
+        }
+        const maxLinesValue = args['max_lines'];
+        const maxLinesSpecified = maxLinesValue !== undefined && maxLinesValue !== 0;
+        const maxLines = maxLinesValue === undefined || maxLinesValue === 0
+            ? 500
+            : typeof maxLinesValue === 'number' && Number.isInteger(maxLinesValue) && maxLinesValue > 0
+                ? maxLinesValue
+                : null;
+        if (maxLines === null) {
+            return (0, tool_1.toolFailure)(labels.formatErrorWithReason(errorMsg('`max_lines` 必须是正整数（或传 0 表示默认值）', '`max_lines` must be a positive integer (or 0 for default)')));
+        }
+        const rangeValue = args['range'];
+        const rangeStr = rangeValue === undefined ? '' : typeof rangeValue === 'string' ? rangeValue.trim() : null;
+        if (rangeStr === null) {
+            return (0, tool_1.toolFailure)(labels.formatErrorWithReason(errorMsg('`range` 必须是 string（传 "" 表示不指定）', '`range` must be a string (use "" for unset)')));
+        }
+        const rangeSpecified = rangeStr !== '';
+        const detectMultiToolCalls = (input) => {
+            const trimmed = input.trimEnd();
+            const lines = trimmed.split(/\r?\n/);
+            if (lines.length <= 1)
+                return null;
+            const suspicious = lines.slice(1).find((l) => l.trimStart().startsWith('@'));
+            if (!suspicious)
+                return null;
+            return suspicious.trimStart().split(/\s+/)[0] ?? null;
+        };
+        const suspiciousTool = detectMultiToolCalls(requestedPath) ??
+            (rangeSpecified ? detectMultiToolCalls(rangeStr) : null);
+        if (suspiciousTool) {
+            return (0, tool_1.toolFailure)(labels.invalidFormatMultiToolCalls(suspiciousTool));
+        }
+        const options = { decorateLinenos: showLinenos, maxLines };
+        if (rangeSpecified) {
+            const match = rangeStr.match(/^(\d+)?~(\d+)?$/);
+            if (!match) {
+                return (0, tool_1.toolFailure)(labels.formatErrorWithReason(errorMsg('`range` 无效（期望："start~end" / "start~" / "~end" / "~"）', 'Invalid `range` (expected "start~end" / "start~" / "~end" / "~")')));
+            }
+            const [, startStr, endStr] = match;
+            if (startStr) {
+                const start = Number.parseInt(startStr, 10);
+                if (!Number.isFinite(start) || start <= 0) {
+                    return (0, tool_1.toolFailure)(labels.formatErrorWithReason(errorMsg('`range` 起始行号无效（必须是正整数）', 'Invalid `range` start (must be a positive integer)')));
+                }
+                options.rangeStart = start;
+            }
+            if (endStr) {
+                const end = Number.parseInt(endStr, 10);
+                if (!Number.isFinite(end) || end <= 0) {
+                    return (0, tool_1.toolFailure)(labels.formatErrorWithReason(errorMsg('`range` 结束行号无效（必须是正整数）', 'Invalid `range` end (must be a positive integer)')));
+                }
+                options.rangeEnd = end;
+            }
+            if (options.rangeStart !== undefined &&
+                options.rangeEnd !== undefined &&
+                options.rangeStart > options.rangeEnd) {
+                return (0, tool_1.toolFailure)(labels.formatErrorWithReason(errorMsg('`range` 无效（start 必须 <= end）', 'Invalid `range` (start must be <= end)')));
+            }
+        }
+        try {
+            const stat = await promises_1.default.stat(absPath);
+            const contentSummary = await readFileContentBounded(absPath, options);
+            const maxLinesRangeMismatch = contentSummary.truncatedByMaxLines &&
+                maxLinesSpecified &&
+                rangeSpecified &&
+                options.rangeEnd !== undefined
+                ? (() => {
+                    const rangeStart = options.rangeStart ?? 1;
+                    const rangeLines = options.rangeEnd - rangeStart + 1;
+                    if (rangeLines > options.maxLines) {
+                        return { maxLines: options.maxLines, rangeLines, used: options.maxLines };
+                    }
+                    return null;
+                })()
+                : null;
+            const headerSummary = language === 'zh'
+                ? `fs_read_file：${displayPath}；size=${stat.size} bytes；total_lines=${contentSummary.totalLines}；shown=${contentSummary.shownLines}.`
+                : `fs_read_file: ${displayPath}; size=${stat.size} bytes; total_lines=${contentSummary.totalLines}; shown=${contentSummary.shownLines}.`;
+            const yaml = [
+                `status: ok`,
+                `mode: fs_read_file`,
+                `path: ${yamlQuote(displayPath)}`,
+                `size_bytes: ${stat.size}`,
+                `total_lines: ${contentSummary.totalLines}`,
+                `shown_lines: ${contentSummary.shownLines}`,
+                `truncated_by_max_lines: ${contentSummary.truncatedByMaxLines}`,
+                `truncated_by_char_limit: ${contentSummary.truncatedByCharLimit}`,
+                `summary: ${yamlQuote(headerSummary)}`,
+            ].join('\n');
+            let markdown = `${formatYamlCodeBlock(yaml)}\n\n`;
+            markdown += `📄 **${labels.fileLabel}:** \`${displayPath}\`\n`;
+            if (maxLinesRangeMismatch) {
+                markdown += labels.warningTruncatedByMaxLinesWithRange(maxLinesRangeMismatch.maxLines, maxLinesRangeMismatch.rangeLines, maxLinesRangeMismatch.used);
+            }
+            if (contentSummary.truncatedByCharLimit) {
+                markdown += labels.warningTruncatedByCharLimit(contentSummary.shownLines, READ_FILE_CONTENT_CHAR_LIMIT);
+            }
+            else if (contentSummary.truncatedByMaxLines && !maxLinesRangeMismatch) {
+                markdown += labels.warningTruncatedByMaxLines(contentSummary.shownLines, options.maxLines);
+            }
+            if ((contentSummary.truncatedByCharLimit || contentSummary.truncatedByMaxLines) &&
+                !maxLinesSpecified &&
+                !rangeSpecified) {
+                const start = contentSummary.shownLines + 1;
+                const end = start + 199;
+                markdown += labels.hintUseRangeNext(displayPath, start, end);
+            }
+            if (contentSummary.truncatedByCharLimit) {
+                markdown += labels.hintLargeFileStrategy(displayPath);
+            }
+            markdown += `**${labels.sizeLabel}:** ${stat.size} bytes\n`;
+            markdown += `**${labels.totalLinesLabel}:** ${contentSummary.totalLines}\n`;
+            if (contentSummary.totalLines === 0) {
+                markdown += `\n${labels.emptyFileLabel}\n`;
+            }
+            markdown += '\n';
+            if (contentSummary.totalLines > 0) {
+                markdown += '```\n';
+                markdown += contentSummary.formattedContent;
+                if (!contentSummary.formattedContent.endsWith('\n')) {
+                    markdown += '\n';
+                }
+                markdown += '```';
+            }
+            return (0, tool_1.toolSuccess)(markdown);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return (0, tool_1.toolFailure)(labels.failedToRead(msg));
+        }
+    },
+};
 const overwriteEntireFileSchema = {
     type: 'object',
     additionalProperties: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.25.0",
+  "version": "1.25.2",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {
@@ -53,8 +53,8 @@
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
     "@longrun-ai/codex-auth": "0.13.0",
-    "@longrun-ai/shell": "1.15.0",
-    "@longrun-ai/kernel": "1.15.0"
+    "@longrun-ai/kernel": "1.15.2",
+    "@longrun-ai/shell": "1.15.2"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",

package/webapp/dist/assets/{_basePickBy-ZLV93S3E.js → _basePickBy-CbWZ8qnS.js}

@@ -1,5 +1,5 @@
-import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-D0wSOJ06.js";
-import { aU as isObject, aC as baseRest, aV as isIterateeCall, aW as keysIn, aX as eq, aY as isArrayLike, aZ as isArray, a_ as identity, a$ as isIndex, b0 as assignValue } from "./index-CDCDAfqP.js";
+import { e as isSymbol, c as baseFlatten, g as baseIteratee, k as keys, h as baseFindIndex, j as baseEach, l as arrayMap, m as hasPath, n as castPath, t as toKey, o as baseGet } from "./_baseUniq-IY-Vfzx1.js";
+import { aR as isObject, aA as baseRest, aS as isIterateeCall, aT as keysIn, aU as eq, aV as isArrayLike, aW as isArray, aX as identity, aY as isIndex, aZ as assignValue } from "./index-arD81Nnh.js";
 var reWhitespace = /\s/;
 function trimmedEndIndex(string) {
   var index = string.length;
@@ -193,4 +193,4 @@ export {
   map as m,
   toFinite as t
 };
-//# sourceMappingURL=_basePickBy-ZLV93S3E.js.map
+//# sourceMappingURL=_basePickBy-CbWZ8qnS.js.map

package/webapp/dist/assets/_basePickBy-CbWZ8qnS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_basePickBy-CbWZ8qnS.js","sources":["../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_trimmedEndIndex.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseTrim.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/toNumber.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/toFinite.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/toInteger.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/flatten.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/defaults.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/last.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createFind.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/findIndex.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/find.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseMap.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/map.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseHas.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/has.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseLt.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseExtremum.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/min.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseSet.js","../../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_basePickBy.js"],"sourcesContent":["/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n  var index = string.length;\n\n  while (index-- && reWhitespace.test(string.charAt(index))) {}\n  return index;\n}\n\nexport default trimmedEndIndex;\n","import trimmedEndIndex from './_trimmedEndIndex.js';\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n  return string\n    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n    : string;\n}\n\nexport default baseTrim;\n","import baseTrim from './_baseTrim.js';\nimport isObject from './isObject.js';\nimport isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = baseTrim(value);\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nexport default toNumber;\n","import toNumber from './toNumber.js';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n    MAX_INTEGER = 1.7976931348623157e+308;\n\n/**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\nfunction toFinite(value) {\n  if (!value) {\n    return value === 0 ? value : 0;\n  }\n  value = toNumber(value);\n  if (value === INFINITY || value === -INFINITY) {\n    var sign = (value < 0 ? -1 : 1);\n    return sign * MAX_INTEGER;\n  }\n  return value === value ? value : 0;\n}\n\nexport default toFinite;\n","import toFinite from './toFinite.js';\n\n/**\n * Converts `value` to an integer.\n *\n * **Note:** This method is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\nfunction toInteger(value) {\n  var result = toFinite(value),\n      remainder = result % 1;\n\n  return result === result ? (remainder ? result - remainder : result) : 0;\n}\n\nexport default toInteger;\n","import baseFlatten from './_baseFlatten.js';\n\n/**\n * Flattens `array` a single level deep.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to flatten.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * _.flatten([1, [2, [3, [4]], 5]]);\n * // => [1, 2, [3, [4]], 5]\n */\nfunction flatten(array) {\n  var length = array == null ? 0 : array.length;\n  return length ? baseFlatten(array, 1) : [];\n}\n\nexport default flatten;\n","import baseRest from './_baseRest.js';\nimport eq from './eq.js';\nimport isIterateeCall from './_isIterateeCall.js';\nimport keysIn from './keysIn.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns own and inherited enumerable string keyed properties of source\n * objects to the destination object for all destination properties that\n * resolve to `undefined`. Source objects are applied from left to right.\n * Once a property is set, additional values of the same property are ignored.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @see _.defaultsDeep\n * @example\n *\n * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n * // => { 'a': 1, 'b': 2 }\n */\nvar defaults = baseRest(function(object, sources) {\n  object = Object(object);\n\n  var index = -1;\n  var length = sources.length;\n  var guard = length > 2 ? sources[2] : undefined;\n\n  if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n    length = 1;\n  }\n\n  while (++index < length) {\n    var source = sources[index];\n    var props = keysIn(source);\n    var propsIndex = -1;\n    var propsLength = props.length;\n\n    while (++propsIndex < propsLength) {\n      var key = props[propsIndex];\n      var value = object[key];\n\n      if (value === undefined ||\n          (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n        object[key] = source[key];\n      }\n    }\n  }\n\n  return object;\n});\n\nexport default defaults;\n","/**\n * Gets the last element of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to query.\n * @returns {*} Returns the last element of `array`.\n * @example\n *\n * _.last([1, 2, 3]);\n * // => 3\n */\nfunction last(array) {\n  var length = array == null ? 0 : array.length;\n  return length ? array[length - 1] : undefined;\n}\n\nexport default last;\n","import baseIteratee from './_baseIteratee.js';\nimport isArrayLike from './isArrayLike.js';\nimport keys from './keys.js';\n\n/**\n * Creates a `_.find` or `_.findLast` function.\n *\n * @private\n * @param {Function} findIndexFunc The function to find the collection index.\n * @returns {Function} Returns the new find function.\n */\nfunction createFind(findIndexFunc) {\n  return function(collection, predicate, fromIndex) {\n    var iterable = Object(collection);\n    if (!isArrayLike(collection)) {\n      var iteratee = baseIteratee(predicate, 3);\n      collection = keys(collection);\n      predicate = function(key) { return iteratee(iterable[key], key, iterable); };\n    }\n    var index = findIndexFunc(collection, predicate, fromIndex);\n    return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;\n  };\n}\n\nexport default createFind;\n","import baseFindIndex from './_baseFindIndex.js';\nimport baseIteratee from './_baseIteratee.js';\nimport toInteger from './toInteger.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * This method is like `_.find` except that it returns the index of the first\n * element `predicate` returns truthy for instead of the element itself.\n *\n * @static\n * @memberOf _\n * @since 1.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param {number} [fromIndex=0] The index to search from.\n * @returns {number} Returns the index of the found element, else `-1`.\n * @example\n *\n * var users = [\n *   { 'user': 'barney',  'active': false },\n *   { 'user': 'fred',    'active': false },\n *   { 'user': 'pebbles', 'active': true }\n * ];\n *\n * _.findIndex(users, function(o) { return o.user == 'barney'; });\n * // => 0\n *\n * // The `_.matches` iteratee shorthand.\n * _.findIndex(users, { 'user': 'fred', 'active': false });\n * // => 1\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.findIndex(users, ['active', false]);\n * // => 0\n *\n * // The `_.property` iteratee shorthand.\n * _.findIndex(users, 'active');\n * // => 2\n */\nfunction findIndex(array, predicate, fromIndex) {\n  var length = array == null ? 0 : array.length;\n  if (!length) {\n    return -1;\n  }\n  var index = fromIndex == null ? 0 : toInteger(fromIndex);\n  if (index < 0) {\n    index = nativeMax(length + index, 0);\n  }\n  return baseFindIndex(array, baseIteratee(predicate, 3), index);\n}\n\nexport default findIndex;\n","import createFind from './_createFind.js';\nimport findIndex from './findIndex.js';\n\n/**\n * Iterates over elements of `collection`, returning the first element\n * `predicate` returns truthy for. The predicate is invoked with three\n * arguments: (value, index|key, collection).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param {number} [fromIndex=0] The index to search from.\n * @returns {*} Returns the matched element, else `undefined`.\n * @example\n *\n * var users = [\n *   { 'user': 'barney',  'age': 36, 'active': true },\n *   { 'user': 'fred',    'age': 40, 'active': false },\n *   { 'user': 'pebbles', 'age': 1,  'active': true }\n * ];\n *\n * _.find(users, function(o) { return o.age < 40; });\n * // => object for 'barney'\n *\n * // The `_.matches` iteratee shorthand.\n * _.find(users, { 'age': 1, 'active': true });\n * // => object for 'pebbles'\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.find(users, ['active', false]);\n * // => object for 'fred'\n *\n * // The `_.property` iteratee shorthand.\n * _.find(users, 'active');\n * // => object for 'barney'\n */\nvar find = createFind(findIndex);\n\nexport default find;\n","import baseEach from './_baseEach.js';\nimport isArrayLike from './isArrayLike.js';\n\n/**\n * The base implementation of `_.map` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction baseMap(collection, iteratee) {\n  var index = -1,\n      result = isArrayLike(collection) ? Array(collection.length) : [];\n\n  baseEach(collection, function(value, key, collection) {\n    result[++index] = iteratee(value, key, collection);\n  });\n  return result;\n}\n\nexport default baseMap;\n","import arrayMap from './_arrayMap.js';\nimport baseIteratee from './_baseIteratee.js';\nimport baseMap from './_baseMap.js';\nimport isArray from './isArray.js';\n\n/**\n * Creates an array of values by running each element in `collection` thru\n * `iteratee`. The iteratee is invoked with three arguments:\n * (value, index|key, collection).\n *\n * Many lodash methods are guarded to work as iteratees for methods like\n * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.\n *\n * The guarded methods are:\n * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,\n * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,\n * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,\n * `template`, `trim`, `trimEnd`, `trimStart`, and `words`\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n * @example\n *\n * function square(n) {\n *   return n * n;\n * }\n *\n * _.map([4, 8], square);\n * // => [16, 64]\n *\n * _.map({ 'a': 4, 'b': 8 }, square);\n * // => [16, 64] (iteration order is not guaranteed)\n *\n * var users = [\n *   { 'user': 'barney' },\n *   { 'user': 'fred' }\n * ];\n *\n * // The `_.property` iteratee shorthand.\n * _.map(users, 'user');\n * // => ['barney', 'fred']\n */\nfunction map(collection, iteratee) {\n  var func = isArray(collection) ? arrayMap : baseMap;\n  return func(collection, baseIteratee(iteratee, 3));\n}\n\nexport default map;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.has` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\nfunction baseHas(object, key) {\n  return object != null && hasOwnProperty.call(object, key);\n}\n\nexport default baseHas;\n","import baseHas from './_baseHas.js';\nimport hasPath from './_hasPath.js';\n\n/**\n * Checks if `path` is a direct property of `object`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = { 'a': { 'b': 2 } };\n * var other = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.has(object, 'a');\n * // => true\n *\n * _.has(object, 'a.b');\n * // => true\n *\n * _.has(object, ['a', 'b']);\n * // => true\n *\n * _.has(other, 'a');\n * // => false\n */\nfunction has(object, path) {\n  return object != null && hasPath(object, path, baseHas);\n}\n\nexport default has;\n","/**\n * The base implementation of `_.lt` which doesn't coerce arguments.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if `value` is less than `other`,\n *  else `false`.\n */\nfunction baseLt(value, other) {\n  return value < other;\n}\n\nexport default baseLt;\n","import isSymbol from './isSymbol.js';\n\n/**\n * The base implementation of methods like `_.max` and `_.min` which accepts a\n * `comparator` to determine the extremum value.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} iteratee The iteratee invoked per iteration.\n * @param {Function} comparator The comparator used to compare values.\n * @returns {*} Returns the extremum value.\n */\nfunction baseExtremum(array, iteratee, comparator) {\n  var index = -1,\n      length = array.length;\n\n  while (++index < length) {\n    var value = array[index],\n        current = iteratee(value);\n\n    if (current != null && (computed === undefined\n          ? (current === current && !isSymbol(current))\n          : comparator(current, computed)\n        )) {\n      var computed = current,\n          result = value;\n    }\n  }\n  return result;\n}\n\nexport default baseExtremum;\n","import baseExtremum from './_baseExtremum.js';\nimport baseLt from './_baseLt.js';\nimport identity from './identity.js';\n\n/**\n * Computes the minimum value of `array`. If `array` is empty or falsey,\n * `undefined` is returned.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Math\n * @param {Array} array The array to iterate over.\n * @returns {*} Returns the minimum value.\n * @example\n *\n * _.min([4, 2, 8, 6]);\n * // => 2\n *\n * _.min([]);\n * // => undefined\n */\nfunction min(array) {\n  return (array && array.length)\n    ? baseExtremum(array, identity, baseLt)\n    : undefined;\n}\n\nexport default min;\n","import assignValue from './_assignValue.js';\nimport castPath from './_castPath.js';\nimport isIndex from './_isIndex.js';\nimport isObject from './isObject.js';\nimport toKey from './_toKey.js';\n\n/**\n * The base implementation of `_.set`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @param {Function} [customizer] The function to customize path creation.\n * @returns {Object} Returns `object`.\n */\nfunction baseSet(object, path, value, customizer) {\n  if (!isObject(object)) {\n    return object;\n  }\n  path = castPath(path, object);\n\n  var index = -1,\n      length = path.length,\n      lastIndex = length - 1,\n      nested = object;\n\n  while (nested != null && ++index < length) {\n    var key = toKey(path[index]),\n        newValue = value;\n\n    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {\n      return object;\n    }\n\n    if (index != lastIndex) {\n      var objValue = nested[key];\n      newValue = customizer ? customizer(objValue, key, nested) : undefined;\n      if (newValue === undefined) {\n        newValue = isObject(objValue)\n          ? objValue\n          : (isIndex(path[index + 1]) ? [] : {});\n      }\n    }\n    assignValue(nested, key, newValue);\n    nested = nested[key];\n  }\n  return object;\n}\n\nexport default baseSet;\n","import baseGet from './_baseGet.js';\nimport baseSet from './_baseSet.js';\nimport castPath from './_castPath.js';\n\n/**\n * The base implementation of  `_.pickBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @param {Function} predicate The function invoked per property.\n * @returns {Object} Returns the new object.\n */\nfunction basePickBy(object, paths, predicate) {\n  var index = -1,\n      length = paths.length,\n      result = {};\n\n  while (++index < length) {\n    var path = paths[index],\n        value = baseGet(object, path);\n\n    if (predicate(value, path)) {\n      baseSet(result, castPath(path, object), value);\n    }\n  }\n  return result;\n}\n\nexport default basePickBy;\n"],"names":["objectProto","hasOwnProperty","collection"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]}

package/webapp/dist/assets/{_baseUniq-D0wSOJ06.js → _baseUniq-IY-Vfzx1.js}

@@ -1,4 +1,4 @@
-import { bh as isObjectLike, bi as baseGetTag, aZ as isArray, bj as Symbol$1, aY as isArrayLike, bk as arrayLikeKeys, bl as baseKeys, bm as memoize, bn as isArguments, bo as copyObject, aW as keysIn, bp as getPrototype, bq as cloneArrayBuffer, br as cloneTypedArray, bs as getTag, bf as baseUnary, bt as nodeUtil, aU as isObject, bu as copyArray, bv as isBuffer, bw as cloneBuffer, bx as initCloneObject, by as Stack, b0 as assignValue, bz as MapCache, aX as eq, bA as Uint8Array, bB as isTypedArray, bC as isLength, a$ as isIndex, a_ as identity, bd as baseFor, bD as Set } from "./index-CDCDAfqP.js";
+import { be as isObjectLike, bf as baseGetTag, aW as isArray, bg as Symbol$1, aV as isArrayLike, bh as arrayLikeKeys, bi as baseKeys, bj as memoize, bk as isArguments, bl as copyObject, aT as keysIn, bm as getPrototype, bn as cloneArrayBuffer, bo as cloneTypedArray, bp as getTag, bc as baseUnary, bq as nodeUtil, aR as isObject, br as copyArray, bs as isBuffer, bt as cloneBuffer, bu as initCloneObject, bv as Stack, aZ as assignValue, bw as MapCache, aU as eq, bx as Uint8Array, by as isTypedArray, bz as isLength, aY as isIndex, aX as identity, ba as baseFor, bA as Set } from "./index-arD81Nnh.js";
 var symbolTag$3 = "[object Symbol]";
 function isSymbol(value) {
   return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag$3;
@@ -833,4 +833,4 @@ export {
   baseIndexOf as y,
   getAllKeysIn as z
 };
-//# sourceMappingURL=_baseUniq-D0wSOJ06.js.map
+//# sourceMappingURL=_baseUniq-IY-Vfzx1.js.map