tarsk 0.6.87 → 0.6.89

package/dist/bundled-skills/tarsk-read/scripts/read.js

@@ -0,0 +1,331 @@
+/**
+ * read — listing / footnote / unchanged copy in the Skill; host does cwd + bytes.
+ */
+
+export const description =
+  "Read a file or list a directory when the path is known. Text caps at 1000 lines / 32KB; continue via reported offset only when a footnote says more remains. Window text with top-level offset/limit. Do not combine offset/limit with select.range; use one or the other. Read returns text, not JSON, so do not apply select.range or guess a JSON path. Do not reread an unchanged range already in context. For a large file, grep to locate the region and read a window (offset/limit) instead of the whole file — whole-file reads of several files bloat context. Listings are non-recursive (dirs end with `/`). Use find for path globs and grep for contents. Images (PNG/JPEG/GIF/WebP under 5 MiB) return as vision attachments. Issue independent reads in the same turn.";
+
+export const parameters = {
+  type: "object",
+  required: ["path"],
+  properties: {
+    path: {
+      description:
+        "File or directory path relative to the repository root, starting with `./` (for example `./shared/src/index.ts`). Absolute paths outside the project are denied; use bash to view those.",
+      type: "string",
+    },
+    offset: {
+      description: "Starting line, 1-indexed. Past the last line returns the last page.",
+      type: "number",
+    },
+    limit: {
+      description: "Maximum lines or directory entries",
+      minimum: 1,
+      type: "number",
+    },
+  },
+};
+
+const READ_UNCHANGED_MARKER_PREFIX = "[Unchanged since toolCallId=";
+
+function formatUnchangedStub(toolCallId, path) {
+  return `${READ_UNCHANGED_MARKER_PREFIX}${toolCallId}. ${path} is identical; request a different offset/limit to page.]`;
+}
+
+function formatDirectoryText(window) {
+  if (window.total === 0) return "(empty directory)";
+  if (window.entryCount === 0) return "(no entries shown)";
+  const output = window.entries.map(function formatEntry(entry) {
+    return `${entry.name}${entry.isDirectory ? "/" : ""}`;
+  });
+  if (
+    window.entryLimitReached !== undefined &&
+    window.startEntry !== undefined &&
+    window.endEntry !== undefined
+  ) {
+    output.push(
+      `\n[Showing entries ${window.startEntry}-${window.endEntry} of ${window.total}. Use offset=${window.endEntry + 1} to continue.]`,
+    );
+  }
+  const listing = output.join("\n");
+  if (
+    window.pastEnd &&
+    window.requestedOffset !== undefined &&
+    window.startEntry !== undefined &&
+    window.endEntry !== undefined
+  ) {
+    return `Offset ${window.requestedOffset} is beyond end of directory (${window.total} entries). Showing entries ${window.startEntry}-${window.endEntry}. Offset is 1-indexed.\n\n${listing}`;
+  }
+  return listing;
+}
+
+function formatOffsetPastEnd(requestedOffset, totalLines, shownStart, shownEnd) {
+  if (totalLines === 0) {
+    return `Offset ${requestedOffset} is beyond end of file (0 lines total). File is empty.`;
+  }
+  return (
+    `Offset ${requestedOffset} is beyond end of file (${totalLines} lines total). ` +
+    `Showing lines ${shownStart}-${shownEnd}. Offset is 1-indexed.`
+  );
+}
+
+function formatText(structured, context) {
+  const {
+    path,
+    resourcePath,
+    selectedContent,
+    startLine,
+    totalFileLines,
+    userLimitedLines,
+    pastEndOffset,
+    firstLineByteLength,
+  } = structured;
+  const startLineDisplay = startLine + 1;
+
+  if (totalFileLines === 0) {
+    return {
+      content: [{ type: "text", text: formatOffsetPastEnd(pastEndOffset ?? 1, 0, 0, 0) }],
+      details: {},
+    };
+  }
+
+  const truncation = context.util.truncateHead(selectedContent);
+  let composed;
+  let details = {};
+
+  if (truncation.firstLineExceedsLimit) {
+    composed = `[Line ${startLineDisplay} is ${context.util.formatSize(firstLineByteLength)}, exceeds ${context.util.formatSize(context.util.maxBytes)} limit. Use bash: sed -n '${startLineDisplay}p' ${path} | head -c ${context.util.maxBytes}]`;
+    details = { truncation };
+  } else if (truncation.truncated) {
+    const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
+    const nextOffset = endLineDisplay + 1;
+    composed = truncation.content;
+    if (truncation.truncatedBy === "lines") {
+      composed += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue.]`;
+    } else {
+      composed += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${context.util.formatSize(context.util.maxBytes)} limit). Use offset=${nextOffset} to continue.]`;
+    }
+    details = { truncation };
+  } else if (userLimitedLines !== undefined && startLine + userLimitedLines < totalFileLines) {
+    const remaining = totalFileLines - (startLine + userLimitedLines);
+    const nextOffset = startLine + userLimitedLines + 1;
+    composed = `${truncation.content}\n\n[${remaining} more lines in file. Use offset=${nextOffset} to continue.]`;
+  } else {
+    composed = truncation.content;
+  }
+
+  const shownEnd = Math.min(
+    totalFileLines,
+    startLine + (truncation.outputLines || userLimitedLines || totalFileLines - startLine),
+  );
+  const raw =
+    pastEndOffset === undefined
+      ? composed
+      : `${formatOffsetPastEnd(pastEndOffset, totalFileLines, startLineDisplay, shownEnd)}\n\n${composed}`;
+  const compressed = context.util.compressUnifiedDiffPreservingFootnotes(raw);
+  const outputText = compressed.applied ? compressed.text : raw;
+
+  let outputLines = 0;
+  if (!truncation.firstLineExceedsLimit && userLimitedLines !== 0) {
+    outputLines =
+      truncation.outputLines || userLimitedLines || Math.max(1, totalFileLines - startLine);
+  }
+
+  const detailsOut = { ...details };
+  if (outputLines > 0) {
+    const endLine = Math.min(totalFileLines, startLineDisplay + outputLines - 1);
+    detailsOut.supersession = {
+      kind: "read",
+      resourcePath,
+      coverage: {
+        kind: "text",
+        startLine: startLineDisplay,
+        endLine,
+        complete: startLineDisplay === 1 && endLine >= totalFileLines,
+      },
+    };
+  }
+
+  return {
+    content: [{ type: "text", text: outputText }],
+    details: detailsOut,
+  };
+}
+
+const SELECT_PATH_SEGMENT = /^[A-Za-z0-9_$-]+$/;
+
+/** Mirrors the host dot-path grammar: `.`-separated segments, `*` and `[]` wildcards. */
+function isValidSelectPath(path) {
+  for (const segment of path.split(".")) {
+    if (segment === "*" || segment === "[]") continue;
+    if (segment.length === 0) return false;
+    if (segment.endsWith("[]")) {
+      const key = segment.slice(0, -2);
+      if (key.length === 0 || !SELECT_PATH_SEGMENT.test(key)) return false;
+      continue;
+    }
+    if (!SELECT_PATH_SEGMENT.test(segment)) return false;
+  }
+  return true;
+}
+
+function sanitizeSelectRange(value, dropped) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    dropped.push("select.range");
+    return undefined;
+  }
+  const range = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (key === "path") {
+      if (typeof raw === "string" && raw.trim() !== "" && isValidSelectPath(raw)) range.path = raw;
+      else dropped.push("select.range.path");
+    } else if (key === "offset" || key === "limit") {
+      if (typeof raw === "number" && Number.isInteger(raw) && raw >= 1) range[key] = raw;
+      else dropped.push(`select.range.${key}`);
+    } else {
+      dropped.push(`select.range.${key}`);
+    }
+  }
+  if (range.offset === undefined && range.limit === undefined) {
+    dropped.push("select.range");
+    return undefined;
+  }
+  return range;
+}
+
+/**
+ * The host rejects a malformed `select` before the tool runs, which loses the
+ * whole result over a stray argument (most often a non-string `range.path`).
+ * Drop the offending axis, keep the call, and say what was dropped.
+ */
+function withSanitizedSelect(args) {
+  const select = args.select;
+  if (select === undefined) return { args, note: undefined };
+  const dropped = [];
+  let next;
+  if (select === null || typeof select !== "object" || Array.isArray(select)) {
+    dropped.push("select");
+  } else {
+    next = {};
+    for (const [key, value] of Object.entries(select)) {
+      if (key === "range") {
+        const range = sanitizeSelectRange(value, dropped);
+        if (range) next.range = range;
+      } else {
+        dropped.push(`select.${key}`);
+      }
+    }
+  }
+  if (dropped.length === 0) return { args, note: undefined };
+  const rest = Object.fromEntries(Object.entries(args).filter(([key]) => key !== "select"));
+  const kept = next && Object.keys(next).length > 0 ? next : undefined;
+  return {
+    args: kept ? { ...rest, select: kept } : rest,
+    note: `[select adjusted: dropped invalid ${dropped.join(", ")} — the host rejects the whole call, so that axis was ignored. Window text in the command (sed -n/head/tail) or read the stored output.]`,
+  };
+}
+
+/**
+ * Top-level offset/limit wins over select.range when both are sent. The host
+ * rejects a conflicting pair; this drops the range so the read still runs.
+ */
+function resolveWindowConflict(args) {
+  const select = args.select;
+  const hasWindow = args.offset !== undefined || args.limit !== undefined;
+  if (!select || typeof select !== "object" || select.range === undefined || !hasWindow) {
+    return { args, note: undefined };
+  }
+  const restSelect = Object.fromEntries(Object.entries(select).filter(([key]) => key !== "range"));
+  const rest = Object.fromEntries(Object.entries(args).filter(([key]) => key !== "select"));
+  const hasOtherAxes = Object.keys(restSelect).length > 0;
+  const nextArgs = hasOtherAxes ? { ...rest, select: restSelect } : rest;
+  return {
+    args: nextArgs,
+    note: "[select.range ignored: offset/limit and select.range are mutually exclusive; used offset/limit.]",
+  };
+}
+
+function withNote(result, note) {
+  if (!note || !Array.isArray(result.content)) return result;
+  const first = result.content[0];
+  if (first?.type !== "text") {
+    return { ...result, content: [{ type: "text", text: note }, ...result.content] };
+  }
+  return {
+    ...result,
+    content: [{ ...first, text: `${note}\n\n${first.text}` }, ...result.content.slice(1)],
+  };
+}
+
+/** @param {Record<string, unknown>} args @param {import("../../../../src/tools/agent-runtime/types.js").AgentRuntime} context @param {{ signal?: AbortSignal, toolCallId?: string, onUpdate?: Function }} [options] */
+export async function execute(args, context, options) {
+  const sanitized = withSanitizedSelect(args);
+  const resolved = resolveWindowConflict(sanitized.args);
+  const note = [sanitized.note, resolved.note].filter(Boolean).join("\n");
+  const result = await executeRead(resolved.args, context, options);
+  return withNote(result, note === "" ? undefined : note);
+}
+
+async function executeRead(args, context, options) {
+  const structured = await context.fs.read(args, {
+    signal: options?.signal,
+    onUpdate: options?.onUpdate,
+    toolCallId: options?.toolCallId,
+  });
+
+  if (structured.status === "aborted") {
+    return { content: [], details: undefined };
+  }
+  if (structured.status === "raw") {
+    return { content: structured.content, details: structured.details };
+  }
+  if (structured.status === "unchanged") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatUnchangedStub(structured.cachedToolCallId, structured.path),
+        },
+      ],
+      details: undefined,
+    };
+  }
+  if (structured.status === "directory") {
+    const text = formatDirectoryText(structured.window);
+    const window = structured.window;
+    return {
+      content: [{ type: "text", text }],
+      details: {
+        ...(window.entryLimitReached !== undefined
+          ? { entryLimitReached: window.entryLimitReached }
+          : {}),
+        supersession: {
+          kind: "read",
+          resourcePath: structured.resourcePath,
+          coverage: {
+            kind: "directory",
+            entryCount: window.entryCount,
+            complete: window.complete,
+            ...(window.startEntry !== undefined && window.endEntry !== undefined
+              ? { startEntry: window.startEntry, endEntry: window.endEntry }
+              : {}),
+          },
+        },
+      },
+    };
+  }
+  if (structured.status === "image") {
+    return {
+      content: [{ type: "image", data: structured.data, mimeType: structured.mimeType }],
+      details: {
+        supersession: {
+          kind: "read",
+          resourcePath: structured.resourcePath,
+          coverage: { kind: "image" },
+        },
+      },
+    };
+  }
+
+  return formatText(structured, context);
+}

