chainlesschain 0.166.107 → 0.166.109

package/src/runtime/headless-stream.js

@@ -66,14 +66,17 @@ import {
   agentLoop as coreAgentLoop,
 } from "./agent-core.js";
 import { composeSystemPrompt } from "./system-prompt.js";
-import { collapseConsecutiveMessagesInPlace } from "./message-roles.js";
+import { createResumeRoleProjection } from "./message-roles.js";
 import {
   estimateMessagesTokens,
   sanitizeToolPairs,
 } from "../harness/prompt-compressor.js";
 import { compactConversationWithProvider } from "../harness/provider-backed-compaction.js";
 import { HostResourceBudget } from "../lib/host-resource-budget.js";
-import { projectCanonicalResumeMessages } from "../lib/session-message-provenance.js";
+import {
+  projectCanonicalResumeMessages,
+  markRuntimeOnlySessionMessage,
+} from "../lib/session-message-provenance.js";
 import { isAbortError } from "../lib/abort-utils.js";
 import { expandFileRefsAsync } from "./file-ref-expander.js";
 // Per-turn helpers resolved at module load (not re-`await import`ed inside the
@@ -137,6 +140,7 @@ import {
   appendToolCallCompact as jsonlAppendToolCallCompact,
   appendLlmRetryCompact as jsonlAppendLlmRetryCompact,
   appendCompactEventIfMessagesMatch as jsonlAppendCompactEventIfMessagesMatch,
+  appendToolRoundsIfMessagesMatch as jsonlAppendToolRoundsIfMessagesMatch,
   appendEvent as jsonlAppendEvent,
   appendAuthorityEvent as jsonlAppendAuthorityEvent,
   readEvents as jsonlReadEvents,
@@ -965,28 +969,6 @@ async function runTurn(
     sideEffects?.ledger,
   );
 
-  // Collapse consecutive same-role turns before the model call ONLY when the
-  // caller flags a resume-degenerate transcript (`mergeRoles`): a resumed
-  // session whose previous run produced NO assistant response leaves a trailing
-  // bare `user` turn, so splicing the first live prompt after it sends two
-  // adjacent `user` messages — which Anthropic/Bedrock reject as "roles must
-  // alternate" (Claude Code 2.1.187 parity). It is GATED rather than applied
-  // every turn because the live turn loop legitimately produces consecutive
-  // `user` messages — an interrupted turn's dangling prompt, a PDH feedback
-  // note (§3.5.13) — that must reach the model distinctly and must not be
-  // folded (folding the interrupt-dangling turn even resurrects the abandoned
-  // request).
-  //
-  // Collapse IN PLACE (not a folded copy): the persistent `messages` array is
-  // reused for every later turn, so leaving the `[user, user]` pair in it would
-  // re-break the SECOND live turn (which re-sends the lingering pair). The gated
-  // turn is the first after resume, still tool-free (resumed history is
-  // user/assistant/system only), so an in-place fold is safe and the helper
-  // never folds `tool` turns regardless. Un-gated later turns are untouched, so
-  // the intentional interrupt/feedback consecutive-`user` states are preserved.
-  if (loopOptions.mergeRoles) {
-    collapseConsecutiveMessagesInPlace(messages);
-  }
   for await (const event of runLoop(messages, loopOptions)) {
     if (evolutionIngress !== null) {
       await evolutionIngress.ingestAgentEvent(event);
@@ -2292,6 +2274,11 @@ async function runAgentHeadlessStreamInWorkspace(
         ? () => null
         : jsonlFindLatestEvent);
   const store = {
+    appendToolRoundsIfMessagesMatch:
+      deps.appendToolRoundsIfMessagesMatch ||
+      (hasInjectedSessionStore
+        ? unavailableAuthorityCapability("appendToolRoundsIfMessagesMatch")
+        : jsonlAppendToolRoundsIfMessagesMatch),
     sessionExists: deps.sessionExists || jsonlSessionExists,
     startSession: deps.startSession || jsonlStartSession,
     appendUserMessage: deps.appendUserMessage || jsonlAppendUserMessage,
@@ -3280,14 +3267,12 @@ async function runAgentHeadlessStreamInWorkspace(
     }
   }
 
-  // Resume-degenerate role sanitation (Claude Code 2.1.187 parity): when the
-  // replayed history ends with a bare `user` turn (the prior run produced no
-  // assistant response), the FIRST live prompt would make two adjacent `user`
-  // messages. Arm a one-shot flag consumed by the first model call so the merge
-  // fires exactly once — the live turn loop's intentional consecutive-`user`
-  // states (interrupt-dangling turn, PDH feedback note) are never folded.
+  // Capture the first resumed request's adjacent role pairs, then normalize
+  // those pairs in provider projections across later turns. Canonical history
+  // and new feedback/interrupt message pairs retain their original structure.
   let sanitizeRolesNextTurn =
     resumedMessages > 0 && messages[messages.length - 1]?.role === "user";
+  let projectProviderMessages;
 
   if (
     options.taskWorklog === true ||
@@ -3778,6 +3763,63 @@ async function runAgentHeadlessStreamInWorkspace(
     };
   }
 
+  const settleToolRounds = () => {
+    if (
+      !persist ||
+      !messages.some(
+        (message) => message.role === "assistant" && message.tool_calls?.length,
+      )
+    )
+      return;
+    sessionHostLease?.assert?.();
+    const expected = requireSynchronousRecoveryResult(
+      store.readVerifiedProjection(sessionId, () => ({
+        accept() {},
+        finish(authority) {
+          return authority.readMessages();
+        },
+      })),
+      "readVerifiedProjection",
+    );
+    return requireSynchronousRecoveryResult(
+      store.appendToolRoundsIfMessagesMatch(sessionId, messages, expected),
+      "appendToolRoundsIfMessagesMatch",
+    );
+  };
+  const settleToolRoundsForHost = (phase, clientMessageId = null) => {
+    try {
+      settleToolRounds();
+      return true;
+    } catch (error) {
+      const persistence = projectSessionPersistenceFailure(
+        createSessionPersistenceFailure(error, {
+          sessionId,
+          operation: "append-event",
+        }),
+        { phase },
+      );
+      if (persistence) terminalPersistenceFailure = persistence;
+      emit({
+        type: "result",
+        is_error: true,
+        session_id: sessionId,
+        subtype: clientMessageId
+          ? "error_input_receipt"
+          : persistence
+            ? "error_persistence"
+            : "error_session_persistence",
+        code: error?.code || "CC_SESSION_TOOL_ROUND_PERSISTENCE_FAILED",
+        error:
+          "Cannot settle completed tool rounds; refresh the session before continuing",
+        ...(clientMessageId
+          ? { client_message_id: clientMessageId, acceptance: "unknown" }
+          : {}),
+        ...(persistence ? { persistence } : {}),
+      });
+      sawError = true;
+      return false;
+    }
+  };
   const loopOptionsBase = {
     ...(evolutionIngress === null ? {} : { evolutionIngress }),
     model,
@@ -3848,8 +3890,14 @@ async function runAgentHeadlessStreamInWorkspace(
     mcpCallLedger: mcpRecoveryRuntime.ledger,
     mcpDispatchAdmission: sessionHostLease?.admitMcpDispatch || null,
     getTaskWorklogContext: () => taskWorklog?.context() || null,
-    onBeforeCompaction: () =>
-      updateWorklog((log) => log.record({ type: "before-compaction" })),
+    onBeforeCompaction: () => {
+      updateWorklog((log) => log.record({ type: "before-compaction" }));
+      try {
+        settleToolRounds();
+      } catch (error) {
+        throw markRuntimeLedgerPersistenceError(error);
+      }
+    },
     onCompaction: persist
       ? (stats, compacted, settlement = {}) => {
           sessionHostLease?.assert?.();
@@ -4449,6 +4497,7 @@ async function runAgentHeadlessStreamInWorkspace(
       continue;
     }
     if (parsed.compact) {
+      if (!settleToolRoundsForHost("before-model")) break;
       updateWorklog((log) => log.record({ type: "before-compaction" }));
       const before = messages.length;
       const expectedMessages = [...messages];
@@ -5076,10 +5125,42 @@ async function runAgentHeadlessStreamInWorkspace(
         // fall through into the normal turn machinery with the correction prompt
       } else {
         const tag = kind === "positive" ? "认可" : "不满意";
-        messages.push({
+        const feedbackMessage = {
           role: "user",
           content: `（用户反馈：对上一轮回复表示${tag}。请在后续回复中延续/修正此偏好。）`,
-        });
+        };
+        if (persist) {
+          if (!settleToolRoundsForHost("before-model")) break;
+          try {
+            sessionHostLease?.assert?.();
+            requireSynchronousRecoveryResult(
+              store.appendUserMessage(sessionId, feedbackMessage.content),
+              "appendUserMessage",
+            );
+          } catch (error) {
+            const persistence = projectSessionPersistenceFailure(
+              createSessionPersistenceFailure(error, {
+                sessionId,
+                operation: "user-turn-append",
+              }),
+              { phase: "before-model" },
+            );
+            if (persistence) terminalPersistenceFailure = persistence;
+            emit({
+              type: "result",
+              subtype: "error_persistence",
+              is_error: true,
+              session_id: sessionId,
+              code: error?.code || "CC_SESSION_FEEDBACK_PERSISTENCE_FAILED",
+              error:
+                "Feedback could not be saved; refresh the session before retrying",
+              ...(persistence ? { persistence } : {}),
+            });
+            sawError = true;
+            break;
+          }
+        }
+        messages.push(feedbackMessage);
         continue;
       }
     }
@@ -5357,6 +5438,8 @@ async function runAgentHeadlessStreamInWorkspace(
     let inputReceipt = null;
     let userEventId = null;
     if (persist) {
+      if (!settleToolRoundsForHost("before-model", parsed.clientMessageId))
+        break;
       try {
         if (parsed.clientMessageId) {
           if (!store.appendInputWithReceipt)
@@ -5451,11 +5534,12 @@ async function runAgentHeadlessStreamInWorkspace(
       ? AbortSignal.any([options.signal, currentAbort.signal])
       : currentAbort.signal;
 
-    // Consume the one-shot resume-degeneracy flag for THIS turn (see
-    // sanitizeRolesNextTurn) so the role merge fires exactly once, whether the
-    // model call completes or is interrupted.
-    const mergeRolesThisTurn = sanitizeRolesNextTurn;
-    sanitizeRolesNextTurn = false;
+    // Capture the resumed pairs once, then normalize those same pairs only in
+    // every provider request. The live authority array retains separate turns.
+    if (sanitizeRolesNextTurn) {
+      projectProviderMessages = createResumeRoleProjection(messages);
+      sanitizeRolesNextTurn = false;
+    }
 
     let outcome;
     try {
@@ -5522,8 +5606,7 @@ async function runAgentHeadlessStreamInWorkspace(
                   event.text.trim().length > 0 &&
                   !event.text.trimStart().startsWith("/")),
             ),
-          // Resume-degenerate role merge for the first live model call only.
-          mergeRoles: mergeRolesThisTurn,
+          projectProviderMessages,
         },
         {
           runLoop,
@@ -5640,9 +5723,21 @@ async function runAgentHeadlessStreamInWorkspace(
         // the array length unchanged. sanitizeToolPairs is idempotent on an
         // already-balanced array and leaves user/text turns untouched, so the
         // intentional dangling-user state above is preserved.
+        const originalMessages = new Set(messages);
         const balanced = sanitizeToolPairs(messages);
+        // Only the sanitizer's newly-created commentary for discarded calls
+        // is ephemeral. Existing real messages retain their authority.
+        for (const message of balanced) {
+          if (
+            !originalMessages.has(message) &&
+            message.role === "assistant" &&
+            !message.tool_calls?.length
+          )
+            markRuntimeOnlySessionMessage(message);
+        }
         messages.length = 0;
         messages.push(...balanced);
+        if (!settleToolRoundsForHost("after-model")) break;
         emit({
           type: "result",
           subtype: "interrupted",
@@ -5654,6 +5749,7 @@ async function runAgentHeadlessStreamInWorkspace(
         continue;
       }
       if (isAbort) break; // outer options.signal — caller is shutting down
+      if (!settleToolRoundsForHost("after-model")) break;
       const transportDetails = transportErrorDetails(err);
       emit({
         type: "result",
@@ -5676,6 +5772,7 @@ async function runAgentHeadlessStreamInWorkspace(
     currentAbort = null;
 
     if (outcome.endReason === "user-input-pending") {
+      if (!settleToolRoundsForHost("after-model")) break;
       emit({
         type: "result",
         subtype: "interrupted",
@@ -5738,9 +5835,9 @@ async function runAgentHeadlessStreamInWorkspace(
     }
 
     // Grow the conversation so the next turn has context.
-    messages.push({ role: "assistant", content: outcome.finalText });
     let assistantEventId = null;
     if (persist) {
+      if (!settleToolRoundsForHost("after-model")) break;
       try {
         assistantEventId = transcriptMessageEventId(
           store.appendAssistantMessage(sessionId, outcome.finalText),
@@ -5764,6 +5861,7 @@ async function runAgentHeadlessStreamInWorkspace(
         }
       }
     }
+    messages.push({ role: "assistant", content: outcome.finalText });
 
     const exhausted =
       outcome.endReason === "budget-exhausted" ||

package/src/runtime/message-roles.js

@@ -1,3 +1,5 @@
+import { canonicalJson } from "@chainlesschain/context-memory-kernel";
+
 /**
  * Conversation role sanitation shared by the headless runner and the
  * stream-json runtime.
@@ -111,6 +113,47 @@ export function mergeConsecutiveMessages(messages) {
   return out;
 }
 
+/**
+ * Capture only the adjacent plain-role pairs present at resume. Reapply their
+ * provider normalization on later requests without mutating canonical history
+ * or folding newly added interrupt/feedback turns. Canonical fingerprints also
+ * recognize the same retained messages after compaction recreates objects.
+ */
+export function createResumeRoleProjection(messages) {
+  const pairs = new Map();
+  const pairKey = (left, right) => canonicalJson([left, right]);
+  for (let index = 1; index < messages.length; index++) {
+    const left = messages[index - 1];
+    const right = messages[index];
+    if (
+      left &&
+      right &&
+      MERGEABLE_ROLES.has(left.role) &&
+      left.role === right.role &&
+      !hasToolCalls(left) &&
+      !hasToolCalls(right)
+    ) {
+      const key = pairKey(left, right);
+      pairs.set(key, (pairs.get(key) || 0) + 1);
+    }
+  }
+  return (requestMessages) => {
+    const remaining = new Map(pairs);
+    const projected = [];
+    for (let index = 0; index < requestMessages.length; index++) {
+      const message = requestMessages[index];
+      const key =
+        index > 0 ? pairKey(requestMessages[index - 1], message) : null;
+      if (key && remaining.get(key) > 0) {
+        const previous = projected.pop();
+        projected.push(...mergeConsecutiveMessages([previous, message]));
+        remaining.set(key, remaining.get(key) - 1);
+      } else projected.push(message);
+    }
+    return projected;
+  };
+}
+
 /**
  * In-place variant: collapse consecutive mergeable-role turns by mutating the
  * given array (same reference is kept, so closures over it stay valid). Used by

package/src/workers/background-agent-worker.js

@@ -24,6 +24,7 @@ import {
   deliverBackgroundNeedsInputNotification,
   insertArgumentsBeforeOptionTerminator,
   mutateBackgroundAgentState,
+  mutateBackgroundAgentStateWithLockRetry,
   openBackgroundLogFile,
   readBackgroundAgentState,
   removeJobFile,
@@ -88,6 +89,7 @@ let server = null;
 let child = null;
 let heartbeat = null;
 let finalized = false;
+let finalizing = false;
 let phase = "turn";
 let turnCount = 0;
 let lastExit = { code: 0, signal: null };
@@ -112,6 +114,79 @@ const pendingInteractions = new Map();
 // relays the throw as {type:"error", message}) instead of silently queued.
 const MAX_PROMPT_QUEUE = 100;
 
+export function isBackgroundAgentWorkerClosing(isFinalized, isFinalizing) {
+  return isFinalized === true || isFinalizing === true;
+}
+
+export function assertBackgroundAgentWorkerAcceptsPrompt(
+  isFinalized,
+  isFinalizing,
+) {
+  if (isBackgroundAgentWorkerClosing(isFinalized, isFinalizing)) {
+    throw new Error("this background session is closing");
+  }
+}
+
+function ownsBackgroundAgentWorkerRecord(current, workerPid, workerGeneration) {
+  return Boolean(
+    current &&
+      (!current.workerGeneration ||
+        current.workerGeneration === workerGeneration) &&
+      (Number(current.workerClaimedPid) === workerPid ||
+        (current.workerClaimedPid == null &&
+          Number(current.workerPid ?? current.pid) === workerPid)),
+  );
+}
+
+export function createBackgroundAgentWorkerFinalStateUpdater({
+  id,
+  workerPid,
+  workerGeneration,
+  code,
+  signal,
+  errorMessage,
+  now = Date.now,
+}) {
+  return (current) => {
+    if (!current || !ownsBackgroundAgentWorkerRecord(
+      current,
+      workerPid,
+      workerGeneration,
+    )) {
+      return null;
+    }
+    if (current.status !== "running") {
+      return { ...current, phase: null, transport: null };
+    }
+    if (current.stopRequestedAt) return null;
+    return {
+      ...current,
+      id,
+      status: errorMessage ? "failed" : code === 0 ? "completed" : "failed",
+      endedAt: now(),
+      exitCode: errorMessage ? (code ?? 1) : code,
+      signal: signal || null,
+      ...(errorMessage ? { error: errorMessage } : {}),
+      phase: null,
+      transport: null,
+    };
+  };
+}
+
+export function isBackgroundAgentWorkerFinalStateSettledOrSuperseded(
+  mutation,
+  { workerPid, workerGeneration },
+) {
+  if (mutation.applied) return true;
+  const current = mutation.state;
+  return (
+    !current ||
+    current.status !== "running" ||
+    Boolean(current.stopRequestedAt) ||
+    !ownsBackgroundAgentWorkerRecord(current, workerPid, workerGeneration)
+  );
+}
+
 /**
  * Bind one idempotent termination settlement to a turn child.
  *
@@ -576,36 +651,38 @@ function finalize(code, signal, errorMessage) {
   // worker and heartbeat alive until its fresh-lease reload either settles
   // every disk-visible pending request or persists retry evidence.
   if (interactionFinalSweep) return;
-  if (finalized) return;
-  finalized = true;
-  clearInterval(heartbeat);
-  try {
-    mutateBackgroundAgentState(job.id, (current) => {
-      if (!current) return null;
-      const ownsRecord =
-        (!current.workerGeneration ||
-          current.workerGeneration === job.workerGeneration) &&
-        (Number(current.workerClaimedPid) === process.pid ||
-          (current.workerClaimedPid == null &&
-            Number(current.workerPid ?? current.pid) === process.pid));
-      if (!ownsRecord) return null;
-      // An external stop/remove owns an already-terminal or deleted record.
-      if (current.status !== "running") {
-        return { ...current, phase: null, transport: null };
+  if (finalized || finalizing) return;
+  finalizing = true;
+
+  const workerIdentity = {
+    workerPid: process.pid,
+    workerGeneration: job.workerGeneration,
+  };
+  const finish = (persistenceFailed) => {
+    finalized = true;
+    finalizing = false;
+    clearInterval(heartbeat);
+    const done = () => {
+      keeperClient?.close();
+      keeperClient = null;
+      try {
+        log?.close();
+      } catch {
+        /* log fd already closed */
       }
-      return {
-        ...current,
-        id: job.id,
-        status: errorMessage ? "failed" : code === 0 ? "completed" : "failed",
-        endedAt: Date.now(),
-        exitCode: errorMessage ? (code ?? 1) : code,
-        signal: signal || null,
-        ...(errorMessage ? { error: errorMessage } : {}),
-        phase: null,
-        transport: null,
-      };
-    });
-  } catch (error) {
+      const originalExitCode = errorMessage ? 1 : (code ?? 1);
+      process.exit(
+        persistenceFailed && originalExitCode === 0 ? 1 : originalExitCode,
+      );
+    };
+    if (server) {
+      server.broadcast({ type: "closing" });
+      server.close().then(done, done);
+    } else {
+      done();
+    }
+  };
+  const reportPersistenceFailure = (error) => {
     try {
       writeSync(
         2,
@@ -616,23 +693,39 @@ function finalize(code, signal, errorMessage) {
     } catch {
       /* inherited stderr may already be closed */
     }
-  }
-  const done = () => {
-    keeperClient?.close();
-    keeperClient = null;
-    try {
-      log?.close();
-    } catch {
-      /* log fd already closed */
-    }
-    process.exit(errorMessage ? 1 : (code ?? 1));
   };
-  if (server) {
-    server.broadcast({ type: "closing" });
-    server.close().then(done, done);
-  } else {
-    done();
-  }
+
+  void mutateBackgroundAgentStateWithLockRetry(
+    job.id,
+    createBackgroundAgentWorkerFinalStateUpdater({
+      id: job.id,
+      ...workerIdentity,
+      code,
+      signal,
+      errorMessage,
+    }),
+  )
+    .then((mutation) => {
+      if (
+        isBackgroundAgentWorkerFinalStateSettledOrSuperseded(
+          mutation,
+          workerIdentity,
+        )
+      ) {
+        finish(false);
+        return;
+      }
+      const error = new Error(
+        "The active worker still owns a nonterminal state after finalization",
+      );
+      error.code = "BACKGROUND_AGENT_FINAL_STATE_UNRESOLVED";
+      reportPersistenceFailure(error);
+      finish(true);
+    })
+    .catch((error) => {
+      reportPersistenceFailure(error);
+      finish(true);
+    });
 }
 
 function scheduleTurnLaunchSettlementRetry(context, delayMs = 250) {
@@ -946,7 +1039,12 @@ function beginTurnLaunchSettlement({
 }
 
 function startTurn(argv, promptText) {
-  if (!writeHeartbeat()) return false;
+  if (
+    isBackgroundAgentWorkerClosing(finalized, finalizing) ||
+    !writeHeartbeat()
+  ) {
+    return false;
+  }
   const nextTurn = turnCount + 1;
   const turnLaunchToken = randomBytes(16).toString("hex");
   // Private spawn-generation binding for the dedicated child IPC channel.
@@ -1483,7 +1581,7 @@ function startTurn(argv, promptText) {
 }
 
 function maybeContinue() {
-  if (finalized) return;
+  if (isBackgroundAgentWorkerClosing(finalized, finalizing)) return;
   // External stop marked the session terminal while a turn was in flight —
   // don't start another turn against a stopped session.
   const current = readBackgroundAgentState(job.id);
@@ -1696,6 +1794,7 @@ async function main() {
       token,
       getStatus,
       onPrompt: (text) => {
+        assertBackgroundAgentWorkerAcceptsPrompt(finalized, finalizing);
         if (!Array.isArray(job.followUpArgv)) {
           throw new Error(
             "this session was launched without follow-up support — start a new one with cc agent --bg",

package/src/assets/web-panel/assets/ChatBubbleRenderer-KX1OITf8.js

@@ -1 +0,0 @@
-import{I as v,P as u,J as S,U as n,R as a,S as y,K as C,Q as x,V as w,_ as B,b as s}from"./vendor-Bn1JzzAn.js";import{_ as k}from"./index-DBmGQHEz.js";import"./icons-DG5UD-6K.js";const M={__name:"ChatBubbleRenderer",props:{event:{type:Object,required:!0}},setup(c,{expose:d}){d();const t=c,r=s(()=>{const e=t.event.content||{};return e.text||e.body||e.message||e.title||JSON.stringify(e).slice(0,200)}),i=s(()=>{const e=t.event.content||{};return e.from||e.sender||e.senderName||t.event.actor||"(unknown)"}),l=s(()=>{const e=(t.event.actor||"").toLowerCase();return e.includes("self")||e==="me"||e.endsWith("_self")}),o=s(()=>{const e=t.event.source.adapter||"";return e.startsWith("messaging-qq")?"magenta":e==="wechat"?"green":"blue"}),m=s(()=>{if(!t.event.occurredAt)return"";try{const e=new Date(t.event.occurredAt),p=e.getFullYear(),f=String(e.getMonth()+1).padStart(2,"0"),g=String(e.getDate()).padStart(2,"0"),b=String(e.getHours()).padStart(2,"0"),h=String(e.getMinutes()).padStart(2,"0");return`${p}-${f}-${g} ${b}:${h}`}catch{return""}}),_={props:t,messageText:r,actorLabel:i,isMine:l,adapterColor:o,formattedTime:m,computed:s};return Object.defineProperty(_,"__isScriptSetup",{enumerable:!1,value:!0}),_}},N={class:"bubble"},T={class:"meta"},R={class:"actor"},V={class:"time"},W={class:"body"};function q(c,d,t,r,i,l){const o=v("a-tag");return u(),S("div",{class:B(["chat-row",{mine:r.isMine}])},[n("div",N,[n("div",T,[n("span",R,a(r.actorLabel),1),n("span",V,a(r.formattedTime),1)]),n("div",W,a(r.messageText),1),t.event.source.adapter?(u(),y(o,{key:0,class:"src",color:r.adapterColor},{default:C(()=>[x(a(t.event.source.adapter),1)]),_:1},8,["color"])):w("v-if",!0)])],2)}const O=k(M,[["render",q],["__scopeId","data-v-49238629"],["__file","/tmp/cc-web-panel-JUM1WW/repo/packages/web-panel/src/components/pdh/renderers/ChatBubbleRenderer.vue"]]);export{O as default};

package/src/assets/web-panel/assets/MobileProjects-CTpVHJMa.js

@@ -1 +0,0 @@
-import{I as n,J as g,c as l,K as r,N as u,P as h,U as o,R as t,Q as b}from"./vendor-Bn1JzzAn.js";import{_ as v,b as m}from"./index-DBmGQHEz.js";import{a8 as M,M as y}from"./icons-DG5UD-6K.js";const B={__name:"MobileProjects",setup(p,{expose:i}){i();const c=u(),{t:e}=m();function a(){c.push("/projects")}function _(){c.push("/mobile-bridge")}const s={router:c,t:e,goToProjects:a,goToMobileBridge:_,get useRouter(){return u},get useI18n(){return m},get MobileOutlined(){return y},get FolderOutlined(){return M}};return Object.defineProperty(s,"__isScriptSetup",{enumerable:!1,value:!0}),s}},x={class:"mobile-projects-placeholder"},O={class:"title"},k={class:"subtitle"},w={class:"explainer"};function T(p,i,c,e,a,_){const s=n("a-alert"),d=n("a-button"),f=n("a-space"),P=n("a-empty"),j=n("a-card");return h(),g("div",x,[l(j,null,{default:r(()=>[l(P,{description:!1},{image:r(()=>[l(e.MobileOutlined,{style:{fontSize:"64px",color:"#bfbfbf"}})]),default:r(()=>[o("h2",O,t(e.t("mobileProjects.title")),1),o("p",k,t(e.t("mobileProjects.subtitle")),1),l(s,{message:e.t("mobileProjects.v02Banner"),type:"info","show-icon":"",class:"banner"},null,8,["message"]),o("div",w,[o("h3",null,t(e.t("mobileProjects.currentDirection")),1),o("p",null,t(e.t("mobileProjects.currentDirectionBody")),1),o("ul",null,[o("li",null,t(e.t("mobileProjects.stepPhone")),1),o("li",null,t(e.t("mobileProjects.stepTap")),1),o("li",null,t(e.t("mobileProjects.stepPull")),1)]),o("h3",null,t(e.t("mobileProjects.reverseDirection")),1),o("p",null,t(e.t("mobileProjects.reverseDirectionBody")),1)]),l(f,{class:"actions"},{default:r(()=>[l(d,{type:"primary",onClick:e.goToProjects},{default:r(()=>[l(e.FolderOutlined),b(" "+t(e.t("mobileProjects.viewLocalProjects")),1)]),_:1}),l(d,{onClick:e.goToMobileBridge},{default:r(()=>[l(e.MobileOutlined),b(" "+t(e.t("mobileProjects.checkBridge")),1)]),_:1})]),_:1})]),_:1})]),_:1})])}const N=v(B,[["render",T],["__scopeId","data-v-9262cc45"],["__file","/tmp/cc-web-panel-JUM1WW/repo/packages/web-panel/src/views/MobileProjects.vue"]]);export{N as default};