ennodia 0.1.1 → 0.2.0

package/src/skills.ts

@@ -426,6 +426,7 @@ function legacySkillDirectory(path: string, scope: "project" | "user"): SkillDir
 async function loadAvailableSkills(cwd?: string): Promise<LoadedSkillDiscovery> {
   const directories = getSkillDirectories(cwd);
   const skillsMap = new Map<string, Skill>();
+  const ambiguousHarnessIds = new Map<string, Set<string>>();
   const warnings: string[] = [];
 
   for (const directory of directories) {
@@ -439,10 +440,42 @@ async function loadAvailableSkills(cwd?: string): Promise<LoadedSkillDiscovery>
         );
         const withInstallation = addInstallation(skill, directory);
         const existing = skillsMap.get(withInstallation.id);
-        skillsMap.set(
-          withInstallation.id,
-          existing ? mergeSkills(existing, withInstallation) : withInstallation,
-        );
+        if (!existing) {
+          skillsMap.set(withInstallation.id, withInstallation);
+          continue;
+        }
+
+        if (existing.hash !== withInstallation.hash) {
+          const ambiguous = ambiguousHarnessIds.get(withInstallation.id) ??
+            new Set<string>();
+          for (const harnessId of withInstallation.harnessIds) {
+            if (existing.harnessIds.includes(harnessId)) {
+              ambiguous.add(harnessId);
+            }
+          }
+          ambiguousHarnessIds.set(withInstallation.id, ambiguous);
+          skillsMap.set(withInstallation.id, {
+            ...existing,
+            harnessIds: existing.harnessIds.filter((harnessId) =>
+              !ambiguous.has(harnessId)
+            ),
+          });
+          warnings.push(
+            `${filePath}: Conflicting skill content for ${existing.id}: ${existing.path} and ${withInstallation.path}. Ennodia kept the higher-priority installation and removed ambiguous harness support.`,
+          );
+          continue;
+        }
+
+        const merged = mergeSkills(existing, withInstallation);
+        const ambiguous = ambiguousHarnessIds.get(withInstallation.id);
+        skillsMap.set(withInstallation.id, ambiguous
+          ? {
+            ...merged,
+            harnessIds: merged.harnessIds.filter((harnessId) =>
+              !ambiguous.has(harnessId)
+            ),
+          }
+          : merged);
       } catch (error) {
         warnings.push(`${filePath}: ${errorMessage(error)}`);
       }
