@akagilnc/pi-workflow-roles 0.1.1883 → 0.1.1918

package/dist/reviewer-child-executor.js

@@ -6,7 +6,7 @@ import { executeEvidenceChild } from "./evidence-child-executor.js";
 export function projectSharedChildFailure(error) {
     if (typeof error === "object" && error !== null && "evidenceChildFailure" in error) {
         const classification = error.evidenceChildFailure;
-        if (classification === "provider" || classification === "child") {
+        if (classification === "provider" || classification === "child" || classification === "unknown") {
             Object.assign(error, { reviewerFailure: classification });
         }
     }

package/dist/typed-provider-http.js

@@ -0,0 +1,60 @@
+import { readFile, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const TYPED_HTTP_FILE = "typed-provider-http.json";
+function typedProviderHttpPath(runDirectory) {
+  return join(runDirectory, TYPED_HTTP_FILE);
+}
+async function clearTypedProviderHttpObservation(runDirectory) {
+  try {
+    await unlink(typedProviderHttpPath(runDirectory));
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+}
+async function recordTypedProviderHttpStatus(runDirectory, observation) {
+  if (observation.httpStatus >= 200 && observation.httpStatus < 300) {
+    await clearTypedProviderHttpObservation(runDirectory);
+    return;
+  }
+  const body = {
+    httpStatus: observation.httpStatus,
+    provider: observation.provider
+  };
+  await writeFile(
+    typedProviderHttpPath(runDirectory),
+    `${JSON.stringify(body)}
+`,
+    "utf8"
+  );
+}
+async function readLatestTypedProviderHttpObservation(runDirectory) {
+  let text;
+  try {
+    text = await readFile(typedProviderHttpPath(runDirectory), "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+  const raw = JSON.parse(text);
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("typed provider HTTP observation must be a JSON object");
+  }
+  const record = raw;
+  if (typeof record.httpStatus !== "number") {
+    throw new Error("typed provider HTTP observation missing numeric httpStatus");
+  }
+  if (typeof record.provider !== "string" || record.provider.trim() === "") {
+    throw new Error("typed provider HTTP observation missing non-empty provider");
+  }
+  return { httpStatus: record.httpStatus, provider: record.provider };
+}
+export {
+  clearTypedProviderHttpObservation,
+  readLatestTypedProviderHttpObservation,
+  recordTypedProviderHttpStatus
+};

package/dist/upstream-error-testimony.js

@@ -0,0 +1,19 @@
+function isNonSuccessHttpStatus(status) {
+  return typeof status === "number" && (status < 200 || status >= 300);
+}
+function hasUpstreamErrorTestimony(input) {
+  if (isNonSuccessHttpStatus(input.httpStatus)) return true;
+  return Array.isArray(input.diagnostics) && input.diagnostics.length > 0;
+}
+function projectConfirmedRemotePayload(input) {
+  return {
+    ...input.body === void 0 ? {} : { body: input.body },
+    ...input.code === void 0 ? {} : { code: input.code },
+    ...input.errno === void 0 ? {} : { errno: input.errno }
+  };
+}
+export {
+  hasUpstreamErrorTestimony,
+  isNonSuccessHttpStatus,
+  projectConfirmedRemotePayload
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akagilnc/pi-workflow-roles",
-  "version": "0.1.1883",
+  "version": "0.1.1918",
   "description": "Soul-bound workflow roles for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/scripts/build-package.mjs

@@ -14,6 +14,8 @@ const entries = [
   "activation-reconciliation",
   "sitian-role-run-coordinates",
   "sitian-record-entry",
+  "typed-provider-http",
+  "upstream-error-testimony",
 ];
 
 /**

package/src/evidence-child-executor.ts

@@ -33,6 +33,11 @@ import { wrapPackageOwnedToolDefinition } from "./package-owned-tool-idle.ts";
 import type { ReviewerPromptText } from "./reviewer-prompt-identity.ts";
 import { createStreamIdleGuard, isStreamIdleTimeoutError } from "./stream-idle-guard.ts";
 import { createReceiptDeliveryPolicy, NO_RECEIPT_LIFECYCLE_ENTRY_TYPE, RECEIPT_DELIVERY_PROMPT, type NoReceiptLifecycleFacts } from "./receipt-delivery-policy.ts";
+import {
+  hasUpstreamErrorTestimony,
+  isNonSuccessHttpStatus,
+  projectConfirmedRemotePayload,
+} from "./upstream-error-testimony.ts";
 
 // ── shared constants / types ──────────────────────────────────────────────
 
@@ -186,15 +191,25 @@ export async function createInheritedRuntime(options: InheritedRuntimeOptions):
         const idle = createStreamIdleGuard(
           options.signal === undefined ? {} : { parentSignal: options.signal },
         );
+        // Typed HTTP status observed via onResponse — never inferred from prose.
+        let observedHttpStatus: number | undefined;
         try {
           const requestSignal = request?.signal;
           const streamSignal = requestSignal === undefined
             ? idle.signal
             : AbortSignal.any([idle.signal, requestSignal]);
+          const priorOnResponse = request?.onResponse;
           const inheritedRequest = {
             ...(request ?? {}),
             ...(dispatch.auth.env === undefined ? {} : { env: dispatch.auth.env }),
             signal: streamSignal,
+            onResponse: async (
+              response: { status: number; headers: Record<string, string> },
+              model: Model<Api>,
+            ) => {
+              if (typeof response?.status === "number") observedHttpStatus = response.status;
+              await priorOnResponse?.(response, model);
+            },
           } as ProviderStreamOptions;
           if (options.runCompletion !== undefined) {
             await new Promise<void>((resolve) => setImmediate(resolve));
@@ -209,12 +224,12 @@ export async function createInheritedRuntime(options: InheritedRuntimeOptions):
               ),
               streamSignal,
             );
-            const response: AssistantMessage = {
+            const response: AssistantMessage = attachObservedHttpStatus({
               ...completed,
               api: model.api,
               provider: model.provider,
               model: model.id,
-            };
+            }, observedHttpStatus);
             if (response.stopReason === "error" || response.stopReason === "aborted") {
               wrapped.push({ type: "error", reason: response.stopReason, error: response });
             } else {
@@ -232,9 +247,12 @@ export async function createInheritedRuntime(options: InheritedRuntimeOptions):
             if (next.done) break;
             sawEvent = true;
             idle.poke();
-            wrapped.push(next.value as any);
+            wrapped.push(enrichStreamEvent(next.value, observedHttpStatus) as any);
           }
-          const response = await waitForStream(source.result(), idle.signal);
+          const response = attachObservedHttpStatus(
+            await waitForStream(source.result(), idle.signal),
+            observedHttpStatus,
+          );
           if (!sawEvent) wrapped.end(response);
           return;
         } catch (error) {
@@ -264,17 +282,26 @@ export async function createInheritedRuntime(options: InheritedRuntimeOptions):
             continue;
           }
           state.streamFailure = failure;
-          const response: AssistantMessage = {
-            role: "assistant",
-            content: [],
+          const projected = projectStructuredRemote(failure);
+          // Prefer structured fields on the thrown failure; fall back to onResponse observation.
+          const httpStatus = projected.httpStatus ?? numericHttpStatus(observedHttpStatus);
+          const response = {
+            role: "assistant" as const,
+            content: [] as [],
             api: model.api,
             provider: model.provider,
             model: model.id,
             usage: emptyUsage(),
-            stopReason: "error",
+            stopReason: "error" as const,
+            // Preserve the held failure message bytes — do not rewrite.
             errorMessage: failure instanceof Error ? failure.message : String(failure),
             timestamp: Date.now(),
-          };
+            ...(projected.diagnostics === undefined ? {} : { diagnostics: projected.diagnostics }),
+            ...(httpStatus === undefined ? {} : { status: httpStatus, statusCode: httpStatus }),
+            ...(projected.body === undefined ? {} : { body: projected.body }),
+            ...(projected.code === undefined ? {} : { code: projected.code }),
+            ...(projected.errno === undefined ? {} : { errno: projected.errno }),
+          } as unknown as AssistantMessage;
           wrapped.push({ type: "error", reason: "error", error: response });
           wrapped.end(response);
           return;
@@ -346,11 +373,114 @@ export async function createInheritedRuntime(options: InheritedRuntimeOptions):
   return state;
 }
 
+type EvidenceChildFailureClassification = "provider" | "child" | "unknown";
 type ClassifiedReviewerError = Error & Readonly<{
-  evidenceChildFailure: "provider" | "child";
+  evidenceChildFailure: EvidenceChildFailureClassification;
   evidenceChildOriginal?: unknown;
 }>;
-function classifiedError(error: unknown, evidenceChildFailure: "provider" | "child"): ClassifiedReviewerError {
+function numericHttpStatus(value: unknown): number | undefined {
+  return isNonSuccessHttpStatus(value) ? value : undefined;
+}
+
+type StructuredRemoteProjection = {
+  readonly hasTestimony: boolean;
+  readonly httpStatus?: number;
+  readonly diagnostics?: unknown;
+  readonly body?: unknown;
+  readonly code?: unknown;
+  readonly errno?: unknown;
+};
+
+/**
+ * Cause-chain reader over the shared upstream-testimony authority.
+ * Shape walking stays here; testimony + confirmed-remote payload rules are shared.
+ */
+function projectStructuredRemote(error: unknown): StructuredRemoteProjection {
+  let httpStatus: number | undefined;
+  let diagnostics: unknown;
+  let body: unknown;
+  let code: unknown;
+  let errno: unknown;
+  let cursor: unknown = error;
+  const seen = new Set<unknown>();
+  while (typeof cursor === "object" && cursor !== null && !seen.has(cursor)) {
+    seen.add(cursor);
+    const record = cursor as Record<string, unknown>;
+    const nodeStatus = numericHttpStatus(record.statusCode)
+      ?? numericHttpStatus(record.status)
+      ?? numericHttpStatus(record.httpStatus);
+    const nodeDiagnostics = Array.isArray(record.diagnostics) && record.diagnostics.length > 0
+      ? record.diagnostics
+      : undefined;
+    const nodeHasTestimony = hasUpstreamErrorTestimony({
+      ...(nodeStatus === undefined ? {} : { httpStatus: nodeStatus }),
+      ...(nodeDiagnostics === undefined ? {} : { diagnostics: nodeDiagnostics }),
+    });
+    if (httpStatus === undefined && nodeStatus !== undefined) httpStatus = nodeStatus;
+    if (diagnostics === undefined && nodeDiagnostics !== undefined) diagnostics = nodeDiagnostics;
+    // Payload only from confirmed-remote nodes — never arbitrary local Error.code.
+    if (nodeHasTestimony) {
+      const payload = projectConfirmedRemotePayload(record);
+      if (body === undefined && payload.body !== undefined) body = payload.body;
+      if (code === undefined && payload.code !== undefined) code = payload.code;
+      if (errno === undefined && payload.errno !== undefined) errno = payload.errno;
+    }
+    cursor = record.cause;
+  }
+  return {
+    hasTestimony: hasUpstreamErrorTestimony({
+      ...(httpStatus === undefined ? {} : { httpStatus }),
+      ...(diagnostics === undefined ? {} : { diagnostics }),
+    }),
+    ...(httpStatus === undefined ? {} : { httpStatus }),
+    ...(diagnostics === undefined ? {} : { diagnostics }),
+    ...(body === undefined ? {} : { body }),
+    ...(code === undefined ? {} : { code }),
+    ...(errno === undefined ? {} : { errno }),
+  };
+}
+
+/**
+ * Attach a directly observed HTTP status onto an error/aborted assistant message.
+ * Does not invent status from errorMessage prose; skips when already held.
+ */
+function attachObservedHttpStatus<T extends AssistantMessage>(
+  message: T,
+  observedHttpStatus: number | undefined,
+): T {
+  if (observedHttpStatus === undefined) return message;
+  if (message.stopReason !== "error" && message.stopReason !== "aborted") return message;
+  if (numericHttpStatus(observedHttpStatus) === undefined) return message;
+  if (projectStructuredRemote(message).httpStatus !== undefined) return message;
+  return Object.assign(message, {
+    status: observedHttpStatus,
+    statusCode: observedHttpStatus,
+  });
+}
+function enrichStreamEvent(event: unknown, observedHttpStatus: number | undefined): unknown {
+  if (observedHttpStatus === undefined || event === null || typeof event !== "object") return event;
+  const record = event as Record<string, unknown>;
+  if (record.type === "error" && record.error !== null && typeof record.error === "object") {
+    return {
+      ...record,
+      error: attachObservedHttpStatus(record.error as AssistantMessage, observedHttpStatus),
+    };
+  }
+  if (record.type === "done" && record.message !== null && typeof record.message === "object") {
+    return {
+      ...record,
+      message: attachObservedHttpStatus(record.message as AssistantMessage, observedHttpStatus),
+    };
+  }
+  if (record.partial !== null && typeof record.partial === "object") {
+    return {
+      ...record,
+      partial: attachObservedHttpStatus(record.partial as AssistantMessage, observedHttpStatus),
+    };
+  }
+  return event;
+}
+function classifiedError(error: unknown, evidenceChildFailure: EvidenceChildFailureClassification): ClassifiedReviewerError {
   const diagnostic = typeof error === "object" && error !== null && typeof (error as { errorMessage?: unknown }).errorMessage === "string"
     ? (error as { errorMessage: string }).errorMessage
     : error === undefined ? "" : String(error);
@@ -359,7 +489,9 @@ function classifiedError(error: unknown, evidenceChildFailure: "provider" | "chi
     : Object.assign(new Error(diagnostic, { cause: error }), { evidenceChildOriginal: error });
   const classification = "evidenceChildFailure" in wrapped
     ? (wrapped as ClassifiedReviewerError).evidenceChildFailure
-    : evidenceChildFailure;
+    : evidenceChildFailure === "provider" && !projectStructuredRemote(error).hasTestimony
+      ? "unknown"
+      : evidenceChildFailure;
   return Object.assign(wrapped, { evidenceChildFailure: classification });
 }
 
@@ -461,13 +593,19 @@ export async function executeEvidenceChild(
         const lastAssistant = [...session.messages]
           .reverse()
           .find((message) => message.role === "assistant");
-        if (lastAssistant?.role === "assistant" && lastAssistant.stopReason === "error") {
+        // error|aborted assistant stops share the upstream-testimony rule: provider only
+        // with direct HTTP/SDK testimony, otherwise existing unknown. child is reserved
+        // for real local child/report failures (no assistant / blank report / cleanup).
+        if (
+          lastAssistant?.role === "assistant"
+          && (lastAssistant.stopReason === "error" || lastAssistant.stopReason === "aborted")
+        ) {
           throw classifiedError(
             new Error(lastAssistant.errorMessage ?? "", { cause: lastAssistant }),
-            "provider",
+            projectStructuredRemote(lastAssistant).hasTestimony ? "provider" : "unknown",
           );
         }
-        if (lastAssistant?.role !== "assistant" || lastAssistant.stopReason === "aborted") {
+        if (lastAssistant?.role !== "assistant") {
           throw classifiedError(
             new Error("Evidence child child terminated without a report", {
               cause: lastAssistant ?? session.messages,
@@ -820,22 +958,37 @@ export async function executeAuditorChild(
           else if (retentionFailure !== undefined) throw retentionFailure;
         } catch (retentionFailure) {
           if (response.stopReason !== "error") throw retentionFailure;
+          // Do not trim/rewrite the held errorMessage bytes.
+          const diagnostic = typeof response.errorMessage === "string" && response.errorMessage.trim() !== ""
+            ? response.errorMessage
+            : undefined;
+          const projected = projectStructuredRemote(response);
           const failure = new Error(
-            response.errorMessage?.trim() || "provider failure",
+            diagnostic ?? "",
             { cause: retentionFailure },
           ) as Error & {
-            knownCause: "provider";
+            knownCause: "provider" | "unrecognized";
             failureCode?: string;
             details: Record<string, unknown>;
           };
-          failure.name = response.model || response.provider || "Error";
-          failure.knownCause = "provider";
-          failure.failureCode = response.provider || response.model;
+          if (projected.hasTestimony && (response.model || response.provider)) {
+            failure.name = response.model || response.provider || "Error";
+            failure.failureCode = response.provider || response.model;
+          }
+          failure.knownCause = projected.hasTestimony ? "provider" : "unrecognized";
           const retentionError = retentionFailure instanceof Error ? retentionFailure : undefined;
           const retentionCause = retentionError?.cause;
           failure.details = {
-            ...(response.provider ? { provider: response.provider } : {}),
-            ...(response.model ? { model: response.model } : {}),
+            ...(diagnostic === undefined ? {} : { errorMessage: diagnostic }),
+            ...(projected.hasTestimony && response.provider ? { provider: response.provider } : {}),
+            ...(projected.hasTestimony && response.model ? { model: response.model } : {}),
+            ...(response.api ? { api: response.api } : {}),
+            ...(response.rawStopReason ? { rawStopReason: response.rawStopReason } : {}),
+            ...(projected.httpStatus === undefined ? {} : { httpStatus: projected.httpStatus }),
+            ...(projected.diagnostics === undefined ? {} : { diagnostics: projected.diagnostics }),
+            ...(projected.body === undefined ? {} : { body: projected.body }),
+            ...(projected.code === undefined ? {} : { code: projected.code }),
+            ...(projected.errno === undefined ? {} : { errno: projected.errno }),
             retentionFailure: {
               name: retentionError?.name ?? typeof retentionFailure,
               message: retentionError?.message ?? String(retentionFailure),
@@ -862,8 +1015,8 @@ export async function executeAuditorChild(
             parent: binding.parent,
             failure: {
               cause: failure.knownCause,
-              identity: { name: failure.name, code: failure.failureCode },
-              diagnostic: failure.message,
+              ...(failure.failureCode === undefined ? {} : { identity: { name: failure.name, code: failure.failureCode } }),
+              ...(failure.message === "" ? {} : { diagnostic: failure.message }),
               details: failure.details,
             },
           });

package/src/factory-board.ts

@@ -28,14 +28,19 @@ import {
 } from "./human-format.ts";
 import {
   DEFAULT_REFRESH_BOUNDARY_SECONDS,
+  buildTicketTrajectoryBookIndex,
   loadTicketTrajectoryRuns,
+  loadUnboundTrajectoryRuns,
   renderTicketTrajectoryStationHtml,
+  type TicketTrajectoryBookIndex,
   type TicketTrajectoryRun,
   type TrajectoryClock,
   type TrajectoryScheduler,
+  type UnboundTrajectoryRun,
 } from "./ticket-trajectory.ts";
 import type { BoardSnapshot, SnapshotTicket, TicketIssueState } from "./ticket-snapshot.ts";
 
+
 /** Unaccepted latest-run mtime bands (page-visible thresholds). */
 export const UNACCEPTED_FLYING_MS = 2 * 60 * 1000;
 export const UNACCEPTED_WATCH_MS = 15 * 60 * 1000;
@@ -403,6 +408,40 @@ function latestKnownStation(runs: readonly TicketTrajectoryRun[]): string | unde
   return latest.station;
 }
 
+/**
+ * Unbound activation card for the existing unknown-set presentation seam.
+ * Not a ticket: no issue number, never placed in a yamen column.
+ */
+function renderUnboundRunCard(input: {
+  bookKey: string;
+  unbound: UnboundTrajectoryRun;
+}): string {
+  const { run, role, observedAt } = input.unbound;
+  const correlationId = input.unbound.correlationId;
+  const stationLabel =
+    run.station === "unknown" ? "未知站" : (YAMEN_LABELS[run.station] ?? run.station);
+  const corrAttr = correlationId === undefined ? "" : ` data-correlation="${attr(correlationId)}"`;
+  const corrMeta =
+    correlationId === undefined ? "" : ` · corr ${escapeHtml(correlationId)}`;
+  return [
+    `<article class="ticket unbound-run"`,
+    ` data-unbound-run="true"`,
+    ` data-book="${attr(input.bookKey)}"`,
+    ` data-run-id="${attr(run.runId)}"`,
+    corrAttr,
+    ` data-placement="unknown"`,
+    `>`,
+    `<header class="ticket-header">`,
+    `<span class="ticket-title">未绑定 · ${escapeHtml(run.runId)}</span>`,
+    `<span class="yamen-tag yamen-unknown" data-yamen="unknown">${escapeHtml(stationLabel)}</span>`,
+    `</header>`,
+    `<p class="unbound-meta" data-unbound-meta="true">`,
+    `role ${escapeHtml(role)}${corrMeta} · ${escapeHtml(observedAt)}`,
+    `</p>`,
+    `</article>`,
+  ].join("");
+}
+
 function renderTicketArticle(input: {
   bookKey: string;
   prepared: PreparedTicket;
@@ -681,8 +720,9 @@ async function prepareTicket(
   ledgerDir: string,
   ticket: SnapshotTicket,
   now: Date,
+  bookIndex?: TicketTrajectoryBookIndex,
 ): Promise<PreparedTicket> {
-  const runs = await loadTicketTrajectoryRuns(ledgerDir, ticket.issueNumber);
+  const runs = await loadTicketTrajectoryRuns(ledgerDir, ticket.issueNumber, bookIndex);
   const pending = ticket.state !== "closed" && runs.length === 0;
   const currentState = decideTicketCurrentState({
     ticketState: ticket.state,
@@ -862,9 +902,11 @@ async function renderLaneHtml(
   now: Date,
   options?: { hidden?: boolean },
 ): Promise<RenderedLane> {
+  // One book-level flat-run index shared by every ticket in this lane.
+  const bookIndex = await buildTicketTrajectoryBookIndex(ledgerDir);
   const prepared = new Map<number, PreparedTicket>();
   for (const ticket of tickets) {
-    prepared.set(ticket.issueNumber, await prepareTicket(ledgerDir, ticket, now));
+    prepared.set(ticket.issueNumber, await prepareTicket(ledgerDir, ticket, now, bookIndex));
   }
 
   const childrenByParent = buildDirectChildrenByParent(prepared);
@@ -980,6 +1022,20 @@ async function renderLaneHtml(
     list.push(entry);
     byPlacement.set(entry.placement, list);
   }
+
+  // Unbound flat runs: isolated from every ticket, honest on the unknown seam.
+  const unboundRuns = await loadUnboundTrajectoryRuns(ledgerDir, bookIndex);
+  for (const unbound of unboundRuns) {
+    unknownEntries.push({
+      placement: "unknown",
+      band: 0,
+      activityMs: unbound.run.mtimeMs,
+      // Sort after real tickets; no issue identity (unbound is not a ticket).
+      issueNumber: Number.MAX_SAFE_INTEGER,
+      html: renderUnboundRunCard({ bookKey, unbound }),
+    });
+  }
+
   unknownEntries.sort(entryCompare);
   unknownTickets.sort((a, b) => a.issueNumber - b.issueNumber);
 
@@ -1469,7 +1525,8 @@ export async function renderFactoryBoardHtml(
         generatedAt,
       );
     }
-    const lane = await renderLaneHtml(
+    let lane: RenderedLane;
+    lane = await renderLaneHtml(
       book.bookKey,
       resolve(book.ledgerDir),
       bookSnap.tickets,