dominds 1.25.16 → 1.25.18

package/dist/cli/create.d.ts

@@ -10,5 +10,5 @@
  * - Template can be a short name (resolved via DOMINDS_TEMPLATE_BASE) or a git URL.
  * - rtws directory is `process.cwd()`. Use 'dominds -C <dir> create ...' to create under another base dir.
  */
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/create.js

@@ -201,9 +201,9 @@ async function runGit(args, cwd) {
     const detail = res.signal ? `signal ${res.signal}` : `exit code ${String(res.code)}`;
     throw new Error(`git failed (${detail}): ${res.cmd}`);
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     try {
-        const parsed = parseArgs(process.argv.slice(2));
+        const parsed = parseArgs(argv);
         switch (parsed.kind) {
             case 'help':
                 printHelp();

package/dist/cli/disable.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/disable.js

@@ -33,10 +33,10 @@ function parseArgs(argv) {
         throw new Error('disable requires exactly one <appId>');
     return { appId: positional[0] };
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     let args;
     try {
-        args = parseArgs(process.argv.slice(2));
+        args = parseArgs(argv);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));

package/dist/cli/doctor.d.ts

@@ -41,5 +41,5 @@ declare function runDoctor(params: {
     issues: ReadonlyArray<AppsResolutionIssue>;
     diagnoses: ReadonlyArray<AppDiagnosis>;
 }>;
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main, runDoctor };

package/dist/cli/doctor.js

@@ -240,10 +240,10 @@ function printDiagnosis(params) {
         console.log(`    - ${action}`);
     }
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     let args;
     try {
-        args = parseArgs(process.argv.slice(2));
+        args = parseArgs(argv);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));

package/dist/cli/enable.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/enable.js

@@ -33,10 +33,10 @@ function parseArgs(argv) {
         throw new Error('enable requires exactly one <appId>');
     return { appId: positional[0] };
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     let args;
     try {
-        args = parseArgs(process.argv.slice(2));
+        args = parseArgs(argv);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));

package/dist/cli/install.d.ts

@@ -5,5 +5,5 @@
  * Usage:
  *   dominds install <spec|path> [--local] [--id <appId>] [--enable] [--force]
  */
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/install.js

@@ -119,11 +119,11 @@ async function resolveInstallSource(params) {
     }
     return { kind: 'npx', spec: params.specOrPath };
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     const rtwsRootAbs = process.cwd();
     let args;
     try {
-        args = parseArgs(process.argv.slice(2));
+        args = parseArgs(argv);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));

package/dist/cli/manual.d.ts

@@ -11,4 +11,4 @@
  *   dominds man team_mgmt --topics index,tools
  */
 import '../tools/builtins';
-export declare function main(): Promise<void>;
+export declare function main(argv?: readonly string[]): Promise<void>;

package/dist/cli/manual.js

@@ -134,9 +134,9 @@ function listAvailableToolsets() {
     }
     console.log(`Available toolsets: ${names.map((name) => `\`${name}\``).join(', ')}`);
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     try {
-        const parsed = parseArgs(process.argv.slice(2));
+        const parsed = parseArgs(argv);
         if (parsed.list || !parsed.toolsetId) {
             listAvailableToolsets();
             return;

package/dist/cli/read.d.ts

@@ -13,5 +13,5 @@
  *   --find <pattern>     Find case-insensitive text in rendered output
  *   --help               Show help
  */
-declare function main(): Promise<void>;
+declare function main(args?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/read.js

@@ -437,8 +437,7 @@ function resolveTargetMemberIds(team, memberId) {
         throw new Error('No team members found.');
     return [fallback.id];
 }
-async function main() {
-    const args = process.argv.slice(2);
+async function main(args = process.argv.slice(2)) {
     let parsed;
     try {
         parsed = parseArgs(args);

package/dist/cli/tui.d.ts

@@ -14,5 +14,5 @@
  *   -p, --print-only: Non-interactive mode (for automated testing)
  *   --version: Show version information
  */
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/tui.js

@@ -166,10 +166,10 @@ function parseArgs(argv) {
     }
     return out;
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     try {
         (0, process_title_1.setRtwsProcessTitle)();
-        const args = parseArgs(process.argv.slice(2));
+        const args = parseArgs(argv);
         // Handle version flag
         if (args.version) {
             showVersion();

package/dist/cli/uninstall.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/uninstall.js

@@ -48,10 +48,10 @@ function parseArgs(argv) {
         throw new Error('uninstall requires exactly one <appId>');
     return { appId: positional[0], purge };
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     let args;
     try {
-        args = parseArgs(process.argv.slice(2));
+        args = parseArgs(argv);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));

package/dist/cli/update.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-declare function main(): Promise<void>;
+declare function main(argv?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/update.js

@@ -36,10 +36,10 @@ function parseArgs(argv) {
         throw new Error('update accepts at most one <appId>');
     return { appId: positional[0] ?? null };
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     let args;
     try {
-        args = parseArgs(process.argv.slice(2));
+        args = parseArgs(argv);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));

package/dist/cli/validate-team-def.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export declare function main(): Promise<void>;
+export declare function main(argv?: readonly string[]): Promise<void>;

package/dist/cli/validate-team-def.js

@@ -50,10 +50,10 @@ function resolveTargetMemberIds(team, memberId) {
         throw new Error('No team members found.');
     return [fallback.id];
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     let parsed;
     try {
-        parsed = parseArgs(process.argv.slice(2));
+        parsed = parseArgs(argv);
     }
     catch (err) {
         console.error('Error:', err instanceof Error ? err.message : String(err));

package/dist/cli/webui.d.ts

@@ -11,5 +11,5 @@
  *   --nobrowser          Do not open a browser (opt-out)
  *   -h, --help           Show help
  */
-declare function main(): Promise<void>;
+declare function main(args?: readonly string[]): Promise<void>;
 export { main };

package/dist/cli/webui.js

@@ -63,9 +63,8 @@ function openInBrowser(url) {
     }
     (0, child_process_1.spawn)('xdg-open', [url], { stdio: 'ignore', detached: true }).unref();
 }
-async function main() {
+async function main(args = process.argv.slice(2)) {
     (0, process_title_1.setRtwsProcessTitle)();
-    const args = process.argv.slice(2);
     let port;
     let host = 'localhost';
     let mode = process.env.NODE_ENV === 'dev' ? 'dev' : 'prod';

package/dist/cli.d.ts

@@ -29,4 +29,4 @@
  */
 import './tools/builtins';
 export declare function configureEnvProxySupport(): void;
-export declare function main(): Promise<void>;
+export declare function main(argv?: readonly string[]): Promise<void>;

package/dist/cli.js

@@ -158,11 +158,11 @@ function printVersion() {
         console.log('dominds (version unknown)');
     }
 }
-async function main() {
+async function main(argv = process.argv.slice(2)) {
     const baseCwd = process.cwd();
     let parsed;
     try {
-        parsed = (0, rtws_cli_1.extractGlobalRtwsChdir)({ argv: process.argv.slice(2), baseCwd });
+        parsed = (0, rtws_cli_1.extractGlobalRtwsChdir)({ argv, baseCwd });
     }
     catch (err) {
         console.error('Error:', err instanceof Error ? err.message : String(err));
@@ -317,52 +317,46 @@ async function main() {
 async function runSubcommand(subcommand, args) {
     try {
         (0, process_title_1.setRtwsProcessTitle)();
-        // Save original argv
-        const originalArgv = process.argv;
-        // Set argv to simulate direct execution of the subcommand
-        process.argv = ['node', subcommand, ...args];
         if (subcommand === 'webui') {
-            await (0, webui_1.main)();
+            await (0, webui_1.main)(args);
         }
         else if (subcommand === 'tui') {
-            await (0, tui_1.main)();
+            await (0, tui_1.main)(args);
         }
         else if (subcommand === 'read') {
-            await (0, read_1.main)();
+            await (0, read_1.main)(args);
         }
         else if (subcommand === 'manual') {
-            await (0, manual_1.main)();
+            await (0, manual_1.main)(args);
         }
         else if (subcommand === 'validate_team_def') {
-            await (0, validate_team_def_1.main)();
+            await (0, validate_team_def_1.main)(args);
         }
         else if (subcommand === 'create') {
-            await (0, create_1.main)();
+            await (0, create_1.main)(args);
         }
         else if (subcommand === 'install') {
-            await (0, install_1.main)();
+            await (0, install_1.main)(args);
         }
         else if (subcommand === 'doctor') {
-            await (0, doctor_1.main)();
+            await (0, doctor_1.main)(args);
         }
         else if (subcommand === 'enable') {
-            await (0, enable_1.main)();
+            await (0, enable_1.main)(args);
         }
         else if (subcommand === 'disable') {
-            await (0, disable_1.main)();
+            await (0, disable_1.main)(args);
         }
         else if (subcommand === 'uninstall') {
-            await (0, uninstall_1.main)();
+            await (0, uninstall_1.main)(args);
         }
         else if (subcommand === 'update') {
-            await (0, update_1.main)();
+            await (0, update_1.main)(args);
         }
         else {
             console.error(`Error: Subcommand '${subcommand}' not implemented`);
             process.exit(1);
         }
-        // Restore original argv
-        process.argv = originalArgv;
     }
     catch (err) {
         console.error(`Failed to execute subcommand '${subcommand}':`, err);

package/dist/docs/context-health.md

@@ -19,6 +19,10 @@ Dominds already has:
 
 - Collect **token usage stats** from LLM provider wrappers after each generation.
 - Compute a simple **context health** signal from provider stats + model metadata.
+- When the current computed health is `caution` or `critical`, keep large function results from
+  adding more raw material to the next prompt. Large return content is replaced with a
+  scope-specific, low-cognitive-load instruction that tells the agent the output is too large to see
+  before `clear_mind`.
 - When the dialog context is “too large”, enforce a **v3 remediation** workflow that is short,
   executable, and regression-testable:
   - In **caution**, record an auto-inserted **role=user prompt** as a normal, persisted user message
@@ -152,6 +156,34 @@ Rules:
 - Do not duplicate Taskdoc content except for a short bridge when strictly needed.
 - Do not paste long raw logs/tool outputs into the continuation package.
 
+### Large Function Results During Remediation
+
+When the current generation's computed context health is `caution` or `critical`, Dominds applies a
+runtime visibility limit to every ordinary function result before it is persisted back into dialog
+history. If current usage is unavailable, the driver falls back to the previous known context health
+for this visibility decision. This limit only applies to returned content. Function arguments remain
+unrestricted, because large arguments are often the necessary path for preserving current-dialog
+details into Taskdoc sections or reminders.
+
+If a function result is larger than the runtime visibility budget, measured by the total returned
+bytes visible to the model, Dominds does not insert the raw return content into the model context.
+Text is counted as UTF-8 bytes; image items use their recorded byte length. Instead, Dominds inserts
+a short scope-specific message:
+
+- Main Dialog: tell the agent that this function return is too large to see before `clear_mind`,
+  instruct it not to retry the same kind of large output, then tell it to write needed next-course
+  information into Taskdoc sections, preserve any remaining easy-to-lose details in reminders, and
+  call `clear_mind({})`.
+- Side Dialog: tell the agent that this function return is too large to see before `clear_mind`,
+  instruct it not to retry the same kind of large output, then tell it to organize the conclusion,
+  evidence pointers, and risks for the Main Dialog, preserve any easy-to-lose details in reminders,
+  and finish the Side Dialog reply as soon as possible.
+
+The replacement text may include only a short human-scale detail such as the approximate original
+byte count. It must not present the tool invocation as an execution failure: the function may have
+executed and produced side effects; only its large return content is unavailable before
+`clear_mind`.
+
 ### Caution (yellow)
 
 When `level === 'caution'`, the driver auto-inserts a **role=user** guidance prompt into the _next_
@@ -240,7 +272,9 @@ Additional constraints:
 2. Thread usage stats into the dialog state (persist alongside dialog turns).
 3. Implement the context health monitor computation and persist it per generation.
 4. Implement v3 remediation (persisted role=user prompt insertion + caution reminder-curation cadence + critical countdown + auto clear_mind).
-5. Add minimal regression guards for the v3 behavior (types + gating).
+5. Suppress oversized function-return content during `caution` / `critical` remediation while leaving
+   function arguments unrestricted.
+6. Add minimal regression guards for the v3 behavior (types + gating).
 
 ## Acceptance Criteria
 
@@ -265,4 +299,8 @@ Additional constraints:
     then `clear_mind`; Side Dialog prompts instruct detailed reminder curation only, then `clear_mind`.
     When the countdown reaches 0, the driver auto-executes `clear_mind` and starts a new course (no Q4H,
     no suspension).
+- During `caution` / `critical`, any ordinary function result whose returned content exceeds the
+  runtime visibility byte budget is replaced with the scope-specific “too large to see before
+  `clear_mind`” instruction instead of raw output. This is not reported as tool execution failure,
+  and function arguments are not limited.
 - UI shows context health with green/yellow/red (and “unknown” handling when usage is unavailable).

package/dist/docs/context-health.zh.md

@@ -16,6 +16,9 @@ Dominds 已具备以下功能：
 
 - 从 LLM 提供商包装器收集每次生成后的 **token 使用统计**。
 - 从提供商统计 + 模型元数据计算简单的**上下文健康**信号。
+- 当本轮计算出的健康状态为 `caution` / `critical` 时，避免大函数返回继续把原始材料塞进下一轮
+  prompt。过大的返回内容会被替换成按主线/支线定制的低心智负担指令，告诉智能体：清理头脑之
+  前，这类大输出当前不可见。
 - 当对话上下文"过大"时，执行简短的、可执行的、可回归测试的 **v3 恢复**工作流：
   - 在 **caution（警告）** 级别，记录一条自动插入的 **role=user prompt** 作为正常的、持久化的用户消息（UI 可见并渲染为正常的用户指令）。
   - 在 **critical（严重）** 级别，通过**倒计时恢复**（最多 5 轮）强制执行稳定性：
@@ -119,6 +122,28 @@ Dominds 计算比率：
 - 除非确有必要，不要重复差遣牒已覆盖的内容。
 - 不要把长原始日志/大段 tool output 直接塞进接续包。
 
+### 处置态下的大函数返回
+
+当本轮生成计算出的上下文健康为 `caution` 或 `critical` 时，Dominds 在普通函数结果写回对话
+历史前，对返回内容应用运行时可见性上限。如果本轮 usage 不可用，则回退使用上一轮已知上下文健
+康来做这个可见性判断。这个限制只作用于函数返回内容；函数输入不受限制，因为较大的 `do_mind`
+/ `change_mind` / `add_reminder` / `update_reminder` 参数经常正是把当前对话细节保存进差遣牒
+或提醒项的必要路径。
+
+如果函数返回内容超过运行时可见性预算（按模型可见的返回总字节数计算），Dominds 不把原始返回
+内容插入模型上下文，而是插入一段按对话范围定制的短消息。文本按 UTF-8 字节计算；图片项使用已
+记录的 `byteLength`。
+
+- 主线对话：告诉智能体“这次函数返回内容太大，清理头脑之前当前不可见”；要求不要重试获取这类
+  大段输出；然后要求把下一程还需要知道的信息写入差遣牒合适章节，把差遣牒没有覆盖、但恢复工
+  作会丢的信息写入提醒项，最后调用 `clear_mind({})`。
+- 支线对话：告诉智能体“这次函数返回内容太大，清理头脑之前当前不可见”；要求不要重试获取这类
+  大段输出；然后要求把需要回传给主线对话的结论、证据定位和风险整理清楚，必要时把恢复工作会
+  丢的信息写入提醒项，并尽快完成当前支线回复。
+
+替换文案可以只保留简短的人类可读细节，例如“本次返回约 N 字节”。不要把这件事表述成工具执行
+失败：函数可能已经执行并产生副作用；只是清理头脑之前，其大段返回内容当前不可见。
+
 ### 警告（黄色）
 
 当 `level === 'caution'` 时，驱动程序在**下一个** LLM 生成轮次自动插入一条 **role=user** 指导提示，并**将其持久化为普通用户消息**，以便 UI 将其渲染为正常的用户指令。
@@ -191,7 +216,8 @@ Dominds 计算比率：
 2. 将使用统计传入对话状态（与每程对话一起持久化）。
 3. 实现上下文健康监控计算并每次生成持久化。
 4. 实现 v3 恢复（持久化的 role=user 提示插入 + 警告提醒整理节奏 + 严重倒计时 + 自动 clear_mind）。
-5. 为 v3 行为添加最小回归防护（类型 + 门控）。
+5. 在 `caution` / `critical` 处置态下隐藏超大函数返回内容，同时保持函数输入不受限制。
+6. 为 v3 行为添加最小回归防护（类型 + 门控）。
 
 ## 验收标准
 
@@ -202,4 +228,7 @@ Dominds 计算比率：
 - v3 恢复：
   - `caution`：驱动程序插入持久化的 role=user prompt（UI 可见的用户指令）。进入 `caution` 时插入一次；保持在 `caution` 状态时按节奏重新插入（默认：每 10 次生成；可按模型配置）。主线提示要求先把未落文档、且下一程需要知会的讨论细节补进差遣牒，再至少调用 `update_reminder` / `add_reminder` 之一维护接续包草稿；支线提示要求不要维护差遣牒/更新提案，直接维护足够详尽的接续包提醒项；然后在就绪时执行 `clear_mind`。
   - `critical`：驱动程序使用**记录的角色为 user 的 prompt** 运行倒计时恢复（最多 5 轮）。每次提示包含倒计时；主线提示指示先补差遣牒，再整理提醒项并 `clear_mind`；支线提示指示只维护详尽提醒项并 `clear_mind`。当倒计时归零时，驱动程序自动执行 `clear_mind` 并开始新一程（无 Q4H，无暂停）。
+- 在 `caution` / `critical` 中，任何普通函数结果的返回内容超过运行时可见性字节预算时，都用按
+  范围定制的“清理头脑之前当前不可见”指令替换原始输出；这不表述为工具执行失败，也不限制函数
+  输入。
 - UI 显示上下文健康状态：绿色/黄色/红色（以及使用情况不可用时的"未知"处理）。