chainlesschain 0.166.38 → 0.166.39

package/src/lib/evolution/governed-skill-synthesis-windows-secure-pipe-host.js

@@ -0,0 +1,236 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const READY_SCHEMA = "chainlesschain.windows-secure-pipe-broker-ready/v1";
+const REQUEST_SCHEMA = "chainlesschain.windows-secure-pipe-broker-request/v1";
+const RESPONSE_SCHEMA = "chainlesschain.windows-secure-pipe-broker-response/v1";
+const SECURITY_KEYS = new Set([
+  "acl",
+  "aclDigest",
+  "peerIdentity",
+  "principalDigest",
+  "remoteClients",
+]);
+const PIPE_PREFIX = "\\\\.\\pipe\\";
+const PIPE_NAME =
+  /^cc-evolution-attestor-trust-(?:approval|ops)-[a-f0-9]{16,64}$/u;
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+
+function exact(value, keys) {
+  return (
+    value &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    Object.getPrototypeOf(value) === Object.prototype &&
+    Reflect.ownKeys(value).length === keys.size &&
+    Reflect.ownKeys(value).every(
+      (key) => typeof key === "string" && keys.has(key),
+    )
+  );
+}
+
+function normalizeSecurity(value) {
+  if (
+    !exact(value, SECURITY_KEYS) ||
+    value.acl !== "protected-current-logon-dacl" ||
+    value.peerIdentity !== "client-process-token-user-and-logon-sid" ||
+    value.remoteClients !== false ||
+    !DIGEST.test(value.aclDigest ?? "") ||
+    !DIGEST.test(value.principalDigest ?? "")
+  ) {
+    throw new Error(
+      "Windows secure pipe broker security descriptor is invalid",
+    );
+  }
+  return Object.freeze({ ...value });
+}
+
+function powershellPath() {
+  const windowsRoot = process.env.SystemRoot || process.env.WINDIR;
+  if (typeof windowsRoot !== "string" || windowsRoot.length < 3) {
+    throw new Error("Windows secure pipe broker cannot locate PowerShell");
+  }
+  return path.join(
+    windowsRoot,
+    "System32",
+    "WindowsPowerShell",
+    "v1.0",
+    "powershell.exe",
+  );
+}
+
+export async function createGovernedSkillSynthesisWindowsSecurePipeHost({
+  endpoint,
+  maxFrameBytes,
+  onRequest,
+}) {
+  if (process.platform !== "win32") {
+    throw new Error("Windows secure pipe host is only available on Windows");
+  }
+  const pipeName = endpoint.startsWith(PIPE_PREFIX)
+    ? endpoint.slice(PIPE_PREFIX.length)
+    : "";
+  if (
+    !PIPE_NAME.test(pipeName) ||
+    !Number.isSafeInteger(maxFrameBytes) ||
+    maxFrameBytes < 1024 ||
+    maxFrameBytes > 1024 * 1024 ||
+    typeof onRequest !== "function"
+  ) {
+    throw new TypeError("Windows secure pipe host configuration is invalid");
+  }
+
+  const scriptPath = fileURLToPath(
+    new URL(
+      "../../../scripts/governed-learning-windows-secure-pipe-broker.ps1",
+      import.meta.url,
+    ),
+  );
+  const child = spawn(
+    powershellPath(),
+    [
+      "-NoLogo",
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      scriptPath,
+      "-PipeName",
+      pipeName,
+      "-MaxFrameBytes",
+      String(maxFrameBytes),
+    ],
+    {
+      windowsHide: true,
+      stdio: ["pipe", "pipe", "pipe"],
+    },
+  );
+  child.stdin.setDefaultEncoding("utf8");
+  let stderr = "";
+  child.stderr.on("data", (chunk) => {
+    if (stderr.length < 32 * 1024) stderr += chunk.toString("utf8");
+  });
+
+  let ready = false;
+  let settled = false;
+  let resolveReady;
+  let rejectReady;
+  const readyPromise = new Promise((resolve, reject) => {
+    resolveReady = resolve;
+    rejectReady = reject;
+  });
+  const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
+
+  const failReady = (error) => {
+    if (settled) return;
+    settled = true;
+    rejectReady(error);
+  };
+  child.once("error", failReady);
+  child.once("exit", (code, signal) => {
+    if (!ready) {
+      failReady(
+        new Error(
+          `Windows secure pipe broker exited before ready (${code ?? signal ?? "unknown"}): ${stderr.trim()}`,
+        ),
+      );
+    }
+  });
+  lines.on("line", async (line) => {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      failReady(new Error("Windows secure pipe broker returned invalid JSON"));
+      child.kill();
+      return;
+    }
+    if (!ready) {
+      try {
+        if (
+          !exact(message, new Set(["ok", "schema", "security"])) ||
+          message.schema !== READY_SCHEMA ||
+          message.ok !== true
+        ) {
+          throw new Error("Windows secure pipe broker readiness is invalid");
+        }
+        const security = normalizeSecurity(message.security);
+        ready = true;
+        settled = true;
+        resolveReady(security);
+      } catch (error) {
+        failReady(error);
+        child.kill();
+      }
+      return;
+    }
+    let response;
+    try {
+      if (
+        !exact(
+          message,
+          new Set([
+            "clientPrincipalDigest",
+            "clientProcessId",
+            "connectionId",
+            "frame",
+            "schema",
+          ]),
+        ) ||
+        message.schema !== REQUEST_SCHEMA ||
+        !/^[a-f0-9]{32}$/u.test(message.connectionId ?? "") ||
+        !Number.isSafeInteger(message.clientProcessId) ||
+        message.clientProcessId < 1 ||
+        !DIGEST.test(message.clientPrincipalDigest ?? "") ||
+        typeof message.frame !== "string" ||
+        Buffer.byteLength(message.frame, "utf8") > maxFrameBytes
+      ) {
+        throw new Error("Windows secure pipe broker request is invalid");
+      }
+      response = await onRequest({
+        frame: message.frame,
+        peer: Object.freeze({
+          processId: message.clientProcessId,
+          principalDigest: message.clientPrincipalDigest,
+        }),
+      });
+    } catch {
+      response = { ok: false, requestId: null, code: "request_denied" };
+    }
+    if (!child.stdin.destroyed) {
+      child.stdin.write(
+        `${JSON.stringify({
+          schema: RESPONSE_SCHEMA,
+          connectionId: message.connectionId,
+          frame: `${JSON.stringify(response)}\n`,
+        })}\n`,
+      );
+    }
+  });
+
+  const security = await readyPromise;
+  return Object.freeze({
+    security,
+    close() {
+      return new Promise((resolve) => {
+        if (child.exitCode !== null || child.signalCode !== null) {
+          resolve();
+          return;
+        }
+        const timer = setTimeout(() => {
+          child.kill();
+          resolve();
+        }, 2_000);
+        timer.unref?.();
+        child.once("exit", () => {
+          clearTimeout(timer);
+          resolve();
+        });
+        child.kill();
+      });
+    },
+  });
+}

