@drisp/cli 0.5.6 → 0.5.8

package/dist/athena-gateway.js

@@ -2241,7 +2241,7 @@ var cachedVersion = null;
 function readVersion() {
   if (cachedVersion !== null) return cachedVersion;
   try {
-    const injected = "0.5.6";
+    const injected = "0.5.8";
     if (typeof injected === "string" && injected.length > 0) {
       cachedVersion = injected;
       return cachedVersion;

package/dist/{chunk-ZU7M6YZW.js → chunk-XIWMD4GT.js}

@@ -5208,16 +5208,21 @@ function translateServerRequest(msg) {
           networkContext: params.networkApprovalContext && typeof params.networkApprovalContext === "object" ? {
             host: params.networkApprovalContext.host,
             protocol: params.networkApprovalContext.protocol
-          } : void 0
+          } : void 0,
+          toolUseId: params.itemId
         }
       );
     }
     case FILE_CHANGE_REQUEST_APPROVAL: {
       const params = msg.params;
-      return permissionRequestEvent("Edit", {
-        reason: params.reason,
-        grantRoot: params.grantRoot
-      });
+      return permissionRequestEvent(
+        "Edit",
+        {
+          reason: params.reason,
+          grantRoot: params.grantRoot
+        },
+        { toolUseId: params.itemId }
+      );
     }
     case PERMISSIONS_REQUEST_APPROVAL: {
       const params = msg.params;
@@ -7700,6 +7705,8 @@ function generateNeutralTitle(event, g) {
       return truncate(
         `Cloud fn \u2717 ${event.data.function_name}: ${event.data.error_message}`
       );
+    case "artifacts.manifest":
+      return "Artifacts manifest";
   }
 }
 
