@linghun/tui 0.1.0 → 0.1.1

package/dist/index.js

@@ -13,10 +13,10 @@ import {
 } from "./chunk-O7EFPSMC.js";
 import {
   handleAppsCommand
-} from "./chunk-JDWXC2OQ.js";
+} from "./chunk-624A7BBJ.js";
 import {
   handleCapabilitiesCommand
-} from "./chunk-QB4VWH7W.js";
+} from "./chunk-LIPZJNXS.js";
 import {
   __testFormatStartAgentDidNotStartMessage,
   __testParseRunWorkflowToolInput,
@@ -28,9 +28,11 @@ import {
   __testUpdateCommandPanelSelection,
   addAllowRuleForTest,
   cancelPendingInteraction,
+  clearRequestActivity,
   configureSlashCommandRuntime,
   confirmPendingInteraction,
   cycleMode,
+  evaluateAggregatedFinalAnswerGate,
   executePermissionApprove,
   executePermissionDeny,
   getWorkspaceTrustCommandGuard,
@@ -79,7 +81,7 @@ import {
   toggleCommandPanelSelection,
   updateCommandPanelSelection,
   writeWorkspaceTrustStartupNotice
-} from "./chunk-4WHZ6JKD.js";
+} from "./chunk-RFSSKGCE.js";
 import {
   createCommandBlock,
   createUserTextBlock
@@ -108,7 +110,7 @@ import {
   sendRemoteEventReal,
   validateRemoteInboundEnvelope,
   validateRemotePairingEnvelope
-} from "./chunk-66BNE332.js";
+} from "./chunk-JJQETFCR.js";
 import "./chunk-UT5BOJKU.js";
 import "./chunk-RM5JDRCW.js";
 import {
@@ -118,15 +120,15 @@ import {
   handleMemoryCommand,
   resumeSessionWithHandoff,
   runAutoLearningOnTurnEnd
-} from "./chunk-GMUCSNUD.js";
+} from "./chunk-Y5ZV47XC.js";
 import "./chunk-VTQL23UM.js";
-import "./chunk-DNQN74CC.js";
+import "./chunk-NL4M3V5D.js";
 import "./chunk-KQJHVJZB.js";
 import {
   handleModelCommand,
   handleModelSetupInput,
   startModelSetup
-} from "./chunk-D7TCSOAZ.js";
+} from "./chunk-WOBNOBB5.js";
 import "./chunk-NMNOAFFT.js";
 import {
   executeExtraTool,
@@ -137,13 +139,13 @@ import {
   handleIndexCommand,
   handleMcpCommand,
   refreshIndexStatus
-} from "./chunk-JQCRCDOC.js";
+} from "./chunk-XWRHWM4H.js";
 import "./chunk-W6NU7ZAV.js";
-import "./chunk-OF3K3CU5.js";
-import "./chunk-SRZIA6B4.js";
 import {
   isPotentiallyMutatingMcpTool
-} from "./chunk-OEYW3JE3.js";
+} from "./chunk-SILJJAK2.js";
+import "./chunk-MXPBYB54.js";
+import "./chunk-SRZIA6B4.js";
 import {
   formatProviderGuardSummary,
   formatRunnerGuardSummary,
@@ -159,16 +161,16 @@ import {
   handleCheckpointCommand,
   handleGitCommand,
   handleWorktreeCommand
-} from "./chunk-GKZYTPN2.js";
+} from "./chunk-O6MKVGVK.js";
 import "./chunk-GTP2KPLY.js";
 import "./chunk-7ZE5JFAZ.js";
 import {
   handlePluginsCommand,
   handleSkillsCommand
-} from "./chunk-FTAEPAVY.js";
+} from "./chunk-3BPKJMIV.js";
 import {
   handleFailuresCommand
-} from "./chunk-2FVEKTKN.js";
+} from "./chunk-QJTET7EZ.js";
 import "./chunk-X7A22JHP.js";
 import {
   startFeishuLongConnection
@@ -186,7 +188,7 @@ import {
   processRemoteBindCommand,
   wecomBridgeAdapter
 } from "./chunk-CFXB5SE5.js";
-import "./chunk-WHFDDZHY.js";
+import "./chunk-5CXN4JLE.js";
 import {
   breakCacheTestHooks
 } from "./chunk-WVAQYKGL.js";
@@ -219,19 +221,23 @@ import {
   showCommandPanel,
   t,
   writeStatus
-} from "./chunk-JO5ANTMR.js";
-import "./chunk-WQMSRO4D.js";
+} from "./chunk-AZU7HXIT.js";
 import "./chunk-V7GDHHBL.js";
 import "./chunk-GCMH5P4W.js";
