ennodia 0.2.0 → 0.3.0

package/src/tasks.ts

@@ -1,6 +1,6 @@
 import { cpSync, existsSync, lstatSync, mkdtempSync, rmSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { basename, join } from "node:path";
+import { basename, join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 import type {
@@ -10,7 +10,9 @@ import type {
   HarnessRunInput,
   HarnessUsage,
 } from "./harnesses";
+import { assertNativeSandboxSupported, assertNativeSubagentsSupported, assertReasoningEffortSupported, DEFAULT_TASK_TIMEOUT_MS, withInputGuidance } from "./harnesses";
 import { preview, tailItems } from "./internal";
+import { signalOwnedProcess } from "./process";
 import {
   augmentPrompt,
   toAppliedSkillInfo,
@@ -21,7 +23,7 @@ export type TaskStatus = "running" | "succeeded" | "failed" | "cancelled";
 
 export type TaskEvent = {
   at: string;
-  type: "started" | "stdout" | "stderr" | "exit" | "cancel" | "error";
+  type: "started" | "input-guidance" | "stdout" | "stderr" | "exit" | "cancel" | "error";
   message?: string;
 };
 
@@ -29,6 +31,14 @@ export type TaskView = {
   id: string;
   harnessId: string;
   harnessName: string;
+  model?: string;
+  reasoningEffort?: HarnessRunInput["reasoningEffort"];
+  nativeSubagents?: "disabled";
+  nativeSandbox?: "read-only" | "workspace-write";
+  persistSession?: boolean;
+  continueTaskId?: string;
+  continuationTaskId?: string;
+  canContinue?: boolean;
   status: TaskStatus;
   cancelRequested: boolean;
   pid?: number;
@@ -40,6 +50,9 @@ export type TaskView = {
   endedAt?: string;
   elapsedMs: number;
   timeoutMs: number;
+  /** Execution cutoff, not an estimate of task completion. */
+  deadlineAt?: string;
+  timeoutSource?: "caller" | "task-manager-default";
   remainingMs: number | null;
   etaConfidence: "timeout-budget" | "unknown" | "complete";
   lastOutputAt?: string;
@@ -58,6 +71,13 @@ export type TaskView = {
    * over stdout for cross-harness comparisons: some adapters' stdout is a
    * full session transcript, others' is just the final reply. */
   finalMessage?: string;
+  finalMessageChars?: number;
+  /** Availability of non-whitespace answer evidence, even in compact views. */
+  hasOutput?: boolean;
+  /** The preferred answer was truncated during capture or in this view. */
+  outputTruncated?: boolean;
+  /** True when preferred answer bytes were lost during stream capture, independent of view limits. */
+  captureTruncated?: boolean;
   /** Best-effort usage metrics parsed from the adapter's own output. */
   usage?: HarnessUsage;
   /** Set when this task ran against an isolated copy of the requested cwd
@@ -80,6 +100,7 @@ export type TaskSpawnInput = {
   stdin: "ignore" | "pipe";
   stdout: "pipe";
   stderr: "pipe";
+  detached: boolean;
 };
 export type TaskSpawn = (input: TaskSpawnInput) => TaskProcess;
 
@@ -95,7 +116,11 @@ type InternalTask = Omit<
   | "stdoutChars"
   | "stderrChars"
   | "eventCount"
+  | "finalMessageChars"
 > & {
+  nativeSessionId?: string;
+  extractSessionId?: HarnessAdapter["extractSessionId"];
+  streamCaptureTruncated?: boolean;
   createdAtMs: number;
   updatedAtMs: number;
   endedAtMs?: number;
@@ -105,11 +130,14 @@ type InternalTask = Omit<
   settled?: Promise<void>;
   streamReaders: Set<ReadableStreamDefaultReader<Uint8Array>>;
   timeout?: Timer;
+  killTimeout?: Timer;
+  forceSignalled?: boolean;
   finalMessagePath?: string;
   /** Exact temporary directory allocated by TaskManager. Keep this separate
    * from cwd because an adapter can override the command working directory. */
   isolatedCwd?: string;
   extractUsage?: HarnessAdapter["extractUsage"];
+  failureReason?: HarnessAdapter["failureReason"];
 };
 
 export type StartTaskResult = {
@@ -127,7 +155,6 @@ export type TaskManagerShutdownOptions = {
   deadlineMs?: number;
 };
 
-const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
 const DEFAULT_DRAIN_TIMEOUT_MS = 1_000;
 const DEFAULT_SHUTDOWN_DEADLINE_MS = 5_000;
 const DEFAULT_MAX_TASKS = 200;
@@ -141,6 +168,8 @@ export class TaskManager {
   private readonly maxTasks: number;
   private readonly spawn: TaskSpawn;
   private readonly removeIsolatedCwd: (path: string) => void;
+  private readonly ownsProcessGroups: boolean;
+  private readonly retainedTasks = new Map<string, number>();
   private shuttingDown = false;
   private shutdownPromise?: Promise<void>;
 
@@ -148,6 +177,7 @@ export class TaskManager {
     this.drainTimeoutMs = options.drainTimeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS;
     this.maxTasks = Math.max(1, options.maxTasks ?? DEFAULT_MAX_TASKS);
     this.spawn = options.spawn ?? ((input) => Bun.spawn(input));
+    this.ownsProcessGroups = !options.spawn && process.platform !== "win32";
     this.removeIsolatedCwd = options.removeIsolatedCwd ?? ((path) => {
       rmSync(path, { recursive: true, force: true });
     });
@@ -166,6 +196,29 @@ export class TaskManager {
       throw new Error(`${adapter.name} is not runnable through Ennodia yet.`);
     }
 
+    if (input.nativeSessionId) throw new Error("Use continueTaskId, not a native session ID.");
+    let previous: InternalTask | undefined;
+    if (input.continueTaskId) {
+      previous = this.tasks.get(input.continueTaskId);
+      if (!previous || previous.status === "running" || !previous.nativeSessionId || !previous.persistSession) {
+        throw new Error("Continuation requires a settled persistent task owned by this TaskManager.");
+      }
+      if (previous.continuationTaskId) throw new Error("Continue the latest task in this session, not an earlier turn.");
+      if (previous.harnessId !== adapter.id) throw new Error("Continuation must use the same harness.");
+      if (input.cwd && resolve(input.cwd) !== resolve(previous.cwd)) throw new Error("Continuation must use the same working directory.");
+      if (input.persistSession === false) throw new Error("Continuation requires session persistence.");
+      input = { ...input, cwd: previous.cwd, model: input.model ?? previous.model,
+        reasoningEffort: input.reasoningEffort ?? previous.reasoningEffort,
+        nativeSubagents: input.nativeSubagents ?? previous.nativeSubagents, persistSession: true };
+    }
+    if (input.persistSession && (!adapter.supportsSessionContinuation || input.isolateCwd)) {
+      throw new Error("Persistent sessions require a supported harness and a persistent working directory.");
+    }
+    assertReasoningEffortSupported(adapter, input.reasoningEffort);
+    assertNativeSubagentsSupported(adapter, input.nativeSubagents);
+    assertNativeSandboxSupported(adapter, input.nativeSandbox);
+    if (adapter.supportsNativeSandbox) input = { ...input, nativeSandbox: input.nativeSandbox ?? "read-only" };
+
     const sourceCwd = input.cwd ?? process.cwd();
     if (!existsSync(sourceCwd)) {
       throw new Error(`Working directory does not exist: ${sourceCwd}`);
@@ -187,10 +240,22 @@ export class TaskManager {
     // as a no-op.
     const finalMessagePath = join(tmpdir(), `ennodia-final-${randomUUID()}.txt`);
 
-    const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const timeoutMs = input.timeoutMs ?? DEFAULT_TASK_TIMEOUT_MS;
+    const now = Date.now();
+    const deadlineMs = now + timeoutMs;
+    const deadlineAt = new Date(deadlineMs).toISOString();
+    const guidedPrompt = withInputGuidance(input.prompt, adapter);
+    const executionPrompt = `${guidedPrompt}
+
+Ennodia execution notice:
+Execution allowance: ${timeoutMs} ms from task launch (${input.timeoutMs === undefined ? "Ennodia default" : "caller supplied"}). Deadline (UTC): ${deadlineAt}. This is a hard cutoff, not a completion estimate or a target duration.
+Check actual UTC time before attributing incomplete work to the deadline. Do not report a cutoff merely because the task is difficult or the answer is getting long. Continue within the remaining allowance unless complete or blocked by a demonstrated access or tool failure.
+Configured native sandbox: ${input.nativeSandbox ?? "harness-managed; check available permissions"}. Report any mismatch between the assignment and available access before attempting the work.
+Before the cutoff, return useful partial findings, verification performed, remaining work, and a justified continuation budget if needed. Only the caller can authorize a follow-up.
+Use only tools and permissions actually available in this session; the caller's tools are not automatically inherited. If access is missing, report the exact tool, file, or permission and its impact. Try a permitted alternative when useful; do not repeat an unchanged failed attempt or claim success without evidence.`;
     const augmentedPrompt = input.skills && input.skills.length > 0
-      ? augmentPrompt(input.prompt, input.skills, adapter.id)
-      : input.prompt;
+      ? augmentPrompt(executionPrompt, input.skills, adapter.id)
+      : executionPrompt;
     let commandSpec: CommandSpec;
     let cwd: string;
     let child: TaskProcess;
@@ -200,6 +265,7 @@ export class TaskManager {
         cwd: resolvedInputCwd,
         prompt: augmentedPrompt,
         finalMessagePath,
+        nativeSessionId: previous?.nativeSessionId,
       });
       cwd = commandSpec.cwd ?? process.cwd();
 
@@ -214,6 +280,7 @@ export class TaskManager {
         stdin: commandSpec.stdin === undefined ? "ignore" : "pipe",
         stdout: "pipe",
         stderr: "pipe",
+        detached: process.platform !== "win32",
       });
     } catch (error) {
       cleanupFailedStartArtifacts(
@@ -223,11 +290,18 @@ export class TaskManager {
       throw error;
     }
 
-    const now = Date.now();
     const task: InternalTask = {
       id: randomUUID(),
       harnessId: adapter.id,
       harnessName: adapter.name,
+      model: input.model,
+      reasoningEffort: input.reasoningEffort,
+      nativeSubagents: input.nativeSubagents,
+      nativeSandbox: input.nativeSandbox,
+      persistSession: input.persistSession,
+      continueTaskId: input.continueTaskId,
+      nativeSessionId: previous?.nativeSessionId,
+      extractSessionId: input.persistSession ? adapter.extractSessionId : undefined,
       status: "running",
       cwd,
       isolatedFrom,
@@ -240,6 +314,8 @@ export class TaskManager {
       createdAtMs: now,
       updatedAtMs: now,
       timeoutMs,
+      timeoutSource: input.timeoutMs === undefined ? "task-manager-default" : "caller",
+      deadlineAt,
       cancelRequested: false,
       drainTimedOut: false,
       timedOut: false,
@@ -251,6 +327,7 @@ export class TaskManager {
       finalMessagePath,
       isolatedCwd,
       extractUsage: adapter.extractUsage,
+      failureReason: adapter.failureReason,
     };
 
     task.process = child;
@@ -259,8 +336,15 @@ export class TaskManager {
     // Publish a task only after the process exists. A synchronous spawn
     // failure must not leave a phantom running task that cannot settle.
     this.tasks.set(task.id, task);
+    if (previous) previous.continuationTaskId = task.id;
     this.pruneTasks(task.id);
-    this.pushEvent(task, { type: "started", message: "Task started." });
+    this.pushEvent(task, { type: "started", message: `Task started. Execution limit: ${timeoutMs}ms (${task.timeoutSource}); deadline: ${task.deadlineAt}. This is not a completion estimate.` });
+    if (guidedPrompt !== input.prompt) {
+      this.pushEvent(task, {
+        type: "input-guidance",
+        message: "Media input guidance was included in the worker prompt. Native inspection remains unverified until the worker reports evidence.",
+      });
+    }
 
     task.streamsDone = Promise.all([
       this.pipeStreamSafely(task, "stdout", child.stdout),
@@ -269,7 +353,6 @@ export class TaskManager {
 
     task.timeout = setTimeout(() => {
       if (task.cancelRequested) {
-        child.kill();
         return;
       }
 
@@ -278,8 +361,8 @@ export class TaskManager {
         type: "error",
         message: `Timed out after ${timeoutMs}ms.`,
       });
-      child.kill();
-    }, timeoutMs);
+      this.terminate(task);
+    }, Math.max(0, deadlineMs - Date.now()));
 
     task.settled = this.watchExit(task, child);
     void task.settled;
@@ -298,7 +381,7 @@ export class TaskManager {
           type: "error",
           message: error instanceof Error ? error.message : String(error),
         });
-        child.kill();
+        this.terminate(task);
       }
     }
 
@@ -323,6 +406,19 @@ export class TaskManager {
     return task ? this.toView(task, options) : undefined;
   }
 
+  /** Keep evidence alive until its owning operation has recorded its result. */
+  retain(taskId: string): void {
+    if (!this.tasks.has(taskId)) throw new Error(`Unknown task: ${taskId}`);
+    this.retainedTasks.set(taskId, (this.retainedTasks.get(taskId) ?? 0) + 1);
+  }
+
+  release(taskId: string): void {
+    const count = this.retainedTasks.get(taskId) ?? 0;
+    if (count > 1) this.retainedTasks.set(taskId, count - 1);
+    else this.retainedTasks.delete(taskId);
+    this.pruneTasks();
+  }
+
   cancel(taskId: string): TaskView {
     const task = this.tasks.get(taskId);
     if (!task) {
@@ -380,7 +476,7 @@ export class TaskManager {
         type: "error",
         message: `Shutdown deadline exceeded after ${deadlineMs}ms; force-killing task.`,
       });
-      task.process?.kill("SIGKILL");
+      this.signal(task, "SIGKILL");
     }
 
     await Promise.allSettled(
@@ -397,21 +493,22 @@ export class TaskManager {
     task: InternalTask,
     child: TaskProcess,
   ): Promise<void> {
+    let terminalStatus: TaskStatus = "failed";
     try {
       const exitCode = await child.exited;
+      if (task.killTimeout) this.signal(task, "SIGKILL");
       await this.waitForOutputDrain(task);
       task.exitCode = exitCode;
 
       if (task.cancelRequested) {
-        task.status = "cancelled";
-      } else if (task.status === "running") {
-        task.status =
+        terminalStatus = "cancelled";
+      } else {
+        terminalStatus =
           exitCode === 0 && !task.timedOut && !task.drainTimedOut
             ? "succeeded"
             : "failed";
       }
 
-      task.endedAtMs = Date.now();
       this.pushEvent(task, {
         type: "exit",
         message: `Process exited with code ${exitCode}.`,
@@ -420,21 +517,37 @@ export class TaskManager {
       await this.waitForOutputDrain(task);
 
       if (task.cancelRequested) {
-        task.status = "cancelled";
-      } else if (task.status === "running") {
-        task.status = "failed";
+        terminalStatus = "cancelled";
+      } else {
+        terminalStatus = "failed";
       }
 
-      task.endedAtMs = Date.now();
       this.pushEvent(task, {
         type: "error",
         message: error instanceof Error ? error.message : String(error),
       });
     } finally {
+      // A CLI can exit before its build/shell children. Clean up the owned
+      // group before deleting an isolated checkout or reporting completion.
+      this.signal(task, "SIGKILL");
       await this.collectFinalMessage(task);
+      if (terminalStatus === "succeeded" && task.failureReason) {
+        try {
+          const reason = task.failureReason(task.finalMessage || task.stdout, task.stderr);
+          if (reason) {
+            terminalStatus = "failed";
+            this.pushEvent(task, { type: "error", message: reason });
+          }
+        } catch (error) {
+          terminalStatus = "failed";
+          this.pushEvent(task, { type: "error", message: `Adapter result check failed: ${String(error)}` });
+        }
+      }
       this.collectUsage(task);
       this.cleanupIsolatedCwd(task);
       this.clearTimers(task);
+      task.status = task.cancelRequested ? "cancelled" : terminalStatus;
+      task.endedAtMs = Date.now();
       this.touch(task);
       this.pruneTasks(task.id);
     }
@@ -464,7 +577,7 @@ export class TaskManager {
   }
 
   private collectUsage(task: InternalTask): void {
-    if (!task.extractUsage) {
+    if (!task.extractUsage || task.streamCaptureTruncated) {
       return;
     }
 
@@ -502,7 +615,8 @@ export class TaskManager {
     }
 
     const removable = [...this.tasks.values()]
-      .filter((task) => task.id !== protectedTaskId && task.status !== "running")
+      .filter((task) => task.id !== protectedTaskId && task.status !== "running" &&
+        !this.retainedTasks.has(task.id))
       .sort((a, b) => a.createdAtMs - b.createdAtMs);
 
     let removed = 0;
@@ -524,7 +638,26 @@ export class TaskManager {
       this.pushEvent(task, { type: "cancel", message });
     }
 
-    task.process?.kill();
+    this.terminate(task);
+  }
+
+  private signal(task: InternalTask, signal: "SIGTERM" | "SIGKILL"): void {
+    if (!task.process || task.forceSignalled) return;
+    try {
+      signalOwnedProcess(task.process, signal, this.ownsProcessGroups);
+      if (signal === "SIGKILL") task.forceSignalled = true;
+    } catch (error) {
+      this.pushEvent(task, { type: "error", message: `Process cleanup failed: ${String(error)}` });
+    }
+  }
+
+  private terminate(task: InternalTask): void {
+    if (task.killTimeout) return;
+    this.signal(task, "SIGTERM");
+    task.killTimeout = setTimeout(() => {
+      this.pushEvent(task, { type: "error", message: "Termination grace period exceeded; force-killing task." });
+      this.signal(task, "SIGKILL");
+    }, 300);
   }
 
   private async waitForSettled(
@@ -638,6 +771,15 @@ export class TaskManager {
         }
 
         const chunk = decoder.decode(value, { stream: true });
+        if (streamName === "stdout" && task.extractSessionId && !task.nativeSessionId) {
+          try {
+            task.nativeSessionId = task.extractSessionId(task.stdout + chunk);
+          } catch (error) {
+            task.extractSessionId = undefined;
+            this.pushEvent(task, { type: "error", message: `Session ID extraction failed: ${String(error)}` });
+          }
+        }
+        task.streamCaptureTruncated ||= task[streamName].length + chunk.length > MAX_CAPTURE_CHARS;
         task[streamName] = appendLimited(task[streamName], chunk);
         task.lastOutputAtMs = Date.now();
         this.pushEvent(task, { type: streamName, message: chunk });
@@ -646,6 +788,7 @@ export class TaskManager {
 
       const finalChunk = decoder.decode();
       if (finalChunk) {
+        task.streamCaptureTruncated ||= task[streamName].length + finalChunk.length > MAX_CAPTURE_CHARS;
         task[streamName] = appendLimited(task[streamName], finalChunk);
         task.lastOutputAtMs = Date.now();
         this.pushEvent(task, { type: streamName, message: finalChunk });
@@ -674,6 +817,14 @@ export class TaskManager {
       id: task.id,
       harnessId: task.harnessId,
       harnessName: task.harnessName,
+      model: task.model,
+      reasoningEffort: task.reasoningEffort,
+      nativeSubagents: task.nativeSubagents,
+      nativeSandbox: task.nativeSandbox,
+      persistSession: task.persistSession,
+      continueTaskId: task.continueTaskId,
+      continuationTaskId: task.continuationTaskId,
+      canContinue: Boolean(!running && task.persistSession && task.nativeSessionId && !task.continuationTaskId),
       status: task.status,
       cancelRequested: task.cancelRequested,
       pid: task.pid,
@@ -685,6 +836,8 @@ export class TaskManager {
       endedAt: task.endedAtMs ? new Date(task.endedAtMs).toISOString() : undefined,
       elapsedMs,
       timeoutMs: task.timeoutMs,
+      timeoutSource: task.timeoutSource,
+      deadlineAt: task.deadlineAt,
       remainingMs,
       etaConfidence: running ? "timeout-budget" : "complete",
       lastOutputAt: task.lastOutputAtMs
@@ -700,7 +853,16 @@ export class TaskManager {
       stderr: includeOutput ? tail(task.stderr, maxOutputChars) : "",
       events: includeEvents ? tailItems(task.events, maxEvents) : [],
       appliedSkills: task.appliedSkills,
-      finalMessage: includeOutput ? task.finalMessage : undefined,
+      finalMessage: includeOutput && task.finalMessage !== undefined
+        ? tail(task.finalMessage, maxOutputChars) : undefined,
+      finalMessageChars: task.finalMessage?.length ?? 0,
+      hasOutput: Boolean(task.finalMessage?.trim() || task.stdout.trim() || task.stderr.trim()),
+      captureTruncated: !task.finalMessage?.trim() && Boolean(task.streamCaptureTruncated),
+      outputTruncated: task.finalMessage?.trim()
+        ? !includeOutput || task.finalMessage.length > maxOutputChars
+        : Boolean(task.streamCaptureTruncated ||
+          task.stdout.length > (includeOutput ? maxOutputChars : 0) ||
+          task.stderr.length > (includeOutput ? maxOutputChars : 0)),
       usage: task.usage,
       isolatedFrom: task.isolatedFrom,
     };
@@ -726,6 +888,10 @@ export class TaskManager {
   }
 
   private clearTimers(task: InternalTask): void {
+    if (task.killTimeout) {
+      clearTimeout(task.killTimeout);
+      task.killTimeout = undefined;
+    }
     if (task.timeout) {
       clearTimeout(task.timeout);
       task.timeout = undefined;

package/src/version.ts

@@ -1 +1 @@
-export const ENNODIA_VERSION = "0.2.0";
+export const ENNODIA_VERSION = "0.3.0";