package/src/lib/hook-audit-store.js

@@ -35,7 +35,7 @@ function digestToken(value) {
 }
 
 function normalizeRecord(record = {}) {
-  return {
+  const normalized = {
     schema: HOOK_AUDIT_RECORD_SCHEMA,
     timestamp: safeToken(record.timestamp || new Date().toISOString(), 64),
     phase: safeToken(record.phase, 32),
@@ -58,6 +58,23 @@ function normalizeRecord(record = {}) {
       : null,
     errorCode: safeToken(record.errorCode, 96),
   };
+  if (record.phase === "no-hooks") {
+    normalized.firstTimestamp = safeToken(
+      record.firstTimestamp || normalized.timestamp,
+      64,
+    );
+    normalized.occurrences = Math.max(
+      1,
+      Math.min(
+        Number.MAX_SAFE_INTEGER,
+        Number.isSafeInteger(Number(record.occurrences))
+          ? Number(record.occurrences)
+          : 1,
+      ),
+    );
+    normalized.eventDigest = digestToken(record.eventDigest || record.eventId);
+  }
+  return normalized;
 }
 
 function hashRecord(prevHash, record) {
@@ -67,6 +84,13 @@ function hashRecord(prevHash, record) {
   );
 }
 
+function extendNoHookEventDigest(current, eventId) {
+  return sha256(
+    "chainlesschain.hook-audit-no-hooks.v1",
+    `${current || "genesis"}\n${eventId || "unknown"}`,
+  );
+}
+
 function validateStore(store) {
   if (Object.keys(store).length === 0) {
     return {
@@ -103,13 +127,55 @@ export class HookAuditStore {
   }
 
   append(record) {
-    const normalized = normalizeRecord({
+    let normalized = normalizeRecord({
       ...record,
       timestamp: record?.timestamp || this.now(),
     });
+    if (normalized.phase === "no-hooks") {
+      normalized = {
+        ...normalized,
+        eventDigest: extendNoHookEventDigest(null, normalized.eventId),
+      };
+    }
     return mutateSecurityStore(this.filePath, "Hook runtime audit", (draft) => {
       const store = validateStore(draft);
       if (Object.keys(draft).length === 0) Object.assign(draft, store);
+      const last = draft.records.at(-1);
+      if (
+        normalized.phase === "no-hooks" &&
+        last?.record?.phase === "no-hooks" &&
+        last.record.event === normalized.event &&
+        last.record.status === normalized.status &&
+        last.record.decision === normalized.decision
+      ) {
+        const coalesced = {
+          ...normalized,
+          firstTimestamp:
+            last.record.firstTimestamp ||
+            last.record.timestamp ||
+            normalized.timestamp,
+          occurrences: Math.min(
+            Number.MAX_SAFE_INTEGER,
+            Math.max(1, Number(last.record.occurrences) || 1) + 1,
+          ),
+          eventDigest: extendNoHookEventDigest(
+            last.record.eventDigest,
+            normalized.eventId,
+          ),
+        };
+        const hash = hashRecord(last.prevHash || null, coalesced);
+        draft.records[draft.records.length - 1] = {
+          record: coalesced,
+          prevHash: last.prevHash || null,
+          hash,
+        };
+        draft.headHash = hash;
+        return Object.freeze({
+          ...coalesced,
+          prevHash: last.prevHash || null,
+          hash,
+        });
+      }
       const prevHash = draft.headHash || draft.anchorHash || null;
       const hash = hashRecord(prevHash, normalized);
       draft.records.push({ record: normalized, prevHash, hash });

package/src/lib/hooks-v2-runtime.js

@@ -611,16 +611,6 @@ class HooksV2Runtime extends EventEmitter {
     const contract = validateHookEvent(eventName, context);
     const eventId = context.event_id || context.eventId || crypto.randomUUID();
     const auditRequired = options.auditRequired === true || this.requireAudit;
-    this._appendAudit(
-      {
-        phase: "dispatch",
-        event: eventName,
-        eventId,
-        status: "accepted",
-        decision: "continue",
-      },
-      { required: auditRequired && contract.decisionCapable },
-    );
     const suppliedHooks = Array.isArray(options.additionalHooks)
       ? options.additionalHooks.map((hook) => normalizeHookDefinition(hook))
       : [];
@@ -631,6 +621,56 @@ class HooksV2Runtime extends EventEmitter {
       (hook) =>
         eventName !== "FileChanged" || fileChangedHookMatches(hook, context),
     );
+    // Resolve and de-duplicate candidates before writing the audit boundary.
+    // A lifecycle event with no executable hook is still fail-closed audited
+    // at decision gates, but adjacent no-op events are represented by one
+    // authenticated aggregate in HookAuditStore instead of two ever-growing
+    // records per turn. This keeps repeated no-hook lifecycle events bounded
+    // in long-lived IDE/stream sessions without hiding an actual execution.
+    const uniqueHooks = [];
+    const seen = new Set();
+    for (const hook of hooks) {
+      if (seen.has(hook.id)) continue;
+      seen.add(hook.id);
+      uniqueHooks.push(hook);
+    }
+    uniqueHooks.sort(
+      (left, right) =>
+        normalizeHookPriority(left.priority) -
+          normalizeHookPriority(right.priority) ||
+        String(left.id).localeCompare(String(right.id)),
+    );
+    if (uniqueHooks.length === 0) {
+      this._appendAudit(
+        {
+          phase: "no-hooks",
+          event: eventName,
+          eventId,
+          status: "success",
+          decision: "continue",
+        },
+        { required: auditRequired && contract.decisionCapable },
+      );
+      return {
+        success: true,
+        results: [],
+        blocked: false,
+        requiresApproval: false,
+        decision: "continue",
+        blockingResult: null,
+        schemaVersion: HOOK_EVENT_SCHEMA_VERSION,
+      };
+    }
+    this._appendAudit(
+      {
+        phase: "dispatch",
+        event: eventName,
+        eventId,
+        status: "accepted",
+        decision: "continue",
+      },
+      { required: auditRequired && contract.decisionCapable },
+    );
     // Reserve the durable record for the inline producer before executing any
     // hook. A process-level EventRuntimeHost may observe the same store, but it
     // cannot reclaim this record until the longest declared hook timeout plus
@@ -682,22 +722,8 @@ class HooksV2Runtime extends EventEmitter {
         pending: true,
       };
     }
-    // Hooks are parallel by default. De-duplicate by id so a reload or layered
-    // config cannot execute the same handler twice. `parallel:false` remains a
-    // deterministic compatibility mode for callers that require ordering.
-    const uniqueHooks = [];
-    const seen = new Set();
-    for (const hook of hooks) {
-      if (seen.has(hook.id)) continue;
-      seen.add(hook.id);
-      uniqueHooks.push(hook);
-    }
-    uniqueHooks.sort(
-      (left, right) =>
-        normalizeHookPriority(left.priority) -
-          normalizeHookPriority(right.priority) ||
-        String(left.id).localeCompare(String(right.id)),
-    );
+    // Hooks are parallel by default. `parallel:false` remains a deterministic
+    // compatibility mode for callers that require ordering.
     const runOne = async (
       hook,
       { forceObserveOnly = false, dispatcher = null } = {},

package/src/lib/learning/skill-synthesizer.js

@@ -16,15 +16,20 @@
  *   5. Persist the accepted candidate to an isolated candidate registry
  */
 
+import { createHash } from "node:crypto";
 import fs from "fs";
 import { firstBalancedJson } from "../json-schema-output.js";
 import path from "path";
+import { isGovernedSkillSynthesisEvaluationReceipt } from "../evolution/governed-skill-synthesis-model-evaluator.js";
+import { isGovernedSkillSynthesisEvaluationPersistenceReceipt } from "../evolution/governed-skill-synthesis-evaluation-ledger-adapter.js";
 
 // ── _deps for test injection ────────────────────────────
 
 const _deps = { fs, path };
 
 export const SYNTHESIS_UNAVAILABLE_CODE = "LEARNING_SYNTHESIS_UNAVAILABLE";
+export const SYNTHESIS_EVALUATION_DOCUMENT_SCHEMA =
+  "chainlesschain.learning-synthesis-evaluation-document/v1";
 
 // ── Helpers ─────────────────────────────────────────────
 
@@ -145,6 +150,7 @@ Output ONLY valid JSON with these fields:
   "verification": "How to confirm success",
   "tools": ["tool_name_1", "tool_name_2"]
 }
+Every value in "tools" MUST be copied exactly from a tool name present in the trajectory.
 If the trajectory is too specific or not reusable, respond with: {"not_applicable": true}`,
     },
     {
@@ -362,7 +368,7 @@ export class SkillSynthesizer {
           continue;
         }
 
-        await this._persistSkill(skillName, content);
+        await this._persistSkill(skillName, content, evaluation);
 
         // Only durable, evaluated candidates count as synthesized.
         this.trajectoryStore.markSynthesized(traj.id, skillName);
@@ -436,9 +442,10 @@ export class SkillSynthesizer {
    * Write SKILL.md to the isolated candidate output registry.
    * @param {string} skillName
    * @param {string} content
-   * @returns {Promise<{skillDir:string, skillFile:string}>}
+   * @param {object|boolean} evaluation
+   * @returns {Promise<{skillDir:string, skillFile:string,evaluationFile:string|null}>}
    */
-  async _persistSkill(skillName, content) {
+  async _persistSkill(skillName, content, evaluation = null) {
     if (!this.candidateOutputDir) {
       throw new Error("candidate output registry is unavailable");
     }
@@ -468,14 +475,68 @@ export class SkillSynthesizer {
     const skillDir = _deps.path.join(canonicalSkillNamespace, "1.0.0");
     const canonicalSkillDir = await this._ensurePrivateDirectory(skillDir);
     this._assertPathWithinCandidateRoot(candidateRoot, canonicalSkillDir);
-    const skillFile = _deps.path.join(canonicalSkillDir, "SKILL.md");
+    let evaluationFile = null;
+    if (
+      evaluation &&
+      typeof evaluation === "object" &&
+      evaluation.receipt !== undefined
+    ) {
+      if (!isGovernedSkillSynthesisEvaluationReceipt(evaluation.receipt)) {
+        throw new Error("candidate evaluation receipt is not governed");
+      }
+      const contentDigest = `sha256:${createHash("sha256")
+        .update(content, "utf8")
+        .digest("hex")}`;
+      if (
+        evaluation.receipt.skillName !== skillName ||
+        evaluation.receipt.candidateDigest !== contentDigest
+      ) {
+        throw new Error(
+          "candidate evaluation receipt does not bind the persisted candidate",
+        );
+      }
+      if (
+        !isGovernedSkillSynthesisEvaluationPersistenceReceipt(
+          evaluation.persistence,
+        ) ||
+        evaluation.persistence.authenticated !== true ||
+        evaluation.persistence.durable !== true ||
+        evaluation.persistence.persisted !== true ||
+        evaluation.persistence.receiptDigest !==
+          evaluation.receipt.receiptDigest ||
+        evaluation.persistence.candidateDigest !==
+          evaluation.receipt.candidateDigest
+      ) {
+        throw new Error(
+          "candidate evaluation receipt is not durably persisted",
+        );
+      }
+      const serialized = JSON.stringify(
+        {
+          schema: SYNTHESIS_EVALUATION_DOCUMENT_SCHEMA,
+          receipt: evaluation.receipt,
+          persistence: evaluation.persistence,
+        },
+        null,
+        2,
+      );
+      if (!serialized || Buffer.byteLength(serialized, "utf8") > 128 * 1024) {
+        throw new Error("candidate evaluation receipt is invalid or oversized");
+      }
+      evaluationFile = _deps.path.join(canonicalSkillDir, "EVALUATION.json");
+      await _deps.fs.promises.writeFile(evaluationFile, `${serialized}\n`, {
+        encoding: "utf-8",
+        flag: "wx",
+      });
+    }
 
+    const skillFile = _deps.path.join(canonicalSkillDir, "SKILL.md");
     await _deps.fs.promises.writeFile(skillFile, content, {
       encoding: "utf-8",
       flag: "wx",
     });
 
-    return { skillDir: canonicalSkillDir, skillFile };
+    return { skillDir: canonicalSkillDir, skillFile, evaluationFile };
   }
 
   _assertCandidateFilesystemSupport() {

package/src/lib/remote-read-loop-guard.js

@@ -48,6 +48,28 @@ function urlTarget(value) {
   };
 }
 
+function localCiLogTarget(command) {
+  if (
+    !/(?:^|[\s;&|])(?:findstr(?:\.exe)?|grep|rg|select-string)\b/iu.test(
+      command,
+    )
+  )
+    return null;
+  const matches = [
+    ...command.matchAll(
+      /[%$()A-Za-z0-9_:.\\/-]*(?:gh|github|action|ci)[A-Za-z0-9_.-]*\.(?:log|txt|xml)\b/giu,
+    ),
+  ];
+  const file = matches.at(-1)?.[0];
+  if (!file) return null;
+  const normalized = file.replaceAll("\\", "/").toLowerCase();
+  return {
+    key: `local-ci-log:${createHash("sha256").update(normalized).digest("hex")}`,
+    github: true,
+    localLog: true,
+  };
+}
+
 /** Classification only; never parse, rewrite, cache or authorize shell execution. */
 export function remoteReadTarget(tool, args = {}) {
   if (tool === "web_search")
@@ -97,7 +119,7 @@ export function remoteReadTarget(tool, args = {}) {
       );
     if (api) return githubTarget(api[1], api[2], api[3], api[4]);
   }
-  return null;
+  return localCiLogTarget(command);
 }
 
 function failedResult(result) {
@@ -107,7 +129,8 @@ function failedResult(result) {
     result.success === false ||
     result.isError === true ||
     result.statusCode >= 400 ||
-    (Number.isInteger(result.exitCode) && result.exitCode !== 0)
+    (Number.isInteger(result.exitCode) && result.exitCode !== 0) ||
+    (Number.isInteger(result.exit_code) && result.exit_code !== 0)
   );
 }
 
@@ -234,6 +257,7 @@ export class RemoteReadLoopGuard {
     return (
       "Remote-read loop recovery: repeated failures or unchanged GitHub Actions logs detected. " +
       "Stop repeating the same download, including switching between web_fetch, gh run view and gh api for the same run/job. " +
+      "Repeated findstr, grep, rg or Select-String misses against the same saved CI log are also one stalled read: exit code 1 means no match, not a new CI failure. " +
       "Use the retained evidence for the user's task. For implementation, inspect/fix the relevant local files; for research/review, synthesize the findings without making unsolicited edits. For a missing CI detail, use one authenticated gh run view <run-id> --job <job-id> --log-failed --repo <owner/repo>, save the result once and search that local log. " +
       "If the overall run is still active but the required job has completed, fetch that job's log directly with gh api repos/<owner>/<repo>/actions/jobs/<job-id>/logs; gh run view may withhold logs until the whole run finishes. " +
       "Check auth, rate limits or command errors before another attempt. If access remains unavailable, report the exact blocker and useful findings; the task is not complete. " +
@@ -262,9 +286,12 @@ export class RemoteReadLoopGuard {
           evidence,
           lastSuccess,
           page,
+          localLog,
         }) => ({
           source: github
-            ? "GitHub Actions logs"
+            ? localLog
+              ? "saved GitHub Actions log"
+              : "GitHub Actions logs"
             : tool === "web_search"
               ? "web_search"
               : "web_fetch",

package/src/assets/web-panel/assets/MarkdownRenderer-DnSfkf98.js

@@ -1 +0,0 @@
-import{P as c,J as p,b as s}from"./vendor-Bn1JzzAn.js";import{r as a}from"./markdown-Yo_c6Krv.js";import{_ as d}from"./index-Bpz5RnQy.js";const _={__name:"MarkdownRenderer",props:{content:{type:String,default:""}},setup(t,{expose:o}){o();const e=t,r=s(()=>a(e.content||"")),n={props:e,rendered:r,computed:s,get renderMarkdown(){return a}};return Object.defineProperty(n,"__isScriptSetup",{enumerable:!1,value:!0}),n}},i=["innerHTML"];function u(t,o,e,r,n,m){return c(),p("div",{class:"markdown-content",innerHTML:r.rendered},null,8,i)}const w=d(_,[["render",u],["__scopeId","data-v-0b0b9f63"],["__file","/tmp/cc-web-panel-ReJu1o/repo/packages/web-panel/src/components/MarkdownRenderer.vue"]]);export{w as M};

package/src/assets/web-panel/assets/OrderTableRenderer-CFbhBT44.js

@@ -1 +0,0 @@
-import{I as w,P as l,J as u,U as s,R as n,c as i,K as v,Q as _,V as g,b as o}from"./vendor-Bn1JzzAn.js";import{_ as S}from"./index-Bpz5RnQy.js";import"./icons-DG5UD-6K.js";const k={__name:"OrderTableRenderer",props:{event:{type:Object,required:!0}},setup(p,{expose:r}){r();const a=p,e=o(()=>a.event.content||{}),d=o(()=>a.event.extra||{}),m=o(()=>d.value.merchant||e.value.merchant||e.value.counterparty||"—"),c=o(()=>e.value.title||e.value.name||e.value.itemName||e.value.text||"—"),y=o(()=>{const t=e.value.amount??e.value.price??e.value.total;return t==null?"—":`${e.value.currency||"¥"} ${typeof t=="number"?t.toFixed(2):t}`}),T=o(()=>d.value.orderNo||e.value.orderNo||e.value.orderId),f=o(()=>e.value.status||e.value.state),b=o(()=>{const t=(f.value||"").toLowerCase();return t.includes("成功")||t.includes("succe")||t.includes("paid")?"green":t.includes("退")||t.includes("refund")?"orange":t.includes("失败")||t.includes("fail")?"red":"default"}),h=o(()=>{if(!a.event.occurredAt)return"";const t=new Date(a.event.occurredAt);return`${t.getFullYear()}-${String(t.getMonth()+1).padStart(2,"0")}-${String(t.getDate()).padStart(2,"0")} ${String(t.getHours()).padStart(2,"0")}:${String(t.getMinutes()).padStart(2,"0")}`}),x={props:a,c:e,e:d,merchantText:m,itemText:c,amountText:y,orderNo:T,statusText:f,statusColor:b,formattedTime:h,computed:o};return Object.defineProperty(x,"__isScriptSetup",{enumerable:!1,value:!0}),x}},N={class:"order-card"},C={class:"head"},O={class:"time"},R={class:"row"},V={class:"val"},B={class:"row"},D={class:"val"},I={class:"row amount-row"},j={class:"val amount"},A={key:0,class:"row"},F={class:"val mono"},J={key:1,class:"row"};function M(p,r,a,e,d,m){const c=w("a-tag");return l(),u("div",N,[s("div",C,[s("span",O,n(e.formattedTime),1),i(c,{color:"gold"},{default:v(()=>[_(n(a.event.source.adapter),1)]),_:1}),i(c,null,{default:v(()=>[_(n(a.event.subtype),1)]),_:1})]),s("div",R,[r[0]||(r[0]=s("span",{class:"key"},"商户",-1)),s("span",V,n(e.merchantText),1)]),s("div",B,[r[1]||(r[1]=s("span",{class:"key"},"商品/项目",-1)),s("span",D,n(e.itemText),1)]),s("div",I,[r[2]||(r[2]=s("span",{class:"key"},"金额",-1)),s("span",j,n(e.amountText),1)]),e.orderNo?(l(),u("div",A,[r[3]||(r[3]=s("span",{class:"key"},"单号",-1)),s("span",F,n(e.orderNo),1)])):g("v-if",!0),e.statusText?(l(),u("div",J,[r[4]||(r[4]=s("span",{class:"key"},"状态",-1)),i(c,{color:e.statusColor},{default:v(()=>[_(n(e.statusText),1)]),_:1},8,["color"])])):g("v-if",!0)])}const K=S(k,[["render",M],["__scopeId","data-v-5ed5524d"],["__file","/tmp/cc-web-panel-ReJu1o/repo/packages/web-panel/src/components/pdh/renderers/OrderTableRenderer.vue"]]);export{K as default};