@@ -11665,6 +11672,7 @@ async function runExec(options) {
   let mappedFinalMessage = null;
   let adapterSessionId = null;
   let activeRunId = null;
+  let beforeTerminalCompletionRan = false;
   let store;
   try {
     store = sessionStoreFactory({
@@ -11787,6 +11795,57 @@ async function runExec(options) {
       feedEvents
     });
   }
+  const runBeforeTerminalCompletion = async () => {
+    if (beforeTerminalCompletionRan || latch.hasFailure() || !options.beforeTerminalCompletion) {
+      return;
+    }
+    beforeTerminalCompletionRan = true;
+    const resolved = resolveFinalMessage({
+      streamMessage: streamFinalMessage,
+      mappedMessage: mappedFinalMessage
+    });
+    const provisionalResult = {
+      success: true,
+      exitCode: EXEC_EXIT_CODE.SUCCESS,
+      athenaSessionId: options.ephemeral ? null : athenaSessionId,
+      adapterSessionId,
+      finalMessage: resolved.message,
+      tokens: cumulativeTokens,
+      durationMs: Math.max(0, now() - startTs)
+    };
+    try {
+      const feedEvents = await options.beforeTerminalCompletion({
+        result: provisionalResult,
+        runId: activeRunId
+      });
+      if (feedEvents && feedEvents.length > 0) {
+        publishFeedEvents(feedEvents);
+      }
+    } catch (error) {
+      latch.register({
+        kind: "output",
+        message: `Artifact upload failed: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  };
+  const writeLastMessageBeforeTerminalCompletion = async () => {
+    if (latch.hasFailure() || !options.outputLastMessagePath) return;
+    const resolved = resolveFinalMessage({
+      streamMessage: streamFinalMessage,
+      mappedMessage: mappedFinalMessage
+    });
+    try {
+      await output.writeLastMessage(
+        options.outputLastMessagePath,
+        resolved.message
+      );
+    } catch (error) {
+      latch.register({
+        kind: "output",
+        message: `Failed writing --output-last-message: ${error instanceof Error ? error.message : String(error)}`
+      });
+    }
+  };
   const unsubscribeEvent = runtime.onEvent((runtimeEvent) => {
     adapterSessionId = runtimeEvent.sessionId;
     if (runtimeEvent.sessionId && activeRunId && !linkedAdapterSessions.has(runtimeEvent.sessionId)) {
@@ -11956,6 +12015,8 @@ async function runExec(options) {
     if (dashboardDecisionTimer) {
       clearInterval(dashboardDecisionTimer);
     }
+    await writeLastMessageBeforeTerminalCompletion();
+    await runBeforeTerminalCompletion();
     await sessionController.kill();
     unsubscribeEvent();
     unsubscribeDecision();
@@ -11974,19 +12035,6 @@ async function runExec(options) {
     output.warn(warning);
     output.emitJsonEvent("exec.warning", { message: warning });
   }
-  if (!latch.hasFailure() && options.outputLastMessagePath) {
-    try {
-      await output.writeLastMessage(
-        options.outputLastMessagePath,
-        resolvedFinalMessage.message
-      );
-    } catch (error) {
-      latch.register({
-        kind: "output",
-        message: `Failed writing --output-last-message: ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
-  }
   const failure = latch.current();
   const exitCode = exitCodeFromFailure(failure);
   const success = exitCode === EXEC_EXIT_CODE.SUCCESS;
@@ -12586,6 +12634,370 @@ async function createRemoteRunEventPublisher({
   };
 }
 
+// src/app/dashboard/artifactCapture.ts
+import { execFile } from "child_process";
+import crypto3 from "crypto";
+import fs21 from "fs/promises";
+import path19 from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+function parseArtifactUploadSpec(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const obj = value;
+  const hasArtifactUpload = Object.hasOwn(obj, "artifactUpload");
+  const hasArtifacts = Object.hasOwn(obj, "artifacts");
+  if (!hasArtifactUpload && !hasArtifacts) return null;
+  const candidate = hasArtifactUpload ? obj["artifactUpload"] : obj["artifacts"];
+  if (typeof candidate !== "object" || candidate === null) {
+    throw new Error("artifact upload spec must be an object");
+  }
+  const spec = candidate;
+  const bucket = spec["bucket"];
+  const prefix = spec["prefix"];
+  const normalizedPrefix = typeof prefix === "string" ? prefix.replace(/^\/+|\/+$/g, "") : null;
+  const accessToken = spec["accessToken"] ?? (typeof spec["credentials"] === "object" && spec["credentials"] !== null ? spec["credentials"]["accessToken"] : void 0);
+  if (typeof bucket !== "string" || bucket.length === 0 || !normalizedPrefix || typeof accessToken !== "string" || accessToken.length === 0) {
+    throw new Error(
+      "artifact upload spec must include bucket, prefix, and accessToken"
+    );
+  }
+  return {
+    bucket,
+    prefix: normalizedPrefix,
+    accessToken,
+    includeIgnored: stringArray(spec["includeIgnored"]),
+    hardDeny: [...DEFAULT_HARD_DENY, ...stringArray(spec["hardDeny"])]
+  };
+}
+async function captureAndUploadArtifacts(input) {
+  const now = input.now ?? Date.now;
+  const uploadObject = input.uploadObject ?? uploadGcsObject;
+  const payloads = await collectArtifactPayloads({
+    projectDir: input.projectDir,
+    includeIgnored: input.spec.includeIgnored,
+    hardDeny: input.spec.hardDeny
+  });
+  const entries = [];
+  for (const [idx, payload] of payloads.entries()) {
+    const id = `${String(idx + 1).padStart(4, "0")}-${safeObjectSegment(
+      payload.kind
+    )}`;
+    const object = joinObjectName(
+      input.spec.prefix,
+      "payloads",
+      `${id}-${safeObjectSegment(payload.path)}`
+    );
+    await uploadObject({
+      bucket: input.spec.bucket,
+      objectName: object,
+      body: payload.bytes,
+      contentType: contentTypeFor(payload.path),
+      accessToken: input.spec.accessToken
+    });
+    entries.push({
+      id,
+      kind: payload.kind,
+      path: payload.path,
+      object,
+      size: payload.bytes.byteLength,
+      sha256: sha256(payload.bytes)
+    });
+  }
+  const manifestObject = joinObjectName(input.spec.prefix, "manifest.json");
+  const manifest = {
+    version: 1,
+    runId: input.runId,
+    athenaSessionId: input.result.athenaSessionId,
+    adapterSessionId: input.result.adapterSessionId,
+    createdAt: new Date(now()).toISOString(),
+    entries,
+    objects: {
+      bucket: input.spec.bucket,
+      prefix: input.spec.prefix,
+      manifest: manifestObject
+    }
+  };
+  await uploadObject({
+    bucket: input.spec.bucket,
+    objectName: manifestObject,
+    body: Buffer.from(`${JSON.stringify(manifest, null, 2)}
+`),
+    contentType: "application/json",
+    accessToken: input.spec.accessToken
+  });
+  return {
+    manifest,
+    feedEvent: makeArtifactManifestFeedEvent({
+      manifest,
+      result: input.result,
+      runId: input.runId,
+      ts: now()
+    })
+  };
+}
+async function collectArtifactPayloads(input) {
+  const hardDeny = input.hardDeny ?? DEFAULT_HARD_DENY;
+  const payloads = [];
+  if (!await isGitWorkspace(input.projectDir)) {
+    return payloads;
+  }
+  const trackedDiff = await gitDiffForAllowedPaths({
+    projectDir: input.projectDir,
+    nameArgs: ["diff", "--name-only", "-z", "--"],
+    diffArgs: ["diff", "--binary", "--"],
+    hardDeny
+  });
+  if (trackedDiff.length > 0) {
+    payloads.push({
+      kind: "tracked_diff",
+      path: "git/tracked.diff",
+      bytes: Buffer.from(trackedDiff)
+    });
+  }
+  const stagedDiff = await gitDiffForAllowedPaths({
+    projectDir: input.projectDir,
+    nameArgs: ["diff", "--name-only", "-z", "--cached", "--"],
+    diffArgs: ["diff", "--binary", "--cached", "--"],
+    hardDeny
+  });
+  if (stagedDiff.length > 0) {
+    payloads.push({
+      kind: "staged_diff",
+      path: "git/staged.diff",
+      bytes: Buffer.from(stagedDiff)
+    });
+  }
+  const upstream = await gitMaybe(input.projectDir, [
+    "rev-parse",
+    "--abbrev-ref",
+    "--symbolic-full-name",
+    "@{u}"
+  ]);
+  if (upstream.trim().length > 0) {
+    const range = `${upstream.trim()}..HEAD`;
+    const commits = await gitDiffForAllowedPaths({
+      projectDir: input.projectDir,
+      nameArgs: ["diff", "--name-only", "-z", range, "--"],
+      diffArgs: ["format-patch", "--stdout", range, "--"],
+      hardDeny
+    });
+    if (commits.length > 0) {
+      payloads.push({
+        kind: "unpushed_commits",
+        path: "git/unpushed.patch",
+        bytes: Buffer.from(commits)
+      });
+    }
+  }
+  const untracked = splitNul(
+    await git(input.projectDir, [
+      "ls-files",
+      "--others",
+      "--exclude-standard",
+      "-z"
+    ])
+  );
+  for (const rel of untracked) {
+    if (!isAllowedRelativePath(rel, hardDeny)) continue;
+    const bytes = await readWorkspaceFile(input.projectDir, rel);
+    if (!bytes) continue;
+    payloads.push({
+      kind: "untracked_file",
+      path: rel,
+      bytes
+    });
+  }
+  for (const rel of input.includeIgnored ?? []) {
+    if (!isAllowedRelativePath(rel, hardDeny)) continue;
+    if (!await isIgnored(input.projectDir, rel)) continue;
+    const bytes = await readWorkspaceFile(input.projectDir, rel);
+    if (!bytes) continue;
+    payloads.push({
+      kind: "included_ignored_file",
+      path: rel,
+      bytes
+    });
+  }
+  return payloads;
+}
+async function readWorkspaceFile(projectDir, rel) {
+  const absolute = path19.resolve(projectDir, rel);
+  const workspaceRoot = await fs21.realpath(projectDir);
+  let stat;
+  try {
+    stat = await fs21.lstat(absolute);
+  } catch {
+    return null;
+  }
+  if (!stat.isFile() || stat.isSymbolicLink()) return null;
+  const real = await fs21.realpath(absolute);
+  const relativeToRoot = path19.relative(workspaceRoot, real);
+  if (relativeToRoot === ".." || relativeToRoot.startsWith(`..${path19.sep}`) || path19.isAbsolute(relativeToRoot)) {
+    return null;
+  }
+  return fs21.readFile(absolute);
+}
+async function gitDiffForAllowedPaths(input) {
+  const paths = splitNul(await git(input.projectDir, input.nameArgs)).filter(
+    (rel) => isAllowedRelativePath(rel, input.hardDeny)
+  );
+  if (paths.length === 0) return "";
+  return git(input.projectDir, [...input.diffArgs, ...paths]);
+}
+async function uploadGcsObject(input) {
+  const url = new URL(
+    `https://storage.googleapis.com/upload/storage/v1/b/${encodeURIComponent(
+      input.bucket
+    )}/o`
+  );
+  url.searchParams.set("uploadType", "media");
+  url.searchParams.set("name", input.objectName);
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${input.accessToken}`,
+      "content-type": input.contentType
+    },
+    body: input.body.buffer.slice(
+      input.body.byteOffset,
+      input.body.byteOffset + input.body.byteLength
+    )
+  });
+  if (!response.ok) {
+    throw new Error(
+      `GCS upload ${input.objectName} failed with HTTP ${response.status}`
+    );
+  }
+}
+function makeArtifactManifestFeedEvent(input) {
+  return {
+    event_id: `${input.runId}:artifacts-manifest`,
+    seq: 0,
+    ts: input.ts,
+    session_id: input.result.athenaSessionId ?? input.runId,
+    run_id: input.runId,
+    kind: "artifacts.manifest",
+    level: "info",
+    actor_id: "system",
+    title: "Artifacts manifest",
+    data: { manifest: input.manifest }
+  };
+}
+async function git(cwd, args) {
+  const result = await execFileAsync("git", args, {
+    cwd,
+    encoding: "buffer",
+    maxBuffer: 50 * 1024 * 1024
+  });
+  return result.stdout.toString("utf8");
+}
+async function gitMaybe(cwd, args) {
+  try {
+    return await git(cwd, args);
+  } catch {
+    return "";
+  }
+}
+async function isGitWorkspace(cwd) {
+  return (await gitMaybe(cwd, ["rev-parse", "--is-inside-work-tree"])).trim() === "true";
+}
+async function isIgnored(cwd, rel) {
+  try {
+    await execFileAsync("git", ["check-ignore", "--quiet", "--", rel], { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function splitNul(value) {
+  return value.split("\0").filter(Boolean);
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+var DEFAULT_HARD_DENY = [
+  ".git",
+  ".git/**",
+  ".env",
+  ".env.*",
+  "**/.env",
+  "**/.env.*",
+  ".ssh",
+  ".ssh/**"
+];
+function isAllowedRelativePath(rel, hardDeny) {
+  if (path19.isAbsolute(rel) || rel.includes("\0")) return false;
+  const normalized = path19.posix.normalize(rel.replaceAll(path19.sep, "/"));
+  if (normalized === ".." || normalized.startsWith("../")) return false;
+  return !hardDeny.some((pattern) => matchesDenyPattern(normalized, pattern));
+}
+function matchesDenyPattern(rel, pattern) {
+  const normalized = pattern.replaceAll(path19.sep, "/");
+  if (normalized.includes("*") || normalized.includes("?")) {
+    return globToRegExp(normalized).test(rel);
+  }
+  if (normalized.endsWith("/**")) {
+    const prefix = normalized.slice(0, -3);
+    return rel === prefix || rel.startsWith(`${prefix}/`);
+  }
+  if (normalized.startsWith("**/")) {
+    const suffix = normalized.slice(3);
+    return rel === suffix || rel.endsWith(`/${suffix}`);
+  }
+  if (normalized.endsWith(".*")) {
+    const prefix = normalized.slice(0, -1);
+    return rel.startsWith(prefix);
+  }
+  return rel === normalized;
+}
+function globToRegExp(pattern) {
+  let source = "^";
+  for (let i = 0; i < pattern.length; i += 1) {
+    const char = pattern[i];
+    const next = pattern[i + 1];
+    if (char === "*") {
+      if (next === "*") {
+        const after = pattern[i + 2];
+        if (after === "/") {
+          source += "(?:.*/)?";
+          i += 2;
+        } else {
+          source += ".*";
+          i += 1;
+        }
+      } else {
+        source += "[^/]*";
+      }
+    } else if (char === "?") {
+      source += "[^/]";
+    } else {
+      source += escapeRegExp(char);
+    }
+  }
+  source += "$";
+  return new RegExp(source);
+}
+function escapeRegExp(value) {
+  return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+function sha256(bytes) {
+  return crypto3.createHash("sha256").update(bytes).digest("hex");
+}
+function joinObjectName(...parts) {
+  return parts.map((part) => part.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
+}
+function safeObjectSegment(value) {
+  const safe = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return safe.length > 0 ? safe.slice(0, 160) : "artifact";
+}
+function contentTypeFor(filePath) {
+  if (filePath.endsWith(".json")) return "application/json";
+  if (filePath.endsWith(".diff") || filePath.endsWith(".patch")) {
+    return "text/x-diff";
+  }
+  return "application/octet-stream";
+}
+
 // src/app/dashboard/remoteRunExecutor.ts
 var DEFAULT_MARKETPLACE_SLUG = "lespaceman/athena-workflow-marketplace";
 function parseRemoteRunSpec(value) {
@@ -12717,6 +13129,8 @@ async function executeRemoteAssignment({
   resolveWorkflowInstallFn = resolveWorkflowInstall,
   installWorkflowFromSourceFn = installWorkflowFromSource,
   readGlobalConfigFn = readGlobalConfig,
+  uploadArtifactObjectFn,
+  dashboardFeedPublisher,
   runStreamConnectTimeoutMs = 5e3
 }) {
   const lastTerminalFailureMessage = { current: null };
@@ -12746,6 +13160,15 @@ async function executeRemoteAssignment({
       send("error", { message: "remote assignment missing prompt" });
       return;
     }
+    let artifactUploadSpec;
+    try {
+      artifactUploadSpec = parseArtifactUploadSpec(frame.runSpec);
+    } catch (err) {
+      send("error", {
+        message: err instanceof Error ? err.message : String(err)
+      });
+      return;
+    }
     let runtimeConfig;
     try {
       const workflowOverride = ensureRemoteWorkflowInstalled({
@@ -12831,7 +13254,22 @@ async function executeRemoteAssignment({
         signal: abortSignal,
         stdout,
         stderr,
-        ...decisionInbox ? { dashboardDecisionInbox: decisionInbox } : {}
+        ...decisionInbox ? { dashboardDecisionInbox: decisionInbox } : {},
+        ...dashboardFeedPublisher ? { dashboardFeedPublisher } : {},
+        ...artifactUploadSpec ? {
+          beforeTerminalCompletion: async ({ result: result2, runId }) => {
+            const artifactRunId = runId ?? frame.runId;
+            const { feedEvent } = await captureAndUploadArtifacts({
+              spec: artifactUploadSpec,
+              projectDir,
+              runId: artifactRunId,
+              result: result2,
+              now,
+              ...uploadArtifactObjectFn ? { uploadObject: uploadArtifactObjectFn } : {}
+            });
+            return [feedEvent];
+          }
+        } : {}
       });
       const failedCompletion = deferredFailedCompletion.current;
       if (failedCompletion) {
@@ -12876,19 +13314,19 @@ async function executeRemoteAssignment({
 }
 
 // src/infra/config/attachmentMirror.ts
-import crypto3 from "crypto";
-import fs21 from "fs";
+import crypto4 from "crypto";
+import fs22 from "fs";
 import os12 from "os";
-import path19 from "path";
+import path20 from "path";
 function attachmentMirrorPath(env = process.env) {
   const home = env["HOME"] ?? os12.homedir();
-  return path19.join(home, ".config", "athena", "attachments.json");
+  return path20.join(home, ".config", "athena", "attachments.json");
 }
 function readAttachmentMirror(env = process.env) {
   const file = attachmentMirrorPath(env);
   let raw;
   try {
-    raw = fs21.readFileSync(file, "utf-8");
+    raw = fs22.readFileSync(file, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
@@ -12912,29 +13350,29 @@ function readAttachmentMirror(env = process.env) {
 function writeAttachmentMirror(mirror, env = process.env) {
   const validated = parseAttachmentMirror(mirror);
   const file = attachmentMirrorPath(env);
-  const dir = path19.dirname(file);
-  fs21.mkdirSync(dir, { recursive: true, mode: 448 });
-  const tmp = `${file}.${process.pid}.${crypto3.randomBytes(4).toString("hex")}.tmp`;
-  const fd = fs21.openSync(tmp, "w", 384);
+  const dir = path20.dirname(file);
+  fs22.mkdirSync(dir, { recursive: true, mode: 448 });
+  const tmp = `${file}.${process.pid}.${crypto4.randomBytes(4).toString("hex")}.tmp`;
+  const fd = fs22.openSync(tmp, "w", 384);
   try {
-    fs21.writeSync(fd, JSON.stringify(validated, null, 2) + "\n");
-    fs21.fsyncSync(fd);
+    fs22.writeSync(fd, JSON.stringify(validated, null, 2) + "\n");
+    fs22.fsyncSync(fd);
   } finally {
-    fs21.closeSync(fd);
+    fs22.closeSync(fd);
   }
   try {
-    fs21.renameSync(tmp, file);
+    fs22.renameSync(tmp, file);
   } catch (err) {
     try {
-      fs21.unlinkSync(tmp);
+      fs22.unlinkSync(tmp);
     } catch {
     }
     throw err;
   }
   if (process.platform !== "win32") {
     try {
-      fs21.chmodSync(dir, 448);
-      fs21.chmodSync(file, 384);
+      fs22.chmodSync(dir, 448);
+      fs22.chmodSync(file, 384);
     } catch {
     }
   }
@@ -12942,7 +13380,7 @@ function writeAttachmentMirror(mirror, env = process.env) {
 function removeAttachmentMirror(env = process.env) {
   const file = attachmentMirrorPath(env);
   try {
-    fs21.unlinkSync(file);
+    fs22.unlinkSync(file);
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
@@ -13208,6 +13646,7 @@ function createDashboardPairedExecution(options) {
   });
   const maxConcurrentRuns = options.maxConcurrentRuns ?? DEFAULT_MAX_CONCURRENT_RUNS;
   const runHistoryLimit = options.runHistoryLimit ?? DEFAULT_RUN_HISTORY_LIMIT;
+  const pairedFeedPublisher = options.pairedFeedPublisher;
   const now = options.now ?? (() => Date.now());
   let completedRuns = 0;
   const active = /* @__PURE__ */ new Map();
@@ -13281,7 +13720,8 @@ function createDashboardPairedExecution(options) {
       projectDir: input.projectDir ?? projectDir,
       log,
       abortSignal: controller.signal,
-      decisionInbox
+      decisionInbox,
+      ...pairedFeedPublisher ? { dashboardFeedPublisher: pairedFeedPublisher } : {}
     }).then(() => {
       if (record.status === "running") record.status = "completed";
     }).catch((err) => {
@@ -13352,9 +13792,9 @@ function createDashboardPairedExecution(options) {
 }
 
 // src/app/dashboard/remoteWorkspaceResolver.ts
-import fs22 from "fs";
+import fs23 from "fs";
 import os13 from "os";
-import path20 from "path";
+import path21 from "path";
 function resolveRemoteWorkspace(frame, options = {}) {
   const spec = parseRemoteRunSpec(frame.runSpec);
   if (!spec) {
@@ -13373,14 +13813,14 @@ function resolveRemoteWorkspace(frame, options = {}) {
   const runnerId = frame.runnerId ?? "legacy";
   const deploymentSlug = deploymentSlugFromUrl(options.dashboardUrl);
   const stateDir = daemonStatePaths(options.env).dir;
-  const projectDir = sessionId ? path20.join(
+  const projectDir = sessionId ? path21.join(
     stateDir,
     "remote-workspaces",
     deploymentSlug,
     sanitizePathSegment(runnerId),
     "sessions",
     sanitizePathSegment(sessionId)
-  ) : path20.join(
+  ) : path21.join(
     stateDir,
     "remote-workspaces",
     deploymentSlug,
@@ -13389,10 +13829,10 @@ function resolveRemoteWorkspace(frame, options = {}) {
     sanitizePathSegment(frame.runId)
   );
   try {
-    fs22.mkdirSync(projectDir, { recursive: true, mode: 448 });
+    fs23.mkdirSync(projectDir, { recursive: true, mode: 448 });
     if (process.platform !== "win32") {
       try {
-        fs22.chmodSync(projectDir, 448);
+        fs23.chmodSync(projectDir, 448);
       } catch {
       }
     }
@@ -13408,8 +13848,8 @@ function resolveRemoteWorkspace(frame, options = {}) {
   return validateProjectDir(projectDir, options.env);
 }
 function validateProjectDir(projectDir, env = process.env) {
-  const resolved = path20.resolve(projectDir);
-  if (!path20.isAbsolute(projectDir)) {
+  const resolved = path21.resolve(projectDir);
+  if (!path21.isAbsolute(projectDir)) {
     return {
       kind: "rejected",
       rejection: {
@@ -13418,7 +13858,7 @@ function validateProjectDir(projectDir, env = process.env) {
       }
     };
   }
-  const home = path20.resolve(env["HOME"] ?? os13.homedir());
+  const home = path21.resolve(env["HOME"] ?? os13.homedir());
   if (resolved === home) {
     return {
       kind: "rejected",
@@ -13430,7 +13870,7 @@ function validateProjectDir(projectDir, env = process.env) {
   }
   let stat;
   try {
-    stat = fs22.statSync(resolved);
+    stat = fs23.statSync(resolved);
   } catch {
     return {
       kind: "rejected",
@@ -13612,6 +14052,7 @@ async function runDashboardRuntimeDaemon(options = {}) {
     executor,
     projectDir,
     decisionInbox,
+    pairedFeedPublisher,
     log,
     maxConcurrentRuns,
     now,
@@ -13855,18 +14296,18 @@ async function runDashboardRuntimeDaemon(options = {}) {
 }
 
 // src/infra/daemon/pidLock.ts
-import fs23 from "fs";
+import fs24 from "fs";
 function acquirePidLock(pidPath) {
   const ownPid = process.pid;
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      const fd = fs23.openSync(pidPath, "wx", 384);
+      const fd = fs24.openSync(pidPath, "wx", 384);
       try {
-        fs23.writeSync(fd, `${ownPid}
+        fs24.writeSync(fd, `${ownPid}
 `);
-        fs23.fsyncSync(fd);
+        fs24.fsyncSync(fd);
       } finally {
-        fs23.closeSync(fd);
+        fs24.closeSync(fd);
       }
       return makeHandle(pidPath, ownPid);
     } catch (err) {
@@ -13880,7 +14321,7 @@ function acquirePidLock(pidPath) {
     }
     if (existing.state === "stale") {
       try {
-        fs23.unlinkSync(pidPath);
+        fs24.unlinkSync(pidPath);
       } catch (err) {
         if (err.code !== "ENOENT") throw err;
       }
@@ -13894,7 +14335,7 @@ function acquirePidLock(pidPath) {
 function readPidLock(pidPath) {
   let raw;
   try {
-    raw = fs23.readFileSync(pidPath, "utf-8");
+    raw = fs24.readFileSync(pidPath, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { state: "absent" };
@@ -13918,9 +14359,9 @@ function makeHandle(pidPath, pid) {
       if (released) return;
       released = true;
       try {
-        const raw = fs23.readFileSync(pidPath, "utf-8").trim();
+        const raw = fs24.readFileSync(pidPath, "utf-8").trim();
         if (raw === String(pid)) {
-          fs23.unlinkSync(pidPath);
+          fs24.unlinkSync(pidPath);
         }
       } catch (err) {
         if (err.code !== "ENOENT") {
@@ -13946,7 +14387,7 @@ function isProcessAlive(pid) {
 }
 
 // src/infra/daemon/udsIpc.ts
-import fs24 from "fs";
+import fs25 from "fs";
 import net2 from "net";
 
 // src/infra/daemon/udsFrameCodec.ts
@@ -13991,7 +14432,7 @@ async function startUdsServer(socketPath, handler, log) {
   });
   if (process.platform !== "win32") {
     try {
-      fs24.chmodSync(socketPath, 384);
+      fs25.chmodSync(socketPath, 384);
     } catch {
     }
   }
@@ -14001,7 +14442,7 @@ async function startUdsServer(socketPath, handler, log) {
         server.close(() => resolve());
       });
       try {
-        fs24.unlinkSync(socketPath);
+        fs25.unlinkSync(socketPath);
       } catch (err) {
         if (err.code !== "ENOENT") {
         }
@@ -14119,7 +14560,7 @@ async function sendUdsRequest(socketPath, request, options = {}) {
 async function unlinkStaleSocket(socketPath) {
   let stat;
   try {
-    stat = fs24.statSync(socketPath);
+    stat = fs25.statSync(socketPath);
   } catch (err) {
     if (err.code === "ENOENT") return;
     throw err;
@@ -14146,7 +14587,7 @@ async function unlinkStaleSocket(socketPath) {
       `uds path ${socketPath} is in use by another process; aborting`
     );
   }
-  fs24.unlinkSync(socketPath);
+  fs25.unlinkSync(socketPath);
 }
 
 export {
@@ -14224,4 +14665,4 @@ export {
   startUdsServer,
   sendUdsRequest
 };
-//# sourceMappingURL=chunk-ZU7M6YZW.js.map
+//# sourceMappingURL=chunk-XIWMD4GT.js.map

package/dist/cli.js

@@ -74,7 +74,7 @@ import {
   writeAttachmentMirror,
   writeGatewayClientConfig,
   wsClientOptionsForEndpoint
-} from "./chunk-ZU7M6YZW.js";
+} from "./chunk-XIWMD4GT.js";
 import {
   generateId as generateId2
 } from "./chunk-BTKQ67RE.js";
@@ -5910,6 +5910,13 @@ var gatewayFunctionCompleted = defaultRenderer(
 var gatewayFunctionFailed = defaultRenderer(
   (event) => `fn ${event.data.reason}: ${event.data.function_name} \u2014 ${event.data.error_message}`
 );
+var artifactsManifest = defaultRenderer(
+  (event) => {
+    const manifest = event.data.manifest;
+    const count = Array.isArray(manifest.entries) ? manifest.entries.length : 0;
+    return `artifacts manifest (${count} item${count === 1 ? "" : "s"})`;
+  }
+);
 var RENDERERS = {
   "session.start": sessionStart,
   "session.end": sessionEnd,
@@ -5968,7 +5975,8 @@ var RENDERERS = {
   "channel.chat.outbound": channelChatOutbound,
   "gateway.function.invoked": gatewayFunctionInvoked,
   "gateway.function.completed": gatewayFunctionCompleted,
-  "gateway.function.failed": gatewayFunctionFailed
+  "gateway.function.failed": gatewayFunctionFailed,
+  "artifacts.manifest": artifactsManifest
 };
 function rendererFor(event) {
   return RENDERERS[event.kind];
@@ -6814,6 +6822,7 @@ function resolveEventToolColumn(event) {
     case "gateway.function.invoked":
     case "gateway.function.completed":
     case "gateway.function.failed":
+    case "artifacts.manifest":
       return "";
   }
 }
@@ -8548,7 +8557,8 @@ function renderDetailLines(event, width, pairedPostEvent, theme = darkTheme) {
     case "channel.chat.outbound":
     case "gateway.function.invoked":
     case "gateway.function.completed":
-    case "gateway.function.failed": {
+    case "gateway.function.failed":
+    case "artifacts.manifest": {
       const header = buildCompactHeader(event, width, { theme });
       const json = JSON.stringify(event.raw ?? event.data, null, 2);
       const content = highlightCode(json, cw, "json");
@@ -15695,7 +15705,7 @@ var cachedVersion = null;
 function readPackageVersion() {
   if (cachedVersion !== null) return cachedVersion;
   try {
-    const injected = "0.5.6";
+    const injected = "0.5.8";
     if (typeof injected === "string" && injected.length > 0) {
       cachedVersion = injected;
       return cachedVersion;

package/dist/dashboard-daemon.js

@@ -3,7 +3,7 @@ import {
   ensureDaemonStateDir,
   runDashboardRuntimeDaemon,
   startUdsServer
-} from "./chunk-ZU7M6YZW.js";
+} from "./chunk-XIWMD4GT.js";
 import "./chunk-BTKQ67RE.js";
 import {
   readDashboardClientConfig,

package/package.json

@@ -17,7 +17,7 @@
 		"hooks",
 		"dashboard"
 	],
-	"version": "0.5.6",
+	"version": "0.5.8",
 	"license": "MIT",
 	"bin": {
 		"athena": "dist/cli.js",