helloloop 0.8.2 → 0.8.5

package/src/cli_analyze_command.mjs

@@ -15,11 +15,15 @@ import {
 import { loadBacklog, loadPolicy } from "./config.mjs";
 import { createContext } from "./context.mjs";
 import { createDiscoveryPromptSession, resolveDiscoveryFailureInteractively } from "./discovery_prompt.mjs";
-import { resolveEngineSelection } from "./engine_selection.mjs";
+import { resolveEngineSelection, resolveHostContext } from "./engine_selection.mjs";
 import { resetRepoForRebuild } from "./rebuild.mjs";
-import { runLoop } from "./runner.mjs";
 import { renderRebuildSummary } from "./cli_render.mjs";
 import { shouldConfirmRepoRebuild } from "./cli_support.mjs";
+import {
+  launchSupervisedCommand,
+  renderSupervisorLaunchSummary,
+  waitForSupervisedResult,
+} from "./supervisor_runtime.mjs";
 
 async function resolveAnalyzeEngineSelection(options) {
   if (options.engineResolution?.ok) {
@@ -202,6 +206,11 @@ async function prepareAnalyzeExecution(initialOptions) {
   }
 }
 
+function shouldDetachSupervisor(options = {}) {
+  return process.env.HELLOLOOP_SUPERVISOR_ACTIVE !== "1"
+    && resolveHostContext(options) !== "terminal";
+}
+
 async function maybeRunAutoExecution(result, activeOptions) {
   const execution = analyzeExecution(result.backlog, activeOptions);
 
@@ -222,15 +231,27 @@ async function maybeRunAutoExecution(result, activeOptions) {
 
   console.log("");
   console.log("开始自动接续执行...");
-  const results = await runLoop(result.context, {
+  const session = launchSupervisedCommand(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));
+  if (shouldDetachSupervisor(activeOptions)) {
+    console.log("- 已切换为后台执行；可稍后运行 `helloloop status` 查看进度。");
+    return 0;
+  }
+  const supervisorPayload = await waitForSupervisedResult(result.context, session);
+  const results = supervisorPayload.results;
+  if (!results) {
+    console.error(supervisorPayload.error || "HelloLoop supervisor 执行失败。");
+    return supervisorPayload.exitCode || 1;
+  }
   const refreshedBacklog = loadBacklog(result.context);
   console.log(renderAutoRunSummary(result.context, refreshedBacklog, results, activeOptions));
-  return results.some((item) => !item.ok) ? 1 : 0;
+  return supervisorPayload.exitCode || 0;
 }
 
 export async function handleAnalyzeCommand(options) {

package/src/cli_args.mjs

@@ -1,6 +1,7 @@
 const REPO_ROOT_PLACEHOLDER = "<REPO_ROOT>";
 const DOCS_PATH_PLACEHOLDER = "<DOCS_PATH>";
 const KNOWN_COMMANDS = new Set([
+  "__supervise",
   "analyze",
   "install",
   "uninstall",
@@ -49,6 +50,8 @@ export function parseArgs(argv) {
     else if (arg === "--claude-home") { options.claudeHome = rest[index + 1]; index += 1; }
     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 === "--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); }
@@ -87,6 +90,7 @@ function helpText() {
     "  --max-tasks <n>       run-loop 最多执行 n 个任务",
     "  --max-attempts <n>    每种策略内最多重试 n 次",
     "  --max-strategies <n>  单任务最多切换 n 种策略继续重试",
+    "  --supervised          通过独立 supervisor 执行；当前 turn 被中断时任务仍可继续",
     "  --allow-high-risk     允许执行 medium/high/critical 风险任务",
     "  --rebuild-existing    分析判断当前项目与文档冲突时，自动清理当前项目后按文档重建",
     "  --required-doc <p>    增加一个全局必读文档（AGENTS.md 会被自动忽略）",
@@ -95,6 +99,7 @@ function helpText() {
     "补充说明：",
     "  analyze 默认支持在命令后混合传入引擎、路径和自然语言要求。",
     "  如果同时检测到多个可用引擎且没有明确指定，会先询问你选择。",
+    "  在 Codex / Claude / Gemini 宿主内，确认后的自动执行会默认切到后台 supervisor。",
     "  示例：npx helloloop claude <DOCS_PATH> <PROJECT_ROOT> 先分析偏差，不要执行",
   ].join("\n");
 }

package/src/cli_command_handlers.mjs

@@ -2,10 +2,41 @@ import path from "node:path";
 
 import { createContext } from "./context.mjs";
 import { loadBacklog, scaffoldIfMissing } from "./config.mjs";
+import { resolveHostContext } from "./engine_selection.mjs";
 import { syncUserSettingsFile } from "./engine_selection_settings.mjs";
 import { installPluginBundle, uninstallPluginBundle } from "./install.mjs";
 import { runLoop, runOnce, renderStatusText } from "./runner.mjs";
 import { renderInstallSummary, renderUninstallSummary } from "./cli_render.mjs";
+import {
+  launchSupervisedCommand,
+  renderSupervisorLaunchSummary,
+  waitForSupervisedResult,
+} from "./supervisor_runtime.mjs";
+
+function shouldUseSupervisor(options = {}) {
+  return !options.dryRun
+    && process.env.HELLOLOOP_SUPERVISOR_ACTIVE !== "1"
+    && (Boolean(options.supervised) || resolveHostContext(options) !== "terminal");
+}
+
+function shouldDetachSupervisor(options = {}) {
+  return resolveHostContext(options) !== "terminal";
+}
+
+async function runSupervised(context, command, options = {}) {
+  const session = launchSupervisedCommand(context, command, options);
+  console.log(renderSupervisorLaunchSummary(session));
+  if (shouldDetachSupervisor(options)) {
+    console.log("- 已切换为后台执行；可稍后运行 `helloloop status` 查看进度。");
+    return {
+      detached: true,
+      exitCode: 0,
+      ok: true,
+      session,
+    };
+  }
+  return waitForSupervisedResult(context, session);
+}
 
 export function handleInstallCommand(options) {
   const userSettings = syncUserSettingsFile({
@@ -87,6 +118,28 @@ export async function handleNextCommand(context, options) {
 }
 
 export async function handleRunOnceCommand(context, options) {
+  if (shouldUseSupervisor(options)) {
+    const payload = await runSupervised(context, "run-once", options);
+    if (payload.detached) {
+      return payload.exitCode || 0;
+    }
+    if (!payload.result) {
+      console.error(payload.error || "HelloLoop supervisor 执行失败。");
+      return payload.exitCode || 1;
+    }
+
+    const result = payload.result;
+    if (!result.ok) {
+      console.error(result.summary || "执行失败。");
+      return payload.exitCode || 1;
+    }
+
+    console.log(result.task
+      ? `完成任务：${result.task.title}\n运行目录：${result.runDir}`
+      : "没有可执行任务。");
+    return 0;
+  }
+
   const result = await runOnce(context, options);
   if (!result.ok) {
     console.error(result.summary || "执行失败。");
@@ -106,6 +159,31 @@ export async function handleRunOnceCommand(context, options) {
 }
 
 export async function handleRunLoopCommand(context, options) {
+  if (shouldUseSupervisor(options)) {
+    const payload = await runSupervised(context, "run-loop", options);
+    if (payload.detached) {
+      return payload.exitCode || 0;
+    }
+    if (!payload.results) {
+      console.error(payload.error || "HelloLoop supervisor 执行失败。");
+      return payload.exitCode || 1;
+    }
+
+    const failed = payload.results.find((item) => !item.ok);
+    for (const item of payload.results) {
+      if (!item.task) {
+        console.log("没有更多可执行任务。");
+        break;
+      }
+      console.log(`${item.ok ? "成功" : "失败"}：${item.task.title}`);
+    }
+    if (failed) {
+      console.error(failed.summary || "连续执行中断。");
+      return payload.exitCode || 1;
+    }
+    return 0;
+  }
+
   const results = await runLoop(context, options);
   const failed = results.find((item) => !item.ok);
 

package/src/completion_review.mjs

@@ -189,6 +189,7 @@ export async function reviewTaskCompletion({
   verifyResult = null,
   runDir,
   policy = {},
+  hostLease = null,
 }) {
   const prompt = buildTaskReviewPrompt({
     task,
@@ -209,6 +210,7 @@ export async function reviewTaskCompletion({
     outputSchemaFile: schemaFile,
     outputPrefix: `${engine}-task-review`,
     skipGitRepoCheck: true,
+    hostLease,
   });
 
   if (!reviewResult.ok) {

package/src/context.mjs

@@ -30,6 +30,12 @@ export function createContext(options = {}) {
     statusFile: resolveFrom(configRoot, "status.json"),
     stateFile: resolveFrom(configRoot, "STATE.md"),
     runsDir: resolveFrom(configRoot, "runs"),
+    supervisorRoot: resolveFrom(configRoot, "supervisor"),
+    supervisorRequestFile: resolveFrom(configRoot, "supervisor", "request.json"),
+    supervisorStateFile: resolveFrom(configRoot, "supervisor", "state.json"),
+    supervisorResultFile: resolveFrom(configRoot, "supervisor", "result.json"),
+    supervisorStdoutFile: resolveFrom(configRoot, "supervisor", "stdout.log"),
+    supervisorStderrFile: resolveFrom(configRoot, "supervisor", "stderr.log"),
     repoVerifyFile: resolveFrom(repoRoot, ".helloagents", "verify.yaml"),
   };
 }

package/src/engine_process_support.mjs

@@ -7,6 +7,15 @@ import {
   resolveVerifyShellInvocation,
 } from "./shell_invocation.mjs";
 
+export function isIgnorableStdinError(error) {
+  const code = String(error?.code || "").trim();
+  const message = String(error?.message || "").toLowerCase();
+  return code === "EPIPE"
+    || code === "ERR_STREAM_DESTROYED"
+    || message.includes("broken pipe")
+    || message.includes("write after end");
+}
+
 export function runChild(command, args, options = {}) {
   return new Promise((resolve) => {
     const child = spawn(command, args, {
@@ -29,6 +38,27 @@ export function runChild(command, args, options = {}) {
     let watchdogReason = "";
     let stallWarned = false;
     let killTimer = null;
+    let leaseExpired = false;
+    let leaseReason = "";
+
+    const requestLeaseTermination = () => {
+      if (leaseExpired) {
+        return;
+      }
+      leaseExpired = true;
+      leaseReason = String(options.leaseStopReason || "检测到宿主窗口已关闭，HelloLoop 已停止当前子进程。").trim();
+      stderr = [
+        stderr.trim(),
+        `[HelloLoop host-lease] ${leaseReason}`,
+      ].filter(Boolean).join("\n");
+      emitHeartbeat("lease_terminating", {
+        message: leaseReason,
+      });
+      child.kill();
+      killTimer = setTimeout(() => {
+        child.kill("SIGKILL");
+      }, killGraceMs);
+    };
 
     const emitHeartbeat = (status, extra = {}) => {
       options.onHeartbeat?.({
@@ -41,6 +71,8 @@ export function runChild(command, args, options = {}) {
         idleSeconds: Math.max(0, Math.floor((Date.now() - lastOutputAt) / 1000)),
         watchdogTriggered,
         watchdogReason,
+        leaseExpired,
+        leaseReason,
         ...extra,
       });
     };
@@ -52,6 +84,11 @@ export function runChild(command, args, options = {}) {
 
     const heartbeatTimer = heartbeatIntervalMs > 0
       ? setInterval(() => {
+        if (typeof options.shouldKeepRunning === "function" && !options.shouldKeepRunning()) {
+          requestLeaseTermination();
+          return;
+        }
+
         const idleMs = Date.now() - lastOutputAt;
         if (stallWarningMs > 0 && idleMs >= stallWarningMs && !stallWarned) {
           stallWarned = true;
@@ -98,10 +135,29 @@ export function runChild(command, args, options = {}) {
       emitHeartbeat("running");
     });
 
-    if (options.stdin) {
-      child.stdin.write(options.stdin);
+    child.stdin.on("error", (error) => {
+      if (isIgnorableStdinError(error)) {
+        return;
+      }
+      stderr = [
+        stderr.trim(),
+        `[HelloLoop stdin] ${String(error?.stack || error || "")}`,
+      ].filter(Boolean).join("\n");
+    });
+
+    try {
+      if (options.stdin) {
+        child.stdin.write(options.stdin);
+      }
+      child.stdin.end();
+    } catch (error) {
+      if (!isIgnorableStdinError(error)) {
+        stderr = [
+          stderr.trim(),
+          `[HelloLoop stdin] ${String(error?.stack || error || "")}`,
+        ].filter(Boolean).join("\n");
+      }
     }
-    child.stdin.end();
 
     child.on("error", (error) => {
       if (heartbeatTimer) {
@@ -125,6 +181,8 @@ export function runChild(command, args, options = {}) {
         idleTimeout: watchdogTriggered,
         watchdogTriggered,
         watchdogReason,
+        leaseExpired,
+        leaseReason,
       });
     });
 
@@ -150,6 +208,8 @@ export function runChild(command, args, options = {}) {
         idleTimeout: watchdogTriggered,
         watchdogTriggered,
         watchdogReason,
+        leaseExpired,
+        leaseReason,
       });
     });
   });

package/src/host_lease.mjs

@@ -0,0 +1,204 @@
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+import { getHostDisplayName, normalizeHostContext } from "./engine_metadata.mjs";
+
+const HOST_PROCESS_NAMES = Object.freeze({
+  codex: ["codex", "codex.exe"],
+  claude: ["claude", "claude.exe"],
+  gemini: ["gemini", "gemini.exe"],
+});
+
+const SHELL_PROCESS_NAMES = new Set([
+  "bash",
+  "cmd",
+  "cmd.exe",
+  "fish",
+  "nu",
+  "nu.exe",
+  "powershell",
+  "powershell.exe",
+  "pwsh",
+  "pwsh.exe",
+  "sh",
+  "tmux",
+  "tmux.exe",
+  "zsh",
+]);
+
+function normalizeProcessName(value) {
+  const raw = path.basename(String(value || "").trim()).toLowerCase();
+  return raw;
+}
+
+function parseUnixProcessTable(text) {
+  return String(text || "")
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const match = line.match(/^(\d+)\s+(\d+)\s+(.+)$/);
+      if (!match) {
+        return null;
+      }
+      return {
+        pid: Number(match[1]),
+        parentPid: Number(match[2]),
+        name: normalizeProcessName(match[3]),
+      };
+    })
+    .filter(Boolean);
+}
+
+function loadProcessTable() {
+  if (process.platform === "win32") {
+    const command = "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name | ConvertTo-Json -Compress";
+    const text = execFileSync("powershell.exe", [
+      "-NoLogo",
+      "-NoProfile",
+      "-Command",
+      command,
+    ], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
+    }).trim();
+    const payload = JSON.parse(text || "[]");
+    const rows = Array.isArray(payload) ? payload : [payload];
+    return rows.map((item) => ({
+      pid: Number(item?.ProcessId || 0),
+      parentPid: Number(item?.ParentProcessId || 0),
+      name: normalizeProcessName(item?.Name || ""),
+    })).filter((item) => item.pid > 0);
+  }
+
+  const text = execFileSync("ps", [
+    "-eo",
+    "pid=,ppid=,comm=",
+  ], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+  return parseUnixProcessTable(text);
+}
+
+function buildAncestry(currentPid = process.pid) {
+  const rows = loadProcessTable();
+  const byPid = new Map(rows.map((item) => [item.pid, item]));
+  const ancestry = [];
+  const seen = new Set();
+  let cursor = byPid.get(Number(currentPid)) || {
+    pid: Number(currentPid),
+    parentPid: Number(process.ppid || 0),
+    name: normalizeProcessName(process.argv[0] || "node"),
+  };
+
+  while (cursor && cursor.pid > 0 && !seen.has(cursor.pid)) {
+    ancestry.push(cursor);
+    seen.add(cursor.pid);
+    cursor = byPid.get(cursor.parentPid);
+  }
+
+  return ancestry;
+}
+
+function matchesHostContext(name, hostContext) {
+  return (HOST_PROCESS_NAMES[hostContext] || []).includes(name);
+}
+
+function pickLeaseCandidate(ancestry, hostContext) {
+  const parents = ancestry.slice(1);
+  if (!parents.length) {
+    return null;
+  }
+
+  if (hostContext !== "terminal") {
+    const matchedHost = parents.find((item) => matchesHostContext(item.name, hostContext));
+    if (matchedHost) {
+      return { ...matchedHost, kind: "host" };
+    }
+  }
+
+  const anyKnownHost = parents.find((item) => (
+    matchesHostContext(item.name, "codex")
+    || matchesHostContext(item.name, "claude")
+    || matchesHostContext(item.name, "gemini")
+  ));
+  if (anyKnownHost) {
+    return { ...anyKnownHost, kind: "host" };
+  }
+
+  const shell = parents.find((item) => SHELL_PROCESS_NAMES.has(item.name));
+  if (shell) {
+    return { ...shell, kind: "shell" };
+  }
+
+  return {
+    ...parents[0],
+    kind: "parent",
+  };
+}
+
+export function resolveHostLease({ hostContext, env = process.env, currentPid = process.pid } = {}) {
+  const normalizedHostContext = normalizeHostContext(hostContext);
+  const overridePid = Number(env.HELLOLOOP_HOST_LEASE_PID || 0);
+  if (Number.isFinite(overridePid) && overridePid > 0) {
+    return {
+      pid: overridePid,
+      name: normalizeProcessName(env.HELLOLOOP_HOST_LEASE_NAME || normalizedHostContext || "host"),
+      kind: "override",
+      hostContext: normalizedHostContext,
+      hostDisplayName: getHostDisplayName(normalizedHostContext),
+    };
+  }
+
+  try {
+    const candidate = pickLeaseCandidate(buildAncestry(currentPid), normalizedHostContext);
+    if (candidate?.pid > 0) {
+      return {
+        pid: candidate.pid,
+        name: candidate.name,
+        kind: candidate.kind,
+        hostContext: normalizedHostContext,
+        hostDisplayName: getHostDisplayName(normalizedHostContext),
+      };
+    }
+  } catch {
+    // ignore host lease discovery failures and fall back to immediate parent
+  }
+
+  return {
+    pid: Number(process.ppid || 0),
+    name: "",
+    kind: "fallback_parent",
+    hostContext: normalizedHostContext,
+    hostDisplayName: getHostDisplayName(normalizedHostContext),
+  };
+}
+
+export function isHostLeaseAlive(lease = {}) {
+  const pid = Number(lease?.pid || 0);
+  if (!Number.isFinite(pid) || pid <= 0) {
+    return true;
+  }
+
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return String(error?.code || "") === "EPERM";
+  }
+}
+
+export function renderHostLeaseLabel(lease = {}) {
+  const pid = Number(lease?.pid || 0);
+  const name = String(lease?.name || "").trim();
+  const displayName = String(lease?.hostDisplayName || getHostDisplayName(lease?.hostContext)).trim() || "当前宿主";
+  if (pid > 0 && name) {
+    return `${displayName}（${name} / pid=${pid}）`;
+  }
+  if (pid > 0) {
+    return `${displayName}（pid=${pid}）`;
+  }
+  return `${displayName}（未检测到稳定宿主进程）`;
+}