-import "./chunk-THZBFYAH.js";
-import {
-  ShellBlockOutput
-} from "./chunk-ECFLCY5V.js";
 import {
   addAllowRule,
   decidePermission,
   loadPermissionState
 } from "./chunk-DDXS2RDZ.js";
+import "./chunk-4E56DWEZ.js";
+import {
+  cleanupCompletedBackgroundTasks,
+  getDurableJobPaths
+} from "./chunk-CDVYF7RU.js";
+import "./chunk-UN53MBAR.js";
+import {
+  ShellBlockOutput
+} from "./chunk-DYDTLRHB.js";
 import {
   formatCatalogHelp,
   formatSlashDiscovery,
@@ -242,14 +248,10 @@ import {
 import {
   createTerminalReadinessView
 } from "./chunk-PBIPV4LD.js";
-import {
-  cleanupCompletedBackgroundTasks,
-  getDurableJobPaths
-} from "./chunk-ZZ2CNCXJ.js";
 import {
   getDurableJobsRoot
-} from "./chunk-TYF4GJR3.js";
-import "./chunk-B4GQTZMT.js";
+} from "./chunk-VAGL7CNR.js";
+import "./chunk-CD54BQJ5.js";
 import "./chunk-L4XXW6Y5.js";
 import {
   classifyProviderVerificationLevel,
@@ -269,16 +271,26 @@ import {
   formatRuntimePathMarker,
   formatStartupPathMarker
 } from "./chunk-VIBENDE3.js";
+import {
+  collectHeadlessArtifactChecklist,
+  createHeadlessBenchInitialPrompt,
+  createHeadlessBenchRepairPrompt,
+  resolveHeadlessBenchConfig,
+  runHeadlessEnvironmentPreflight,
+  validateHeadlessBenchCompletion
+} from "./chunk-4UER2AKI.js";
 import {
   formatConfigOverview,
   formatFeaturePolicy,
   validateExtensionContributionExecution
-} from "./chunk-LVIM2PA7.js";
-import "./chunk-RVY34HK4.js";
+} from "./chunk-QG2FJ3NR.js";
+import "./chunk-KOULRCYJ.js";
 import {
+  getTrackedProcessSnapshot,
   installProcessGuardExitHandlers,
-  requestTrackedProcessStop
-} from "./chunk-JHGWGH2C.js";
+  requestTrackedProcessStop,
+  trackChildProcess
+} from "./chunk-J6CYFWSW.js";
 import "./chunk-E72U7WW7.js";
 import {
   buildConfigPanelActions,
@@ -286,7 +298,7 @@ import {
   createShellViewModel,
   mapPendingApprovalToPermission,
   mapRequestActivityToView
-} from "./chunk-AKPXMCVF.js";
+} from "./chunk-HIIYRATQ.js";
 import {
   buildTranscriptScreenBuffer,
   isSelectionStale,
@@ -306,7 +318,7 @@ import "./chunk-KI7C6ZOD.js";
 import {
   createModelSystemPrompt,
   sanitizeMainScreenLeakage
-} from "./chunk-3GCIXKCI.js";
+} from "./chunk-7TYK55JT.js";
 import "./chunk-J7ZE2JKP.js";
 import "./chunk-BOV4K7FP.js";
 import "./chunk-KTWV5JC5.js";
