neko-harness 0.3.1 → 0.3.3

package/dist/gateway.js

@@ -434,6 +434,125 @@ async function prepareInput(content, model) {
   let index = 0;
   return content.map((b) => b.type === "image" ? prepared[index++] : b);
 }
+// packages/core/src/jobs.ts
+import { defineDoc } from "@earendil-works/pi-durable";
+var JOB_LIMITS = {
+  maxRunning: 4,
+  keepTerminal: 20,
+  startWindowMs: 2000,
+  tailBytes: 64 * 1024,
+  tailLines: 1000,
+  reportBytes: 4 * 1024,
+  reportLines: 40,
+  readBytes: 64 * 1024,
+  titleChars: 200,
+  commandBytes: 32 * 1024,
+  maxTimeoutSeconds: 7 * 24 * 3600
+};
+var JobsDoc = defineDoc({
+  kind: "app.neko.jobs",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: () => ({ next: 1, items: [] })
+});
+var summarizeJobRecord = (job, outputBytes = job.totalBytes ?? 0) => {
+  const {
+    tail: _tail,
+    totalBytes: _total,
+    runnerId: _runner,
+    reporterId: _reporter,
+    stopOrigin: _origin,
+    ...rest
+  } = job;
+  return { ...rest, outputBytes };
+};
+var isTerminalJob = (status) => status !== "running";
+var encoder = new TextEncoder;
+var decoder = new TextDecoder;
+var byteLength = (text) => encoder.encode(text).length;
+function tailOf(text, maxBytes, maxLines) {
+  let bytes = encoder.encode(text);
+  if (bytes.length > maxBytes) {
+    let start = bytes.length - maxBytes;
+    while (start < bytes.length && (bytes[start] & 192) === 128)
+      start++;
+    bytes = bytes.subarray(start);
+    text = decoder.decode(bytes);
+  }
+  let index = text.length;
+  let seen = 0;
+  if (text.endsWith(`
+`))
+    index--;
+  while (index > 0) {
+    const found = text.lastIndexOf(`
+`, index - 1);
+    if (found < 0)
+      break;
+    if (++seen >= maxLines)
+      return text.slice(found + 1);
+    index = found;
+  }
+  return text;
+}
+
+class OutputBuffer {
+  #chunks = [];
+  #bytes = 0;
+  #total = 0;
+  #maxBytes;
+  #maxLines;
+  constructor(maxBytes = JOB_LIMITS.tailBytes, maxLines = JOB_LIMITS.tailLines) {
+    this.#maxBytes = maxBytes;
+    this.#maxLines = maxLines;
+  }
+  static fromTail(tail, totalBytes) {
+    const buffer = new OutputBuffer;
+    buffer.#chunks = [tail];
+    buffer.#bytes = byteLength(tail);
+    buffer.#total = totalBytes;
+    return buffer;
+  }
+  get totalBytes() {
+    return this.#total;
+  }
+  append(text) {
+    if (!text)
+      return;
+    const size = byteLength(text);
+    this.#total += size;
+    this.#bytes += size;
+    this.#chunks.push(text);
+    if (this.#bytes > this.#maxBytes * 2)
+      this.#trim();
+  }
+  #trim() {
+    const text = tailOf(this.#chunks.join(""), this.#maxBytes, this.#maxLines);
+    this.#chunks = [text];
+    this.#bytes = byteLength(text);
+    return text;
+  }
+  tail() {
+    return this.#trim();
+  }
+  read(since, maxBytes = JOB_LIMITS.readBytes) {
+    const tail = this.#trim();
+    const start = this.#total - this.#bytes;
+    const all = encoder.encode(tail);
+    let begin = since === undefined ? start : Math.min(Math.max(since, start), this.#total);
+    let bytes = all.subarray(begin - start);
+    let cut = Math.max(0, bytes.length - maxBytes);
+    while (cut < bytes.length && (bytes[cut] & 192) === 128)
+      cut++;
+    begin += cut;
+    bytes = bytes.subarray(cut);
+    const dropped = Math.max(0, begin - (since ?? 0));
+    return { text: decoder.decode(bytes), offset: this.#total, truncated: dropped > 0, dropped };
+  }
+}
+var reportTail = (text) => tailOf(text, JOB_LIMITS.reportBytes, JOB_LIMITS.reportLines);
 // packages/core/src/image-prompt.ts
 var DEFAULT_IMAGE_PROMPT = {
   version: 2,
@@ -560,6 +679,53 @@ function toolResultText(content) {
   return content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text ?? "").join(`
 `);
 }
+var WRITE_DIFF_MAX_LINES = 2000;
+var WRITE_DIFF_MAX_BYTES = 64 * 1024;
+function countDiffLines(diff) {
+  let added = 0;
+  let removed = 0;
+  for (const line of diff.split(`
+`)) {
+    if (line.startsWith("+") && !line.startsWith("+++"))
+      added++;
+    else if (line.startsWith("-") && !line.startsWith("---"))
+      removed++;
+  }
+  return { added, removed };
+}
+function editResultDiff(details) {
+  if (typeof details !== "object" || details === null)
+    return null;
+  const diff = details.diff;
+  return typeof diff === "string" ? diff : null;
+}
+function synthesizedWriteDiff(args) {
+  const record = args ?? {};
+  if (typeof record.content !== "string")
+    return null;
+  const content = record.content;
+  const shown = [];
+  let offset = 0;
+  let bytes = 0;
+  while (offset < content.length && shown.length < WRITE_DIFF_MAX_LINES) {
+    const newline = content.indexOf(`
+`, offset);
+    const end = newline === -1 ? content.length : newline;
+    const overhead = shown.length === 0 ? 2 : 3;
+    const remaining = WRITE_DIFF_MAX_BYTES - bytes - overhead;
+    if (end - offset > remaining)
+      break;
+    const line = content.slice(offset, end);
+    const lineBytes = Buffer.byteLength(line, "utf8");
+    if (lineBytes > remaining)
+      break;
+    shown.push(`+ ${line}`);
+    bytes += lineBytes + overhead;
+    offset = newline === -1 ? content.length : end + 1;
+  }
+  return { diff: shown.join(`
+`), added: shown.length, removed: 0, truncated: offset < content.length };
+}
 function totalUsage(state) {
   const total = {
     input: 0,
@@ -592,6 +758,8 @@ function projectChatView(view, modelLabel, options = {}) {
       if (message.role !== "toolResult")
         continue;
       const diagnostics = entry.data?.diagnostics ?? [];
+      const diff = message.toolName === "edit" ? editResultDiff(message.details) : null;
+      const counts = diff === null ? null : countDiffLines(diff);
       results.set(message.toolCallId, {
         type: "tool",
         key: `t${message.toolCallId}`,
@@ -608,7 +776,10 @@ function projectChatView(view, modelLabel, options = {}) {
         ].filter(Boolean).join(`
 `),
         durationMs: message.durationMs ?? null,
-        note: null
+        note: null,
+        diff,
+        diffAdded: counts?.added ?? null,
+        diffRemoved: counts?.removed ?? null
       });
     }
   }
@@ -639,6 +810,17 @@ function projectChatView(view, modelLabel, options = {}) {
   const items = [];
   for (const entry of view.entries) {
     const message = entry.model?.[0];
+    const jobReport = entry.kind === NekoInput.kind ? entry.data?.jobReport : undefined;
+    if (message?.role === "user" && jobReport) {
+      items.push({
+        type: "system",
+        key: `e${entry.id}`,
+        id: entry.id,
+        text: userText(message.content),
+        jobId: jobReport.jobId
+      });
+      continue;
+    }
     if (message?.role === "user") {
       const defaultImagePrompt = entry.kind === NekoInput.kind ? savedDefaultImagePrompt(message.content, entry.data?.defaultImagePrompt) : undefined;
       items.push({
@@ -666,6 +848,7 @@ function projectChatView(view, modelLabel, options = {}) {
         } else {
           const summary = summarizeToolCall(block.name, block.arguments);
           const slot = live.tools?.find((s) => s.callId === block.id);
+          const synthesized = block.name === "write" ? synthesizedWriteDiff(block.arguments) : null;
           items.push({
             type: "tool",
             key: `t${block.id}`,
@@ -678,7 +861,11 @@ function projectChatView(view, modelLabel, options = {}) {
             output: slot?.output ?? null,
             result: null,
             durationMs: null,
-            note: ran ? null : "Not run: response interrupted."
+            note: ran ? null : "Not run: response interrupted.",
+            diff: synthesized?.diff ?? null,
+            diffAdded: synthesized?.added ?? null,
+            diffRemoved: synthesized?.removed ?? null,
+            diffTruncated: synthesized?.truncated ?? false
           });
         }
       }
@@ -726,7 +913,17 @@ function projectChatView(view, modelLabel, options = {}) {
 }
 function withArgs(item, name, args) {
   const summary = summarizeToolCall(name, args);
-  return { ...item, name, summary: summary.args, detail: summary.detail ?? null };
+  const synthesized = name === "write" ? synthesizedWriteDiff(args) : null;
+  return {
+    ...item,
+    name,
+    summary: summary.args,
+    detail: summary.detail ?? null,
+    diff: synthesized?.diff ?? item.diff,
+    diffAdded: synthesized?.added ?? item.diffAdded,
+    diffRemoved: synthesized?.removed ?? item.diffRemoved,
+    diffTruncated: synthesized?.truncated ?? false
+  };
 }
 function assistantItem(message, id) {
   let thinking = "";
@@ -779,13 +976,18 @@ ${block.text}`;
     if (block.type === "toolCall") {
       const slot = live.tools?.find((candidate) => candidate.callId === block.id);
       const summary = summarizeToolCall(block.name, block.arguments);
+      const synthesized = block.name === "write" ? synthesizedWriteDiff(block.arguments) : null;
       toolCalls.push({
         callId: block.id,
         name: block.name,
         summary: summary.args,
         detail: summary.detail ?? null,
         phase: slot === undefined || slot.status === "pending" ? "pending" : slot.status,
-        output: slot?.status === "running" ? slot.output ?? null : null
+        output: slot?.status === "running" ? slot.output ?? null : null,
+        diff: synthesized?.diff ?? null,
+        diffAdded: synthesized?.added ?? null,
+        diffRemoved: synthesized?.removed ?? null,
+        diffTruncated: synthesized?.truncated ?? false
       });
     }
   }
@@ -840,7 +1042,7 @@ import { deepseekProvider } from "@earendil-works/pi-ai/providers/deepseek";
 import {
   AssistantEntry as AssistantEntry2,
   createRegistry,
-  defineDoc as defineDoc4,
+  defineDoc as defineDoc5,
   Harness,
   LiveDoc as importLiveDoc,
   MemoryStorage,
@@ -1079,150 +1281,20 @@ var ImageDetails = defineExtension2({
   ]
 });
 
-// packages/core/src/prompt/invoke.ts
-import { dirname as dirname4 } from "path";
-
-// packages/core/src/prompt/diagnostics.ts
-var ignorePromptDiagnostic = () => {};
-var warnPromptDiagnostic = ({ path, message }) => {
-  console.warn(`[neko-prompt] ${JSON.stringify(path)}: ${message}`);
-};
-var isMissing = (error) => typeof error === "object" && error !== null && ("code" in error) && (error.code === "ENOENT" || error.code === "ENOTDIR");
-
-// packages/core/src/prompt/skills.ts
-import { readdir, readFile as readFile2 } from "fs/promises";
-import { basename, dirname as dirname3, join as join3 } from "path";
-var MAX_NAME_LENGTH = 64;
-var MAX_DESCRIPTION_LENGTH = 1024;
-var parseSkillFile = (content, filePath, report = ignorePromptDiagnostic) => {
-  const skip = (message) => {
-    report({ path: filePath, message });
-    return null;
-  };
-  try {
-    const { frontmatter } = parseFrontmatter(content);
-    const description = frontmatter.description;
-    if (typeof description !== "string" || description.trim() === "")
-      return skip("Skill description is missing or empty; skipped.");
-    if (description.length > MAX_DESCRIPTION_LENGTH)
-      return skip("Skill description is too long; skipped.");
-    const name = typeof frontmatter.name === "string" && frontmatter.name.trim() !== "" ? frontmatter.name : basename(dirname3(filePath));
-    if (name.length > MAX_NAME_LENGTH || /[\s\p{Cc}]/u.test(name))
-      return skip("Skill name is too long or contains whitespace/control characters; skipped.");
-    return {
-      name,
-      description,
-      filePath,
-      disableModelInvocation: frontmatter["disable-model-invocation"] === true
-    };
-  } catch {
-    return skip("Invalid skill frontmatter; skipped.");
-  }
-};
-var scanSkillsDir = async (dir, report = ignorePromptDiagnostic, capture) => {
-  let entries;
-  try {
-    entries = await readdir(dir, { withFileTypes: true });
-  } catch (error) {
-    if (!isMissing(error))
-      report({ path: dir, message: "Cannot scan skills directory; skipped." });
-    return [];
-  }
-  const skills = [];
-  for (const entry of entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
-    if (!entry.isDirectory())
-      continue;
-    const filePath = join3(dir, entry.name, "SKILL.md");
-    let content;
-    try {
-      content = await readFile2(filePath, "utf8");
-    } catch (error) {
-      if (!isMissing(error))
-        report({ path: filePath, message: "Cannot read skill; skipped." });
-      continue;
-    }
-    const skill = parseSkillFile(content, filePath, report);
-    if (skill) {
-      skills.push(skill);
-      capture?.(skill, content);
-    }
-  }
-  return skills;
-};
-var mergeSkills = (groups) => {
-  const byName = new Map;
-  for (const group of groups)
-    for (const skill of group)
-      byName.set(skill.name, skill);
-  return [...byName.values()];
-};
-var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-var formatSkillsForPrompt = (skills) => {
-  const visible = skills.filter((skill) => !skill.disableModelInvocation);
-  if (visible.length === 0)
-    return "";
-  const lines = [
-    "The following skills provide specialized instructions for specific tasks.",
-    "Use the read tool to load a skill's file when the task matches its description.",
-    "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md) and use that absolute path in tool commands.",
-    "",
-    "<available_skills>"
-  ];
-  for (const skill of visible) {
-    lines.push("  <skill>");
-    lines.push(`    <name>${escapeXml(skill.name)}</name>`);
-    lines.push(`    <description>${escapeXml(skill.description)}</description>`);
-    lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
-    lines.push("  </skill>");
-  }
-  lines.push("</available_skills>");
-  return lines.join(`
-`);
-};
-
-// packages/core/src/prompt/invoke.ts
-var expandSkillCommand = async (text, skills, readFile, report = warnPromptDiagnostic, metadata) => {
-  if (!text.startsWith("/skill:"))
-    return text;
-  const spaceIndex = text.indexOf(" ");
-  const skillName = spaceIndex === -1 ? text.slice(7) : text.slice(7, spaceIndex);
-  const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1).trim();
-  const skill = skills.find((s) => s.name === skillName);
-  if (!skill)
-    return text;
-  let body;
-  try {
-    body = stripFrontmatter(await readFile(skill.filePath)).trim();
-  } catch {
-    report({ path: skill.filePath, message: "Cannot expand known skill; original input preserved." });
-    return text;
-  }
-  metadata?.({
-    name: skill.name,
-    location: skill.filePath,
-    body: `References are relative to ${dirname4(skill.filePath)}.
-
-${body}`,
-    args
-  });
-  const block = `<skill name="${escapeXml(skill.name)}" location="${escapeXml(skill.filePath)}">
-References are relative to ${dirname4(skill.filePath)}.
-
-${body}
-</skill>`;
-  return args ? `${block}
-
-${args}` : block;
-};
-
-// packages/core/src/prompt/prompt.ts
-import { defineExtension as defineExtension4, section } from "@earendil-works/pi-durable";
+// packages/core/src/job-engine.ts
+import { withAbortSignal as withAbortSignal2 } from "@earendil-works/chord/context";
+import {
+  defineExtension as defineExtension4,
+  defineTask as defineTask2,
+  defineTool as defineTool3
+} from "@earendil-works/pi-durable";
+import { Type as Type3 } from "typebox";
 
 // packages/core/src/subagents.ts
 import {
   AssistantEntry,
   configure,
-  defineDoc,
+  defineDoc as defineDoc2,
   defineExtension as defineExtension3,
   defineTask,
   defineTool as defineTool2,
@@ -1276,7 +1348,7 @@ function subagentUsageTotals(state) {
 
 // packages/core/src/subagents.ts
 var agentIdFor = (childId) => `agent-${childId}`;
-var DelegationsDoc = defineDoc({
+var DelegationsDoc = defineDoc2({
   kind: "app.neko.delegations",
   version: 1,
   scope: "conversation",
@@ -1284,7 +1356,7 @@ var DelegationsDoc = defineDoc({
   fork: "initial",
   initial: () => ({ items: [] })
 });
-var SubagentsDoc = defineDoc({
+var SubagentsDoc = defineDoc2({
   kind: "app.neko.subagents",
   version: 1,
   scope: "conversation",
@@ -1292,7 +1364,7 @@ var SubagentsDoc = defineDoc({
   fork: "initial",
   initial: () => ({ items: [] })
 });
-var SubagentDoc = defineDoc({
+var SubagentDoc = defineDoc2({
   kind: "app.neko.subagent",
   version: 1,
   scope: "conversation",
@@ -1300,7 +1372,7 @@ var SubagentDoc = defineDoc({
   fork: "initial",
   initial: () => ({ role: null, parentId: null })
 });
-var SlotsDoc = defineDoc({
+var SlotsDoc = defineDoc2({
   kind: "app.neko.subagent-slots",
   version: 1,
   scope: "session",
@@ -1631,7 +1703,7 @@ function createSubagentExtension(prepare, discard) {
                 thinkingLevel: agent.thinkingLevel,
                 cwd: agent.cwd,
                 extensions: agent.extensions.filter((e) => e.name !== extension.name),
-                tools: agent.tools.filter((t) => t.name !== "subagent" && (role === "coder" || READ_TOOLS.has(t.name) || role === "explore" && t.name === "bash"))
+                tools: agent.tools.filter((t) => t.name !== "subagent" && t.name !== "job" && (role === "coder" || READ_TOOLS.has(t.name) || role === "explore" && t.name === "bash"))
               });
               Object.assign(await tx.doc(SubagentDoc, created.id), { role, parentId: api.conversationId });
               identity = {
@@ -1772,7 +1844,567 @@ async function installSubagentCoordinator(harness, parents, context) {
   harness.closed.finally(stop).catch(() => {});
 }
 
+// packages/core/src/job-engine.ts
+var plain = (value) => JSON.parse(JSON.stringify(value));
+
+class JobEntry {
+  controller = new AbortController;
+  buffer = new OutputBuffer;
+  windowOpen = false;
+  suppressReport = false;
+  exited;
+  #resolve;
+  constructor() {
+    this.exited = new Promise((resolve) => {
+      this.#resolve = resolve;
+    });
+  }
+  finish() {
+    this.#resolve();
+  }
+}
+
+class JobRegistry {
+  #entries = new Map;
+  static key(conversationId, jobId) {
+    return `${conversationId}:${jobId}`;
+  }
+  ensure(conversationId, jobId) {
+    const key = JobRegistry.key(conversationId, jobId);
+    let entry = this.#entries.get(key);
+    if (!entry) {
+      entry = new JobEntry;
+      this.#entries.set(key, entry);
+    }
+    return entry;
+  }
+  get(conversationId, jobId) {
+    return this.#entries.get(JobRegistry.key(conversationId, jobId));
+  }
+  delete(conversationId, jobId) {
+    this.#entries.delete(JobRegistry.key(conversationId, jobId));
+  }
+  abortAll() {
+    for (const entry of this.#entries.values())
+      entry.controller.abort();
+  }
+  abortConversation(conversationId) {
+    for (const [key, entry] of this.#entries)
+      if (key.startsWith(`${conversationId}:`))
+        entry.controller.abort();
+  }
+}
+var statusWord = {
+  running: "running",
+  exited: "exited",
+  failed: "failed",
+  stopped: "stopped",
+  lost: "lost"
+};
+var describe = (job) => {
+  const parts = [statusWord[job.status]];
+  if (job.exitCode !== null)
+    parts.push(`exit code ${job.exitCode}`);
+  if (job.reason === "timeout")
+    parts.push(`timed out after ${job.timeoutSeconds} seconds`);
+  if (job.reason === "spawn-error")
+    parts.push("could not start");
+  if (job.reason === "restart")
+    parts.push("the process was lost when the gateway restarted and was not re-run");
+  return parts.join(", ");
+};
+function reportText(job, tail) {
+  const body = reportTail(tail);
+  return [
+    `[Background job ${job.jobId} "${job.title}" ${describe(job)}]`,
+    `Command: ${job.command}`,
+    body ? `Last output (use the job tool's output action with jobId "${job.jobId}" for more):
+${body}` : "It produced no output."
+  ].join(`
+`);
+}
+async function settleJob(tx, conversationId, jobId, outcome, tail, quiet, reporter) {
+  const state = await tx.doc(JobsDoc, conversationId);
+  const job = state.items.find((item) => item.jobId === jobId);
+  if (!job || isTerminalJob(job.status))
+    return;
+  job.status = outcome.status;
+  job.exitCode = outcome.exitCode;
+  if (outcome.reason)
+    job.reason = outcome.reason;
+  job.endedAt = Date.now();
+  job.tail = tail.text;
+  job.totalBytes = tail.totalBytes;
+  if (!quiet && (job.status !== "stopped" || job.stopOrigin === "user"))
+    job.reporterId = await tx.createTask(reporter, { jobId, text: reportText(job, tail.text), status: job.status, exitCode: job.exitCode }, { ownership: { kind: "conversation" }, conversationId, background: true });
+  const terminal = state.items.filter((item) => isTerminalJob(item.status));
+  if (terminal.length > JOB_LIMITS.keepTerminal) {
+    const drop = new Set(terminal.sort((a, b) => (a.endedAt ?? 0) - (b.endedAt ?? 0)).slice(0, terminal.length - JOB_LIMITS.keepTerminal).map((item) => item.jobId));
+    state.items = state.items.filter((item) => !drop.has(item.jobId));
+  }
+  return job;
+}
+function createReporter() {
+  return defineTask2({
+    name: "app.neko.job-reporter",
+    version: 1,
+    initial: () => ({ phase: "report" }),
+    phases: {
+      report: async (task, runtime, ctx) => {
+        const target = await runtime.conversation(runtime.conversationId, ctx);
+        await target.submit({
+          type: "input",
+          content: task.input.text,
+          whenBusy: "followUp",
+          requestId: `job-report:${task.input.jobId}`,
+          entry: {
+            kind: NekoInput.kind,
+            data: {
+              at: Date.now(),
+              prompt: task.input.text,
+              images: [],
+              jobReport: { jobId: task.input.jobId, status: task.input.status, exitCode: task.input.exitCode }
+            }
+          }
+        }, ctx);
+        await runtime.commit(() => ({ status: "terminal", outcome: { status: "completed", result: null } }), ctx);
+      }
+    },
+    abort: (_task, runtime, ctx) => runtime.commit(() => ({ status: "terminal", outcome: { status: "aborted" } }), ctx)
+  });
+}
+var delay = (ms, signal) => new Promise((resolve) => {
+  const timer = setTimeout(done, ms);
+  function done() {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", done);
+    resolve();
+  }
+  if (signal?.aborted)
+    done();
+  else
+    signal?.addEventListener("abort", done, { once: true });
+});
+var action = Type3.Union([Type3.Literal("start"), Type3.Literal("output"), Type3.Literal("stop"), Type3.Literal("list")]);
+var parameters2 = Type3.Object({
+  action,
+  command: Type3.Optional(Type3.String({ description: "start: shell command to run in the session's working directory." })),
+  title: Type3.Optional(Type3.String({ description: "start: short label shown in the job list." })),
+  timeout: Type3.Optional(Type3.Number({ description: "start: optional timeout in seconds; no default timeout." })),
+  jobId: Type3.Optional(Type3.String({ description: "output/stop: the job id returned by start or list." })),
+  since: Type3.Optional(Type3.Integer({ description: "output: resume after this offset, as returned by the previous output call." }))
+});
+var stringField = (value, name) => {
+  if (typeof value !== "string" || !value.trim())
+    throw new Error(`Invalid job arguments: ${name} must be a nonempty string.`);
+  return value;
+};
+
+class JobManager {
+  registry = new JobRegistry;
+  #reporter = createReporter();
+  #runner = this.#createRunner();
+  extension;
+  constructor() {
+    this.extension = this.#createExtension();
+  }
+  #closing = false;
+  #createRunner() {
+    const registry = this.registry;
+    const reporter = this.#reporter;
+    return defineTask2({
+      name: "app.neko.job-runner",
+      version: 1,
+      initial: () => ({ phase: "start" }),
+      phases: {
+        start: (_task, runtime, ctx) => runtime.commit(() => ({ status: "running", checkpoint: { phase: "exec" } }), ctx),
+        exec: async (task, runtime, ctx) => {
+          const { jobId, command, cwd, timeoutSeconds } = task.input;
+          const entry = registry.ensure(runtime.conversationId, jobId);
+          let outcome;
+          try {
+            const env = await runtime.env(ctx);
+            if (!env) {
+              outcome = { status: "failed", exitCode: null, reason: "spawn-error" };
+            } else {
+              const result = await env.exec(command, {
+                ...cwd ? { cwd } : {},
+                ...timeoutSeconds === undefined ? {} : { timeout: timeoutSeconds },
+                onOutput: (text) => entry.buffer.append(text)
+              }, withAbortSignal2(entry.controller.signal, ctx));
+              if (result.ok)
+                outcome = {
+                  status: result.value.exitCode === 0 ? "exited" : "failed",
+                  exitCode: result.value.exitCode
+                };
+              else if (result.error.code === "timeout")
+                outcome = { status: "failed", exitCode: null, reason: "timeout" };
+              else if (result.error.code === "aborted")
+                outcome = { status: "stopped", exitCode: null, reason: "aborted" };
+              else
+                outcome = { status: "failed", exitCode: null, reason: "spawn-error" };
+            }
+            if (this.#closing) {
+              await new Promise((resolve) => {
+                if (!ctx.abortSignal || ctx.abortSignal.aborted)
+                  resolve();
+                else
+                  ctx.abortSignal.addEventListener("abort", () => resolve(), { once: true });
+              });
+              throw ctx.abortSignal?.reason ?? new Error("Job runner interrupted by shutdown");
+            }
+            const quiet = entry.windowOpen;
+            if (quiet)
+              entry.suppressReport = true;
+            const tail = { text: entry.buffer.tail(), totalBytes: entry.buffer.totalBytes };
+            await runtime.commit(async (tx) => {
+              const job = await settleJob(tx, runtime.conversationId, jobId, outcome, tail, quiet, reporter);
+              return {
+                status: "terminal",
+                outcome: { status: "completed", result: { status: job?.status ?? outcome.status } }
+              };
+            }, ctx);
+          } finally {
+            registry.delete(runtime.conversationId, jobId);
+            entry.finish();
+          }
+        }
+      },
+      abort: async (task, runtime, ctx) => {
+        const { jobId } = task.input;
+        const entry = registry.get(runtime.conversationId, jobId);
+        entry?.controller.abort();
+        const restart = task.abortReason === "restart";
+        const outcome = restart ? { status: "lost", exitCode: null, reason: "restart" } : { status: "stopped", exitCode: null, reason: "aborted" };
+        try {
+          await runtime.commit(async (tx) => {
+            const known = (await tx.doc(JobsDoc, runtime.conversationId)).items.find((item) => item.jobId === jobId);
+            const tail = entry ? { text: entry.buffer.tail(), totalBytes: entry.buffer.totalBytes } : { text: known?.tail ?? "", totalBytes: known?.totalBytes ?? 0 };
+            await settleJob(tx, runtime.conversationId, jobId, outcome, tail, false, reporter);
+            return { status: "terminal", outcome: { status: "aborted" } };
+          }, ctx);
+        } finally {
+          registry.delete(runtime.conversationId, jobId);
+          entry?.finish();
+        }
+      }
+    });
+  }
+  #createExtension() {
+    return defineExtension4({
+      name: "neko-jobs",
+      tasks: [this.#runner, this.#reporter],
+      tools: [
+        defineTool3({
+          name: "job",
+          description: "Run long-lived commands (dev servers, watchers, long builds) in the background. start: command (optional title, timeout seconds) returns a jobId immediately; the command has no stdin. output: jobId (optional since offset) reads the output tail or what is new. stop: jobId terminates the whole process tree. list: show this session's jobs. When a job ends you receive a report; do not poll. At most 4 jobs run at once.",
+          parameters: parameters2,
+          replay: "unsafe",
+          execute: async (input, api, context) => {
+            const args = input;
+            if ((await api.snapshot(SubagentDoc, api.conversationId, context))?.role)
+              throw new Error("Subagents cannot use jobs.");
+            const io = {
+              commit: (change) => api.commit(change, context),
+              state: async () => api.snapshot(JobsDoc, api.conversationId, context)
+            };
+            const kind = args.action;
+            if (kind === "list")
+              return this.#text(this.#listText((await io.state())?.items ?? []));
+            if (kind === "output") {
+              const jobId = stringField(args.jobId, "jobId");
+              const since = args.since;
+              if (since !== undefined && (!Number.isInteger(since) || since < 0))
+                throw new Error("Invalid job arguments: since must be a non-negative integer.");
+              return this.#text(await this.output(io, api.conversationId, jobId, since));
+            }
+            if (kind === "stop") {
+              const jobId = stringField(args.jobId, "jobId");
+              const job = await this.stop(io, api.conversationId, jobId, "model", context);
+              return this.#text(`Job ${job.jobId} ${describe(job)}.`);
+            }
+            if (kind !== "start")
+              throw new Error("Invalid job arguments: action must be start, output, stop or list.");
+            const command = stringField(args.command, "command");
+            if (Buffer.byteLength(command) > JOB_LIMITS.commandBytes)
+              throw new Error("Invalid job arguments: command is too long.");
+            const timeout = args.timeout;
+            if (timeout !== undefined && (typeof timeout !== "number" || !Number.isFinite(timeout) || timeout <= 0 || timeout > JOB_LIMITS.maxTimeoutSeconds))
+              throw new Error("Invalid job arguments: timeout must be a positive number of seconds.");
+            const title = typeof args.title === "string" && args.title.trim() ? args.title.trim() : command;
+            const agent = await api.agent(context);
+            return this.#text(await this.start(io, api.conversationId, agent.cwd ?? "", {
+              command,
+              title: title.slice(0, JOB_LIMITS.titleChars),
+              ...timeout === undefined ? {} : { timeoutSeconds: timeout }
+            }, context));
+          }
+        })
+      ]
+    });
+  }
+  #text(text) {
+    return { output: [{ type: "text", text }] };
+  }
+  #listText(items) {
+    if (!items.length)
+      return "No jobs.";
+    return items.map((job) => `${job.jobId} [${describe(job)}] "${job.title}" \u2014 ${job.command}`).join(`
+`);
+  }
+  async start(io, conversationId, cwd, args, context) {
+    let allocated;
+    let entry;
+    let created;
+    try {
+      created = await io.commit(async (tx) => {
+        const state = await tx.doc(JobsDoc, conversationId);
+        if (state.items.filter((item) => item.status === "running").length >= JOB_LIMITS.maxRunning)
+          throw new Error(`Too many running jobs (limit ${JOB_LIMITS.maxRunning}). Stop one with the job tool's stop action first.`);
+        const jobId = `job-${state.next++}`;
+        const record = {
+          jobId,
+          title: args.title,
+          command: args.command,
+          cwd,
+          status: "running",
+          startedAt: Date.now(),
+          endedAt: null,
+          exitCode: null,
+          ...args.timeoutSeconds === undefined ? {} : { timeoutSeconds: args.timeoutSeconds },
+          runnerId: 0
+        };
+        allocated = jobId;
+        entry = this.registry.ensure(conversationId, jobId);
+        entry.windowOpen = true;
+        record.runnerId = await tx.createTask(this.#runner, {
+          jobId,
+          command: args.command,
+          cwd,
+          ...args.timeoutSeconds === undefined ? {} : { timeoutSeconds: args.timeoutSeconds }
+        }, { ownership: { kind: "conversation" }, conversationId, background: true, abandonOnRestart: true });
+        state.items.push(record);
+        return plain(record);
+      });
+    } catch (error) {
+      if (allocated)
+        this.registry.delete(conversationId, allocated);
+      throw error;
+    }
+    const live = entry;
+    await Promise.race([live.exited, delay(JOB_LIMITS.startWindowMs, context.abortSignal)]);
+    live.windowOpen = false;
+    if (live.suppressReport)
+      await live.exited;
+    const job = (await io.state())?.items.find((item) => item.jobId === created.jobId) ?? created;
+    const read = live.buffer.read();
+    return this.#render(job, read.text, read.offset, read.dropped);
+  }
+  #render(job, text, offset, dropped) {
+    const lines = [`Job ${job.jobId} ${describe(job)}.`, `Title: ${job.title}`, `Command: ${job.command}`];
+    if (dropped > 0)
+      lines.push(`(${dropped} bytes of earlier output were dropped)`);
+    lines.push(text ? `Output (next offset ${offset}):
+${text}` : `No new output (next offset ${offset}).`);
+    return lines.join(`
+`);
+  }
+  async output(io, conversationId, jobId, since) {
+    const job = await this.#find(io, jobId);
+    const output = this.read(conversationId, job, since);
+    return this.#render(job, output.text, output.offset, output.dropped);
+  }
+  async readOutput(io, conversationId, jobId, since) {
+    const job = await this.#find(io, jobId);
+    const output = this.read(conversationId, job, since);
+    return { job: summarizeJobRecord(job, output.offset), output };
+  }
+  async#find(io, jobId) {
+    const job = (await io.state())?.items.find((item) => item.jobId === jobId);
+    if (!job)
+      throw new Error(`Unknown job ${jobId}.`);
+    return job;
+  }
+  async list(io, conversationId) {
+    return ((await io.state())?.items ?? []).map((job) => summarizeJobRecord(job, this.registry.get(conversationId, job.jobId)?.buffer.totalBytes ?? job.totalBytes ?? 0));
+  }
+  read(conversationId, job, since) {
+    const entry = isTerminalJob(job.status) ? undefined : this.registry.get(conversationId, job.jobId);
+    return (entry?.buffer ?? OutputBuffer.fromTail(job.tail ?? "", job.totalBytes ?? 0)).read(since);
+  }
+  async stop(io, conversationId, jobId, origin, context) {
+    let live;
+    const found = await io.commit(async (tx) => {
+      live = undefined;
+      const job = (await tx.doc(JobsDoc, conversationId)).items.find((item) => item.jobId === jobId);
+      if (!job)
+        throw new Error(`Unknown job ${jobId}.`);
+      if (isTerminalJob(job.status))
+        return { job: plain(job) };
+      job.stopOrigin ??= origin;
+      live = this.registry.get(conversationId, jobId);
+      if (live)
+        return { job: plain(job) };
+      const settled = await settleJob(tx, conversationId, jobId, { status: "stopped", exitCode: null }, { text: job.tail ?? "", totalBytes: job.totalBytes ?? 0 }, false, this.#reporter);
+      return { job: plain(settled ?? job) };
+    });
+    const entry = live;
+    if (entry) {
+      entry.controller.abort();
+      await Promise.race([entry.exited, delay(1e4, context?.abortSignal)]);
+      return (await io.state())?.items.find((item) => item.jobId === jobId) ?? found.job;
+    }
+    return found.job;
+  }
+  async stopAll(io, conversationId, origin = "archive") {
+    const running = ((await io.state())?.items ?? []).filter((item) => item.status === "running");
+    for (const job of running)
+      await this.stop(io, conversationId, job.jobId, origin);
+  }
+  shutdown() {
+    this.#closing = true;
+    this.registry.abortAll();
+  }
+}
+
+// packages/core/src/prompt/invoke.ts
+import { dirname as dirname4 } from "path";
+
+// packages/core/src/prompt/diagnostics.ts
+var ignorePromptDiagnostic = () => {};
+var warnPromptDiagnostic = ({ path, message }) => {
+  console.warn(`[neko-prompt] ${JSON.stringify(path)}: ${message}`);
+};
+var isMissing = (error) => typeof error === "object" && error !== null && ("code" in error) && (error.code === "ENOENT" || error.code === "ENOTDIR");
+
+// packages/core/src/prompt/skills.ts
+import { readdir, readFile as readFile2 } from "fs/promises";
+import { basename, dirname as dirname3, join as join3 } from "path";
+var MAX_NAME_LENGTH = 64;
+var MAX_DESCRIPTION_LENGTH = 1024;
+var parseSkillFile = (content, filePath, report = ignorePromptDiagnostic) => {
+  const skip = (message) => {
+    report({ path: filePath, message });
+    return null;
+  };
+  try {
+    const { frontmatter } = parseFrontmatter(content);
+    const description = frontmatter.description;
+    if (typeof description !== "string" || description.trim() === "")
+      return skip("Skill description is missing or empty; skipped.");
+    if (description.length > MAX_DESCRIPTION_LENGTH)
+      return skip("Skill description is too long; skipped.");
+    const name = typeof frontmatter.name === "string" && frontmatter.name.trim() !== "" ? frontmatter.name : basename(dirname3(filePath));
+    if (name.length > MAX_NAME_LENGTH || /[\s\p{Cc}]/u.test(name))
+      return skip("Skill name is too long or contains whitespace/control characters; skipped.");
+    return {
+      name,
+      description,
+      filePath,
+      disableModelInvocation: frontmatter["disable-model-invocation"] === true
+    };
+  } catch {
+    return skip("Invalid skill frontmatter; skipped.");
+  }
+};
+var scanSkillsDir = async (dir, report = ignorePromptDiagnostic, capture) => {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch (error) {
+    if (!isMissing(error))
+      report({ path: dir, message: "Cannot scan skills directory; skipped." });
+    return [];
+  }
+  const skills = [];
+  for (const entry of entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+    if (!entry.isDirectory())
+      continue;
+    const filePath = join3(dir, entry.name, "SKILL.md");
+    let content;
+    try {
+      content = await readFile2(filePath, "utf8");
+    } catch (error) {
+      if (!isMissing(error))
+        report({ path: filePath, message: "Cannot read skill; skipped." });
+      continue;
+    }
+    const skill = parseSkillFile(content, filePath, report);
+    if (skill) {
+      skills.push(skill);
+      capture?.(skill, content);
+    }
+  }
+  return skills;
+};
+var mergeSkills = (groups) => {
+  const byName = new Map;
+  for (const group of groups)
+    for (const skill of group)
+      byName.set(skill.name, skill);
+  return [...byName.values()];
+};
+var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+var formatSkillsForPrompt = (skills) => {
+  const visible = skills.filter((skill) => !skill.disableModelInvocation);
+  if (visible.length === 0)
+    return "";
+  const lines = [
+    "The following skills provide specialized instructions for specific tasks.",
+    "Use the read tool to load a skill's file when the task matches its description.",
+    "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md) and use that absolute path in tool commands.",
+    "",
+    "<available_skills>"
+  ];
+  for (const skill of visible) {
+    lines.push("  <skill>");
+    lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+    lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+    lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
+    lines.push("  </skill>");
+  }
+  lines.push("</available_skills>");
+  return lines.join(`
+`);
+};
+
+// packages/core/src/prompt/invoke.ts
+var expandSkillCommand = async (text, skills, readFile, report = warnPromptDiagnostic, metadata) => {
+  if (!text.startsWith("/skill:"))
+    return text;
+  const spaceIndex = text.indexOf(" ");
+  const skillName = spaceIndex === -1 ? text.slice(7) : text.slice(7, spaceIndex);
+  const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1).trim();
+  const skill = skills.find((s) => s.name === skillName);
+  if (!skill)
+    return text;
+  let body;
+  try {
+    body = stripFrontmatter(await readFile(skill.filePath)).trim();
+  } catch {
+    report({ path: skill.filePath, message: "Cannot expand known skill; original input preserved." });
+    return text;
+  }
+  metadata?.({
+    name: skill.name,
+    location: skill.filePath,
+    body: `References are relative to ${dirname4(skill.filePath)}.
+
+${body}`,
+    args
+  });
+  const block = `<skill name="${escapeXml(skill.name)}" location="${escapeXml(skill.filePath)}">
+References are relative to ${dirname4(skill.filePath)}.
+
+${body}
+</skill>`;
+  return args ? `${block}
+
+${args}` : block;
+};
+
 // packages/core/src/prompt/prompt.ts
+import { defineExtension as defineExtension5, section } from "@earendil-works/pi-durable";
 var KEYS = ["preamble", "rules", "project_context", "skills", "cwd"];
 var PREAMBLE = "You are an expert coding assistant operating inside neko, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.";
 var TOOL_GUIDELINES = {
@@ -1794,6 +2426,9 @@ var TOOL_GUIDELINES = {
     "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions."
   ],
   bash: ["Use bash for file operations like ls, rg, find"],
+  job: [
+    'Use job {action:"start", command, title?, timeout?} for long-running commands (dev servers, watchers, long builds or tests) instead of bash, which would block. Jobs have no stdin. start returns within 2 seconds, with the early result if the command already ended; a job that ends later reports back to you automatically, so do not poll. Read new output with {action:"output", jobId, since?} using the offset from the previous call, list jobs with {action:"list"}, end one with {action:"stop", jobId}. Run short commands with bash.'
+  ],
   web_search: ["Use web_search for current information from the internet instead of guessing."],
   web_extract: ["Use web_extract to read the full content of a web page when you have its URL."]
 };
@@ -1833,7 +2468,7 @@ var createNekoPrompt = (loadResources) => {
     };
     return sections;
   };
-  return defineExtension4({
+  return defineExtension5({
     name: "neko-prompt",
     sections: KEYS.map((key) => section(key, async (input, context) => {
       let pending = built.get(input);
@@ -1985,13 +2620,13 @@ var createResourceSnapshots = (load, submission) => {
 import { stripVTControlCharacters } from "util";
 import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import {
-  defineDoc as defineDoc2,
-  defineExtension as defineExtension5,
-  defineTask as defineTask2,
+  defineDoc as defineDoc3,
+  defineExtension as defineExtension6,
+  defineTask as defineTask3,
   InboxDoc,
   LiveDoc as LiveDoc2
 } from "@earendil-works/pi-durable";
-var SessionMetadataDoc = defineDoc2({
+var SessionMetadataDoc = defineDoc3({
   kind: "app.neko.session-metadata",
   version: 1,
   scope: "conversation",
@@ -2054,7 +2689,7 @@ function mergeUsage(base, extra) {
 function namingTask() {
   let active = 0;
   const waits = new Set;
-  return defineTask2({
+  return defineTask3({
     name: "app.neko.name",
     version: 1,
     initial: () => ({ phase: "wait", until: Date.now() + 100 }),
@@ -2178,7 +2813,7 @@ class SessionMetadataManager {
     this.storage = storage;
     this.context = context;
     this.report = report;
-    registry.install(defineExtension5({ name: "neko-naming", tasks: [this.task] }));
+    registry.install(defineExtension6({ name: "neko-naming", tasks: [this.task] }));
     this.#unsubscribe = harness.subscribeCommits(({ changes }) => {
       const ids = new Set;
       const submissions = new Map;
@@ -2322,14 +2957,14 @@ import { randomUUID } from "crypto";
 import { realpath } from "fs/promises";
 import {
   configure as configure2,
-  defineDoc as defineDoc3,
-  defineExtension as defineExtension6,
+  defineDoc as defineDoc4,
+  defineExtension as defineExtension7,
   hook as hook2,
   ToolTask as ToolTask2,
   wrapTool
 } from "@earendil-works/pi-durable";
 import { createBashTool } from "@earendil-works/pi-durable/tools";
-var ApprovalsDoc = defineDoc3({
+var ApprovalsDoc = defineDoc4({
   kind: "app.neko.approvals",
   version: 1,
   scope: "conversation",
@@ -2437,7 +3072,7 @@ class ToolApprovals {
   }
 }
 function createApprovalExtension(service) {
-  return defineExtension6({
+  return defineExtension7({
     name: "neko-tool-approvals",
     hooks: [
       hook2(ToolTask2, {
@@ -2501,8 +3136,8 @@ async function prepareApprovalConversations(harness, ids, extension, context) {
 }
 
 // packages/core/src/web-search.ts
-import { Type as Type3 } from "@earendil-works/pi-ai";
-import { defineExtension as defineExtension7, defineTool as defineTool3 } from "@earendil-works/pi-durable";
+import { Type as Type4 } from "@earendil-works/pi-ai";
+import { defineExtension as defineExtension8, defineTool as defineTool4 } from "@earendil-works/pi-durable";
 var SEARCH_URL = "https://api.tavily.com/search";
 var EXTRACT_URL = "https://api.tavily.com/extract";
 var REQUEST_TIMEOUT_MS = 30000;
@@ -2620,15 +3255,15 @@ function urlKey(value) {
   }
 }
 function createWebSearchTools(resolveKey, fetchImpl = fetch) {
-  return defineExtension7({
+  return defineExtension8({
     name: "neko-web-search",
     tools: [
-      defineTool3({
+      defineTool4({
         name: "web_search",
         description: "Search the live web for current or unknown information. Returns ranked sources (title, URL, bounded excerpts). Use only when up-to-date or external information is needed; use web_extract to read a known URL.",
-        parameters: Type3.Object({
-          query: Type3.String({ minLength: 1, maxLength: 4096, description: "The search query" }),
-          maxResults: Type3.Optional(Type3.Number({ description: `Maximum number of results (1-${MAX_RESULTS}, default ${DEFAULT_RESULTS})` }))
+        parameters: Type4.Object({
+          query: Type4.String({ minLength: 1, maxLength: 4096, description: "The search query" }),
+          maxResults: Type4.Optional(Type4.Number({ description: `Maximum number of results (1-${MAX_RESULTS}, default ${DEFAULT_RESULTS})` }))
         }),
         async execute({ query, maxResults }, _api, context) {
           try {
@@ -2653,11 +3288,11 @@ ${truncate(String(item.url ?? ""), 300)}
           }
         }
       }),
-      defineTool3({
+      defineTool4({
         name: "web_extract",
         description: "Extract bounded markdown excerpts from web pages by URL. Every requested URL has a result or failure entry; long content is truncated.",
-        parameters: Type3.Object({
-          urls: Type3.Array(Type3.String({ maxLength: 2048, description: "http(s) URL" }), {
+        parameters: Type4.Object({
+          urls: Type4.Array(Type4.String({ maxLength: 2048, description: "http(s) URL" }), {
             minItems: 1,
             maxItems: MAX_URLS,
             description: `URLs to extract (1-${MAX_URLS})`
@@ -2704,7 +3339,7 @@ ${truncate(String(item.url ?? ""), 300)}
 // packages/core/src/workspace-files.ts
 import { realpath as realpath2, stat } from "fs/promises";
 import { basename as basename2, isAbsolute as isAbsolute2, relative, resolve as resolve3, sep } from "path";
-import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT2, withAbortSignal as withAbortSignal2 } from "@earendil-works/chord/context";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT2, withAbortSignal as withAbortSignal3 } from "@earendil-works/chord/context";
 import { getOrThrow as getOrThrow2 } from "@earendil-works/pi-durable/env";
 import { Connection, LocalExecutionEnv, localDaemon } from "@earendil-works/pi-env";
 function relativeQuery(query) {
@@ -2870,7 +3505,7 @@ class WorkspaceFiles {
             for (const user of [...current.users])
               this.#closeWatcher(user);
           }
-        }, withAbortSignal2(current.controller.signal, BACKGROUND_CONTEXT2));
+        }, withAbortSignal3(current.controller.signal, BACKGROUND_CONTEXT2));
         if (result.ok) {
           current.watcher = result.value;
           if (current.controller.signal.aborted)
@@ -2898,7 +3533,7 @@ class WorkspaceFiles {
   async#scan(item) {
     const controller = new AbortController;
     item.controller = controller;
-    const context = withAbortSignal2(controller.signal, BACKGROUND_CONTEXT2);
+    const context = withAbortSignal3(controller.signal, BACKGROUND_CONTEXT2);
     while (this.#active >= this.limits.concurrent) {
       await new Promise((resolve, reject) => {
         const wake = () => {
@@ -3064,7 +3699,7 @@ function cancellable(work, signal) {
 // packages/core/src/runtime.ts
 var DEFAULT_MODEL = { provider: "deepseek", modelId: "deepseek-flash" };
 var DEFAULT_STORAGE_PATH = join5(homedir4(), ".neko", "neko.sqlite");
-var ArchivedDoc = defineDoc4({
+var ArchivedDoc = defineDoc5({
   kind: "app.neko.conversation",
   version: 1,
   scope: "conversation",
@@ -3072,7 +3707,7 @@ var ArchivedDoc = defineDoc4({
   fork: "initial",
   initial: () => ({ archived: false })
 });
-var WorkspacesDoc = defineDoc4({
+var WorkspacesDoc = defineDoc5({
   kind: "app.neko.workspaces",
   version: 1,
   scope: "conversation",
@@ -3080,7 +3715,7 @@ var WorkspacesDoc = defineDoc4({
   fork: "initial",
   initial: () => ({ items: [] })
 });
-var ActivityDoc = defineDoc4({
+var ActivityDoc = defineDoc5({
   kind: "app.neko.activity",
   version: 1,
   scope: "conversation",
@@ -3138,6 +3773,8 @@ async function createNekoRuntime(options = {}) {
   registry.install(createSubagentExtension(async (id, requestId, cwd) => {
     resourceSnapshots.stage(id, requestId, cwd, await loadResources(cwd));
   }, resourceSnapshots.discard));
+  const jobs = new JobManager;
+  registry.install(jobs.extension);
   for (const extension of options.extensions ?? [])
     registry.install(extension);
   let approvals;
@@ -3201,6 +3838,10 @@ async function createNekoRuntime(options = {}) {
     if (target)
       await registerWorkspace(savedWorkspace((await target.agent(context)).cwd));
   }
+  const jobIo = (id) => ({
+    commit: (change) => harness.commit(change, context),
+    state: () => harness.snapshot(JobsDoc, id, context)
+  });
   let lastActivity = 0;
   for (const record of existing)
     lastActivity = Math.max(lastActivity, (await harness.snapshot(ActivityDoc, record.id, context))?.lastUsedAt ?? 0);
@@ -3223,6 +3864,7 @@ async function createNekoRuntime(options = {}) {
   const cleanup = () => {
     if (!closing)
       closing = (async () => {
+        jobs.shutdown();
         await workspaceFiles.close();
         await metadata.close();
       })();
@@ -3355,6 +3997,16 @@ async function createNekoRuntime(options = {}) {
     compactionRecord() {
       return readCompaction(harness, storage, target.id, context);
     },
+    jobs() {
+      return jobs.list(jobIo(target.id), target.id);
+    },
+    jobOutput(jobId, since) {
+      return jobs.readOutput(jobIo(target.id), target.id, jobId, since);
+    },
+    async stopJob(jobId) {
+      const job = await jobs.stop(jobIo(target.id), target.id, jobId, "user", context);
+      return summarizeJobRecord(job);
+    },
     async compact(instructions) {
       const agent = await target.agent(context);
       if (agent.model?.provider === "deepseek" && !await models.checkAuth("deepseek"))
@@ -3546,6 +4198,7 @@ async function createNekoRuntime(options = {}) {
     getConversation,
     async archiveConversation(id) {
       await (await sessionFor(id)).abort();
+      await jobs.stopAll(jobIo(id), id);
       await metadata.archive(id);
       await harness.commit(async (tx) => {
         (await tx.doc(ArchivedDoc, id)).archived = true;
@@ -3687,7 +4340,7 @@ import { dirname as dirname5, join as join7 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // packages/core/src/application-version.ts
-var RUNNING_VERSION = "0.3.1";
+var RUNNING_VERSION = "0.3.3";
 var APPLICATION_PROTOCOL = 4;
 function stableVersion(value) {
   return typeof value === "string" && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(value) && value.split(".").every((n) => Number.isSafeInteger(Number(n)));
@@ -3837,11 +4490,11 @@ class UpdateChecker {
 }
 
 // packages/gateway/src/server-services.ts
-import { Type as Type7 } from "typebox";
+import { Type as Type8 } from "typebox";
 
 // packages/gateway/src/contract.ts
 import { method, remote } from "@earendil-works/chord";
-import { Type as Type4 } from "typebox";
+import { Type as Type5 } from "typebox";
 var rpc = (args, result) => [args, result];
 function contract(name, def) {
   const variants = Object.fromEntries(Object.entries(def.variants).map(([key, value]) => [
@@ -3853,19 +4506,19 @@ function contract(name, def) {
   ]));
   return remote(name, { ...def, variants });
 }
-var str = Type4.String();
-var num = Type4.Number();
-var bool = Type4.Boolean();
-var nil = Type4.Null();
-var integer = Type4.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER });
-var nullableString = Type4.Union([str, nil]);
-var phase = Type4.Enum(["pending", "running", "done"]);
-var level = Type4.Enum(["project", "user", "builtin"]);
-var thinking = Type4.Enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
-var model = Type4.Object({ provider: str, modelId: str });
-var change = Type4.Object({ model: Type4.Optional(model), thinkingLevel: Type4.Optional(thinking) }, { additionalProperties: false });
-var usage = Type4.Object({ input: num, output: num, cacheRead: num, cacheWrite: num, cost: num });
-var image = Type4.Object({
+var str = Type5.String();
+var num = Type5.Number();
+var bool = Type5.Boolean();
+var nil = Type5.Null();
+var integer = Type5.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER });
+var nullableString = Type5.Union([str, nil]);
+var phase = Type5.Enum(["pending", "running", "done"]);
+var level = Type5.Enum(["project", "user", "builtin"]);
+var thinking = Type5.Enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+var model = Type5.Object({ provider: str, modelId: str });
+var change = Type5.Object({ model: Type5.Optional(model), thinkingLevel: Type5.Optional(thinking) }, { additionalProperties: false });
+var usage = Type5.Object({ input: num, output: num, cacheRead: num, cacheWrite: num, cost: num });
+var image = Type5.Object({
   name: str,
   mimeType: str,
   width: integer,
@@ -3874,99 +4527,125 @@ var image = Type4.Object({
   entryId: integer,
   contentIndex: integer
 });
-var skill = Type4.Object({ name: str, location: str, body: str, args: str });
-var call = Type4.Object({
+var skill = Type5.Object({ name: str, location: str, body: str, args: str });
+var call = Type5.Object({
   callId: str,
   name: str,
   summary: str,
   detail: nullableString,
   phase,
-  output: nullableString
+  output: nullableString,
+  diff: nullableString,
+  diffAdded: Type5.Union([num, nil]),
+  diffRemoved: Type5.Union([num, nil]),
+  diffTruncated: Type5.Optional(bool)
 });
-var DelegationSchema = Type4.Object({
+var DelegationSchema = Type5.Object({
   parentId: integer,
-  agentId: Type4.Optional(str),
-  round: Type4.Optional(integer),
-  runnerId: Type4.Optional(integer),
-  inputEntryId: Type4.Optional(integer),
-  answerEntryId: Type4.Optional(integer),
-  roundUsage: Type4.Optional(Type4.Union([usage, nil])),
+  agentId: Type5.Optional(str),
+  round: Type5.Optional(integer),
+  runnerId: Type5.Optional(integer),
+  inputEntryId: Type5.Optional(integer),
+  answerEntryId: Type5.Optional(integer),
+  roundUsage: Type5.Optional(Type5.Union([usage, nil])),
   taskId: integer,
   callId: str,
   childId: integer,
-  role: Type4.Enum(["explore", "plan", "coder"]),
+  role: Type5.Enum(["explore", "plan", "coder"]),
   title: str,
   createdAt: num,
-  startedAt: Type4.Union([num, nil]),
-  endedAt: Type4.Union([num, nil]),
-  status: Type4.Enum(["queued", "running", "completed", "failed", "cancelled"]),
+  startedAt: Type5.Union([num, nil]),
+  endedAt: Type5.Union([num, nil]),
+  status: Type5.Enum(["queued", "running", "completed", "failed", "cancelled"]),
   report: nullableString,
-  approvalCount: Type4.Optional(integer),
-  historyThrough: Type4.Optional(integer),
-  historyUsage: Type4.Optional(usage)
+  approvalCount: Type5.Optional(integer),
+  historyThrough: Type5.Optional(integer),
+  historyUsage: Type5.Optional(usage)
 });
-var SubagentSummarySchema = Type4.Object({
+var SubagentSummarySchema = Type5.Object({
   agentId: str,
   parentId: integer,
   childId: integer,
-  role: Type4.Enum(["explore", "plan", "coder"]),
+  role: Type5.Enum(["explore", "plan", "coder"]),
   title: str,
-  status: Type4.Enum(["idle", "queued", "running"]),
-  activeRoundId: Type4.Union([integer, nil]),
+  status: Type5.Enum(["idle", "queued", "running"]),
+  activeRoundId: Type5.Union([integer, nil]),
   lastRoundId: integer,
-  lastReport: Type4.Optional(nullableString),
+  lastReport: Type5.Optional(nullableString),
   roundCount: integer,
   taskTitle: str,
   approvalCount: integer,
   createdAt: num,
-  historyThrough: Type4.Optional(integer),
-  historyUsage: Type4.Optional(usage)
+  historyThrough: Type5.Optional(integer),
+  historyUsage: Type5.Optional(usage)
 });
-var ChatViewSchema = Type4.Object({
-  historyBefore: Type4.Optional(Type4.Union([integer, nil])),
-  agents: Type4.Optional(Type4.Array(SubagentSummarySchema)),
-  rounds: Type4.Optional(Type4.Array(DelegationSchema)),
-  subagents: Type4.Optional(Type4.Array(DelegationSchema)),
-  taskUsage: Type4.Optional(usage),
+var jobStatus = Type5.Enum(["running", "exited", "failed", "stopped", "lost"]);
+var JobSummarySchema = Type5.Object({
+  jobId: str,
+  title: str,
+  command: str,
+  cwd: str,
+  status: jobStatus,
+  startedAt: num,
+  endedAt: Type5.Union([num, nil]),
+  exitCode: Type5.Union([num, nil]),
+  reason: Type5.Optional(Type5.Enum(["timeout", "spawn-error", "restart", "aborted"])),
+  timeoutSeconds: Type5.Optional(num),
+  outputBytes: integer
+});
+var JobOutputSchema = Type5.Object({
+  job: JobSummarySchema,
+  text: str,
+  offset: integer,
+  truncated: bool,
+  dropped: integer
+});
+var ChatViewSchema = Type5.Object({
+  historyBefore: Type5.Optional(Type5.Union([integer, nil])),
+  agents: Type5.Optional(Type5.Array(SubagentSummarySchema)),
+  jobs: Type5.Optional(Type5.Array(JobSummarySchema)),
+  rounds: Type5.Optional(Type5.Array(DelegationSchema)),
+  subagents: Type5.Optional(Type5.Array(DelegationSchema)),
+  taskUsage: Type5.Optional(usage),
   model: str,
-  agent: Type4.Object({ model: Type4.Union([model, nil]), thinkingLevel: Type4.Union([thinking, nil]) }),
+  agent: Type5.Object({ model: Type5.Union([model, nil]), thinkingLevel: Type5.Union([thinking, nil]) }),
   cwd: str,
   busy: bool,
   status: nullableString,
   usage,
-  contextUsage: Type4.Optional(Type4.Object({ tokens: Type4.Union([num, nil]), window: num, percent: Type4.Union([num, nil]) })),
-  compaction: Type4.Optional(Type4.Object({
-    failure: Type4.Optional(Type4.Object({ taskId: integer, reason: Type4.Enum(["manual", "threshold", "overflow"]), error: str })),
-    active: Type4.Array(Type4.Object({
+  contextUsage: Type5.Optional(Type5.Object({ tokens: Type5.Union([num, nil]), window: num, percent: Type5.Union([num, nil]) })),
+  compaction: Type5.Optional(Type5.Object({
+    failure: Type5.Optional(Type5.Object({ taskId: integer, reason: Type5.Enum(["manual", "threshold", "overflow"]), error: str })),
+    active: Type5.Array(Type5.Object({
       taskId: integer,
-      reason: Type4.Enum(["manual", "threshold", "overflow"]),
+      reason: Type5.Enum(["manual", "threshold", "overflow"]),
       blocking: bool,
       attempt: integer,
-      retry: Type4.Optional(Type4.Object({ at: num, error: str }))
+      retry: Type5.Optional(Type5.Object({ at: num, error: str }))
     })),
-    latest: Type4.Union([
+    latest: Type5.Union([
       nil,
-      Type4.Object({
+      Type5.Object({
         taskId: integer,
-        phase: Type4.Enum(["summarizing", "waiting-to-apply", "applied", "nothing", "skipped", "cancelled", "failed"]),
+        phase: Type5.Enum(["summarizing", "waiting-to-apply", "applied", "nothing", "skipped", "cancelled", "failed"]),
         at: num
       })
     ])
   })),
-  items: Type4.Array(Type4.Union([
-    Type4.Object({
-      type: Type4.Literal("user"),
-      order: Type4.Optional(num),
+  items: Type5.Array(Type5.Union([
+    Type5.Object({
+      type: Type5.Literal("user"),
+      order: Type5.Optional(num),
       key: str,
       id: integer,
       text: str,
-      images: Type4.Optional(Type4.Array(image)),
-      skill: Type4.Optional(skill),
-      defaultImagePrompt: Type4.Optional(Type4.Object({ version: Type4.Integer({ minimum: 1 }), text: str }))
+      images: Type5.Optional(Type5.Array(image)),
+      skill: Type5.Optional(skill),
+      defaultImagePrompt: Type5.Optional(Type5.Object({ version: Type5.Integer({ minimum: 1 }), text: str }))
     }),
-    Type4.Object({
-      type: Type4.Literal("assistant"),
-      order: Type4.Optional(num),
+    Type5.Object({
+      type: Type5.Literal("assistant"),
+      order: Type5.Optional(num),
       key: str,
       id: integer,
       thinking: str,
@@ -3975,11 +4654,11 @@ var ChatViewSchema = Type4.Object({
       errorMessage: nullableString,
       note: nullableString
     }),
-    Type4.Object({
-      type: Type4.Literal("tool"),
-      order: Type4.Optional(num),
+    Type5.Object({
+      type: Type5.Literal("tool"),
+      order: Type5.Optional(num),
       key: str,
-      images: Type4.Optional(Type4.Array(image)),
+      images: Type5.Optional(Type5.Array(image)),
       callId: str,
       name: str,
       summary: str,
@@ -3988,50 +4667,61 @@ var ChatViewSchema = Type4.Object({
       isError: bool,
       output: nullableString,
       result: nullableString,
-      durationMs: Type4.Union([num, nil]),
-      note: nullableString
+      durationMs: Type5.Union([num, nil]),
+      note: nullableString,
+      diff: nullableString,
+      diffAdded: Type5.Union([num, nil]),
+      diffRemoved: Type5.Union([num, nil]),
+      diffTruncated: Type5.Optional(bool)
     }),
-    Type4.Object({ type: Type4.Literal("system"), order: Type4.Optional(num), key: str, id: integer, text: str })
+    Type5.Object({
+      type: Type5.Literal("system"),
+      order: Type5.Optional(num),
+      key: str,
+      id: integer,
+      text: str,
+      jobId: Type5.Optional(str)
+    })
   ])),
-  streaming: Type4.Union([nil, Type4.Object({ thinking: str, text: str, toolCalls: Type4.Array(call) })])
+  streaming: Type5.Union([nil, Type5.Object({ thinking: str, text: str, toolCalls: Type5.Array(call) })])
 });
-var SessionSummarySchema = Type4.Object({
+var SessionSummarySchema = Type5.Object({
   workspaceRoot: str,
   lastUsedAt: num,
   title: str,
   firstPromptPreview: str,
   createdAt: num,
-  lastMessageAt: Type4.Union([num, nil]),
-  model: Type4.Union([model, nil]),
-  status: Type4.Enum(["idle", "running", "error"]),
+  lastMessageAt: Type5.Union([num, nil]),
+  model: Type5.Union([model, nil]),
+  status: Type5.Enum(["idle", "running", "error"]),
   id: str
 });
-var DirectoryStateSchema = Type4.Object({ revision: integer, sessions: Type4.Array(SessionSummarySchema) });
-var WorkspaceSummarySchema = Type4.Object({ path: str, createdAt: num });
-var WorkspaceStateSchema = Type4.Object({ revision: integer, workspaces: Type4.Array(WorkspaceSummarySchema) });
-var credentialStatus = Type4.Object({
+var DirectoryStateSchema = Type5.Object({ revision: integer, sessions: Type5.Array(SessionSummarySchema) });
+var WorkspaceSummarySchema = Type5.Object({ path: str, createdAt: num });
+var WorkspaceStateSchema = Type5.Object({ revision: integer, workspaces: Type5.Array(WorkspaceSummarySchema) });
+var credentialStatus = Type5.Object({
   savedConfigured: bool,
   environmentConfigured: bool,
-  source: Type4.Enum(["saved", "environment", "runtime", "keyless", "none"])
+  source: Type5.Enum(["saved", "environment", "runtime", "keyless", "none"])
 });
-var CredentialStateSchema = Type4.Object({
+var CredentialStateSchema = Type5.Object({
   revision: integer,
-  statuses: Type4.Object({ deepseek: credentialStatus, tavily: credentialStatus })
+  statuses: Type5.Object({ deepseek: credentialStatus, tavily: credentialStatus })
 });
-var AttachmentSchema = Type4.Object({ sessionId: str, attachmentId: str });
-var chatInput = Type4.Object({ sessionId: str, attachmentId: str }, { additionalProperties: false });
+var AttachmentSchema = Type5.Object({ sessionId: str, attachmentId: str });
+var chatInput = Type5.Object({ sessionId: str, attachmentId: str }, { additionalProperties: false });
 var NekoSessionDirectory = contract("neko.session-directory", {
   version: 1,
-  input: Type4.Object({}, { additionalProperties: false }),
+  input: Type5.Object({}, { additionalProperties: false }),
   variants: { ready: { state: { state: DirectoryStateSchema } } }
 });
 var NekoSessionManagement = contract("neko.session-management", {
   version: 1,
-  input: Type4.Object({}, { additionalProperties: false }),
+  input: Type5.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       methods: {
-        create: rpc(Type4.Object({ ...change.properties, cwd: Type4.Optional(str) }, { additionalProperties: false }), SessionSummarySchema),
+        create: rpc(Type5.Object({ ...change.properties, cwd: Type5.Optional(str) }, { additionalProperties: false }), SessionSummarySchema),
         archive: rpc(str, nil),
         attach: rpc(str, AttachmentSchema),
         detach: rpc(nil, nil),
@@ -4040,30 +4730,30 @@ var NekoSessionManagement = contract("neko.session-management", {
     }
   }
 });
-var resize = Type4.Object({
-  maxWidth: Type4.Optional(integer),
-  maxHeight: Type4.Optional(integer),
-  maxBytes: Type4.Optional(integer),
-  jpegQuality: Type4.Optional(integer)
+var resize = Type5.Object({
+  maxWidth: Type5.Optional(integer),
+  maxHeight: Type5.Optional(integer),
+  maxBytes: Type5.Optional(integer),
+  jpegQuality: Type5.Optional(integer)
 });
-var inputLimits = Type4.Object({
-  maxRequestBytes: Type4.Optional(integer),
-  images: Type4.Optional(Type4.Object({
-    resize: Type4.Optional(resize),
-    maxPerMessage: Type4.Optional(integer),
-    maxPerRequest: Type4.Optional(integer)
+var inputLimits = Type5.Object({
+  maxRequestBytes: Type5.Optional(integer),
+  images: Type5.Optional(Type5.Object({
+    resize: Type5.Optional(resize),
+    maxPerMessage: Type5.Optional(integer),
+    maxPerRequest: Type5.Optional(integer)
   }))
 });
-var modelInfo = Type4.Object({
+var modelInfo = Type5.Object({
   provider: str,
   modelId: str,
   name: str,
   contextWindow: num,
-  input: Type4.Array(str),
-  inputLimits: Type4.Optional(inputLimits),
+  input: Type5.Array(str),
+  inputLimits: Type5.Optional(inputLimits),
   reasoning: bool,
-  supportedThinkingLevels: Type4.Array(thinking),
-  thinkingLevelAdjustments: Type4.Object({
+  supportedThinkingLevels: Type5.Array(thinking),
+  thinkingLevelAdjustments: Type5.Object({
     off: thinking,
     minimal: thinking,
     low: thinking,
@@ -4075,31 +4765,31 @@ var modelInfo = Type4.Object({
 });
 var NekoModels = contract("neko.models", {
   version: 1,
-  input: Type4.Object({}, { additionalProperties: false }),
-  variants: { ready: { methods: { list: rpc(nil, Type4.Array(modelInfo)) } } }
+  input: Type5.Object({}, { additionalProperties: false }),
+  variants: { ready: { methods: { list: rpc(nil, Type5.Array(modelInfo)) } } }
 });
-var imageChunk = Type4.Object({ data: str, total: integer, mimeType: str });
+var imageChunk = Type5.Object({ data: str, total: integer, mimeType: str });
 var NekoSubagent = contract("neko.subagent", {
   version: 1,
-  input: Type4.Object({
+  input: Type5.Object({
     sessionId: str,
     attachmentId: str,
-    taskId: Type4.Optional(integer),
-    agentId: Type4.Optional(str)
+    taskId: Type5.Optional(integer),
+    agentId: Type5.Optional(str)
   }),
   variants: {
     ready: {
       state: { revision: integer },
       methods: {
-        chunk: rpc(Type4.Object({
-          kind: Type4.Enum(["view", "history"]),
-          before: Type4.Optional(integer),
-          token: Type4.Optional(integer),
+        chunk: rpc(Type5.Object({
+          kind: Type5.Enum(["view", "history"]),
+          before: Type5.Optional(integer),
+          token: Type5.Optional(integer),
           offset: integer
-        }), Type4.Object({ token: integer, data: str, next: Type4.Union([integer, nil]) })),
-        getImage: rpc(Type4.Object({ entryId: integer, contentIndex: integer, offset: integer }), imageChunk),
-        decideApproval: rpc(Type4.Object({ id: integer, version: str, decision: Type4.Enum(["allowed", "denied"]) }), Type4.Enum(["pending", "allowed", "denied", "cancelled"])),
-        stop: rpc(Type4.Union([nil, Type4.Object({ taskId: integer })]), nil)
+        }), Type5.Object({ token: integer, data: str, next: Type5.Union([integer, nil]) })),
+        getImage: rpc(Type5.Object({ entryId: integer, contentIndex: integer, offset: integer }), imageChunk),
+        decideApproval: rpc(Type5.Object({ id: integer, version: str, decision: Type5.Enum(["allowed", "denied"]) }), Type5.Enum(["pending", "allowed", "denied", "cancelled"])),
+        stop: rpc(Type5.Union([nil, Type5.Object({ taskId: integer })]), nil)
       }
     }
   }
@@ -4111,79 +4801,81 @@ var NekoChat = contract("neko.chat", {
     ready: {
       state: { view: ChatViewSchema },
       methods: {
-        submit: rpc(Type4.Object({
+        submit: rpc(Type5.Object({
           content: str,
-          images: Type4.Optional(Type4.Array(str, { maxItems: 4 })),
-          requestId: Type4.Optional(str),
-          whenBusy: Type4.Optional(Type4.Enum(["steer", "followUp"]))
+          images: Type5.Optional(Type5.Array(str, { maxItems: 4 })),
+          requestId: Type5.Optional(str),
+          whenBusy: Type5.Optional(Type5.Enum(["steer", "followUp"]))
         }, { additionalProperties: false }), nil),
         abort: rpc(nil, nil),
         usage: rpc(nil, usage),
-        skills: rpc(nil, Type4.Array(Type4.Object({ name: str, description: str, location: str, level }))),
+        skills: rpc(nil, Type5.Array(Type5.Object({ name: str, description: str, location: str, level }))),
+        jobOutput: rpc(Type5.Object({ jobId: str, since: Type5.Optional(integer) }, { additionalProperties: false }), JobOutputSchema),
+        jobStop: rpc(Type5.Object({ jobId: str }, { additionalProperties: false }), JobSummarySchema),
         configure: rpc(change, nil),
-        compact: rpc(Type4.Object({ instructions: Type4.Optional(str) }, { additionalProperties: false }), nil),
-        importImage: rpc(str, Type4.Object({ id: str, name: str })),
-        draftImage: rpc(Type4.Object({ id: str, offset: integer }, { additionalProperties: false }), imageChunk),
-        beginImage: rpc(Type4.Object({ name: str, mimeType: str, size: Type4.Integer({ minimum: 1, maximum: 20971520 }) }, { additionalProperties: false }), str),
-        appendImage: rpc(Type4.Object({ id: str, offset: integer, data: Type4.String({ maxLength: 350000 }) }, { additionalProperties: false }), nil),
+        compact: rpc(Type5.Object({ instructions: Type5.Optional(str) }, { additionalProperties: false }), nil),
+        importImage: rpc(str, Type5.Object({ id: str, name: str })),
+        draftImage: rpc(Type5.Object({ id: str, offset: integer }, { additionalProperties: false }), imageChunk),
+        beginImage: rpc(Type5.Object({ name: str, mimeType: str, size: Type5.Integer({ minimum: 1, maximum: 20971520 }) }, { additionalProperties: false }), str),
+        appendImage: rpc(Type5.Object({ id: str, offset: integer, data: Type5.String({ maxLength: 350000 }) }, { additionalProperties: false }), nil),
         finishImage: rpc(str, nil),
         releaseImage: rpc(str, nil),
-        getImage: rpc(Type4.Object({ entryId: integer, contentIndex: integer, offset: integer }, { additionalProperties: false }), imageChunk)
+        getImage: rpc(Type5.Object({ entryId: integer, contentIndex: integer, offset: integer }, { additionalProperties: false }), imageChunk)
       }
     }
   }
 });
-var browse = Type4.Object({ path: str, query: Type4.Optional(str), showHidden: Type4.Optional(bool), cursor: Type4.Optional(str) }, { additionalProperties: false });
-var page = Type4.Object({
+var browse = Type5.Object({ path: str, query: Type5.Optional(str), showHidden: Type5.Optional(bool), cursor: Type5.Optional(str) }, { additionalProperties: false });
+var page = Type5.Object({
   path: str,
   parent: nullableString,
-  entries: Type4.Array(Type4.Object({ name: str, path: str, error: Type4.Optional(str) })),
+  entries: Type5.Array(Type5.Object({ name: str, path: str, error: Type5.Optional(str) })),
   next: nullableString
 });
 var NekoWorkspaces = contract("neko.workspaces", {
   version: 1,
-  input: Type4.Object({}, { additionalProperties: false }),
+  input: Type5.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       state: { state: WorkspaceStateSchema },
       methods: {
-        add: rpc(Type4.Object({ path: str }, { additionalProperties: false }), WorkspaceSummarySchema),
+        add: rpc(Type5.Object({ path: str }, { additionalProperties: false }), WorkspaceSummarySchema),
         browse: rpc(browse, page)
       }
     }
   }
 });
-var provider = Type4.Enum(["deepseek", "tavily"]);
+var provider = Type5.Enum(["deepseek", "tavily"]);
 var NekoCredentials = contract("neko.credentials", {
   version: 1,
-  input: Type4.Object({}, { additionalProperties: false }),
+  input: Type5.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       state: { state: CredentialStateSchema },
       methods: {
-        save: rpc(Type4.Object({ provider, key: Type4.String({ minLength: 1, maxLength: 8192 }) }, { additionalProperties: false }), nil),
-        remove: rpc(Type4.Object({ provider }, { additionalProperties: false }), nil)
+        save: rpc(Type5.Object({ provider, key: Type5.String({ minLength: 1, maxLength: 8192 }) }, { additionalProperties: false }), nil),
+        remove: rpc(Type5.Object({ provider }, { additionalProperties: false }), nil)
       }
     }
   }
 });
-var FileCandidatesSchema = Type4.Object({
-  entries: Type4.Array(Type4.Object({ name: str, path: str, kind: Type4.Enum(["file", "directory"]) }), { maxItems: 100 }),
+var FileCandidatesSchema = Type5.Object({
+  entries: Type5.Array(Type5.Object({ name: str, path: str, kind: Type5.Enum(["file", "directory"]) }), { maxItems: 100 }),
   limited: bool,
   incomplete: bool
 });
 var NekoWorkspaceFiles = contract("neko.workspace-files", {
   version: 1,
-  input: Type4.Object({}, { additionalProperties: false }),
+  input: Type5.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       methods: {
-        search: rpc(Type4.Object({ workspaceRoot: str, query: str }, { additionalProperties: false }), FileCandidatesSchema)
+        search: rpc(Type5.Object({ workspaceRoot: str, query: str }, { additionalProperties: false }), FileCandidatesSchema)
       }
     }
   }
 });
-var marketSkill = Type4.Object({
+var marketSkill = Type5.Object({
   name: str,
   description: str,
   category: str,
@@ -4193,38 +4885,38 @@ var marketSkill = Type4.Object({
   sha256: str,
   sizeBytes: integer,
   uploadedAt: str,
-  installed: Type4.Object({ project: bool, user: bool, builtin: bool }),
-  activeLevel: Type4.Union([level, nil])
+  installed: Type5.Object({ project: bool, user: bool, builtin: bool }),
+  activeLevel: Type5.Union([level, nil])
 });
-var preview = Type4.Object({ body: str, files: Type4.Array(str) });
-var scope = Type4.Enum(["user", "project"]);
-var installResult = Type4.Object({ name: str, scope, path: str, shadowedBy: Type4.Optional(scope) });
+var preview = Type5.Object({ body: str, files: Type5.Array(str) });
+var scope = Type5.Enum(["user", "project"]);
+var installResult = Type5.Object({ name: str, scope, path: str, shadowedBy: Type5.Optional(scope) });
 var NekoSkillMarket = contract("neko.skill-market", {
   version: 1,
-  input: Type4.Object({}, { additionalProperties: false }),
+  input: Type5.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       methods: {
-        list: rpc(Type4.Object({ query: Type4.Optional(str), workspaceRoot: Type4.Optional(str) }, { additionalProperties: false }), Type4.Array(marketSkill)),
-        detail: rpc(Type4.Object({ name: str, workspaceRoot: Type4.Optional(str) }, { additionalProperties: false }), marketSkill),
-        preview: rpc(Type4.Object({ name: str }, { additionalProperties: false }), preview),
-        install: rpc(Type4.Object({ name: str, scope, workspaceRoot: Type4.Optional(str), overwrite: Type4.Optional(bool) }, { additionalProperties: false }), installResult),
-        uninstall: rpc(Type4.Object({ name: str, scope, workspaceRoot: Type4.Optional(str) }, { additionalProperties: false }), nil)
+        list: rpc(Type5.Object({ query: Type5.Optional(str), workspaceRoot: Type5.Optional(str) }, { additionalProperties: false }), Type5.Array(marketSkill)),
+        detail: rpc(Type5.Object({ name: str, workspaceRoot: Type5.Optional(str) }, { additionalProperties: false }), marketSkill),
+        preview: rpc(Type5.Object({ name: str }, { additionalProperties: false }), preview),
+        install: rpc(Type5.Object({ name: str, scope, workspaceRoot: Type5.Optional(str), overwrite: Type5.Optional(bool) }, { additionalProperties: false }), installResult),
+        uninstall: rpc(Type5.Object({ name: str, scope, workspaceRoot: Type5.Optional(str) }, { additionalProperties: false }), nil)
       }
     }
   }
 });
-var ApplicationInfoSchema = Type4.Object({
+var ApplicationInfoSchema = Type5.Object({
   runningVersion: str,
   installedVersion: nullableString,
-  protocolVersion: Type4.Integer({ minimum: 1 }),
+  protocolVersion: Type5.Integer({ minimum: 1 }),
   latestVersion: nullableString,
-  checkedAt: Type4.Union([integer, nil]),
-  checkState: Type4.Enum(["unknown", "checking", "ok", "failed", "development"])
+  checkedAt: Type5.Union([integer, nil]),
+  checkState: Type5.Enum(["unknown", "checking", "ok", "failed", "development"])
 });
 var NekoApplicationInfo = contract("neko.application-info", {
   version: 1,
-  input: Type4.Object({}),
+  input: Type5.Object({}),
   variants: { ready: { state: { info: ApplicationInfoSchema }, methods: { check: rpc(nil, ApplicationInfoSchema) } } }
 });
 
@@ -4240,9 +4932,9 @@ import {
   opaque as opaque2,
   resource as resource2
 } from "@earendil-works/chord";
-import { withAbortSignal as withAbortSignal3 } from "@earendil-works/chord/context";
+import { withAbortSignal as withAbortSignal4 } from "@earendil-works/chord/context";
 import { UsageDoc as UsageDoc4 } from "@earendil-works/pi-durable";
-import { Type as Type6 } from "typebox";
+import { Type as Type7 } from "typebox";
 
 // packages/gateway/src/image-uploads.ts
 var IMAGE_CHUNK_BYTES = 256 * 1024;
@@ -4349,7 +5041,7 @@ import {
   resource
 } from "@earendil-works/chord";
 import { UsageDoc as UsageDoc3 } from "@earendil-works/pi-durable";
-import { Type as Type5 } from "typebox";
+import { Type as Type6 } from "typebox";
 async function openReader(runtime, childId, parentId, context, through, historyUsage) {
   const child = await runtime.harness.conversation(childId, context);
   if (!child)
@@ -4474,15 +5166,15 @@ async function openReader(runtime, childId, parentId, context, through, historyU
 }
 var ChildProjection = local("neko.subagent-projection", {
   version: 1,
-  input: Type5.Object({ parentId: Type5.Integer(), agentId: Type5.String() }),
+  input: Type6.Object({ parentId: Type6.Integer(), agentId: Type6.String() }),
   members: {
-    revision: Type5.Integer(),
+    revision: Type6.Integer(),
     reader: opaque("neko.subagent-reader@1")
   }
 });
 function installSubagentHost(host, runtime, context) {
   host.serve(ChildProjection, (input, _principal, self) => {
-    const { revision } = self.state({ revision: cell(Type5.Integer(), 0) });
+    const { revision } = self.state({ revision: cell(Type6.Integer(), 0) });
     const { reader } = self.resources({
       reader: resource({
         rev: 1,
@@ -4524,7 +5216,7 @@ function installSubagentHost(host, runtime, context) {
     };
     const { target } = self.resources({ target: resource({ rev: 1, deps: [owner], open: check }) });
     const shared = self.get(ChildProjection, { parentId: Number(input.sessionId), agentId: input.agentId ?? `round-${input.taskId}` }, { principal: hostPrincipal });
-    const { authorizedRevision } = self.state({ authorizedRevision: cell(Type5.Integer(), 0) });
+    const { authorizedRevision } = self.state({ authorizedRevision: cell(Type6.Integer(), 0) });
     self.listen({
       authorizedView: listener(shared.revision, async (value, ctx) => {
         try {
@@ -4579,7 +5271,7 @@ function installSubagentHost(host, runtime, context) {
 }
 
 // packages/gateway/src/session-host.ts
-var OwnerInput = Type6.Object({});
+var OwnerInput = Type7.Object({});
 var Owner = local2("neko.attachment-owner", {
   version: 1,
   input: OwnerInput,
@@ -4587,7 +5279,7 @@ var Owner = local2("neko.attachment-owner", {
 });
 var Projection = local2("neko.projection", {
   version: 1,
-  input: Type6.Object({ id: Type6.String() }),
+  input: Type7.Object({ id: Type7.String() }),
   members: {
     view: ChatViewSchema,
     reader: opaque2("neko.projection-reader@1")
@@ -4603,6 +5295,8 @@ var emptyView = {
   items: [],
   streaming: null
 };
+var JOB_COMMAND_PREVIEW_CHARS = 1000;
+var clipJob = (job) => job.command.length > JOB_COMMAND_PREVIEW_CHARS ? { ...job, command: `${job.command.slice(0, JOB_COMMAND_PREVIEW_CHARS)}\u2026` } : job;
 async function openProjection(runtime, session, context) {
   const view = await session.viewState();
   const history = new Map;
@@ -4618,7 +5312,7 @@ async function openProjection(runtime, session, context) {
   const stopMetadata = runtime.onDirectoryChange(() => changed?.(null));
   let childIds = new Set;
   const stopChildren = runtime.harness.subscribeCommits(({ changes }) => {
-    if (changes.some((change) => change.type === "document" && (["app.neko.delegations", "app.neko.approvals", "app.neko.subagents"].includes(change.record.kind) && change.conversationId === session.id || change.record.kind === "pi.usage" && change.conversationId !== undefined && childIds.has(change.conversationId))))
+    if (changes.some((change) => change.type === "document" && (["app.neko.delegations", "app.neko.approvals", "app.neko.subagents", "app.neko.jobs"].includes(change.record.kind) && change.conversationId === session.id || change.record.kind === "pi.usage" && change.conversationId !== undefined && childIds.has(change.conversationId))))
       changed?.(null);
   });
   return {
@@ -4644,6 +5338,7 @@ async function openProjection(runtime, session, context) {
           }, naming)
         }
       }, "", { models: runtime.listModels(), contextEntries: view.value.entries, compaction });
+      const jobs = (await session.jobs()).map(clipJob);
       const subagents = await listDelegations(runtime.harness, session.id, context);
       const approvals = await runtime.approvals.list(session.id, context);
       for (const entry of subagents)
@@ -4658,6 +5353,7 @@ async function openProjection(runtime, session, context) {
       const u = totalUsage(aggregate);
       return {
         ...projected,
+        jobs,
         agents: summarizeSubagents(subagents, (await runtime.harness.snapshot(SubagentsDoc, session.id, context))?.items),
         subagents: subagents.map(({ usageStart: _start, usageEnd: _end, ...entry }) => ({
           ...entry,
@@ -4829,7 +5525,7 @@ function serveSessions(host, runtime, context) {
       getImage: async (input, ctx) => {
         if (!Number.isSafeInteger(input.offset) || input.offset < 0 || !Number.isSafeInteger(input.contentIndex) || input.contentIndex < 0)
           throw new ChordError2("invalid", "Invalid image range");
-        const entry = await shared.reader.entry(input.entryId, withAbortSignal3(ctx.signal, context));
+        const entry = await shared.reader.entry(input.entryId, withAbortSignal4(ctx.signal, context));
         const content = entry?.model?.[0]?.content;
         const image = Array.isArray(content) ? content[input.contentIndex] : undefined;
         if (image?.type !== "image")
@@ -4866,6 +5562,21 @@ function serveSessions(host, runtime, context) {
         return null;
       },
       skills: () => runtime.listSkills(projection.value.session.id),
+      jobOutput: async ({ jobId, since }) => {
+        try {
+          const { job, output } = await projection.value.session.jobOutput(jobId, since);
+          return { job: clipJob(job), ...output };
+        } catch (error) {
+          throw new ChordError2("invalid", error instanceof Error ? error.message : "Cannot read job output");
+        }
+      },
+      jobStop: async ({ jobId }) => {
+        try {
+          return clipJob(await projection.value.session.stopJob(jobId));
+        } catch (error) {
+          throw new ChordError2("invalid", error instanceof Error ? error.message : "Cannot stop job");
+        }
+      },
       usage: async () => {
         const usage = totalUsage(await projection.value.session.usage());
         return {
@@ -5600,12 +6311,12 @@ async function listDrives() {
 // packages/gateway/src/server-services.ts
 var ServerState = local3("neko.server-state", {
   version: 1,
-  input: Type7.Object({}),
+  input: Type8.Object({}),
   members: {
     directory: DirectoryStateSchema,
     workspaces: WorkspaceStateSchema,
     credentials: CredentialStateSchema,
-    refreshCredentials: method2(Type7.Null(), Type7.Null())
+    refreshCredentials: method2(Type8.Null(), Type8.Null())
   }
 });
 async function createNekoServerServices(options) {