package/dist/bundled-skills/tarsk-read-skill/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: tarsk-read-skill
+description: >-
+  Tarsk Tool skill publishing: read_skill.
+version: 2.0.0
+tools:
+  - read_skill
+disable-model-invocation: true
+---
+
+# tarsk-read-skill
+
+Publishes: read_skill.
+
+Miss copy in `scripts/read_skill.js`. Host `context.skillsCatalog.read`
+(load + preprocess).

package/dist/bundled-skills/tarsk-read-skill/scripts/read_skill.js

@@ -0,0 +1,37 @@
+/**
+ * read_skill — miss copy in the Skill; host loads + preprocesses the body.
+ */
+
+export const description =
+  "Load the full instructions for an activated skill. Use this when you need to understand how to use a skill whose metadata (name, description, whenToUse) was shown in the Available Skills section.";
+
+export const parameters = {
+  type: "object",
+  required: ["skillName"],
+  properties: {
+    skillName: {
+      description: "Skill name",
+      type: "string",
+    },
+  },
+};
+
+/** @param {Record<string, unknown>} args @param {import("../../../../src/tools/agent-runtime/types.js").AgentRuntime} context */
+export async function execute(args, context) {
+  const result = await context.skillsCatalog.read(args);
+  if (!result.ok) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Skill not found: ${result.skillName}. Available skills: ${result.available.join(", ")}`,
+        },
+      ],
+      details: undefined,
+    };
+  }
+  return {
+    content: [{ type: "text", text: result.text }],
+    details: undefined,
+  };
+}

package/dist/bundled-skills/tarsk-read-skill-reference/SKILL.md

@@ -0,0 +1,19 @@
+---
+name: tarsk-read-skill-reference
+description: >-
+  Tarsk Tool skill publishing: read_skill_reference.
+version: 2.0.0
+tools:
+  - read_skill_reference
+deferred-tools:
+  - read_skill_reference
+disable-model-invocation: true
+---
+
+# tarsk-read-skill-reference
+
+Publishes: read_skill_reference.
+
+Miss / path-error copy in `scripts/read_skill_reference.js`. Host
+`context.skillsCatalog.readReference` returns structured load results (path
+containment stays in the host).

package/dist/bundled-skills/tarsk-read-skill-reference/scripts/read_skill_reference.js

@@ -0,0 +1,60 @@
+/**
+ * read_skill_reference — miss copy in the Skill; host holds path containment + read.
+ */
+
+export const description =
+  "Read a reference file from an activated skill. Skills provide additional documentation in their references/ directory.";
+
+export const parameters = {
+  type: "object",
+  required: ["skillName", "referencePath"],
+  properties: {
+    skillName: {
+      description: "Skill name",
+      type: "string",
+    },
+    referencePath: {
+      description:
+        'Path to the reference file relative to the skill\'s references/ directory (e.g., "api-reference.md" or "guides/setup.md")',
+      type: "string",
+    },
+  },
+};
+
+/** @param {Record<string, unknown>} args @param {import("../../../../src/tools/agent-runtime/types.js").AgentRuntime} context */
+export async function execute(args, context) {
+  const result = await context.skillsCatalog.readReference(args);
+  if (result.ok) {
+    return {
+      content: [{ type: "text", text: result.text }],
+      details: undefined,
+    };
+  }
+  let text;
+  switch (result.reason) {
+    case "skill_not_found":
+      text = `Skill not found: ${result.skillName}. Available skills: ${result.available.join(", ")}`;
+      break;
+    case "no_references":
+      text = `Skill '${result.skillName}' has no references directory`;
+      break;
+    case "invalid_path":
+      text = `Invalid reference path: ${result.referencePath}. Path must be within the skill's references directory.`;
+      break;
+    case "not_found":
+      text =
+        result.available.length > 0
+          ? `Reference file '${result.referencePath}' not found in skill '${result.skillName}'. Available references:\n${result.available.join("\n")}`
+          : `Reference file '${result.referencePath}' not found in skill '${result.skillName}'`;
+      break;
+    case "read_error":
+      text = `Failed to read reference file: ${result.message}`;
+      break;
+    default:
+      text = "Failed to read skill reference";
+  }
+  return {
+    content: [{ type: "text", text }],
+    details: undefined,
+  };
+}

