helloloop 0.9.1 → 0.10.0

package/src/host_continuation.mjs

@@ -0,0 +1,305 @@
+import path from "node:path";
+
+import { ensureDir, fileExists, nowIso, readJson, sleep, writeJson, writeText } from "./common.mjs";
+import { createContext } from "./context.mjs";
+import { collectRepoStatusSnapshot } from "./runner_status.mjs";
+
+const RESUME_DIR_NAME = "host-resume";
+const SNAPSHOT_FILE_NAME = "resume.json";
+const PROMPT_FILE_NAME = "resume-prompt.md";
+
+const ISSUE_MATCHERS = [
+  {
+    code: "rate_limit",
+    label: "429 / 限流或临时容量不足",
+    patterns: ["429", "too many requests", "rate limit", "retry limit", "capacity"],
+  },
+  {
+    code: "auth",
+    label: "403 / 鉴权、订阅或权限异常",
+    patterns: ["403", "forbidden", "subscription_not_found", "subscription", "not authenticated"],
+  },
+  {
+    code: "server",
+    label: "5xx / 服务端暂时异常",
+    patterns: ["500", "502", "503", "504", "server error", "service unavailable", "bad gateway"],
+  },
+  {
+    code: "network",
+    label: "网络或流中断",
+    patterns: ["network", "timeout", "timed out", "connection reset", "stream closed", "socket"],
+  },
+];
+
+function resumeRoot(context) {
+  return path.join(context.configRoot, RESUME_DIR_NAME);
+}
+
+function resumeFiles(context) {
+  const root = resumeRoot(context);
+  return {
+    root,
+    snapshotFile: path.join(root, SNAPSHOT_FILE_NAME),
+    promptFile: path.join(root, PROMPT_FILE_NAME),
+  };
+}
+
+function normalizeText(value) {
+  return String(value || "").trim();
+}
+
+function findIssue(summaryText) {
+  const normalized = normalizeText(summaryText).toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+
+  for (const matcher of ISSUE_MATCHERS) {
+    if (matcher.patterns.some((pattern) => normalized.includes(String(pattern).toLowerCase()))) {
+      return {
+        code: matcher.code,
+        label: matcher.label,
+        summary: normalizeText(summaryText),
+      };
+    }
+  }
+
+  return {
+    code: "unknown",
+    label: "宿主中断或未知异常",
+    summary: normalizeText(summaryText),
+  };
+}
+
+function shouldInferIssue(snapshot, summaryText) {
+  const normalized = normalizeText(summaryText).toLowerCase();
+  if (!normalized) {
+    return false;
+  }
+
+  if (["failed", "paused_manual", "probe_failed", "retry_waiting", "stopped_host_closed"].includes(
+    normalizeText(snapshot?.runtime?.status),
+  )) {
+    return true;
+  }
+  if (["failed", "stopped"].includes(normalizeText(snapshot?.supervisor?.status))) {
+    return true;
+  }
+
+  return ISSUE_MATCHERS.some((matcher) => matcher.patterns.some((pattern) => normalized.includes(String(pattern).toLowerCase())));
+}
+
+function buildCurrentAction(snapshot) {
+  return normalizeText(
+    snapshot?.activity?.current?.label
+    || snapshot?.runtime?.failureReason
+    || snapshot?.latestStatus?.message
+    || snapshot?.runtime?.status
+    || snapshot?.supervisor?.status
+    || "等待新事件",
+  );
+}
+
+function buildRecentFiles(snapshot) {
+  const changes = Array.isArray(snapshot?.activity?.recentFileChanges)
+    ? snapshot.activity.recentFileChanges
+    : [];
+  const firstGroup = changes.find((item) => Array.isArray(item?.changes) && item.changes.length);
+  if (!firstGroup) {
+    return [];
+  }
+  return firstGroup.changes.slice(0, 5).map((item) => `${item.kind}:${item.path}`);
+}
+
+function buildPromptLines(context, hostResume) {
+  const lines = [
+    "继续刚才被主 CLI / 主终端中断的 HelloLoop 会话，不要从头重新分析，不要忘记刚才中断前的任务。",
+    `目标仓库：${context.repoRoot}`,
+    `后台会话 ID：${hostResume.sessionId || "unknown"}`,
+    `后台命令：${hostResume.command || "unknown"}`,
+    `后台状态：${hostResume.supervisorStatus || "unknown"}`,
+    `当前任务：${hostResume.taskTitle || "无"}`,
+    `当前阶段：${hostResume.stage || "unknown"}`,
+    `当前动作：${hostResume.currentAction || "等待新事件"}`,
+    `当前运行状态：${hostResume.runtimeStatus || "idle"}`,
+  ];
+
+  if (hostResume.issue?.label) {
+    lines.push(`最近宿主异常：${hostResume.issue.label}`);
+  }
+  if (hostResume.issue?.summary) {
+    lines.push(`异常摘要：${hostResume.issue.summary}`);
+  }
+  if (hostResume.todoLabel) {
+    lines.push(`当前待办进度：${hostResume.todoLabel}`);
+  }
+  if (hostResume.nextTaskTitle) {
+    lines.push(`下一任务：${hostResume.nextTaskTitle}`);
+  }
+  if (hostResume.recentFiles.length) {
+    lines.push(`最近文件变化：${hostResume.recentFiles.join(" | ")}`);
+  }
+
+  lines.push("");
+  lines.push("接续规则：");
+  lines.push("1. 先读取 HelloLoop 当前状态；优先运行 `helloloop dashboard --json`，或至少运行 `helloloop status`。");
+  if (hostResume.supervisorActive) {
+    lines.push("2. 如果后台 supervisor 仍在运行，不要重复启动新的主线，只接续观察、汇报和必要控制。");
+  } else {
+    lines.push("2. 如果后台 supervisor 已停止，基于当前仓库和 backlog 从中断位置继续，不要重建无关任务。");
+  }
+  lines.push("3. 如果刚才是因为 429 / 403 / 网络抖动等宿主级异常中断，本轮要直接承接原任务，不要要求用户重复描述。");
+  lines.push("4. 只有发现后台已停且需要恢复时，才重新执行 `helloloop run-loop` / `helloloop run-once` / `helloloop analyze -y`。");
+  lines.push("5. 用户当前明确要求：继续刚才被中断之前的任务，并持续推进上面的开发工作。");
+
+  return lines;
+}
+
+export function buildHostContinuationSnapshot(context, options = {}) {
+  const snapshot = options.snapshot || collectRepoStatusSnapshot(context, options);
+  const sessionId = normalizeText(options.sessionId || snapshot?.supervisor?.sessionId);
+  const supervisorStatus = normalizeText(snapshot?.supervisor?.status);
+  const runtimeStatus = normalizeText(snapshot?.runtime?.status || snapshot?.latestStatus?.stage || "idle");
+  const currentAction = buildCurrentAction(snapshot);
+  const todoCompleted = Number(snapshot?.activity?.todo?.completed || 0);
+  const todoTotal = Number(snapshot?.activity?.todo?.total || 0);
+  const todoLabel = todoTotal > 0 ? `${todoCompleted}/${todoTotal}` : "";
+  const issueSummary = [
+    snapshot?.runtime?.failureReason,
+    snapshot?.latestStatus?.message,
+    snapshot?.runtime?.status,
+    currentAction,
+  ].filter(Boolean).join("\n");
+  const issue = shouldInferIssue(snapshot, issueSummary)
+    ? findIssue(issueSummary)
+    : null;
+  const recentFiles = buildRecentFiles(snapshot);
+
+  const hostResume = {
+    schemaVersion: 1,
+    generatedAt: nowIso(),
+    repoRoot: context.repoRoot,
+    repoName: path.basename(context.repoRoot),
+    sessionId,
+    command: normalizeText(snapshot?.supervisor?.command),
+    supervisorStatus,
+    supervisorActive: ["launching", "running"].includes(supervisorStatus),
+    stage: normalizeText(snapshot?.latestStatus?.stage),
+    taskId: snapshot?.latestStatus?.taskId || "",
+    taskTitle: normalizeText(snapshot?.latestStatus?.taskTitle),
+    runtimeStatus,
+    currentAction,
+    todoLabel,
+    issue,
+    nextTaskId: snapshot?.nextTask?.id || "",
+    nextTaskTitle: normalizeText(snapshot?.nextTask?.title),
+    recentFiles,
+    summary: snapshot?.summary || null,
+    prompt: "",
+  };
+
+  hostResume.prompt = buildPromptLines(context, hostResume).join("\n");
+  return hostResume;
+}
+
+export function refreshHostContinuationArtifacts(context, options = {}) {
+  const hostResume = buildHostContinuationSnapshot(context, options);
+  const files = resumeFiles(context);
+  ensureDir(files.root);
+  writeJson(files.snapshotFile, hostResume);
+  writeText(files.promptFile, `${hostResume.prompt}\n`);
+  return {
+    ...hostResume,
+    snapshotFile: files.snapshotFile,
+    promptFile: files.promptFile,
+  };
+}
+
+export function readHostContinuationSnapshot(context, options = {}) {
+  const files = resumeFiles(context);
+  if (!options.refresh && fileExists(files.snapshotFile)) {
+    try {
+      const loaded = readJson(files.snapshotFile);
+      return {
+        ...loaded,
+        snapshotFile: files.snapshotFile,
+        promptFile: files.promptFile,
+      };
+    } catch {
+      // fallback to rebuilding below
+    }
+  }
+  return refreshHostContinuationArtifacts(context, options);
+}
+
+export function renderHostContinuationText(hostResume) {
+  return [
+    "HelloLoop 宿主续跑提示",
+    "======================",
+    `仓库：${hostResume.repoRoot}`,
+    `后台会话：${hostResume.sessionId || "unknown"}`,
+    `后台命令：${hostResume.command || "unknown"}`,
+    `后台状态：${hostResume.supervisorStatus || "unknown"}`,
+    `当前任务：${hostResume.taskTitle || "无"}`,
+    `当前阶段：${hostResume.stage || "unknown"}`,
+    `当前动作：${hostResume.currentAction || "等待新事件"}`,
+    ...(hostResume.issue?.label ? [`最近异常：${hostResume.issue.label}`] : []),
+    ...(hostResume.todoLabel ? [`当前待办：${hostResume.todoLabel}`] : []),
+    ...(hostResume.nextTaskTitle ? [`下一任务：${hostResume.nextTaskTitle}`] : []),
+    "",
+    hostResume.prompt,
+  ].filter(Boolean).join("\n");
+}
+
+function buildResumeSignature(hostResume) {
+  return JSON.stringify({
+    sessionId: hostResume.sessionId,
+    supervisorStatus: hostResume.supervisorStatus,
+    taskId: hostResume.taskId,
+    stage: hostResume.stage,
+    runtimeStatus: hostResume.runtimeStatus,
+    currentAction: hostResume.currentAction,
+    todoLabel: hostResume.todoLabel,
+    issueCode: hostResume.issue?.code || "",
+    nextTaskId: hostResume.nextTaskId,
+  });
+}
+
+export async function runHostContinuationCommand(context, options = {}) {
+  const pollMs = Math.max(500, Number(options.pollMs || options.watchPollMs || 2000));
+  let previousSignature = "";
+
+  while (true) {
+    const hostResume = refreshHostContinuationArtifacts(context, options);
+    const signature = buildResumeSignature(hostResume);
+
+    if (signature !== previousSignature || !options.watch) {
+      previousSignature = signature;
+      if (options.json) {
+        console.log(JSON.stringify(hostResume));
+      } else {
+        if (options.watch && process.stdout.isTTY) {
+          process.stdout.write("\x1bc");
+        }
+        console.log(renderHostContinuationText(hostResume));
+      }
+    }
+
+    if (!options.watch) {
+      return 0;
+    }
+
+    await sleep(pollMs);
+  }
+}
+
+export function buildDashboardHostContinuation(entry, repoSnapshot) {
+  const context = createContext({
+    repoRoot: entry.repoRoot,
+    configDirName: entry.configDirName,
+  });
+  return buildHostContinuationSnapshot(context, {
+    snapshot: repoSnapshot,
+    sessionId: entry.sessionId,
+  });
+}