@@ -589,6 +622,12 @@ function addInstallation(skill: Skill, directory: SkillDirectory): Skill {
 }
 
 function mergeSkills(primary: Skill, secondary: Skill): Skill {
+  if (primary.hash !== secondary.hash) {
+    throw new Error(
+      `Conflicting skill content for ${primary.id}: ${primary.path} and ${secondary.path}. Ennodia will keep the higher-priority installation without claiming support from the conflicting installation.`,
+    );
+  }
+
   return {
     ...primary,
     harnessIds: [...new Set([...primary.harnessIds, ...secondary.harnessIds])].sort(),
@@ -721,18 +760,97 @@ function splitFrontmatter(content: string): {
 
   const metadata: Record<string, string> = {};
   const frontmatter = normalized.slice(4, end).trim();
-  for (const line of frontmatter.split("\n")) {
-    const match = /^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/.exec(line.trim());
+  const lines = frontmatter.split("\n");
+
+  for (let i = 0; i < lines.length; i++) {
+    const match = /^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/.exec(lines[i].trim());
     if (!match) {
       continue;
     }
 
-    metadata[match[1]] = unquote(match[2].trim());
+    const key = match[1];
+    const rest = match[2].trim();
+    const blockScalar = /^([|>])([+-]?)$/.exec(rest);
+
+    if (blockScalar) {
+      const style = blockScalar[1] as "|" | ">";
+      const chomp = blockScalar[2];
+      const consumed = readYamlBlockScalar(lines, i + 1);
+      metadata[key] = foldYamlBlockScalar(consumed.value, style, chomp);
+      i = consumed.nextIndex - 1;
+      continue;
+    }
+
+    metadata[key] = unquote(rest);
   }
 
   return { metadata, body: normalized.slice(end + 5) };
 }
 
+function readYamlBlockScalar(
+  lines: string[],
+  startIndex: number,
+): { value: string[]; nextIndex: number } {
+  const value: string[] = [];
+  let indent: number | null = null;
+  let i = startIndex;
+
+  for (; i < lines.length; i++) {
+    const rawLine = lines[i];
+    if (rawLine.trim() === "") {
+      value.push("");
+      continue;
+    }
+
+    const lineIndent = rawLine.match(/^ */)?.[0].length ?? 0;
+    if (indent === null) {
+      if (lineIndent === 0) {
+        break;
+      }
+      indent = lineIndent;
+    } else if (lineIndent < indent) {
+      break;
+    }
+
+    value.push(rawLine.slice(indent ?? 0));
+  }
+
+  return { value, nextIndex: i };
+}
+
+function foldYamlBlockScalar(
+  lines: string[],
+  style: "|" | ">",
+  chomp: string,
+): string {
+  const trimmed = [...lines];
+  while (trimmed.length && trimmed[trimmed.length - 1] === "" && chomp !== "+") {
+    trimmed.pop();
+  }
+
+  if (style === "|") {
+    return trimmed.join("\n");
+  }
+
+  const paragraphs: string[] = [];
+  let current: string[] = [];
+  for (const line of trimmed) {
+    if (line === "") {
+      if (current.length) {
+        paragraphs.push(current.join(" "));
+        current = [];
+      }
+      continue;
+    }
+    current.push(line);
+  }
+  if (current.length) {
+    paragraphs.push(current.join(" "));
+  }
+
+  return paragraphs.join("\n").trim();
+}
+
 function stringField(
   record: Record<string, unknown>,
   key: string,
@@ -805,10 +923,12 @@ function firstParagraph(content: string): string | undefined {
 }
 
 function skillSupportsHarness(skill: Skill, harnessId: string): boolean {
-  return (
-    skill.harnessIds.includes(harnessId) ||
-    skill.harnessIds.includes("legacy")
-  );
+  if (skill.native) {
+    return skill.harnessIds.includes(harnessId);
+  }
+
+  return skill.harnessIds.includes(harnessId) ||
+    skill.harnessIds.includes("legacy");
 }
 
 function unquote(value: string): string {

package/src/tasks.ts

@@ -1,10 +1,14 @@
-import { existsSync } from "node:fs";
-import { basename } from "node:path";
+import { cpSync, existsSync, lstatSync, mkdtempSync, rmSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 import type {
+  CommandSpec,
   HarnessAdapter,
   HarnessDiscovery,
   HarnessRunInput,
+  HarnessUsage,
 } from "./harnesses";
 import { preview, tailItems } from "./internal";
 import {
@@ -49,6 +53,16 @@ export type TaskView = {
   stderr: string;
   events: TaskEvent[];
   appliedSkills?: AppliedSkillInfo[];
+  /** Clean final message, distinct from raw stdout, when the adapter supports
+   * writing one out-of-band (e.g. Codex's --output-last-message). Prefer this
+   * over stdout for cross-harness comparisons: some adapters' stdout is a
+   * full session transcript, others' is just the final reply. */
+  finalMessage?: string;
+  /** 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
+   * (see HarnessRunInput.isolateCwd), naming the original directory. */
+  isolatedFrom?: string;
 };
 
 export type TaskViewOptions = {
@@ -91,6 +105,11 @@ type InternalTask = Omit<
   settled?: Promise<void>;
   streamReaders: Set<ReadableStreamDefaultReader<Uint8Array>>;
   timeout?: Timer;
+  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"];
 };
 
 export type StartTaskResult = {
@@ -101,6 +120,7 @@ export type TaskManagerOptions = {
   drainTimeoutMs?: number;
   maxTasks?: number;
   spawn?: TaskSpawn;
+  removeIsolatedCwd?: (path: string) => void;
 };
 
 export type TaskManagerShutdownOptions = {
@@ -120,6 +140,7 @@ export class TaskManager {
   private readonly drainTimeoutMs: number;
   private readonly maxTasks: number;
   private readonly spawn: TaskSpawn;
+  private readonly removeIsolatedCwd: (path: string) => void;
   private shuttingDown = false;
   private shutdownPromise?: Promise<void>;
 
@@ -127,6 +148,9 @@ 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.removeIsolatedCwd = options.removeIsolatedCwd ?? ((path) => {
+      rmSync(path, { recursive: true, force: true });
+    });
   }
 
   start(
@@ -142,18 +166,61 @@ export class TaskManager {
       throw new Error(`${adapter.name} is not runnable through Ennodia yet.`);
     }
 
+    const sourceCwd = input.cwd ?? process.cwd();
+    if (!existsSync(sourceCwd)) {
+      throw new Error(`Working directory does not exist: ${sourceCwd}`);
+    }
+
+    let isolatedCwd: string | undefined;
+    let isolatedFrom: string | undefined;
+    let resolvedInputCwd = input.cwd;
+    if (input.isolateCwd) {
+      isolatedCwd = isolateDirectory(sourceCwd);
+      resolvedInputCwd = isolatedCwd;
+      isolatedFrom = sourceCwd;
+    }
+
+    // Always allocate a scratch path; adapters that support writing a clean
+    // final message (e.g. Codex's --output-last-message) opt in by
+    // referencing input.finalMessagePath in buildCommand. Adapters that
+    // don't support it simply never create the file, and it's cleaned up
+    // as a no-op.
+    const finalMessagePath = join(tmpdir(), `ennodia-final-${randomUUID()}.txt`);
+
     const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const augmentedPrompt = input.skills && input.skills.length > 0
       ? augmentPrompt(input.prompt, input.skills, adapter.id)
       : input.prompt;
-    const commandSpec = adapter.buildCommand(discovery.commandPath, {
-      ...input,
-      prompt: augmentedPrompt,
-    });
-    const cwd = commandSpec.cwd ?? process.cwd();
+    let commandSpec: CommandSpec;
+    let cwd: string;
+    let child: TaskProcess;
+    try {
+      commandSpec = adapter.buildCommand(discovery.commandPath, {
+        ...input,
+        cwd: resolvedInputCwd,
+        prompt: augmentedPrompt,
+        finalMessagePath,
+      });
+      cwd = commandSpec.cwd ?? process.cwd();
 
-    if (!existsSync(cwd)) {
-      throw new Error(`Working directory does not exist: ${cwd}`);
+      if (!existsSync(cwd)) {
+        throw new Error(`Working directory does not exist: ${cwd}`);
+      }
+
+      child = this.spawn({
+        cmd: [commandSpec.command, ...commandSpec.args],
+        cwd,
+        env: { ...process.env, ...commandSpec.env },
+        stdin: commandSpec.stdin === undefined ? "ignore" : "pipe",
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+    } catch (error) {
+      cleanupFailedStartArtifacts(
+        finalMessagePath,
+        isolatedCwd,
+      );
+      throw error;
     }
 
     const now = Date.now();
@@ -163,6 +230,7 @@ export class TaskManager {
       harnessName: adapter.name,
       status: "running",
       cwd,
+      isolatedFrom,
       command: [
         basename(commandSpec.command),
         ...commandSpec.args.map((arg) => arg === augmentedPrompt ? "<prompt>" : arg),
@@ -180,24 +248,20 @@ export class TaskManager {
       events: [],
       streamReaders: new Set(),
       appliedSkills: input.skills?.map(toAppliedSkillInfo),
+      finalMessagePath,
+      isolatedCwd,
+      extractUsage: adapter.extractUsage,
     };
 
+    task.process = child;
+    task.pid = child.pid;
+
+    // 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);
     this.pruneTasks(task.id);
     this.pushEvent(task, { type: "started", message: "Task started." });
 
-    const child = this.spawn({
-      cmd: [commandSpec.command, ...commandSpec.args],
-      cwd,
-      env: { ...process.env, ...commandSpec.env },
-      stdin: commandSpec.stdin === undefined ? "ignore" : "pipe",
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-
-    task.process = child;
-    task.pid = child.pid;
-
     task.streamsDone = Promise.all([
       this.pipeStreamSafely(task, "stdout", child.stdout),
       this.pipeStreamSafely(task, "stderr", child.stderr),
@@ -325,6 +389,7 @@ export class TaskManager {
 
     for (const task of this.tasks.values()) {
       this.clearTimers(task);
+      this.cleanupIsolatedCwd(task);
     }
   }
 
@@ -366,12 +431,70 @@ export class TaskManager {
         message: error instanceof Error ? error.message : String(error),
       });
     } finally {
+      await this.collectFinalMessage(task);
+      this.collectUsage(task);
+      this.cleanupIsolatedCwd(task);
       this.clearTimers(task);
       this.touch(task);
       this.pruneTasks(task.id);
     }
   }
 
+  private async collectFinalMessage(task: InternalTask): Promise<void> {
+    if (!task.finalMessagePath) {
+      return;
+    }
+
+    try {
+      if (existsSync(task.finalMessagePath)) {
+        const content = (await readFile(task.finalMessagePath, "utf8")).trim();
+        if (content) {
+          task.finalMessage = content;
+        }
+        rmSync(task.finalMessagePath, { force: true });
+      }
+    } catch (error) {
+      this.pushEvent(task, {
+        type: "error",
+        message: `Failed to read final message file: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      });
+    }
+  }
+
+  private collectUsage(task: InternalTask): void {
+    if (!task.extractUsage) {
+      return;
+    }
+
+    try {
+      task.usage = task.extractUsage(task.stdout, task.stderr);
+    } catch {
+      task.usage = undefined;
+    }
+  }
+
+  private cleanupIsolatedCwd(task: InternalTask): boolean {
+    if (!task.isolatedCwd) {
+      return true;
+    }
+
+    try {
+      this.removeIsolatedCwd(task.isolatedCwd);
+      task.isolatedCwd = undefined;
+      return true;
+    } catch (error) {
+      this.pushEvent(task, {
+        type: "error",
+        message: `Failed to remove isolated working directory: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      });
+      return false;
+    }
+  }
+
   private pruneTasks(protectedTaskId?: string): void {
     const overflow = this.tasks.size - this.maxTasks;
     if (overflow <= 0) {
@@ -382,8 +505,16 @@ export class TaskManager {
       .filter((task) => task.id !== protectedTaskId && task.status !== "running")
       .sort((a, b) => a.createdAtMs - b.createdAtMs);
 
-    for (const task of removable.slice(0, overflow)) {
+    let removed = 0;
+    for (const task of removable) {
+      if (removed >= overflow) {
+        break;
+      }
+      if (!this.cleanupIsolatedCwd(task)) {
+        continue;
+      }
       this.tasks.delete(task.id);
+      removed += 1;
     }
   }
 
@@ -569,6 +700,9 @@ export class TaskManager {
       stderr: includeOutput ? tail(task.stderr, maxOutputChars) : "",
       events: includeEvents ? tailItems(task.events, maxEvents) : [],
       appliedSkills: task.appliedSkills,
+      finalMessage: includeOutput ? task.finalMessage : undefined,
+      usage: task.usage,
+      isolatedFrom: task.isolatedFrom,
     };
   }
 
@@ -627,3 +761,39 @@ function trimEventMessage(message: string): string {
 
   return `${message.slice(0, MAX_EVENT_MESSAGE_CHARS)}...`;
 }
+
+const ISOLATION_EXCLUDED_DIRS = new Set(["node_modules", ".git"]);
+
+function isolateDirectory(source: string): string {
+  const target = mkdtempSync(join(tmpdir(), "ennodia-cwd-"));
+  try {
+    cpSync(source, target, {
+      recursive: true,
+      filter: (candidate) => {
+        if (ISOLATION_EXCLUDED_DIRS.has(basename(candidate))) {
+          return false;
+        }
+        if (lstatSync(candidate).isSymbolicLink()) {
+          throw new Error(
+            `Cannot isolate working directory containing symbolic link: ${candidate}`,
+          );
+        }
+        return true;
+      },
+    });
+    return target;
+  } catch (error) {
+    rmSync(target, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+function cleanupFailedStartArtifacts(
+  finalMessagePath: string,
+  isolatedCwd?: string,
+): void {
+  rmSync(finalMessagePath, { force: true });
+  if (isolatedCwd) {
+    rmSync(isolatedCwd, { recursive: true, force: true });
+  }
+}

package/src/version.ts

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