@@ -331,9 +343,10 @@ import {
   validateCodebaseMemoryToolExecution
 } from "./chunk-I3NTAIMF.js";
 import {
-  appendSystemEvent
-} from "./chunk-64MJP6FK.js";
-import "./chunk-O7S3HYE6.js";
+  appendSystemEvent,
+  createEvidenceRecord,
+  rememberEvidence
+} from "./chunk-L2GU3PWU.js";
 import {
   BACKGROUND_KIND_CAPS,
   BACKGROUND_RUNNING_GLOBAL_CAP,
@@ -361,6 +374,7 @@ import {
   createSingleToolCallContinuation,
   runtimeFromContinuation
 } from "./chunk-RDGM4RUE.js";
+import "./chunk-O7S3HYE6.js";
 import {
   LINGHUN_BASH_MAX_OUTPUT_DEFAULT,
   LINGHUN_BASH_MAX_OUTPUT_UPPER_LIMIT,
@@ -510,6 +524,11 @@ import {
   createToolContext
 } from "@linghun/tools";
 var tuiStatus = "ready";
+var DEFAULT_HEADLESS_MAX_CONTINUATIONS = 3;
+var MAX_HEADLESS_CONTINUATIONS = 3;
+var HEADLESS_CONTINUATION_BACKOFF_BASE_MS = 250;
+var HEADLESS_CLEANUP_SETTLE_MS = 500;
+var HEADLESS_DEADLINE_CLOSURE_WINDOW_MS = 6e4;
 async function createAgentRegistryState(projectPath) {
   const result = await loadAgentRegistry(projectPath);
   return { agents: result.items, errors: result.errors };
@@ -550,11 +569,7 @@ function toggleCurrentCommandPanelDetails(context) {
   context.ctrlOExpandState = { active: false };
   return true;
 }
-async function runTui(options = {}) {
-  const input = options.stdin ?? defaultStdin;
-  const output = options.stdout ?? defaultStdout;
-  const errorOutput = options.stderr ?? defaultStderr;
-  const projectPath = options.projectPath ?? process.cwd();
+async function createTuiRuntimeContext(projectPath) {
   const config = await loadConfig(projectPath);
   const storagePaths = resolveStoragePaths(config, projectPath);
   const store = new SessionStore({ sessionRootDir: storagePaths.sessions, projectPath });
@@ -600,6 +615,7 @@ async function runTui(options = {}) {
     backgroundAbortControllers: /* @__PURE__ */ new Map(),
     discoveredDeferredToolNames: /* @__PURE__ */ new Set()
   };
+  context.tools.trackChildProcess = (child, options) => trackChildProcess(child, options);
   context.turnContinuity = createInitialContinuityState();
   context.recentTaskKinds = [];
   context.workflows.templates = mergeWorkflowTemplates(
@@ -607,8 +623,9 @@ async function runTui(options = {}) {
     context.agentRegistry.agents.map(registryAgentToWorkflowTemplate),
     context.workflowRegistry.workflows.map(registryWorkflowToTemplate)
   );
-  installProcessGuardExitHandlers();
-  const startup = await prepareTuiStartup(input, output, context);
+  return { context, store };
+}
+async function hydrateRuntimeContext(context) {
   await refreshIndexStatus(context);
   await hydrateDurableJobBackgroundTasks(context);
   await hydratePersistentAgents(context);
@@ -617,8 +634,8 @@ async function runTui(options = {}) {
   context.store.prune(50).catch(() => {
   });
   context.failureLearning.records = await loadFailureRecords(context.failureLearning);
-  const gateway = createModelGateway(context.config);
-  context.modelGateway = gateway;
+}
+function attachProviderRuntimeHooks(context) {
   registerProviderHooks({
     onRetry: (info) => {
       if (info.requestContext === "agent") return;
@@ -632,6 +649,19 @@ async function runTui(options = {}) {
     }
   });
   context.pushNotification = (text, tone) => pushTransientNotification(context, text, tone);
+}
+async function runTui(options = {}) {
+  const input = options.stdin ?? defaultStdin;
+  const output = options.stdout ?? defaultStdout;
+  const errorOutput = options.stderr ?? defaultStderr;
+  const projectPath = options.projectPath ?? process.cwd();
+  const { context, store } = await createTuiRuntimeContext(projectPath);
+  installProcessGuardExitHandlers();
+  const startup = await prepareTuiStartup(input, output, context);
+  await hydrateRuntimeContext(context);
+  const gateway = createModelGateway(context.config);
+  context.modelGateway = gateway;
+  attachProviderRuntimeHooks(context);
   const sigintHandler = () => {
     requestTrackedProcessStop(false);
     void handleInterruptCommand([], context, output).catch((error) => {
@@ -663,6 +693,420 @@ async function runTui(options = {}) {
     process.removeListener("SIGINT", sigintHandler);
   }
 }
+async function runHeadlessTask(options) {
+  const output = options.stdout ?? defaultStdout;
+  const errorOutput = options.stderr ?? defaultStderr;
+  const projectPath = options.projectPath ?? process.cwd();
+  const prompt = options.prompt.trim();
+  if (!prompt) {
+    writeLine(errorOutput, "\u9519\u8BEF\uFF1Aheadless run prompt \u4E0D\u80FD\u4E3A\u7A7A\u3002");
+    return 2;
+  }
+  const runtime = options.__testContext && options.__testStore ? { context: options.__testContext, store: options.__testStore } : await createTuiRuntimeContext(projectPath);
+  const { context, store } = runtime;
+  context.permissionMode = options.mode ?? "full-access";
+  context.planAccepted = false;
+  installProcessGuardExitHandlers();
+  if (!options.__testSkipHydration) {
+    await hydrateRuntimeContext(context);
+  }
+  const gateway = options.__testGateway ?? createModelGateway(context.config);
+  const sendHeadlessMessage = options.__testSendMessage ?? sendMessage;
+  context.modelGateway = gateway;
+  attachProviderRuntimeHooks(context);
+  const maxApprovals = Math.max(0, Math.min(options.maxApprovals ?? 32, 200));
+  const autoApprove = options.autoApprove ?? true;
+  const maxContinuations = Math.max(
+    0,
+    Math.min(options.maxContinuations ?? DEFAULT_HEADLESS_MAX_CONTINUATIONS, MAX_HEADLESS_CONTINUATIONS)
+  );
+  const deadlineAtMs = resolveHeadlessDeadlineAtMs(options);
+  const benchConfig = await resolveHeadlessBenchConfig({
+    prompt,
+    projectPath,
+    ...options.bench ? { options: options.bench } : {}
+  });
+  const benchPreflight = benchConfig.enabled && benchConfig.preflight ? await runHeadlessEnvironmentPreflight(projectPath) : void 0;
+  if (benchConfig.enabled && benchPreflight) {
+    writeLine(output, `[headless] bench preflight: ${benchPreflight.summary}`);
+  }
+  try {
+    let approvals = 0;
+    let continuations = 0;
+    let requestAttempts = 0;
+    let benchValidationPassed = !benchConfig.enabled;
+    let lastValidation;
+    const runOneRequest = async (text) => {
+      requestAttempts += 1;
+      const previousProviderFailureId = context.lastProviderFailure?.evidenceId;
+      const deferredApprovals = [];
+      const messagePromise = sendHeadlessMessage(text, context, gateway, output);
+      const pump = createHeadlessApprovalPump({
+        context,
+        gateway,
+        output,
+        errorOutput,
+        autoApprove,
+        maxApprovals,
+        getApprovals: () => approvals,
+        setApprovals: (value) => {
+          approvals = value;
+        },
+        deferredApprovals
+      });
+      const messageResult = await runWithHeadlessApprovalPump(messagePromise, pump);
+      if (messageResult.exitCode !== void 0) {
+        return { exitCode: messageResult.exitCode };
+      }
+      const approvalStatus = await pumpHeadlessApprovals({
+        context,
+        gateway,
+        output,
+        errorOutput,
+        autoApprove,
+        maxApprovals,
+        approvals,
+        deferredApprovals
+      });
+      approvals = approvalStatus.approvals;
+      if (approvalStatus.exitCode !== void 0) {
+        return { exitCode: approvalStatus.exitCode };
+      }
+      const deferredStatus = await runDeferredHeadlessApprovals({
+        context,
+        gateway,
+        output,
+        errorOutput,
+        autoApprove,
+        maxApprovals,
+        approvals,
+        deferredApprovals
+      });
+      approvals = deferredStatus.approvals;
+      if (deferredStatus.exitCode !== void 0) {
+        return { exitCode: deferredStatus.exitCode };
+      }
+      const providerFailure = context.lastProviderFailure;
+      const hasNewProviderFailure = Boolean(providerFailure) && providerFailure?.evidenceId !== previousProviderFailureId;
+      return { providerFailure: hasNewProviderFailure };
+    };
+    const initialPrompt = createHeadlessBenchInitialPrompt({
+      originalPrompt: prompt,
+      config: benchConfig,
+      ...benchPreflight ? { preflight: benchPreflight } : {}
+    });
+    let status = await runOneRequest(initialPrompt);
+    while (status.exitCode === void 0 && status.providerFailure && continuations < maxContinuations && shouldRunHeadlessProviderContinuation(context)) {
+      continuations += 1;
+      const sessionId = await ensureSession(context);
+      const continuationPrompt = createHeadlessProviderContinuationPrompt(context);
+      await appendSystemEvent(
+        context,
+        sessionId,
+        `headless_provider_stream_continuation: attempt=${continuations}; reason=${context.lastProviderFailure?.summary ?? "provider_failure"}`,
+        "warning"
+      );
+      writeLine(output, `[headless] provider stream failed; continuing attempt ${continuations}/${maxContinuations}`);
+      context.lastProviderFailure = void 0;
+      await sleep(createHeadlessContinuationBackoffMs(continuations));
+      status = await runOneRequest(continuationPrompt);
+    }
+    if (continuations > 0 && !status.providerFailure) {
+      context.lastProviderFailure = void 0;
+    }
+    if (status.exitCode !== void 0) {
+      return status.exitCode;
+    }
+    if (status.providerFailure) {
+      writeLine(
+        errorOutput,
+        createHeadlessProviderFailureDiagnostic(context, {
+          requestAttempts,
+          continuations,
+          maxContinuations
+        })
+      );
+      return 1;
+    }
+    if (benchConfig.enabled) {
+      for (let repairAttempt = 0; repairAttempt <= benchConfig.maxRepairAttempts; repairAttempt += 1) {
+        const validation = await validateHeadlessBenchCompletion({ projectPath, config: benchConfig });
+        lastValidation = validation;
+        if (validation.ok) {
+          benchValidationPassed = true;
+          writeLine(output, `[headless] bench validation passed: ${validation.summary}`);
+          break;
+        }
+        const failure = validation.failure;
+        writeLine(
+          errorOutput,
+          `[headless] bench validation failed: ${failure.category}; ${failure.summary.split(/\r?\n/u)[0]}`
+        );
+        if (repairAttempt >= benchConfig.maxRepairAttempts) {
+          writeLine(
+            errorOutput,
+            `\u9519\u8BEF\uFF1Aheadless bench \u4FEE\u8865\u5DF2\u8FBE\u4E0A\u9650 ${benchConfig.maxRepairAttempts}\uFF0C\u6700\u540E\u5931\u8D25\u7C7B\u522B\uFF1A${failure.category}`
+          );
+          return 5;
+        }
+        if (isHeadlessDeadlineApproaching(deadlineAtMs)) {
+          const remaining = formatHeadlessRemainingTime(deadlineAtMs);
+          writeLine(
+            errorOutput,
+            `[headless] deadline approaching (${remaining}); closure validation ran, skipping repair loop.`
+          );
+          return 6;
+        }
+        const repairPrompt = createHeadlessBenchRepairPrompt({
+          originalPrompt: prompt,
+          failure,
+          attempt: repairAttempt + 1,
+          maxAttempts: benchConfig.maxRepairAttempts,
+          profile: benchConfig.profile,
+          ...benchPreflight ? { preflight: benchPreflight } : {}
+        });
+        const repairStatus = await runOneRequest(repairPrompt);
+        if (repairStatus.exitCode !== void 0) {
+          return repairStatus.exitCode;
+        }
+        if (repairStatus.providerFailure) {
+          writeLine(errorOutput, "\u9519\u8BEF\uFF1Aheadless bench \u4FEE\u8865\u671F\u95F4 provider stream \u5931\u8D25\u3002");
+          return 1;
+        }
+      }
+    }
+    if (context.sessionId) {
+      await recordHeadlessArtifactChecklist(context, context.sessionId, benchConfig, lastValidation);
+    }
+    const cleanup = await finishHeadlessRuntime(context);
+    if (!cleanup.ok) {
+      const cleanupMessage = `\u8B66\u544A\uFF1Aheadless run \u6536\u5C3E\u5931\u8D25\uFF1A${cleanup.reason}`;
+      writeLine(errorOutput, cleanupMessage);
+      if (context.sessionId) {
+        await appendSystemEvent(context, context.sessionId, cleanupMessage, "warning").catch(
+          () => void 0
+        );
+      }
+      if (benchValidationPassed) {
+        writeLine(errorOutput, "\u8B66\u544A\uFF1A\u4EFB\u52A1\u7ED3\u679C\u5DF2\u5B8C\u6210\u4F46\u6E05\u7406\u5931\u8D25\uFF1B\u8FD9\u4E0D\u662F agent \u89E3\u9898\u5931\u8D25\u3002");
+      } else {
+        return 4;
+      }
+    }
+    if (context.sessionId && !context.sessionEnded) {
+      await store.appendEvent(context.sessionId, createSessionEndEvent(context.sessionId));
+      context.sessionEnded = true;
+    }
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "headless run \u6267\u884C\u5931\u8D25\u3002";
+    writeLine(errorOutput, `\u9519\u8BEF\uFF1A${message}`);
+    return 1;
+  } finally {
+    await finishHeadlessRuntime(context);
+  }
+}
+async function pumpHeadlessApprovals(input) {
+  let approvals = input.approvals;
+  while (input.context.pendingLocalApproval) {
+    if (!input.autoApprove) {
+      input.context.activeAbortController?.abort();
+      writeLine(
+        input.errorOutput,
+        `\u9519\u8BEF\uFF1Aheadless run \u505C\u5728\u6743\u9650\u786E\u8BA4\uFF1A${input.context.pendingLocalApproval.kind}\u3002\u8BF7\u5F00\u542F --auto-approve \u6216\u6539\u7528\u4EA4\u4E92\u6A21\u5F0F\u3002`
+      );
+      return { approvals, exitCode: 3 };
+    }
+    if (approvals >= input.maxApprovals) {
+      input.context.activeAbortController?.abort();
+      writeLine(
+        input.errorOutput,
+        `\u9519\u8BEF\uFF1Aheadless run \u81EA\u52A8\u6279\u51C6\u8D85\u8FC7\u4E0A\u9650 ${input.maxApprovals}\uFF0C\u505C\u5728\u6743\u9650\u786E\u8BA4\uFF1A${input.context.pendingLocalApproval.kind}\u3002`
+      );
+      return { approvals, exitCode: 3 };
+    }
+    const approval = input.context.pendingLocalApproval;
+    input.context.pendingLocalApproval = void 0;
+    approvals += 1;
+    writeLine(input.output, `[headless] auto-approved ${approval.kind}`);
+    if (input.deferredApprovals && hasModelContinuation(approval)) {
+      input.deferredApprovals.push(approval);
+      continue;
+    }
+    await executePermissionApprove(approval, input.context, input.gateway, input.output);
+  }
+  return { approvals };
+}
+async function runDeferredHeadlessApprovals(input) {
+  let approvals = input.approvals;
+  while (input.deferredApprovals.length > 0) {
+    const approval = input.deferredApprovals.shift();
+    if (!approval) continue;
+    await executePermissionApprove(approval, input.context, input.gateway, input.output);
+    const nested = await pumpHeadlessApprovals({
+      context: input.context,
+      gateway: input.gateway,
+      output: input.output,
+      errorOutput: input.errorOutput,
+      autoApprove: input.autoApprove,
+      maxApprovals: input.maxApprovals,
+      approvals
+    });
+    approvals = nested.approvals;
+    if (nested.exitCode !== void 0) {
+      return { approvals, exitCode: nested.exitCode };
+    }
+  }
+  return { approvals };
+}
+function hasModelContinuation(approval) {
+  return "continuation" in approval && Boolean(approval.continuation);
+}
+function createHeadlessApprovalPump(input) {
+  let running;
+  return async () => {
+    if (running) return running;
+    running = pumpHeadlessApprovals({
+      context: input.context,
+      gateway: input.gateway,
+      output: input.output,
+      errorOutput: input.errorOutput,
+      autoApprove: input.autoApprove,
+      maxApprovals: input.maxApprovals,
+      approvals: input.getApprovals(),
+      deferredApprovals: input.deferredApprovals
+    }).then((result) => {
+      input.setApprovals(result.approvals);
+      return result;
+    });
+    try {
+      return await running;
+    } finally {
+      running = void 0;
+    }
+  };
+}
+async function runWithHeadlessApprovalPump(messagePromise, pump) {
+  let settled = false;
+  let exitCode;
+  const loop = (async () => {
+    while (!settled && exitCode === void 0) {
+      const result = await pump();
+      exitCode = result.exitCode;
+      if (exitCode !== void 0) break;
+      await sleep(50);
+    }
+  })();
+  try {
+    await messagePromise;
+  } finally {
+    settled = true;
+    await loop;
+  }
+  return exitCode !== void 0 ? { exitCode } : {};
+}
+function sleep(ms) {
+  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+function createHeadlessContinuationBackoffMs(attempt) {
+  return Math.min(HEADLESS_CONTINUATION_BACKOFF_BASE_MS * 2 ** Math.max(0, attempt - 1), 1500);
+}
+function resolveHeadlessDeadlineAtMs(options) {
+  if (typeof options.deadlineAtMs === "number" && Number.isFinite(options.deadlineAtMs)) {
+    return options.deadlineAtMs;
+  }
+  if (typeof options.deadlineMs === "number" && Number.isFinite(options.deadlineMs)) {
+    return Date.now() + Math.max(0, options.deadlineMs);
+  }
+  const envDeadlineAt = Number.parseInt(process.env.LINGHUN_HEADLESS_DEADLINE_AT_MS ?? "", 10);
+  if (Number.isFinite(envDeadlineAt) && envDeadlineAt > 0) {
+    return envDeadlineAt;
+  }
+  return void 0;
+}
+function isHeadlessDeadlineApproaching(deadlineAtMs) {
+  return deadlineAtMs !== void 0 && deadlineAtMs - Date.now() <= HEADLESS_DEADLINE_CLOSURE_WINDOW_MS;
+}
+function formatHeadlessRemainingTime(deadlineAtMs) {
+  if (deadlineAtMs === void 0) return "unknown";
+  return `${Math.max(0, Math.ceil((deadlineAtMs - Date.now()) / 1e3))}s remaining`;
+}
+function shouldRunHeadlessProviderContinuation(context) {
+  return context.evidence.some((record) => !record.supportsClaims.includes("provider_failure")) || context.tools.changedFiles.length > 0;
+}
+async function recordHeadlessArtifactChecklist(context, sessionId, config, lastValidation) {
+  const checklist = await collectHeadlessArtifactChecklist({
+    projectPath: context.projectPath,
+    config,
+    changedFiles: context.tools.changedFiles,
+    ...lastValidation ? { lastValidation } : {}
+  });
+  const evidence = createEvidenceRecord(
+    "command_output",
+    `headless artifact checklist: ${checklist.summary}`,
+    "headless:artifact-checklist",
+    [
+      "headless_artifact_checklist",
+      checklist.verificationRan ? "verification_ran" : "verification_not_run",
+      checklist.changedFiles.length > 0 ? "file_written" : "no_file_changes"
+    ]
+  );
+  rememberEvidence(context, evidence);
+  await context.store.appendEvent(sessionId, { type: "evidence_record", ...evidence });
+  await appendSystemEvent(context, sessionId, `headless artifact checklist: ${checklist.summary}`, "info");
+}
+var __testHeadlessRuntime = {
+  isDeadlineApproaching: isHeadlessDeadlineApproaching,
+  formatRemainingTime: formatHeadlessRemainingTime
+};
+function createHeadlessProviderFailureDiagnostic(context, input) {
+  const failure = context.lastProviderFailure;
+  const lastEvidence = context.evidence.find(
+    (record) => !record.supportsClaims.includes("provider_failure")
+  );
+  const changedFiles = context.tools.changedFiles.length;
+  return [
+    "\u9519\u8BEF\uFF1Aprovider stream \u5931\u8D25\uFF0Cheadless continuation \u5DF2\u8FBE\u4E0A\u9650\u6216\u7F3A\u5C11\u53EF\u6062\u590D\u8BC1\u636E\u3002",
+    `providerKind=${failure?.kind ?? "unknown"}`,
+    `providerCode=${failure?.code ?? "unknown"}`,
+    `attempts=${input.requestAttempts}`,
+    `continuations=${input.continuations}/${input.maxContinuations}`,
+    `lastSuccessfulTool=${lastEvidence?.source ?? "none"}`,
+    `fileChanges=${changedFiles > 0 ? `yes:${changedFiles}` : "no"}`,
+    failure?.summary ? `summary=${failure.summary}` : ""
+  ].filter(Boolean).join(" ");
+}
+function createHeadlessProviderContinuationPrompt(context) {
+  return context.language === "en-US" ? "The previous response stream was interrupted. Continue the original task based on the current workspace state, transcript, tool evidence, and any file changes already present. Do not restart from scratch unless needed." : "\u4E0A\u4E00\u8F6E\u54CD\u5E94\u6D41\u4E2D\u65AD\u3002\u8BF7\u57FA\u4E8E\u5F53\u524D\u5DE5\u4F5C\u533A\u72B6\u6001\u3001\u5DF2\u6709 transcript\u3001\u5DE5\u5177\u8BC1\u636E\u548C\u5DF2\u7ECF\u5B58\u5728\u7684\u6587\u4EF6\u6539\u52A8\u7EE7\u7EED\u5B8C\u6210\u539F\u4EFB\u52A1\uFF1B\u9664\u975E\u5FC5\u8981\uFF0C\u4E0D\u8981\u4ECE\u5934\u91CD\u505A\u3002";
+}
+async function finishHeadlessRuntime(context) {
+  if (context.pendingLocalApproval) {
+    return { ok: false, reason: `\u4ECD\u6709\u6743\u9650\u786E\u8BA4\u672A\u5904\u7406\uFF1A${context.pendingLocalApproval.kind}` };
+  }
+  if (context.activeAbortController) {
+    context.activeAbortController.abort();
+  }
+  context.tools.abortSignal = void 0;
+  context.interrupt = { type: "idle" };
+  clearRequestActivity(context);
+  context.activeAbortController = void 0;
+  const stopResult = requestTrackedProcessStop(true);
+  await sleep(HEADLESS_CLEANUP_SETTLE_MS);
+  const stillTracked = getTrackedProcessSnapshot();
+  if (stopResult.failures.length > 0) {
+    return {
+      ok: false,
+      reason: `\u6E05\u7406\u672C\u5730\u5B50\u8FDB\u7A0B\u5931\u8D25\uFF1A${stopResult.failures.map((failure) => `${failure.pid}:${failure.message}`).join("; ")}`
+    };
+  }
+  if (stillTracked.length > 0) {
+    return {
+      ok: false,
+      reason: `\u4ECD\u6709\u672C\u5730\u5B50\u8FDB\u7A0B\u672A\u9000\u51FA\uFF1A${stillTracked.map((entry) => `${entry.pid}${entry.label ? `(${entry.label})` : ""}`).join(", ")}`
+    };
+  }
+  return { ok: true };
+}
 var MAX_TOOL_LOG_FILES = 200;
 async function cleanStaleToolLogs(context) {
   const logsRoot = resolveStoragePaths(context.config, context.projectPath).logs;
@@ -2220,6 +2664,7 @@ export {
   __testCreateVerificationLevelForReadiness,
   __testFormatStartAgentDidNotStartMessage,
   __testGetCurrentWorkflowStepRequest,
+  __testHeadlessRuntime,
   __testParseRunWorkflowToolInput,
   __testRenderInteractiveChoiceLines,
   __testRunWorkflowStepsWithPlan,
@@ -2273,6 +2718,7 @@ export {
   dingtalkBridgeAdapter,
   dingtalkStreamFrameToBridgeEvent,
   estimateFileMetrics,
+  evaluateAggregatedFinalAnswerGate,
   executeExtraTool,
   executeSearchExtraTools,
   feishuBridgeAdapter,
@@ -2320,6 +2766,7 @@ export {
   recordModelUsage,
   runAutoLearningOnTurnEnd,
   runCommandCaptureForTest,
+  runHeadlessTask,
   runTui,
   runVerificationCommandForTest,
   runtimeFromContinuation,