@zixt/host 0.0.55 → 0.0.57

package/dist/index.js

@@ -31,7 +31,7 @@ import { homedir } from "node:os";
 // package.json
 var package_default = {
   name: "@zixt/host",
-  version: "0.0.55",
+  version: "0.0.57",
   type: "module",
   exports: {
     ".": "./src/client.ts",
@@ -16023,6 +16023,10 @@ var UploadAttachmentRequest = external_exports.object({
 });
 var UploadAttachmentResponse = external_exports.object({ attachment: TaskAttachmentRef });
 var TASK_ARTIFACT_MAX_BYTES = 10 * 1024 * 1024;
+var TASK_ARTIFACT_CHAT_HREF_PREFIX = "/.zixt/task-files/";
+function taskArtifactChatHref(artifactId) {
+  return `${TASK_ARTIFACT_CHAT_HREF_PREFIX}${artifactId}`;
+}
 var TaskArtifact = external_exports.object({
   id: TaskArtifactId,
   taskId: TaskId,
@@ -16032,6 +16036,7 @@ var TaskArtifact = external_exports.object({
   sha256: external_exports.string().regex(/^[a-f0-9]{64}$/),
   createdAt: IsoDate
 });
+var OrgFileResponse = external_exports.object({ artifact: TaskArtifact });
 var TaskFileCapability = external_exports.object({
   target: external_exports.enum(["zixt", "slack", "linear"]),
   operation: external_exports.enum(["download", "share", "issue_attachment"]),
@@ -16227,6 +16232,68 @@ var TaskEventRecord = external_exports.object({
   attachments: external_exports.array(TaskAttachmentRef).max(TASK_MESSAGE_MAX_ATTACHMENTS).optional(),
   at: IsoDate
 });
+var TaskTimingPhaseKind = external_exports.enum([
+  /** Waiting for a Machine: queue, dispatch, and re-queue between runs. */
+  "queued",
+  /** Assigned to a Machine, session not started yet. */
+  "startup",
+  /** Preparing the environment: dependencies, folders, tools, services. */
+  "setup",
+  /** Reading, searching, and browsing to find things out. */
+  "research",
+  /** Doing the Task's actual work: edits, writes, configuration, other tools. */
+  "work",
+  /** Running checks: tests, builds, linters, verification. */
+  "validation",
+  /** Work that happened after checks had already started in the same run. */
+  "rework",
+  /** Reporting and handing off the result: messages, pull requests, files. */
+  "delivery",
+  /** Parked on a question or an approval a person owed. */
+  "awaiting_person",
+  /** Nothing was running: the Task sat between runs with no one waiting on it. */
+  "idle",
+  /** Measured time the Task's activity record cannot break down. */
+  "unattributed"
+]);
+var TaskTimingBasis = external_exports.enum(["measured", "estimated"]);
+var TaskTimingPhase = external_exports.object({
+  kind: TaskTimingPhaseKind,
+  durationMs: external_exports.number().int().min(0),
+  basis: TaskTimingBasis,
+  /** Activity steps behind an estimated phase; 0 for measured lifecycle phases. */
+  steps: external_exports.number().int().min(0)
+}).strict();
+var TaskTimingRun = external_exports.object({
+  epoch: external_exports.number().int().min(1),
+  status: TaskStatus,
+  startedAt: IsoDate.nullable(),
+  finishedAt: IsoDate.nullable(),
+  /** Waiting for this run's Machine, including re-queue after an earlier run. */
+  waitingMs: external_exports.number().int().min(0),
+  activeMs: external_exports.number().int().min(0),
+  unattributedMs: external_exports.number().int().min(0)
+}).strict();
+var TASK_TIMING_MAX_RUNS = 50;
+var TaskTimingBreakdown = external_exports.object({
+  schemaVersion: external_exports.literal(1),
+  from: IsoDate,
+  to: IsoDate,
+  totalElapsedMs: external_exports.number().int().min(0),
+  /** Time a Machine was running the Task, broken down or not. */
+  activeMs: external_exports.number().int().min(0),
+  /** Queue, startup, approval, and idle time: nothing was being worked on. */
+  waitingMs: external_exports.number().int().min(0),
+  /** Active time the activity record cannot name. */
+  unattributedMs: external_exports.number().int().min(0),
+  runCount: external_exports.number().int().min(0),
+  /** False while the Task can still accrue time; the breakdown is then a snapshot. */
+  settled: external_exports.boolean(),
+  /** True once at least one estimated phase carries time worth showing. */
+  attributed: external_exports.boolean(),
+  phases: external_exports.array(TaskTimingPhase),
+  runs: external_exports.array(TaskTimingRun).max(TASK_TIMING_MAX_RUNS)
+}).strict();
 var CreateTaskInput = external_exports.object({
   /** Stable client-generated key: retrying the same submission returns one Task. */
   requestId: external_exports.uuid().optional(),
@@ -16486,7 +16553,9 @@ var TaskDetailResponse = external_exports.object({
   reviewAuthorization: TaskReviewAuthorization,
   context: TaskResolvedContext,
   /** Newest host-observed folder/Git state; null until a current Host reports it. */
-  workingContext: TaskWorkingContext.nullable().default(null)
+  workingContext: TaskWorkingContext.nullable().default(null),
+  /** TS-19 timing breakdown; null when the Task has no usable timing evidence. */
+  timing: TaskTimingBreakdown.nullable().default(null)
 });
 var TaskSupportBundle = external_exports.object({
   schemaVersion: external_exports.literal(1),
@@ -18083,7 +18152,17 @@ var ConversationEventProjection = external_exports.discriminatedUnion("kind", [
     terminalGroup: external_exports.string().min(1).max(200).nullable().optional()
   }).strict(),
   /** A Manager loop failure a person should see (provider outage, refusal). */
-  external_exports.object({ ...conversationEventBase, kind: external_exports.literal("error"), message: external_exports.string() }).strict()
+  external_exports.object({
+    ...conversationEventBase,
+    kind: external_exports.literal("error"),
+    message: external_exports.string(),
+    /**
+     * `notice` marks a record that is not a fault: the person stopped this
+     * turn themselves. Absent on every historical row, so a missing value
+     * keeps reading as the fault it always was.
+     */
+    severity: external_exports.enum(["error", "notice"]).optional()
+  }).strict()
 ]);
 var ManagerIntegrationProvider = external_exports.enum(["slack", "github"]);
 var ManagerIntegrationOperation = external_exports.enum(["connect", "reconnect", "check", "remove"]);
@@ -18221,6 +18300,24 @@ var ConversationDetailResponse = external_exports.object({
   conversation: ConversationProjection,
   events: external_exports.array(ConversationEventProjection)
 }).strict();
+var ConversationInterruptTurnOutcome = external_exports.enum(["interrupted", "not_running"]);
+var ConversationInterruptTaskOutcome = external_exports.enum([
+  "stop_requested",
+  "already_finished",
+  "not_stopped"
+]);
+var ConversationInterruptTaskResult = external_exports.object({
+  taskId: TaskId,
+  outcome: ConversationInterruptTaskOutcome,
+  /** Why the stop did not happen; null unless the outcome is `not_stopped`. */
+  detail: external_exports.string().max(300).nullable()
+}).strict();
+var CONVERSATION_INTERRUPT_TASK_LIMIT = 100;
+var InterruptConversationResponse = external_exports.object({
+  conversation: ConversationProjection,
+  managerTurn: ConversationInterruptTurnOutcome,
+  tasks: external_exports.array(ConversationInterruptTaskResult).max(CONVERSATION_INTERRUPT_TASK_LIMIT)
+}).strict();
 var ManagerStreamFrame = external_exports.discriminatedUnion("type", [
   external_exports.object({ type: external_exports.literal("event"), event: ConversationEventProjection }).strict(),
   external_exports.object({ type: external_exports.literal("delta"), text: external_exports.string() }).strict(),
@@ -19980,6 +20077,7 @@ async function discoverTools(params, fetchFn = fetch) {
 import { createHash } from "node:crypto";
 import { lstat, readFile, realpath } from "node:fs/promises";
 import { basename, extname, isAbsolute, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
 var MEDIA_TYPES = {
   ".csv": "text/csv",
   ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
@@ -20042,6 +20140,146 @@ async function publishTaskFile(input) {
     data: bytes.toString("base64")
   });
 }
+function markdownLinkDestinations(markdown) {
+  const ignored = new Uint8Array(markdown.length);
+  let fence = null;
+  let offset = 0;
+  for (const line of markdown.split(/(?<=\n)/)) {
+    const body = line.endsWith("\n") ? line.slice(0, -1) : line;
+    const match = /^( {0,3})(`{3,}|~{3,})/.exec(body);
+    const marker = match?.[2]?.[0];
+    const markerLength = match?.[2]?.length ?? 0;
+    const closes = fence !== null && marker === fence.marker && markerLength >= fence.length && body.slice(match?.[0].length ?? 0).trim() === "";
+    if (fence || match) ignored.fill(1, offset, offset + line.length);
+    if (!fence && marker) fence = { marker, length: markerLength };
+    else if (closes) fence = null;
+    offset += line.length;
+  }
+  for (let index = 0; index < markdown.length; index++) {
+    if (ignored[index] || markdown[index] !== "`") continue;
+    let length = 1;
+    while (markdown[index + length] === "`") length++;
+    const delimiter3 = "`".repeat(length);
+    const close = markdown.indexOf(delimiter3, index + length);
+    if (close < 0) continue;
+    ignored.fill(1, index, close + length);
+    index = close + length - 1;
+  }
+  const destinations = [];
+  const escaped = (index) => {
+    let slashes = 0;
+    for (let cursor = index - 1; cursor >= 0 && markdown[cursor] === "\\"; cursor--) slashes++;
+    return slashes % 2 === 1;
+  };
+  for (let index = 0; index < markdown.length; index++) {
+    if (ignored[index] || markdown[index] !== "[" || escaped(index) || index > 0 && markdown[index - 1] === "!") {
+      continue;
+    }
+    let labelDepth = 1;
+    let closeLabel = index + 1;
+    for (; closeLabel < markdown.length && labelDepth > 0; closeLabel++) {
+      if (ignored[closeLabel] || escaped(closeLabel)) continue;
+      if (markdown[closeLabel] === "[") labelDepth++;
+      else if (markdown[closeLabel] === "]") labelDepth--;
+    }
+    if (labelDepth !== 0 || markdown[closeLabel] !== "(") continue;
+    let cursor = closeLabel + 1;
+    while (markdown[cursor] === " " || markdown[cursor] === "	") cursor++;
+    if (markdown[cursor] === "<") {
+      const start2 = cursor + 1;
+      cursor = start2;
+      while (cursor < markdown.length && markdown[cursor] !== "\n" && (markdown[cursor] !== ">" || escaped(cursor))) {
+        cursor++;
+      }
+      if (markdown[cursor] !== ">") continue;
+      destinations.push({ start: start2, end: cursor, value: markdown.slice(start2, cursor) });
+      index = cursor;
+      continue;
+    }
+    const start = cursor;
+    let depth = 1;
+    while (cursor < markdown.length) {
+      if (escaped(cursor)) {
+        cursor++;
+        continue;
+      }
+      const char = markdown[cursor];
+      if (char === "(") depth++;
+      else if (char === ")") {
+        depth--;
+        if (depth === 0) break;
+      } else if ((char === " " || char === "	" || char === "\n") && depth === 1) {
+        break;
+      }
+      cursor++;
+    }
+    if (cursor > start) {
+      destinations.push({ start, end: cursor, value: markdown.slice(start, cursor) });
+      index = cursor;
+    }
+  }
+  return destinations;
+}
+function localPathFromMarkdownDestination(destination) {
+  const unescaped = destination.replace(/\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g, "$1");
+  if (/^file:\/\//i.test(unescaped)) {
+    try {
+      return fileURLToPath(unescaped);
+    } catch {
+      return null;
+    }
+  }
+  const windowsAbsolute = /^[A-Za-z]:[\\/]/.test(unescaped);
+  if (!windowsAbsolute && /^[A-Za-z][A-Za-z\d+.-]*:/.test(unescaped)) return null;
+  if (unescaped.startsWith("#") || unescaped.startsWith("//")) return null;
+  try {
+    return decodeURIComponent(unescaped);
+  } catch {
+    return unescaped;
+  }
+}
+async function publishLinkedTaskFiles(input) {
+  const replacements = [];
+  const publications = new Map(input.publishedArtifacts);
+  const artifacts = [];
+  for (const destination of markdownLinkDestinations(input.summary)) {
+    const localPath = localPathFromMarkdownDestination(destination.value);
+    if (!localPath) continue;
+    const candidate = resolve(input.cwd, localPath);
+    const key = await realpath(candidate).catch(() => candidate);
+    let artifact = publications.get(key);
+    if (artifact === void 0) {
+      try {
+        const outcome = await publishTaskFile({
+          path: localPath,
+          cwd: input.cwd,
+          allowedRoots: input.allowedRoots,
+          agentOp: input.agentOp
+        });
+        const parsed = TaskArtifact.safeParse(
+          outcome.ok && outcome.result && typeof outcome.result === "object" ? outcome.result["artifact"] : void 0
+        );
+        artifact = parsed.success ? parsed.data : null;
+      } catch {
+        artifact = null;
+      }
+      publications.set(key, artifact);
+      if (artifact) artifacts.push(artifact);
+    }
+    if (artifact) {
+      replacements.push({
+        start: destination.start,
+        end: destination.end,
+        href: taskArtifactChatHref(artifact.id)
+      });
+    }
+  }
+  let summary = input.summary;
+  for (const replacement of replacements.reverse()) {
+    summary = summary.slice(0, replacement.start) + replacement.href + summary.slice(replacement.end);
+  }
+  return { summary, artifacts };
+}
 
 // src/runners/exec.ts
 import { spawn } from "node:child_process";
@@ -35500,6 +35738,25 @@ function createCliRunner(adapter, opts = {}) {
       }
     }
     if (task.cancelledNow()) return cancelledBeforeRun();
+    const publishedTaskFiles = /* @__PURE__ */ new Map();
+    const publishFile = async (path, mediaType) => {
+      const outcome = await publishTaskFile({
+        path,
+        ...mediaType ? { mediaType } : {},
+        cwd,
+        allowedRoots: [taskRoot, cwd],
+        agentOp: (op) => task.agentOp(op)
+      });
+      const parsed = TaskArtifact.safeParse(
+        outcome.ok && outcome.result && typeof outcome.result === "object" ? outcome.result["artifact"] : void 0
+      );
+      if (parsed.success) {
+        const candidate = resolve9(cwd, path);
+        const key = await realpath8(candidate).catch(() => candidate);
+        publishedTaskFiles.set(key, parsed.data);
+      }
+      return outcome;
+    };
     const [secrets, attachedConnections, providerGrants] = await Promise.all([
       task.secrets(),
       task.connections(),
@@ -35643,13 +35900,7 @@ function createCliRunner(adapter, opts = {}) {
             pendingAsks--;
           }
         },
-        publishFile: (path, mediaType) => publishTaskFile({
-          path,
-          ...mediaType ? { mediaType } : {},
-          cwd,
-          allowedRoots: [taskRoot, cwd],
-          agentOp: (op) => task.agentOp(op)
-        }),
+        publishFile,
         agentOp: (op) => task.agentOp(op),
         // GitHub repository work belongs in the installed `git` and `gh`
         // commands backed by GithubShellAuth. Do not advertise the bundled
@@ -35955,6 +36206,16 @@ ${attachmentSection}` : prompt;
           opts.onUnsafeRunnerCleanup?.(result.summary);
         }
       }
+      if (result.outcome === "done") {
+        const linkedFiles = await publishLinkedTaskFiles({
+          summary: result.summary,
+          cwd,
+          allowedRoots: [taskRoot, cwd],
+          publishedArtifacts: publishedTaskFiles,
+          agentOp: (op) => task.agentOp(op)
+        });
+        result = { ...result, summary: linkedFiles.summary };
+      }
       task.event(
         "status",
         `${adapter.displayName} finished. Tokens in ${result.usage.inputTokens}, out ${result.usage.outputTokens}` + (result.usage.totalCostUsd !== void 0 ? `, cost $${result.usage.totalCostUsd.toFixed(4)}` : "")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zixt/host",
-  "version": "0.0.55",
+  "version": "0.0.57",
   "type": "module",
   "exports": {
     ".": "./src/client.ts",