package/src/install_codex.mjs

@@ -5,9 +5,11 @@ import {
   assertPathInside,
   codexBundleEntries,
   copyBundleEntries,
+  isSamePath,
   readExistingJsonOrThrow,
   removePathIfExists,
   removeTargetIfNeeded,
+  runtimeBundleEntries,
   resolveCodexLocalRoot,
   resolveHomeDir,
 } from "./install_shared.mjs";
@@ -145,6 +147,8 @@ export function installCodexHost(bundleRoot, options = {}) {
   const configFile = path.join(resolvedCodexHome, "config.toml");
   const manifestFile = path.join(bundleRoot, ".codex-plugin", "plugin.json");
   const existingMarketplace = readExistingJsonOrThrow(marketplaceFile, "Codex marketplace 配置");
+  const bundleIsPluginRoot = isSamePath(bundleRoot, targetPluginRoot);
+  const bundleIsInstalledRoot = isSamePath(bundleRoot, targetInstalledPluginRoot);
 
   if (!fileExists(manifestFile)) {
     throw new Error(`未找到 Codex 插件 manifest：${manifestFile}`);
@@ -152,16 +156,24 @@ export function installCodexHost(bundleRoot, options = {}) {
 
   assertPathInside(resolvedLocalRoot, targetPluginRoot, "Codex 本地插件目录");
   assertPathInside(resolvedCodexHome, targetPluginCacheRoot, "Codex 插件缓存目录");
-  removeTargetIfNeeded(targetPluginRoot, options.force);
-  removeTargetIfNeeded(targetPluginCacheRoot, options.force);
+  if (!bundleIsPluginRoot) {
+    removeTargetIfNeeded(targetPluginRoot, options.force);
+  }
+  if (!bundleIsInstalledRoot) {
+    removeTargetIfNeeded(targetPluginCacheRoot, options.force);
+  }
 
   ensureDir(targetPluginsRoot);
-  ensureDir(targetPluginRoot);
-  ensureDir(targetInstalledPluginRoot);
-  copyBundleEntries(bundleRoot, targetPluginRoot, codexBundleEntries);
-  copyBundleEntries(bundleRoot, targetInstalledPluginRoot, codexBundleEntries);
-  removePathIfExists(path.join(targetPluginRoot, ".git"));
-  removePathIfExists(path.join(targetInstalledPluginRoot, ".git"));
+  if (!bundleIsPluginRoot) {
+    ensureDir(targetPluginRoot);
+    copyBundleEntries(bundleRoot, targetPluginRoot, runtimeBundleEntries);
+    removePathIfExists(path.join(targetPluginRoot, ".git"));
+  }
+  if (!bundleIsInstalledRoot) {
+    ensureDir(targetInstalledPluginRoot);
+    copyBundleEntries(bundleRoot, targetInstalledPluginRoot, codexBundleEntries);
+    removePathIfExists(path.join(targetInstalledPluginRoot, ".git"));
+  }
 
   ensureDir(path.dirname(marketplaceFile));
   updateCodexMarketplace(marketplaceFile, existingMarketplace);

package/src/install_shared.mjs

@@ -11,6 +11,7 @@ export const runtimeBundleEntries = [
   "README.md",
   "bin",
   "hosts",
+  "native",
   "package.json",
   "scripts",
   "skills",
@@ -46,6 +47,14 @@ export function assertPathInside(parentDir, targetDir, label) {
   }
 }
 
+export function isSamePath(leftPath, rightPath) {
+  if (!leftPath || !rightPath) {
+    return false;
+  }
+  const normalize = (value) => path.resolve(value).replace(/[\\\/]+$/u, "").toLowerCase();
+  return normalize(leftPath) === normalize(rightPath);
+}
+
 function sleepSync(ms) {
   const shared = new SharedArrayBuffer(4);
   const view = new Int32Array(shared);

package/src/node_process_launch.mjs

@@ -0,0 +1,28 @@
+import { spawn } from "node:child_process";
+
+import {
+  HIDDEN_PROCESS_PROXY_TARGET_ENV,
+  resolveWindowsHiddenProcessProxyExecutable,
+} from "./windows_hidden_shell_proxy.mjs";
+
+export function spawnNodeProcess(options = {}) {
+  const useWindowsHiddenProxy = process.platform === "win32";
+  const command = useWindowsHiddenProxy
+    ? resolveWindowsHiddenProcessProxyExecutable()
+    : process.execPath;
+
+  return spawn(command, Array.isArray(options.args) ? options.args : [], {
+    cwd: options.cwd || process.cwd(),
+    detached: options.detached === true,
+    shell: false,
+    windowsHide: true,
+    stdio: options.stdio || "pipe",
+    env: {
+      ...process.env,
+      ...(options.env || {}),
+      ...(useWindowsHiddenProxy
+        ? { [HIDDEN_PROCESS_PROXY_TARGET_ENV]: process.execPath }
+        : {}),
+    },
+  });
+}

package/src/process.mjs

@@ -19,6 +19,7 @@ export async function runCodexExec({ context, prompt, runDir, policy, hostLease
     policy,
     executionMode: "execute",
     outputPrefix: "codex",
+    skipGitRepoCheck: true,
     hostLease,
   });
 }
@@ -32,6 +33,7 @@ export async function runEngineExec({ engine, context, prompt, runDir, policy, h
     policy,
     executionMode: "execute",
     outputPrefix: engine,
+    skipGitRepoCheck: engine === "codex",
     hostLease,
   });
 }

package/src/runner_execute_task.mjs

@@ -3,6 +3,7 @@ import path from "node:path";
 import { rememberEngineSelection } from "./engine_selection.mjs";
 import { getEngineDisplayName } from "./engine_metadata.mjs";
 import { ensureDir, nowIso, writeText } from "./common.mjs";
+import { refreshHostContinuationArtifacts } from "./host_continuation.mjs";
 import { isHostLeaseAlive } from "./host_lease.mjs";
 import { saveBacklog, writeStatus } from "./config.mjs";
 import { reviewTaskCompletion } from "./completion_review.mjs";
@@ -277,6 +278,9 @@ export async function executeSingleTask(context, options = {}) {
     summary: "",
     message: `开始执行任务：${execution.task.title}`,
   });
+  refreshHostContinuationArtifacts(context, {
+    sessionId: options.supervisorSessionId || "",
+  });
 
   const state = {
     engineResolution: execution.engineResolution,

package/src/runner_execution_support.mjs

@@ -2,7 +2,7 @@ import {
   rememberEngineSelection,
   resolveEngineSelection,
 } from "./engine_selection.mjs";
-import { nowIso } from "./common.mjs";
+import { fileExists, nowIso, readJson } from "./common.mjs";
 import {
   loadBacklog,
   loadPolicy,
@@ -13,6 +13,72 @@ import {
 } from "./config.mjs";
 import { getTask, selectNextTask, unresolvedDependencies, updateTask } from "./backlog.mjs";
 import { makeRunDir } from "./runner_status.mjs";
+import { shouldPromptForEngineSelection } from "./execution_interactivity.mjs";
+
+function isPidAlive(pid) {
+  const value = Number(pid || 0);
+  if (!Number.isFinite(value) || value <= 0) {
+    return false;
+  }
+  try {
+    process.kill(value, 0);
+    return true;
+  } catch (error) {
+    return String(error?.code || "") === "EPERM";
+  }
+}
+
+function hasLiveSupervisor(context) {
+  if (!fileExists(context.supervisorStateFile)) {
+    return false;
+  }
+  try {
+    const supervisor = readJson(context.supervisorStateFile);
+    const status = String(supervisor?.status || "").trim();
+    if (!["launching", "running"].includes(status)) {
+      return false;
+    }
+    return isPidAlive(supervisor?.pid);
+  } catch {
+    return false;
+  }
+}
+
+function recoverStaleInProgressTasks(context, backlog, options = {}) {
+  const staleTasks = Array.isArray(backlog?.tasks)
+    ? backlog.tasks.filter((task) => task?.status === "in_progress")
+    : [];
+  if (!staleTasks.length) {
+    return backlog;
+  }
+
+  let shouldRecover = !hasLiveSupervisor(context);
+  if (!shouldRecover && fileExists(context.statusFile)) {
+    try {
+      const latestStatus = readJson(context.statusFile);
+      const currentSessionId = String(options.supervisorSessionId || "").trim();
+      const recordedSessionId = String(latestStatus?.sessionId || "").trim();
+      if (currentSessionId && recordedSessionId && currentSessionId !== recordedSessionId) {
+        shouldRecover = true;
+      }
+    } catch {
+      // ignore malformed status files and keep current decision
+    }
+  }
+  if (!shouldRecover) {
+    return backlog;
+  }
+
+  for (const task of staleTasks) {
+    updateTask(backlog, task.id, {
+      status: "pending",
+      startedAt: "",
+      finishedAt: "",
+    });
+  }
+  saveBacklog(context, backlog);
+  return backlog;
+}
 
 function resolveTask(backlog, options) {
   if (options.taskId) {
@@ -28,7 +94,7 @@ function resolveTask(backlog, options) {
 export async function resolveExecutionSetup(context, options = {}) {
   const policy = loadPolicy(context);
   const projectConfig = loadProjectConfig(context);
-  const backlog = loadBacklog(context);
+  const backlog = recoverStaleInProgressTasks(context, loadBacklog(context), options);
   const task = resolveTask(backlog, options);
   if (!task) {
     return {
@@ -52,7 +118,7 @@ export async function resolveExecutionSetup(context, options = {}) {
       context,
       policy,
       options,
-      interactive: !options.yes,
+      interactive: shouldPromptForEngineSelection(options),
     });
 
   return {

package/src/runner_once.mjs

@@ -1,5 +1,6 @@
 import { selectNextTask, summarizeBacklog } from "./backlog.mjs";
 import { loadBacklog, writeStateMarkdown, writeStatus } from "./config.mjs";
+import { refreshHostContinuationArtifacts } from "./host_continuation.mjs";
 import { executeSingleTask } from "./runner_execute_task.mjs";
 import { renderStatusMarkdown } from "./runner_status.mjs";
 
@@ -25,6 +26,9 @@ export async function runOnce(context, options = {}) {
     lastResult: result.ok ? "本轮成功" : (result.summary || result.kind),
     nextTask,
   }));
+  refreshHostContinuationArtifacts(context, {
+    sessionId: options.supervisorSessionId || "",
+  });
 
   return result;
 }

package/src/runner_status.mjs

@@ -1,5 +1,10 @@
 import path from "node:path";
 
+import {
+  readJsonIfExists,
+  selectLatestActivityFile,
+  selectLatestRuntimeFile,
+} from "./activity_projection.mjs";
 import { fileExists, readJson, sanitizeId, tailText, timestampForFile } from "./common.mjs";
 import { renderTaskSummary, selectNextTask, summarizeBacklog } from "./backlog.mjs";
 import { loadBacklog } from "./config.mjs";
@@ -83,16 +88,42 @@ export function renderStatusMarkdown(context, { summary, currentTask, lastResult
   ].join("\n");
 }
 
-export function renderStatusText(context, options = {}) {
+export function collectRepoStatusSnapshot(context, options = {}) {
   const backlog = loadBacklog(context);
   const summary = summarizeBacklog(backlog);
   const nextTask = selectNextTask(backlog, options);
-  const supervisor = fileExists(context.supervisorStateFile)
-    ? readJson(context.supervisorStateFile)
-    : null;
-  const latestStatus = fileExists(context.statusFile)
-    ? readJson(context.statusFile)
-    : null;
+  const supervisor = fileExists(context.supervisorStateFile) ? readJson(context.supervisorStateFile) : null;
+  const latestStatus = fileExists(context.statusFile) ? readJson(context.statusFile) : null;
+  const runtimeFile = latestStatus?.runDir ? selectLatestRuntimeFile(latestStatus.runDir) : "";
+  const runtime = readJsonIfExists(runtimeFile);
+  const activityFile = runtime?.activityFile && fileExists(runtime.activityFile)
+    ? runtime.activityFile
+    : (latestStatus?.runDir ? selectLatestActivityFile(latestStatus.runDir, runtime?.attemptPrefix || "") : "");
+  const activity = readJsonIfExists(activityFile);
+
+  return {
+    summary,
+    nextTask,
+    supervisor,
+    latestStatus,
+    runtimeFile,
+    runtime,
+    activityFile,
+    activity,
+  };
+}
+
+export function renderStatusText(context, options = {}) {
+  const snapshot = collectRepoStatusSnapshot(context, options);
+  const {
+    summary,
+    nextTask,
+    supervisor,
+    latestStatus,
+    runtime,
+    activity,
+  } = snapshot;
+  const hostResume = options.hostResume || null;
 
   return [
     "HelloLoop 状态",
@@ -109,6 +140,9 @@ export function renderStatusText(context, options = {}) {
         `后台会话：${supervisor.status}`,
         `后台会话 ID：${supervisor.sessionId || "unknown"}`,
         `后台租约：${renderHostLeaseLabel(supervisor.lease)}`,
+        ...(Number.isFinite(Number(supervisor.guardianRestartCount)) && Number(supervisor.guardianRestartCount) > 0
+          ? [`守护重拉起次数：${supervisor.guardianRestartCount}`]
+          : []),
       ]
       : []),
     ...(latestStatus?.taskTitle
@@ -118,10 +152,32 @@ export function renderStatusText(context, options = {}) {
         `当前运行阶段：${latestStatus.stage || "unknown"}`,
       ]
       : []),
+    ...(runtime?.status
+      ? [
+        `当前引擎状态：${runtime.status}`,
+        ...(Number.isFinite(Number(runtime.recoveryCount))
+          ? [`自动恢复次数：${runtime.recoveryCount}`]
+          : []),
+      ]
+      : []),
+    ...(activity?.current?.label
+      ? [`当前动作：${activity.current.label}`]
+      : []),
+    ...(activity?.todo?.total
+      ? [`当前待办：${activity.todo.completed}/${activity.todo.total}`]
+      : []),
+    ...(Array.isArray(activity?.activeCommands) && activity.activeCommands[0]?.label
+      ? [`活动命令：${activity.activeCommands[0].label}`]
+      : []),
+    ...(hostResume?.issue?.label
+      ? [`宿主续跑：${hostResume.issue.label}`]
+      : (hostResume?.supervisorActive ? ["宿主续跑：后台仍在运行，可直接接续观察"] : [])),
     "",
     nextTask ? "下一任务：" : "下一任务：无",
     nextTask ? renderTaskSummary(nextTask) : "",
     "",
+    "聚合看板：helloloop dashboard",
+    "续跑提示：helloloop resume-host",
     "实时观察：helloloop watch",
   ].filter(Boolean).join("\n");
 }