@mmerterden/multi-agent-pipeline 20.11.0 → 20.12.0

package/pipeline/scripts/usage-report.mjs

@@ -27,7 +27,15 @@
  * @module pipeline/scripts/usage-report
  */
 
-import { readFileSync, existsSync, readdirSync, appendFileSync } from "fs";
+import {
+  readFileSync,
+  existsSync,
+  readdirSync,
+  appendFileSync,
+  mkdirSync,
+  renameSync,
+  writeFileSync,
+} from "fs";
 import { canonicalEndpoint } from "../lib/usage-endpoint.mjs";
 import { homedir, platform } from "os";
 import { dirname, join } from "path";
@@ -709,27 +717,78 @@ function buildEvent(state, { event = null, login = null } = {}) {
   };
 }
 
+function hostOf(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The outcome of one POST. A redirect is never followed, because the ingest
+ * token would ride along to wherever it points; its target host is reported
+ * instead, so a moved endpoint is visible rather than silent.
+ */
 async function post(endpoint, token, event) {
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), TIMEOUT_MS);
   try {
-    await fetch(endpoint, {
+    const res = await fetch(endpoint, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         "X-Usage-Token": token,
       },
       body: JSON.stringify(event),
-      redirect: "error",
+      redirect: "manual",
       signal: ctrl.signal,
     });
-  } catch {
-    /* never break the run on a telemetry failure */
+    if (res.status >= 300 && res.status < 400) {
+      return {
+        outcome: "redirected",
+        status: res.status,
+        location: hostOf(res.headers.get("location") || ""),
+      };
+    }
+    if (!res.ok) return { outcome: "rejected", status: res.status };
+    let body = null;
+    try {
+      body = await res.json();
+    } catch {
+      /* a 2xx without a JSON body is still a delivery */
+    }
+    return { outcome: body?.accepted === false ? "not-accepted" : "accepted", status: res.status };
+  } catch (err) {
+    const reason = ctrl.signal.aborted ? "timeout" : (err?.cause?.code ?? err?.name ?? "error");
+    return { outcome: "failed", reason: codeOf(String(reason), 40) };
   } finally {
     clearTimeout(timer);
   }
 }
 
+export const LAST_SEND_FILE = "usage-last-send.json";
+
+/**
+ * Overwrites the record of the most recent send attempt. The emitter runs
+ * detached with its output discarded, so this file is the only place a broken
+ * reporting path shows up; doctor reads it. It carries no token and no path.
+ */
+function recordSend(entry) {
+  const dir = join(homedir(), ".claude", "logs", "multi-agent");
+  const target = join(dir, LAST_SEND_FILE);
+  const tmp = `${target}.${process.pid}.tmp`;
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(tmp, JSON.stringify({ t: new Date().toISOString(), ...entry }) + "\n", {
+      mode: 0o600,
+    });
+    renameSync(tmp, target);
+  } catch {
+    /* logs dir unwritable - never break the run */
+  }
+}
+
 // The write-only ingest token rides in a header; sending it over http would
 // leak it in cleartext, contradicting the setup contract ("transmitted only
 // over TLS"). Accept https anywhere, and http ONLY for loopback (local dev).
@@ -759,10 +818,16 @@ async function main() {
   if (!args.dryRun) {
     if (prefs.optOut === true) return;
     if (prefs.enabled !== true) return;
-    if (!endpointAllowed(endpoint)) return;
+    if (!endpointAllowed(endpoint)) {
+      recordSend({ id: args.taskId, outcome: "skipped", reason: "endpoint-not-allowed" });
+      return;
+    }
   }
   const token = args.dryRun ? "" : resolveToken();
-  if (!args.dryRun && !token) return;
+  if (!args.dryRun && !token) {
+    recordSend({ id: args.taskId, outcome: "skipped", reason: "no-token" });
+    return;
+  }
 
   const statePath = resolveStatePath(args);
   let state = statePath ? readJson(statePath) : null;
@@ -782,7 +847,10 @@ async function main() {
   const who = resolveReportingLogin();
   if (!who.login) {
     process.stderr.write(`usage-report: not sent - ${who.reason}\n`);
-    if (!args.dryRun) return;
+    if (!args.dryRun) {
+      recordSend({ id: runId(state), ev: kind, outcome: "skipped", reason: "no-login" });
+      return;
+    }
   }
 
   const event = buildEvent(state, { event: kind, login: who.login });
@@ -793,7 +861,14 @@ async function main() {
   }
 
   if (event.st !== "in_progress") appendErrorLedger(event);
-  await post(endpoint, token, event);
+  const result = await post(endpoint, token, event);
+  recordSend({ id: event.id, ev: event.ev, host: hostOf(endpoint), ...result });
+  if (result.outcome !== "accepted") {
+    const detail = result.status ?? result.reason;
+    const where = result.location ? ` to ${result.location}` : "";
+    const verb = result.outcome === "not-accepted" ? "not accepted" : result.outcome;
+    process.stderr.write(`usage-report: ${verb}${where} (${detail}) by ${hostOf(endpoint)}\n`);
+  }
 }
 
 // Entry-point check: compare file URLs, never string-split a path.

package/pipeline/skills/.skill-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": "1.0.0",
-  "generatedAt": "2026-09-29T06:46:22Z",
+  "generatedAt": "2026-09-29T13:31:43Z",
   "skillCount": 218,
   "entries": [
     {
@@ -701,7 +701,7 @@
     },
     {
       "path": "shared/external/swift-architecture/SKILL.md",
-      "sha256": "36566e7a79f2e6c760cc31fb1ee1a635c0e32988357c20af3502a03ecb371753"
+      "sha256": "295f6ce1488a93f64e5e78228b90863924fe21911769307844cc73f621c04ab1"
     },
     {
       "path": "shared/external/swift-charts/SKILL.md",

package/pipeline/skills/shared/external/swift-architecture/SKILL.md

@@ -13,6 +13,10 @@ SwiftUI with Observation (iOS 17 or later) unless a UIKit type appears.
 
 ## Scope boundary
 
+The samples here pass dependencies through initializers. In a repo that resolves
+dependencies from a keyed container, `reference/architecture/dependency-injection.md`
+takes precedence over initializer injection in every sample in this skill.
+
 This skill decides:
 
 - which pattern a feature uses,