helloloop 0.8.6 → 0.9.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "helloloop",
-  "version": "0.8.6",
+  "version": "0.9.1",
   "description": "HelloLoop 的 Claude Code 原生插件元数据，用于多 CLI 宿主分发。",
   "author": {
     "name": "HelloLoop"

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "helloloop",
-  "version": "0.8.6",
+  "version": "0.9.1",
   "description": "面向 Codex CLI、Claude Code、Gemini CLI 的多宿主开发工作流插件，Codex 路径为首发与参考实现。",
   "author": {
     "name": "HelloLoop"

package/README.md

@@ -102,6 +102,7 @@ npx helloloop gemini <PATH> 接续完成剩余开发
 从当前版本开始，`HelloLoop` 的自动执行主线统一走 **detached supervisor + host lease** 模式：
 
 - `analyze` 确认后的自动执行、`run-once`、`run-loop` 都默认切到后台 supervisor
+- 交互终端里默认会**自动附着观察**这个后台 supervisor：你仍然能在当前 CLI 里看到实时进度与流式输出
 - 当前对话 turn 就算被误按 `Esc`、被宿主暂停、或当前工具调用被中断，后台 supervisor 仍会继续
 - 原有的 15 分钟级恢复、健康探测、同引擎自动恢复，也会继续由这个后台 supervisor 接管
 - 这不是“当前进程死掉后每 15 分钟重新拉起一遍主进程”，而是 supervisor 本身持续存活，所以恢复链不会因为当前 turn 消失而断掉
@@ -109,9 +110,11 @@ npx helloloop gemini <PATH> 接续完成剩余开发
 
 常见场景：
 
-- 在 `Codex` / `Claude` / `Gemini` 宿主里运行 `helloloop`：确认后默认转入后台执行，可用 `helloloop status` 查看进度
-- 在普通终端里运行 `npx helloloop`、`npx helloloop run-once`、`npx helloloop run-loop`：默认也会转入后台执行
-- `--supervised` 仍然保留，但现在只是兼容参数，不再是开启后台 supervisor 的前提
+- 在 `Codex` / `Claude` / `Gemini` 宿主里运行 `helloloop`：确认后默认后台执行，并尽量保持当前 CLI 可观察
+- 在普通终端里运行 `npx helloloop`、`npx helloloop run-once`、`npx helloloop run-loop`：默认也是“后台执行 + 当前终端附着观察”
+- 如果你就是想让命令立刻返回、不占当前终端：显式加 `--detach`
+- 如果你稍后想重新接上实时观察：运行 `helloloop watch` 或 `helloloop status --watch`
+- 因此当前版本**不需要先上 Web 看板** 才能解决“后台执行看不到过程”的问题；CLI 观察链已经是第一优先级
 
 ## 无人值守恢复
 
@@ -374,7 +377,7 @@ npx helloloop install --host all --force
 - `Codex` 会刷新 home 根下的插件源码目录、已安装缓存、`config.toml` 启用项和 marketplace 条目
 - `Claude` 会刷新 marketplace、缓存插件目录，以及 `settings.json` / `known_marketplaces.json` / `installed_plugins.json` 中的 `helloloop` 条目
 - `Gemini` 会刷新 `extensions/helloloop/`，不会动同目录下其他扩展
-- 安装 / 升级 / 重装时，会同步校准 `~/.helloloop/settings.json` 的当前版本结构：补齐缺失项、清理未知项、保留已知项现有值
+- 安装 / 升级 / 重装时，会把 `~/.helloloop/settings.json` 严格收敛到当前版本 schema：补齐缺失项、清理未知项、把非法值重置为当前版本默认值
 - 如果 `~/.helloloop/settings.json` 被确认不是合法 JSON，会先备份原文件，再按当前版本结构重建
 - 如果只是首次读取时出现瞬时异常，但重读后内容合法，则不会误生成备份文件
 - 如果宿主自己的配置 JSON（如 `Codex marketplace.json`、`Claude settings.json`、`known_marketplaces.json`、`installed_plugins.json`）本身已损坏，`HelloLoop` 会先明确报错并停止，不会先清理现有安装再失败
@@ -443,6 +446,7 @@ npx helloloop
 | `doctor` | 检查宿主环境、插件资产与目标仓库状态 |
 | `init` | 手动初始化 `.helloloop/` 模板 |
 | `status` | 查看 backlog 摘要和当前状态 |
+| `watch` | 重新附着后台 supervisor，持续查看实时进度 |
 | `next` | 生成下一任务的干跑预览 |
 | `run-once` | 执行一个任务 |
 | `run-loop` | 连续执行多个任务 |
@@ -456,7 +460,8 @@ npx helloloop
 | `-y` / `--yes` | 跳过执行确认直接开始；但如果未显式指定引擎，会直接报错而不是自动选引擎 |
 | `--repo <dir>` | 高级覆盖：显式指定项目仓库 |
 | `--docs <dir|file>` | 高级覆盖：显式指定开发文档 |
-| `--supervised` | 兼容保留；当前版本默认已启用 detached supervisor |
+| `--watch` | 启动后台 supervisor 后，当前终端继续附着观察实时输出 |
+| `--detach` | 仅启动后台 supervisor，立即返回，不进入观察模式 |
 | `--rebuild-existing` | 项目与文档冲突时，自动清理现有项目后重建 |
 | `--host <name>` | 安装宿主：`codex` / `claude` / `gemini` / `all` |
 | `--config-dir <dir>` | 状态目录名，默认 `.helloloop` |
@@ -465,8 +470,11 @@ npx helloloop
 
 ```bash
 npx helloloop status
+npx helloloop status --watch
+npx helloloop watch
 npx helloloop next
 npx helloloop run-once
+npx helloloop run-loop --detach
 ```
 
 ## Doctor
@@ -527,7 +535,7 @@ git push origin vX.Y.Z-beta.N
 
 - 正式版本使用 npm `latest` 渠道，beta 版本使用 npm `beta` 渠道
 - 如果测试、版本校验或打包检查失败，npm 发布与 GitHub Release 都不会继续执行
-- `0.8.6` 起已统一为全流程后台 supervisor：`analyze` 确认后的自动执行、`run-once`、`run-loop` 默认都后台化，不再要求普通终端显式追加 `--supervised`
+- `0.9.1` 起按破坏性升级思路继续收紧：后台 supervisor + CLI 附着观察成为默认工作流，同时 `settings.json` 与 Codex 安装布局只接受当前版本规范，不再为旧布局做兼容兜底
 - GitHub Release 阶段现已改为使用官方 `gh` CLI + `generate-notes` API 创建 / 更新 release，不再依赖会触发 Node runtime deprecation warning 的第三方 action
 
 ## 宿主写入范围
@@ -567,7 +575,7 @@ git push origin vX.Y.Z-beta.N
 说明：
 
 - 这里不保存项目 backlog、状态、运行记录
-- 安装 / 升级 / 重装时，会对 `settings.json` 做结构校准，但不会校验或篡改你已存在的已知项内容
+- 安装 / 升级 / 重装时，会对 `settings.json` 做严格 schema 校准；已知字段只要值不合法，也会按当前版本默认值重置
 - 只有在 `settings.json` 被确认非法时，才会先备份，再重建为当前版本结构
 - 如果只是读取瞬时异常、重读后合法，不会误生成 `.bak`
 

package/hosts/claude/marketplace/plugins/helloloop/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "helloloop",
-  "version": "0.8.6",
+  "version": "0.9.1",
   "description": "HelloLoop 的 Claude Code 原生插件元数据，用于多 CLI 宿主分发。",
   "author": {
     "name": "HelloLoop"

package/hosts/gemini/extension/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "helloloop",
-  "version": "0.8.6",
+  "version": "0.9.1",
   "description": "HelloLoop 的 Gemini CLI 原生扩展，用于按开发文档接续推进项目开发。",
   "contextFileName": "GEMINI.md",
   "excludeTools": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "helloloop",
-  "version": "0.8.6",
+  "version": "0.9.1",
   "description": "面向 Codex CLI、Claude Code、Gemini CLI 的多宿主开发工作流插件",
   "author": "HelloLoop",
   "license": "Apache-2.0",
@@ -30,7 +30,7 @@
     "templates"
   ],
   "scripts": {
-    "test": "node --test tests/analyze_cli.test.mjs tests/analyze_cli_path_resolution.test.mjs tests/analyze_intent_cli.test.mjs tests/analyze_runtime_failure.test.mjs tests/output_schema_contract.test.mjs tests/engine_process_support.test.mjs tests/engine_selection_cli.test.mjs tests/cli_surface.test.mjs tests/cli_doctor_surface.test.mjs tests/host_lifecycle_integrity.test.mjs tests/user_settings_lifecycle.test.mjs tests/host_single_host_integrity.test.mjs tests/install_script.test.mjs tests/mainline_continuation.test.mjs tests/multi_host_runtime.test.mjs tests/multi_host_runtime_recovery.test.mjs tests/process_shell.test.mjs tests/prompt_guardrails.test.mjs tests/ralph_loop.test.mjs tests/runtime_recovery.test.mjs tests/plugin_bundle.test.mjs tests/supervisor_runtime.test.mjs tests/terminal_session_limits.test.mjs"
+    "test": "node --test tests/analyze_cli.test.mjs tests/analyze_cli_path_resolution.test.mjs tests/analyze_intent_cli.test.mjs tests/analyze_runtime_failure.test.mjs tests/output_schema_contract.test.mjs tests/engine_process_support.test.mjs tests/engine_selection_cli.test.mjs tests/engine_selection_runtime.test.mjs tests/cli_surface.test.mjs tests/cli_doctor_surface.test.mjs tests/host_lifecycle_integrity.test.mjs tests/user_settings_lifecycle.test.mjs tests/host_single_host_integrity.test.mjs tests/install_script.test.mjs tests/mainline_continuation.test.mjs tests/multi_host_runtime.test.mjs tests/multi_host_runtime_recovery.test.mjs tests/process_shell.test.mjs tests/prompt_guardrails.test.mjs tests/ralph_loop.test.mjs tests/runtime_recovery.test.mjs tests/plugin_bundle.test.mjs tests/supervisor_runtime.test.mjs tests/supervisor_watch.test.mjs tests/terminal_session_limits.test.mjs"
   },
   "engines": {
     "node": ">=20"

package/src/cli.mjs

@@ -10,6 +10,7 @@ import {
   handleRunOnceCommand,
   handleStatusCommand,
   handleUninstallCommand,
+  handleWatchCommand,
 } from "./cli_command_handlers.mjs";
 import { resolveContextFromOptions, resolveStandardCommandOptions } from "./cli_context.mjs";
 import { runDoctor } from "./cli_support.mjs";
@@ -66,6 +67,7 @@ export async function runCli(argv) {
       "run-loop": () => handleRunLoopCommand(context, options),
       "run-once": () => handleRunOnceCommand(context, options),
       status: () => handleStatusCommand(context, options),
+      watch: () => handleWatchCommand(context, options),
     };
     if (!handlers[command]) {
       throw new Error(`未知命令：${command}`);

package/src/cli_analyze_command.mjs

@@ -18,10 +18,7 @@ import { resolveEngineSelection } from "./engine_selection.mjs";
 import { resetRepoForRebuild } from "./rebuild.mjs";
 import { renderRebuildSummary } from "./cli_render.mjs";
 import { shouldConfirmRepoRebuild } from "./cli_support.mjs";
-import {
-  launchSupervisedCommand,
-  renderSupervisorLaunchSummary,
-} from "./supervisor_runtime.mjs";
+import { launchAndMaybeWatchSupervisedCommand } from "./supervisor_cli_support.mjs";
 
 async function resolveAnalyzeEngineSelection(options) {
   if (options.engineResolution?.ok) {
@@ -224,16 +221,13 @@ async function maybeRunAutoExecution(result, activeOptions) {
 
   console.log("");
   console.log("开始自动接续执行...");
-  const session = launchSupervisedCommand(result.context, "run-loop", {
+  const payload = await launchAndMaybeWatchSupervisedCommand(result.context, "run-loop", {
     ...activeOptions,
-    supervised: false,
     engineResolution: result.engineResolution?.ok ? result.engineResolution : activeOptions.engineResolution,
     maxTasks: resolveAutoRunMaxTasks(result.backlog, activeOptions) || undefined,
     fullAutoMainline: true,
   });
-  console.log(renderSupervisorLaunchSummary(session));
-  console.log("- 已切换为后台执行；可稍后运行 `helloloop status` 查看进度。");
-  return 0;
+  return payload.exitCode || 0;
 }
 
 export async function handleAnalyzeCommand(options) {

package/src/cli_args.mjs

@@ -7,6 +7,7 @@ const KNOWN_COMMANDS = new Set([
   "uninstall",
   "init",
   "status",
+  "watch",
   "next",
   "run-once",
   "run-loop",
@@ -51,7 +52,10 @@ export function parseArgs(argv) {
     else if (arg === "--gemini-home") { options.geminiHome = rest[index + 1]; index += 1; }
     else if (arg === "--config-dir") { options.configDirName = rest[index + 1]; index += 1; }
     else if (arg === "--session-file") { options.sessionFile = rest[index + 1]; index += 1; }
-    else if (arg === "--supervised") options.supervised = true;
+    else if (arg === "--watch") options.watch = true;
+    else if (arg === "--detach") options.detach = true;
+    else if (arg === "--session-id") { options.sessionId = rest[index + 1]; index += 1; }
+    else if (arg === "--watch-poll-ms") { options.watchPollMs = Number(rest[index + 1]); index += 1; }
     else if (arg === "--required-doc") { options.requiredDocs.push(rest[index + 1]); index += 1; }
     else if (arg === "--constraint") { options.constraints.push(rest[index + 1]); index += 1; }
     else { options.positionalArgs.push(arg); }
@@ -70,6 +74,7 @@ function helpText() {
     "  uninstall             从所选宿主卸载插件并清理注册信息",
     "  init                  初始化 .helloloop 配置",
     "  status                查看 backlog 与下一任务",
+    "  watch                 附着到后台 supervisor，持续查看实时进度",
     "  next                  生成下一任务干跑预览",
     "  run-once              执行一个任务",
     "  run-loop              连续执行多个任务",
@@ -90,7 +95,9 @@ function helpText() {
     "  --max-tasks <n>       run-loop 最多执行 n 个任务",
     "  --max-attempts <n>    每种策略内最多重试 n 次",
     "  --max-strategies <n>  单任务最多切换 n 种策略继续重试",
-    "  --supervised          兼容保留；当前版本默认就会通过独立 supervisor 后台执行",
+    "  --watch               启动后台 supervisor 后，当前终端继续附着观察实时输出",
+    "  --detach              仅启动后台 supervisor 后立即返回，不进入观察模式",
+    "  --session-id <id>     status/watch 指定附着的后台会话 ID",
     "  --allow-high-risk     允许执行 medium/high/critical 风险任务",
     "  --rebuild-existing    分析判断当前项目与文档冲突时，自动清理当前项目后按文档重建",
     "  --required-doc <p>    增加一个全局必读文档（AGENTS.md 会被自动忽略）",
@@ -100,6 +107,8 @@ function helpText() {
     "  analyze 默认支持在命令后混合传入引擎、路径和自然语言要求。",
     "  如果同时检测到多个可用引擎且没有明确指定，会先询问你选择。",
     "  当前版本默认会把自动执行 / run-once / run-loop 切到后台 supervisor。",
+    "  交互终端默认会自动附着观察；如只想立即返回，请显式加 --detach。",
+    "  任何时候都可运行 `helloloop watch` 或 `helloloop status --watch` 重新附着观察。",
     "  示例：npx helloloop claude <DOCS_PATH> <PROJECT_ROOT> 先分析偏差，不要执行",
   ].join("\n");
 }

package/src/cli_command_handlers.mjs

@@ -7,26 +7,10 @@ import { installPluginBundle, uninstallPluginBundle } from "./install.mjs";
 import { runLoop, runOnce, renderStatusText } from "./runner.mjs";
 import { renderInstallSummary, renderUninstallSummary } from "./cli_render.mjs";
 import {
-  launchSupervisedCommand,
-  renderSupervisorLaunchSummary,
-} from "./supervisor_runtime.mjs";
-
-function shouldUseSupervisor(options = {}) {
-  return !options.dryRun
-    && process.env.HELLOLOOP_SUPERVISOR_ACTIVE !== "1";
-}
-
-async function runSupervised(context, command, options = {}) {
-  const session = launchSupervisedCommand(context, command, options);
-  console.log(renderSupervisorLaunchSummary(session));
-  console.log("- 已切换为后台执行；可稍后运行 `helloloop status` 查看进度。");
-  return {
-    detached: true,
-    exitCode: 0,
-    ok: true,
-    session,
-  };
-}
+  launchAndMaybeWatchSupervisedCommand,
+  shouldUseSupervisor,
+} from "./supervisor_cli_support.mjs";
+import { watchSupervisorSession } from "./supervisor_watch.mjs";
 
 export function handleInstallCommand(options) {
   const userSettings = syncUserSettingsFile({
@@ -79,9 +63,33 @@ export async function handleDoctorCommand(context, options, runDoctor) {
   return 0;
 }
 
-export function handleStatusCommand(context, options) {
+export async function handleStatusCommand(context, options) {
   console.log(renderStatusText(context, options));
-  return 0;
+  if (!options.watch) {
+    return 0;
+  }
+
+  const result = await watchSupervisorSession(context, {
+    sessionId: options.sessionId,
+    pollMs: options.watchPollMs,
+  });
+  if (result.empty) {
+    console.log("当前没有正在运行的后台 supervisor。");
+    return 1;
+  }
+  return result.exitCode || 0;
+}
+
+export async function handleWatchCommand(context, options) {
+  const result = await watchSupervisorSession(context, {
+    sessionId: options.sessionId,
+    pollMs: options.watchPollMs,
+  });
+  if (result.empty) {
+    console.log("当前没有正在运行的后台 supervisor。");
+    return 1;
+  }
+  return result.exitCode || 0;
 }
 
 export async function handleNextCommand(context, options) {
@@ -109,7 +117,7 @@ export async function handleNextCommand(context, options) {
 
 export async function handleRunOnceCommand(context, options) {
   if (shouldUseSupervisor(options)) {
-    const payload = await runSupervised(context, "run-once", options);
+    const payload = await launchAndMaybeWatchSupervisedCommand(context, "run-once", options);
     return payload.exitCode || 0;
   }
 
@@ -133,7 +141,7 @@ export async function handleRunOnceCommand(context, options) {
 
 export async function handleRunLoopCommand(context, options) {
   if (shouldUseSupervisor(options)) {
-    const payload = await runSupervised(context, "run-loop", options);
+    const payload = await launchAndMaybeWatchSupervisedCommand(context, "run-loop", options);
     return payload.exitCode || 0;
   }
 

package/src/common.mjs

@@ -26,6 +26,11 @@ export function writeText(filePath, content) {
   fs.writeFileSync(filePath, content, "utf8");
 }
 
+export function appendText(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  fs.appendFileSync(filePath, content, "utf8");
+}
+
 export function writeJson(filePath, value) {
   writeText(filePath, `${JSON.stringify(value, null, 2)}\n`);
 }
@@ -64,3 +69,9 @@ export function resolveFrom(rootDir, ...segments) {
 export function normalizeRelative(rootDir, targetPath) {
   return path.relative(rootDir, targetPath).replaceAll("\\", "/");
 }
+
+export function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, Math.max(0, Number(ms || 0)));
+  });
+}

package/src/engine_process_support.mjs

@@ -121,17 +121,21 @@ export function runChild(command, args, options = {}) {
     emitHeartbeat("running");
 
     child.stdout.on("data", (chunk) => {
-      stdout += chunk.toString();
+      const text = chunk.toString();
+      stdout += text;
       stdoutBytes += chunk.length;
       lastOutputAt = Date.now();
       stallWarned = false;
+      options.onStdout?.(text);
       emitHeartbeat("running");
     });
     child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
+      const text = chunk.toString();
+      stderr += text;
       stderrBytes += chunk.length;
       lastOutputAt = Date.now();
       stallWarned = false;
+      options.onStderr?.(text);
       emitHeartbeat("running");
     });
 

package/src/engine_selection_settings.mjs

@@ -46,25 +46,34 @@ function defaultUserSettings() {
   };
 }
 
-function cloneJsonValue(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-
 function isPlainObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 
-function syncValueBySchema(schemaValue, currentValue) {
-  if (!isPlainObject(schemaValue)) {
-    return currentValue === undefined ? cloneJsonValue(schemaValue) : currentValue;
-  }
+function normalizeString(value, fallback = "") {
+  return typeof value === "string" ? value.trim() : fallback;
+}
 
-  const source = isPlainObject(currentValue) ? currentValue : {};
-  const next = {};
-  for (const [key, childSchema] of Object.entries(schemaValue)) {
-    next[key] = syncValueBySchema(childSchema, Object.hasOwn(source, key) ? source[key] : undefined);
+function normalizeBoolean(value, fallback = false) {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+function normalizePositiveInteger(value, fallback, minimum = 1) {
+  const numericValue = Number(value);
+  if (!Number.isInteger(numericValue) || numericValue < minimum) {
+    return fallback;
   }
-  return next;
+  return numericValue;
+}
+
+function normalizeTerminalConcurrencySettings(settings = {}) {
+  const defaults = defaultTerminalConcurrencySettings();
+  return {
+    enabled: normalizeBoolean(settings?.enabled, defaults.enabled),
+    visibleMax: normalizePositiveInteger(settings?.visibleMax, defaults.visibleMax, 0),
+    backgroundMax: normalizePositiveInteger(settings?.backgroundMax, defaults.backgroundMax, 0),
+    totalMax: normalizePositiveInteger(settings?.totalMax, defaults.totalMax, 0),
+  };
 }
 
 function mergeValueBySchema(schemaValue, baseValue, patchValue) {
@@ -87,16 +96,6 @@ function mergeValueBySchema(schemaValue, baseValue, patchValue) {
   return next;
 }
 
-export function syncUserSettingsShape(settings = {}) {
-  return syncValueBySchema(defaultUserSettings(), settings);
-}
-
-function readRawUserSettingsDocument(options = {}) {
-  const settingsFile = resolveUserSettingsFile(options.userSettingsFile);
-  const settings = fileExists(settingsFile) ? readJson(settingsFile) : {};
-  return syncUserSettingsShape(settings);
-}
-
 export function resolveUserSettingsHome() {
   return String(process.env.HELLOLOOP_HOME || "").trim()
     || path.join(os.homedir(), ".helloloop");
@@ -113,32 +112,49 @@ function normalizeEmailNotificationSettings(emailSettings = {}) {
   const smtp = emailSettings?.smtp || {};
 
   return {
-    ...defaults,
-    ...emailSettings,
+    enabled: normalizeBoolean(emailSettings?.enabled, defaults.enabled),
     to: Array.isArray(emailSettings?.to)
       ? emailSettings.to.map((item) => String(item || "").trim()).filter(Boolean)
-      : (typeof emailSettings?.to === "string" && emailSettings.to.trim() ? [emailSettings.to.trim()] : []),
+      : defaults.to,
+    from: normalizeString(emailSettings?.from, defaults.from),
     smtp: {
-      ...defaults.smtp,
-      ...smtp,
+      host: normalizeString(smtp?.host, defaults.smtp.host),
+      port: normalizePositiveInteger(smtp?.port, defaults.smtp.port),
+      secure: normalizeBoolean(smtp?.secure, defaults.smtp.secure),
+      starttls: normalizeBoolean(smtp?.starttls, defaults.smtp.starttls),
+      username: normalizeString(smtp?.username, defaults.smtp.username),
+      usernameEnv: normalizeString(smtp?.usernameEnv, defaults.smtp.usernameEnv),
+      password: typeof smtp?.password === "string" ? smtp.password : defaults.smtp.password,
+      passwordEnv: normalizeString(smtp?.passwordEnv, defaults.smtp.passwordEnv),
+      timeoutSeconds: normalizePositiveInteger(smtp?.timeoutSeconds, defaults.smtp.timeoutSeconds),
+      rejectUnauthorized: normalizeBoolean(smtp?.rejectUnauthorized, defaults.smtp.rejectUnauthorized),
     },
   };
 }
 
-export function loadUserSettingsDocument(options = {}) {
-  const settings = readRawUserSettingsDocument(options);
-
+export function syncUserSettingsShape(settings = {}) {
   return {
-    ...settings,
-    defaultEngine: normalizeEngineName(settings?.defaultEngine),
-    lastSelectedEngine: normalizeEngineName(settings?.lastSelectedEngine),
+    defaultEngine: normalizeEngineName(settings?.defaultEngine) || "",
+    lastSelectedEngine: normalizeEngineName(settings?.lastSelectedEngine) || "",
     notifications: {
-      ...(settings?.notifications || {}),
       email: normalizeEmailNotificationSettings(settings?.notifications?.email || {}),
     },
+    runtime: {
+      terminalConcurrency: normalizeTerminalConcurrencySettings(settings?.runtime?.terminalConcurrency || {}),
+    },
   };
 }
 
+function readRawUserSettingsDocument(options = {}) {
+  const settingsFile = resolveUserSettingsFile(options.userSettingsFile);
+  const settings = fileExists(settingsFile) ? readJson(settingsFile) : {};
+  return syncUserSettingsShape(settings);
+}
+
+export function loadUserSettingsDocument(options = {}) {
+  return readRawUserSettingsDocument(options);
+}
+
 export function loadUserSettings(options = {}) {
   const settings = loadUserSettingsDocument(options);
   return {

package/src/install_codex.mjs

@@ -133,7 +133,6 @@ export function installCodexHost(bundleRoot, options = {}) {
   const resolvedLocalRoot = resolveCodexLocalRoot(options.codexHome);
   const targetPluginsRoot = path.join(resolvedLocalRoot, "plugins");
   const targetPluginRoot = path.join(targetPluginsRoot, CODEX_PLUGIN_NAME);
-  const legacyTargetPluginRoot = path.join(resolvedCodexHome, "plugins", CODEX_PLUGIN_NAME);
   const targetPluginCacheRoot = path.join(
     resolvedCodexHome,
     "plugins",
@@ -143,13 +142,9 @@ export function installCodexHost(bundleRoot, options = {}) {
   );
   const targetInstalledPluginRoot = path.join(targetPluginCacheRoot, "local");
   const marketplaceFile = path.join(resolvedLocalRoot, ".agents", "plugins", "marketplace.json");
-  const legacyMarketplaceFile = path.join(resolvedCodexHome, ".agents", "plugins", "marketplace.json");
   const configFile = path.join(resolvedCodexHome, "config.toml");
   const manifestFile = path.join(bundleRoot, ".codex-plugin", "plugin.json");
   const existingMarketplace = readExistingJsonOrThrow(marketplaceFile, "Codex marketplace 配置");
-  const existingLegacyMarketplace = legacyMarketplaceFile === marketplaceFile
-    ? existingMarketplace
-    : readExistingJsonOrThrow(legacyMarketplaceFile, "Codex legacy marketplace 配置");
 
   if (!fileExists(manifestFile)) {
     throw new Error(`未找到 Codex 插件 manifest：${manifestFile}`);
@@ -159,9 +154,6 @@ export function installCodexHost(bundleRoot, options = {}) {
   assertPathInside(resolvedCodexHome, targetPluginCacheRoot, "Codex 插件缓存目录");
   removeTargetIfNeeded(targetPluginRoot, options.force);
   removeTargetIfNeeded(targetPluginCacheRoot, options.force);
-  if (legacyTargetPluginRoot !== targetPluginRoot) {
-    removePathIfExists(legacyTargetPluginRoot);
-  }
 
   ensureDir(targetPluginsRoot);
   ensureDir(targetPluginRoot);
@@ -173,9 +165,6 @@ export function installCodexHost(bundleRoot, options = {}) {
 
   ensureDir(path.dirname(marketplaceFile));
   updateCodexMarketplace(marketplaceFile, existingMarketplace);
-  if (legacyMarketplaceFile !== marketplaceFile) {
-    removeCodexMarketplaceEntry(legacyMarketplaceFile, existingLegacyMarketplace);
-  }
   upsertCodexPluginConfig(configFile);
 
   return {
@@ -192,7 +181,6 @@ export function uninstallCodexHost(options = {}) {
   const resolvedCodexHome = resolveHomeDir(options.codexHome, ".codex");
   const resolvedLocalRoot = resolveCodexLocalRoot(options.codexHome);
   const targetPluginRoot = path.join(resolvedLocalRoot, "plugins", CODEX_PLUGIN_NAME);
-  const legacyTargetPluginRoot = path.join(resolvedCodexHome, "plugins", CODEX_PLUGIN_NAME);
   const targetPluginCacheRoot = path.join(
     resolvedCodexHome,
     "plugins",
@@ -201,29 +189,19 @@ export function uninstallCodexHost(options = {}) {
     CODEX_PLUGIN_NAME,
   );
   const marketplaceFile = path.join(resolvedLocalRoot, ".agents", "plugins", "marketplace.json");
-  const legacyMarketplaceFile = path.join(resolvedCodexHome, ".agents", "plugins", "marketplace.json");
   const configFile = path.join(resolvedCodexHome, "config.toml");
   const existingMarketplace = readExistingJsonOrThrow(marketplaceFile, "Codex marketplace 配置");
-  const existingLegacyMarketplace = legacyMarketplaceFile === marketplaceFile
-    ? existingMarketplace
-    : readExistingJsonOrThrow(legacyMarketplaceFile, "Codex legacy marketplace 配置");
 
   const removedPlugin = removePathIfExists(targetPluginRoot);
-  const removedLegacyPlugin = legacyTargetPluginRoot === targetPluginRoot
-    ? false
-    : removePathIfExists(legacyTargetPluginRoot);
   const removedCache = removePathIfExists(targetPluginCacheRoot);
   const removedMarketplace = removeCodexMarketplaceEntry(marketplaceFile, existingMarketplace);
-  const removedLegacyMarketplace = legacyMarketplaceFile === marketplaceFile
-    ? false
-    : removeCodexMarketplaceEntry(legacyMarketplaceFile, existingLegacyMarketplace);
   const removedConfig = removeCodexPluginConfig(configFile);
 
   return {
     host: "codex",
     displayName: "Codex",
     targetRoot: targetPluginRoot,
-    removed: removedPlugin || removedLegacyPlugin || removedCache || removedMarketplace || removedLegacyMarketplace || removedConfig,
+    removed: removedPlugin || removedCache || removedMarketplace || removedConfig,
     marketplaceFile,
     configFile,
   };

package/src/runner_execute_task.mjs

@@ -4,7 +4,7 @@ import { rememberEngineSelection } from "./engine_selection.mjs";
 import { getEngineDisplayName } from "./engine_metadata.mjs";
 import { ensureDir, nowIso, writeText } from "./common.mjs";
 import { isHostLeaseAlive } from "./host_lease.mjs";
-import { saveBacklog } from "./config.mjs";
+import { saveBacklog, writeStatus } from "./config.mjs";
 import { reviewTaskCompletion } from "./completion_review.mjs";
 import { updateTask } from "./backlog.mjs";
 import { buildTaskPrompt } from "./prompt.mjs";
@@ -267,6 +267,16 @@ export async function executeSingleTask(context, options = {}) {
 
   updateTask(execution.backlog, execution.task.id, { status: "in_progress", startedAt: nowIso() });
   saveBacklog(context, execution.backlog);
+  writeStatus(context, {
+    ok: true,
+    sessionId: options.supervisorSessionId || "",
+    stage: "task-started",
+    taskId: execution.task.id,
+    taskTitle: execution.task.title,
+    runDir: execution.runDir,
+    summary: "",
+    message: `开始执行任务：${execution.task.title}`,
+  });
 
   const state = {
     engineResolution: execution.engineResolution,

package/src/runner_once.mjs

@@ -11,6 +11,7 @@ export async function runOnce(context, options = {}) {
 
   writeStatus(context, {
     ok: result.ok,
+    sessionId: options.supervisorSessionId || "",
     stage: result.kind,
     taskId: result.task?.id || null,
     taskTitle: result.task?.title || "",

package/src/runner_status.mjs

@@ -90,6 +90,9 @@ export function renderStatusText(context, options = {}) {
   const supervisor = fileExists(context.supervisorStateFile)
     ? readJson(context.supervisorStateFile)
     : null;
+  const latestStatus = fileExists(context.statusFile)
+    ? readJson(context.statusFile)
+    : null;
 
   return [
     "HelloLoop 状态",
@@ -108,8 +111,17 @@ export function renderStatusText(context, options = {}) {
         `后台租约：${renderHostLeaseLabel(supervisor.lease)}`,
       ]
       : []),
+    ...(latestStatus?.taskTitle
+      ? [
+        `当前运行任务：${latestStatus.taskTitle}`,
+        `当前运行目录：${latestStatus.runDir || "unknown"}`,
+        `当前运行阶段：${latestStatus.stage || "unknown"}`,
+      ]
+      : []),
     "",
     nextTask ? "下一任务：" : "下一任务：无",
     nextTask ? renderTaskSummary(nextTask) : "",
+    "",
+    "实时观察：helloloop watch",
   ].filter(Boolean).join("\n");
 }

package/src/runtime_engine_support.mjs

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 
-import { nowIso, writeText } from "./common.mjs";
+import { appendText, nowIso, writeText } from "./common.mjs";
 import { getEngineDisplayName } from "./engine_metadata.mjs";
 import {
   buildClaudeArgs,
@@ -165,6 +165,8 @@ export async function runEngineAttempt({
 }) {
   const attemptPromptFile = path.join(runDir, `${attemptPrefix}-prompt.md`);
   const attemptLastMessageFile = path.join(runDir, `${attemptPrefix}-last-message.txt`);
+  const attemptStdoutFile = path.join(runDir, `${attemptPrefix}-stdout.log`);
+  const attemptStderrFile = path.join(runDir, `${attemptPrefix}-stderr.log`);
 
   if (invocation.error) {
     const result = {
@@ -208,6 +210,8 @@ export async function runEngineAttempt({
     recoveryCount,
     recoveryHistory,
   });
+  writeText(attemptStdoutFile, "");
+  writeText(attemptStderrFile, "");
 
   const result = await runChild(invocation.command, finalArgs, {
     cwd: context.repoRoot,
@@ -226,6 +230,12 @@ export async function runEngineAttempt({
         heartbeat: payload,
       });
     },
+    onStdout(text) {
+      appendText(attemptStdoutFile, text);
+    },
+    onStderr(text) {
+      appendText(attemptStderrFile, text);
+    },
     shouldKeepRunning() {
       return isHostLeaseAlive(hostLease);
     },

package/src/supervisor_cli_support.mjs

@@ -0,0 +1,48 @@
+import { launchSupervisedCommand, renderSupervisorLaunchSummary } from "./supervisor_runtime.mjs";
+import { watchSupervisorSession } from "./supervisor_watch.mjs";
+
+export function shouldUseSupervisor(options = {}) {
+  return !options.dryRun
+    && process.env.HELLOLOOP_SUPERVISOR_ACTIVE !== "1";
+}
+
+export function shouldAutoWatchSupervisor(options = {}) {
+  if (options.detach) {
+    return false;
+  }
+  if (options.watch === true) {
+    return true;
+  }
+  if (options.watch === false) {
+    return false;
+  }
+  return Boolean(process.stdout.isTTY);
+}
+
+export async function launchAndMaybeWatchSupervisedCommand(context, command, options = {}) {
+  const session = launchSupervisedCommand(context, command, options);
+  console.log(renderSupervisorLaunchSummary(session));
+
+  if (!shouldAutoWatchSupervisor(options)) {
+    console.log("- 已切换为后台执行；可稍后运行 `helloloop watch` 或 `helloloop status` 查看进度。");
+    return {
+      detached: true,
+      exitCode: 0,
+      ok: true,
+      session,
+    };
+  }
+
+  console.log("- 已进入附着观察模式；按 Ctrl+C 仅退出观察，不会停止后台任务。");
+  const watchResult = await watchSupervisorSession(context, {
+    sessionId: session.sessionId,
+    pollMs: options.watchPollMs,
+  });
+  return {
+    detached: false,
+    exitCode: watchResult.exitCode,
+    ok: watchResult.ok,
+    session,
+    watchResult,
+  };
+}

package/src/supervisor_runtime.mjs

@@ -96,7 +96,10 @@ export function launchSupervisedCommand(context, command, options = {}) {
       repoRoot: context.repoRoot,
       configDirName: context.configDirName,
     },
-    options: toSerializableOptions(options),
+    options: toSerializableOptions({
+      ...options,
+      supervisorSessionId: sessionId,
+    }),
     lease,
     terminalSessionFile: terminalSession?.file || "",
   };

package/src/supervisor_watch.mjs

@@ -0,0 +1,320 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { fileExists, readJson, sleep } from "./common.mjs";
+import { renderHostLeaseLabel } from "./host_lease.mjs";
+
+const FINAL_STATUSES = new Set(["completed", "failed", "stopped"]);
+
+function readJsonIfExists(filePath) {
+  if (!filePath || !fileExists(filePath)) {
+    return null;
+  }
+
+  try {
+    return readJson(filePath);
+  } catch {
+    return null;
+  }
+}
+
+function writeLine(stream, message) {
+  stream.write(`${message}\n`);
+}
+
+function buildSessionSummary(supervisor) {
+  if (!supervisor?.sessionId) {
+    return "";
+  }
+
+  return [
+    `[HelloLoop watch] 已附着后台会话：${supervisor.sessionId}`,
+    `[HelloLoop watch] 宿主租约：${renderHostLeaseLabel(supervisor.lease)}`,
+  ].join("\n");
+}
+
+function formatSupervisorState(supervisor) {
+  if (!supervisor?.status) {
+    return "";
+  }
+
+  const label = {
+    launching: "后台 supervisor 启动中",
+    running: "后台 supervisor 正在运行",
+    completed: "后台 supervisor 已完成",
+    failed: "后台 supervisor 执行失败",
+    stopped: "后台 supervisor 已停止",
+  }[String(supervisor.status)] || `后台 supervisor 状态：${supervisor.status}`;
+
+  const suffix = supervisor.message ? `：${supervisor.message}` : "";
+  return `[HelloLoop watch] ${label}${suffix}`;
+}
+
+function formatTaskStatus(status) {
+  if (!status?.taskTitle) {
+    return "";
+  }
+
+  const lines = [`[HelloLoop watch] 当前任务：${status.taskTitle}`];
+  if (status.runDir) {
+    lines.push(`[HelloLoop watch] 运行目录：${status.runDir}`);
+  }
+  if (status.stage) {
+    lines.push(`[HelloLoop watch] 阶段：${status.stage}`);
+  }
+  return lines.join("\n");
+}
+
+function selectRuntimeFile(runDir) {
+  if (!runDir || !fileExists(runDir)) {
+    return "";
+  }
+
+  const candidates = [];
+  for (const entry of fs.readdirSync(runDir, { withFileTypes: true })) {
+    if (entry.isFile() && entry.name.endsWith("-runtime.json")) {
+      candidates.push(path.join(runDir, entry.name));
+      continue;
+    }
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const nestedDir = path.join(runDir, entry.name);
+    for (const nestedName of fs.readdirSync(nestedDir)) {
+      if (nestedName.endsWith("-runtime.json")) {
+        candidates.push(path.join(nestedDir, nestedName));
+      }
+    }
+  }
+
+  candidates.sort((left, right) => {
+    const rightTime = fs.statSync(right).mtimeMs;
+    const leftTime = fs.statSync(left).mtimeMs;
+    return rightTime - leftTime;
+  });
+
+  return candidates[0] || "";
+}
+
+function formatRuntimeState(runtime, previousRuntime) {
+  if (!runtime?.status) {
+    return "";
+  }
+
+  const idleSeconds = Number(runtime?.heartbeat?.idleSeconds || 0);
+  const idleBucket = Math.floor(idleSeconds / 30);
+  const previousIdleBucket = Math.floor(Number(previousRuntime?.heartbeat?.idleSeconds || 0) / 30);
+  const signature = [
+    runtime.status,
+    runtime.attemptPrefix || "",
+    runtime.recoveryCount || 0,
+    runtime.failureCode || "",
+    runtime.failureReason || "",
+    runtime.nextRetryAt || "",
+    runtime.notification?.reason || "",
+  ].join("|");
+  const previousSignature = previousRuntime
+    ? [
+      previousRuntime.status,
+      previousRuntime.attemptPrefix || "",
+      previousRuntime.recoveryCount || 0,
+      previousRuntime.failureCode || "",
+      previousRuntime.failureReason || "",
+      previousRuntime.nextRetryAt || "",
+      previousRuntime.notification?.reason || "",
+    ].join("|")
+    : "";
+
+  if (signature === previousSignature && (runtime.status !== "running" || idleBucket === previousIdleBucket || idleBucket === 0)) {
+    return "";
+  }
+
+  if (runtime.status === "running") {
+    if (idleBucket === 0 || idleBucket === previousIdleBucket) {
+      return "";
+    }
+    return `[HelloLoop watch] 仍在执行：${runtime.attemptPrefix || "当前尝试"}，最近输出距今约 ${idleBucket * 30} 秒`;
+  }
+
+  const labels = {
+    recovering: "进入同引擎恢复",
+    suspected_stall: "疑似卡住，继续观察",
+    watchdog_terminating: "触发 watchdog，准备终止当前子进程",
+    watchdog_waiting: "watchdog 等待子进程退出",
+    retry_waiting: "等待自动重试",
+    probe_waiting: "准备执行健康探测",
+    probe_running: "正在执行健康探测",
+    paused_manual: "自动恢复预算已耗尽，任务暂停",
+    lease_terminating: "宿主租约失效，正在停止当前子进程",
+    stopped_host_closed: "宿主窗口已关闭，后台任务停止",
+    completed: "当前任务执行完成",
+    failed: "当前任务执行失败",
+  };
+  const label = labels[String(runtime.status)] || `运行状态更新：${runtime.status}`;
+  const details = [
+    runtime.attemptPrefix ? `attempt=${runtime.attemptPrefix}` : "",
+    Number.isFinite(Number(runtime.recoveryCount)) ? `recovery=${runtime.recoveryCount}` : "",
+    runtime.nextRetryAt ? `next=${runtime.nextRetryAt}` : "",
+    runtime.failureReason || "",
+  ].filter(Boolean).join(" | ");
+
+  return `[HelloLoop watch] ${label}${details ? ` | ${details}` : ""}`;
+}
+
+function readTextDelta(filePath, offset) {
+  if (!filePath || !fileExists(filePath)) {
+    return { nextOffset: 0, text: "" };
+  }
+
+  const stats = fs.statSync(filePath);
+  if (stats.size <= 0) {
+    return { nextOffset: 0, text: "" };
+  }
+
+  const start = Math.max(0, Math.min(Number(offset || 0), stats.size));
+  if (stats.size === start) {
+    return { nextOffset: start, text: "" };
+  }
+
+  const handle = fs.openSync(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(stats.size - start);
+    fs.readSync(handle, buffer, 0, buffer.length, start);
+    return {
+      nextOffset: stats.size,
+      text: buffer.toString("utf8"),
+    };
+  } finally {
+    fs.closeSync(handle);
+  }
+}
+
+function readAndWriteDelta(cursor, filePath, stream) {
+  if (cursor.file !== filePath) {
+    cursor.file = filePath || "";
+    cursor.offset = 0;
+  }
+
+  if (!filePath) {
+    return;
+  }
+
+  const delta = readTextDelta(filePath, cursor.offset);
+  cursor.offset = delta.nextOffset;
+  if (!delta.text) {
+    return;
+  }
+
+  stream.write(delta.text);
+  if (!delta.text.endsWith("\n")) {
+    stream.write("\n");
+  }
+}
+
+function resolveStatusForSession(status, sessionId) {
+  if (!status) {
+    return null;
+  }
+  if (!sessionId || !status.sessionId || status.sessionId === sessionId) {
+    return status;
+  }
+  return null;
+}
+
+function buildWatchResult(supervisor, result) {
+  const exitCode = Number(result?.exitCode ?? supervisor?.exitCode ?? (supervisor?.status === "completed" ? 0 : 1));
+  return {
+    sessionId: result?.sessionId || supervisor?.sessionId || "",
+    status: result?.ok === true
+      ? "completed"
+      : (supervisor?.status || (exitCode === 0 ? "completed" : "failed")),
+    ok: result?.ok === true || exitCode === 0,
+    exitCode,
+  };
+}
+
+export async function watchSupervisorSession(context, options = {}) {
+  const pollMs = Math.max(200, Number(options.pollMs || 1000));
+  const stdoutStream = options.stdoutStream || process.stdout;
+  const stderrStream = options.stderrStream || process.stderr;
+  const expectedSessionId = String(options.sessionId || "").trim();
+  const stdoutCursor = { file: "", offset: 0 };
+  const stderrCursor = { file: "", offset: 0 };
+  let printedSessionId = "";
+  let lastSupervisorSignature = "";
+  let lastTaskSignature = "";
+  let previousRuntime = null;
+  let missingPolls = 0;
+
+  while (true) {
+    const supervisor = readJsonIfExists(context.supervisorStateFile);
+    const result = readJsonIfExists(context.supervisorResultFile);
+    const activeSessionId = expectedSessionId || supervisor?.sessionId || result?.sessionId || "";
+    const taskStatus = resolveStatusForSession(readJsonIfExists(context.statusFile), activeSessionId);
+    const runtimeFile = taskStatus?.runDir ? selectRuntimeFile(taskStatus.runDir) : "";
+    const runtime = readJsonIfExists(runtimeFile);
+
+    if (!supervisor && !result) {
+      missingPolls += 1;
+      if (missingPolls >= 3) {
+        return {
+          sessionId: activeSessionId,
+          status: "",
+          ok: false,
+          exitCode: 1,
+          empty: true,
+        };
+      }
+      await sleep(pollMs);
+      continue;
+    }
+    missingPolls = 0;
+
+    if (supervisor?.sessionId && supervisor.sessionId !== printedSessionId) {
+      printedSessionId = supervisor.sessionId;
+      writeLine(stdoutStream, buildSessionSummary(supervisor));
+    }
+
+    const supervisorSignature = supervisor
+      ? [supervisor.sessionId || "", supervisor.status || "", supervisor.message || ""].join("|")
+      : "";
+    if (supervisorSignature && supervisorSignature !== lastSupervisorSignature) {
+      lastSupervisorSignature = supervisorSignature;
+      writeLine(stdoutStream, formatSupervisorState(supervisor));
+    }
+
+    const taskSignature = taskStatus
+      ? [taskStatus.sessionId || "", taskStatus.taskId || "", taskStatus.taskTitle || "", taskStatus.runDir || "", taskStatus.stage || ""].join("|")
+      : "";
+    if (taskSignature && taskSignature !== lastTaskSignature) {
+      lastTaskSignature = taskSignature;
+      writeLine(stdoutStream, formatTaskStatus(taskStatus));
+    }
+
+    const runtimeMessage = formatRuntimeState(runtime, previousRuntime);
+    if (runtimeMessage) {
+      writeLine(stdoutStream, runtimeMessage);
+    }
+    previousRuntime = runtime || previousRuntime;
+
+    const activePrefix = runtime?.attemptPrefix || "";
+    const runtimeDir = runtimeFile ? path.dirname(runtimeFile) : "";
+    const stdoutFile = runtimeDir && activePrefix
+      ? path.join(runtimeDir, `${activePrefix}-stdout.log`)
+      : "";
+    const stderrFile = runtimeDir && activePrefix
+      ? path.join(runtimeDir, `${activePrefix}-stderr.log`)
+      : "";
+
+    readAndWriteDelta(stdoutCursor, stdoutFile, stdoutStream);
+    readAndWriteDelta(stderrCursor, stderrFile, stderrStream);
+
+    if (supervisor?.status && FINAL_STATUSES.has(String(supervisor.status))) {
+      readAndWriteDelta(stdoutCursor, stdoutFile, stdoutStream);
+      readAndWriteDelta(stderrCursor, stderrFile, stderrStream);
+      return buildWatchResult(supervisor, result);
+    }
+
+    await sleep(pollMs);
+  }
+}