package/dist/bundled-skills/tarsk-run-js/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: tarsk-run-js
+description: >-
+  Tarsk Tool skill publishing: run_js.
+version: 3.1.0
+tools:
+  - run_js
+disable-model-invocation: true
+---
+
+# tarsk-run-js
+
+Publishes: run_js.
+
+Truncation / trivial-read redirect notice in `scripts/run_js.js`. Host
+`context.js.run` returns structured ok / trivial_read (worker + proxy catalog).
+Failure diagnostics still throw from the host (recovery policy, like
+`shell.resolveExit`).

package/dist/bundled-skills/tarsk-run-js/scripts/run_js.js

@@ -0,0 +1,192 @@
+/**
+ * run_js — truncation / trivial-read notice in the Skill; host holds worker +
+ * proxy catalog + failure diagnostics (still thrown from host).
+ */
+
+export const description =
+  "Default for multi-hop work: when one result decides the next call, or you would loop (grep→read each, list→act), put the whole chain here so intermediates stay out of chat. Independent known-arg calls stay parallel direct tools. Single known-file window → read, not run_js. Prefer `plan` (foreach + return) or `code` with chain/readMany/grepMany/locate/callTool. Cannot call run_js/ask_user/agent/tool_search, and deferred tools (notes, tasks, projects, history, browser, fetch, chat_title, images, execute_skill_script) join the catalog only after tool_search surfaces them — call those directly. Return once; on failure retry with patches and omit code. `code` is plain JavaScript only (async body, `await callTool(...)`, `return`): no shell commands, markdown fences, or prose. A syntax error is reported before the run. `code` must return a value explicitly; an undefined or null return fails the call. `intention` is required on every call, including `patches` retries.";
+
+export const parameters = {
+  type: "object",
+  required: ["intention"],
+  properties: {
+    intention: {
+      description:
+        "Why this code is being run. Required on every call, including `patches` retries.",
+      type: "string",
+    },
+    code: {
+      description:
+        "JS to chain tools / reduce output (not Node APIs). Omit when using patches. await callTool(name, params) → {text, error}. Prefer read/find/grep helpers over bash. No file writes (use the write/edit tools) and no TextEncoder/btoa/atob — compute text/JSON only. End with an explicit `return` of the reduced answer; undefined or null return values fail.",
+      type: "string",
+    },
+    plan: {
+      additionalProperties: false,
+      description:
+        "Declarative tool graph with foreach instead of code. Args are tool parameters; refs infer dependsOn.",
+      type: "object",
+      required: ["steps"],
+      properties: {
+        steps: {
+          minItems: 1,
+          maxItems: 100,
+          type: "array",
+          items: {
+            additionalProperties: false,
+            type: "object",
+            required: ["id", "tool"],
+            properties: {
+              id: {
+                pattern: "^[A-Za-z_][A-Za-z0-9_-]*$",
+                type: "string",
+              },
+              tool: {
+                minLength: 1,
+                type: "string",
+              },
+              args: {
+                type: "object",
+                patternProperties: {
+                  "^(.*)$": {},
+                },
+              },
+              foreach: {
+                description: "Array or $step; args may use $item / $index.",
+                anyOf: [
+                  {
+                    type: "string",
+                  },
+                  {
+                    type: "array",
+                    items: {},
+                  },
+                ],
+              },
+              dependsOn: {
+                description: "Extra ordering edges.",
+                type: "array",
+                items: {
+                  type: "string",
+                },
+              },
+            },
+          },
+        },
+        return: {
+          description:
+            "Projection (default last step). Refs: $id.text, $id.lines, $id.json.key. `.json` parses that step's text and fails if it is not JSON (grep content/read are text) — use $id.text for those.",
+        },
+        maxChars: {
+          minimum: 128,
+          maximum: 64000,
+          default: 16000,
+          description: "Final JSON character budget.",
+          type: "integer",
+        },
+      },
+    },
+    patches: {
+      description: "Retry edits on the last failed script; omit code. Each old matches once.",
+      type: "array",
+      items: {
+        type: "object",
+        required: ["old", "new"],
+        properties: {
+          old: {
+            description:
+              "Exact unique substring from the last failed run_js code (include enough context).",
+            type: "string",
+          },
+          new: {
+            description: "Replacement text; empty deletes the match.",
+            type: "string",
+          },
+        },
+      },
+    },
+  },
+};
+
+const TRIVIAL_RUN_JS_READ_NOTICE =
+  "[Redirected trivial run_js to read. Use read({ path, offset, limit }) for a known file window.]";
+
+const RUN_JS_CODE_RESULT_MAX_CHARS = 16000;
+
+function formatRunJsResultText(result) {
+  if (typeof result === "string") {
+    return result;
+  }
+  return JSON.stringify(result, null, 2) || "undefined";
+}
+
+function truncationNotice(shownChars, totalChars) {
+  return (
+    `\n\n[Truncated run_js result: showing ${shownChars} of ${totalChars} chars. ` +
+    `Return a reduced answer (sliceText), or use read({ path, offset, limit }) for a known file window.]`
+  );
+}
+
+function capRunJsCodeResultText(text, maxChars = RUN_JS_CODE_RESULT_MAX_CHARS) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  const placeholderNotice = truncationNotice(maxChars, text.length);
+  const budget = Math.max(0, maxChars - placeholderNotice.length);
+  const head = text.slice(0, budget);
+  return `${head}${truncationNotice(head.length, text.length)}`;
+}
+
+function formatOk(value) {
+  return capRunJsCodeResultText(formatRunJsResultText(value));
+}
+
+function formatTrivialRead(structured) {
+  const first = structured.content[0];
+  const body = first?.type === "text" && typeof first.text === "string" ? first.text : "";
+  const text = body ? `${TRIVIAL_RUN_JS_READ_NOTICE}\n\n${body}` : TRIVIAL_RUN_JS_READ_NOTICE;
+  const rest = structured.content.slice(1);
+  return {
+    content: [{ type: "text", text }, ...rest],
+    details: structured.details,
+  };
+}
+
+/**
+ * Compile the `code` body as an async function body so a syntax error returns
+ * with its message before the worker starts. Skipped when the engine blocks
+ * the constructor (the host still reports its own compile error).
+ */
+function compileCheckCode(code) {
+  if (typeof code !== "string" || code.trim() === "") return undefined;
+  let AsyncFunction;
+  try {
+    AsyncFunction = Object.getPrototypeOf(async function probe() {}).constructor;
+  } catch {
+    return undefined;
+  }
+  try {
+    new AsyncFunction("callTool", code);
+    return undefined;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return `[run_js syntax error: ${error.message}. Fix the code and retry; do not repeat the same body. Use patches to edit the last failed script.]`;
+    }
+    return undefined;
+  }
+}
+
+/** @param {Record<string, unknown>} args @param {import("../../../../src/tools/agent-runtime/types.js").AgentRuntime} context @param {{ signal?: AbortSignal, toolCallId?: string }} [options] */
+export async function execute(args, context, options) {
+  const syntaxNotice = compileCheckCode(args.code);
+  if (syntaxNotice) {
+    throw new Error(syntaxNotice);
+  }
+  const structured = await context.js.run(args, options);
+  if (structured.status === "trivial_read") {
+    return formatTrivialRead(structured);
+  }
+  return {
+    content: [{ type: "text", text: formatOk(structured.value) }],
+    details: undefined,
+  };
+}

package/dist/bundled-skills/tarsk-tasks/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: tarsk-tasks
+description: >-
+  Tarsk Tool skill publishing: tasks.
+version: 2.0.0
+tools:
+  - tasks
+deferred-tools:
+  - tasks
+disable-model-invocation: true
+---
+
+# tarsk-tasks
+
+Publishes: tasks.
+
+Ok/error JSON copy in `scripts/tasks.js`. Host `context.tasks.query` (DB +
+launch).