larkway 0.3.26 → 0.3.27

package/dist/cli/index.js

@@ -124047,9 +124047,9 @@ var ResponseSurfacePrototypeConfigSchema = external_exports.object({
    */
   allowed_threads: external_exports.array(external_exports.string().min(1)).default([]),
   /**
-   * Post-first gate. Default true means the bridge starts a lightweight post
-   * as the live main surface when post outbound is available, and creates a
-   * card only for fallback or card-only capabilities.
+   * Historical post-first gate retained for config compatibility. The default
+   * runtime no longer uses post-first lazy card creation; CardKit is the main
+   * surface and legacy cards remain the visible fallback.
    */
   lazy_card_creation: external_exports.boolean().default(true),
   /**
@@ -124059,8 +124059,8 @@ var ResponseSurfacePrototypeConfigSchema = external_exports.object({
    */
   kill_switch: external_exports.boolean().default(false),
   /**
-   * Gate for real post outbound. Defaults on, but the runtime still requires
-   * an injected post client and all safety gates before any post path.
+   * Gate for real post outbound. Defaults on so create-only visible fallback
+   * posts remain available when CardKit and legacy card rendering both fail.
    */
   post_outbound_enabled: external_exports.boolean().default(true),
   /**
@@ -124082,8 +124082,8 @@ var ResponseSurfacePrototypeConfigSchema = external_exports.object({
    */
   allowed_mention_open_ids: external_exports.array(external_exports.string().min(1)).default([]),
   /**
-   * Hard cap for surface dispatch. PR4 still keeps production post outbound
-   * unavailable, but fake-channel dispatch tests enforce this bounded shape.
+   * Historical post dispatch cap retained for schema compatibility and
+   * isolated dispatcher tests.
    */
   max_posts_per_turn: external_exports.number().int().min(0).max(10).default(1),
   /**
@@ -124102,8 +124102,8 @@ var ResponseSurfacePrototypeConfigSchema = external_exports.object({
    */
   max_post_attempts: external_exports.number().int().min(1).max(5).default(3),
   /**
-   * Future channel threshold for lazy card creation. Bounded so config cannot
-   * grow unbounded or encode business rules.
+   * Historical threshold for removed lazy card creation experiments. Bounded
+   * so older config remains parseable without growing arbitrary business rules.
    */
   text_threshold_chars: external_exports.number().int().min(1).max(2e4).default(1200)
 }).default(responseSurfacePrototypeConfigDefaults);

package/dist/main.js

@@ -118708,9 +118708,9 @@ var ResponseSurfacePrototypeConfigSchema = external_exports.object({
    */
   allowed_threads: external_exports.array(external_exports.string().min(1)).default([]),
   /**
-   * Post-first gate. Default true means the bridge starts a lightweight post
-   * as the live main surface when post outbound is available, and creates a
-   * card only for fallback or card-only capabilities.
+   * Historical post-first gate retained for config compatibility. The default
+   * runtime no longer uses post-first lazy card creation; CardKit is the main
+   * surface and legacy cards remain the visible fallback.
    */
   lazy_card_creation: external_exports.boolean().default(true),
   /**
@@ -118720,8 +118720,8 @@ var ResponseSurfacePrototypeConfigSchema = external_exports.object({
    */
   kill_switch: external_exports.boolean().default(false),
   /**
-   * Gate for real post outbound. Defaults on, but the runtime still requires
-   * an injected post client and all safety gates before any post path.
+   * Gate for real post outbound. Defaults on so create-only visible fallback
+   * posts remain available when CardKit and legacy card rendering both fail.
    */
   post_outbound_enabled: external_exports.boolean().default(true),
   /**
@@ -118743,8 +118743,8 @@ var ResponseSurfacePrototypeConfigSchema = external_exports.object({
    */
   allowed_mention_open_ids: external_exports.array(external_exports.string().min(1)).default([]),
   /**
-   * Hard cap for surface dispatch. PR4 still keeps production post outbound
-   * unavailable, but fake-channel dispatch tests enforce this bounded shape.
+   * Historical post dispatch cap retained for schema compatibility and
+   * isolated dispatcher tests.
    */
   max_posts_per_turn: external_exports.number().int().min(0).max(10).default(1),
   /**
@@ -118763,8 +118763,8 @@ var ResponseSurfacePrototypeConfigSchema = external_exports.object({
    */
   max_post_attempts: external_exports.number().int().min(1).max(5).default(3),
   /**
-   * Future channel threshold for lazy card creation. Bounded so config cannot
-   * grow unbounded or encode business rules.
+   * Historical threshold for removed lazy card creation experiments. Bounded
+   * so older config remains parseable without growing arbitrary business rules.
    */
   text_threshold_chars: external_exports.number().int().min(1).max(2e4).default(1200)
 }).default(responseSurfacePrototypeConfigDefaults);
@@ -118793,9 +118793,6 @@ function shouldProvideResponseSurfaceCardKitClient(config) {
 function isResponseSurfaceCardKitAvailable(config, facts, opts) {
   return !!(opts.cardKitClientAvailable && shouldProvideResponseSurfaceCardKitClient(config) && isResponseSurfacePrototypeAllowlisted(config, facts));
 }
-function isResponseSurfacePostOutboundAvailable(config, facts, opts) {
-  return !!(opts.postClientAvailable && shouldProvideResponseSurfacePostClient(config) && isResponseSurfacePrototypeAllowlisted(config, facts));
-}
 
 // src/bridge/stateFile.ts
 var optionalUrl = external_exports.preprocess(
@@ -119755,93 +119752,6 @@ async function finalizeExistingCardKitCard(opts) {
   return sequence;
 }
 
-// src/bridge/surfaceController.ts
-var SurfaceController = class _SurfaceController {
-  decision;
-  constructor(decision) {
-    this.decision = decision;
-  }
-  static create(input) {
-    const cfg = input.prototypeConfig;
-    if (!cfg?.enabled) {
-      return new _SurfaceController({
-        startCardImmediately: true,
-        prototypeEnabled: false,
-        lazyCardCreationEnabled: false,
-        reason: "prototype-disabled"
-      });
-    }
-    if (cfg.kill_switch) {
-      return new _SurfaceController({
-        startCardImmediately: true,
-        prototypeEnabled: false,
-        lazyCardCreationEnabled: false,
-        reason: "kill-switch-active"
-      });
-    }
-    if (!isResponseSurfacePrototypeAllowlisted(cfg, {
-      chatId: input.chatId,
-      threadId: input.threadId
-    })) {
-      return new _SurfaceController({
-        startCardImmediately: true,
-        prototypeEnabled: false,
-        lazyCardCreationEnabled: false,
-        reason: "not-allowlisted"
-      });
-    }
-    if (!cfg.lazy_card_creation) {
-      return new _SurfaceController({
-        startCardImmediately: true,
-        prototypeEnabled: true,
-        lazyCardCreationEnabled: false,
-        reason: "lazy-card-disabled"
-      });
-    }
-    if (!cfg.post_outbound_enabled) {
-      return new _SurfaceController({
-        startCardImmediately: true,
-        prototypeEnabled: true,
-        lazyCardCreationEnabled: false,
-        reason: "post-outbound-disabled"
-      });
-    }
-    if (!input.postOutboundAvailable) {
-      return new _SurfaceController({
-        startCardImmediately: true,
-        prototypeEnabled: true,
-        lazyCardCreationEnabled: false,
-        reason: "post-outbound-unavailable-card-fallback"
-      });
-    }
-    if (input.postLedgerAvailable === false) {
-      return new _SurfaceController({
-        startCardImmediately: true,
-        prototypeEnabled: true,
-        lazyCardCreationEnabled: false,
-        reason: "post-ledger-unavailable-card-fallback"
-      });
-    }
-    if (input.visibleFallbackAvailable === false) {
-      return new _SurfaceController({
-        startCardImmediately: true,
-        prototypeEnabled: true,
-        lazyCardCreationEnabled: false,
-        reason: "visible-fallback-unavailable-card-fallback"
-      });
-    }
-    return new _SurfaceController({
-      startCardImmediately: false,
-      prototypeEnabled: true,
-      lazyCardCreationEnabled: true,
-      reason: "lazy-card-ready"
-    });
-  }
-  shouldStartCardImmediately() {
-    return this.decision.startCardImmediately;
-  }
-};
-
 // src/lark/postContent.ts
 function assertSafeUserId(userId) {
   if (!/^[A-Za-z0-9_:-]+$/.test(userId)) {
@@ -120609,162 +120519,6 @@ async function dispatchResponseSurface(input) {
   return result;
 }
 
-// src/bridge/postProgress.ts
-var DEFAULT_PLACEHOLDER_TEXT = "\u52AA\u529B\u56DE\u7B54\u4E2D...";
-var DEFAULT_PATCH_INTERVAL_MS2 = 1500;
-var DEFAULT_MAX_PROGRESS_EDITS = 16;
-function normalizeText2(text) {
-  return text.replace(/\r\n/g, "\n").trim();
-}
-function progressText(raw, fallback) {
-  const text = normalizeText2(raw);
-  if (!text) return fallback;
-  return text.length > 3500 ? `${text.slice(0, 3500)}
-
-_\u5904\u7406\u4E2D\u5185\u5BB9\u8F83\u957F\uFF0C\u7EC8\u7A3F\u4F1A\u6536\u655B\u3002_` : text;
-}
-var LivePostProgressHandle = class {
-  messageId;
-  idempotencyKey;
-  role = "primary";
-  postClient;
-  patchIntervalMs;
-  maxProgressEdits;
-  initialText;
-  textBuffer = "";
-  lastPatchedText = "";
-  progressEdits = 0;
-  pendingPatch = null;
-  inFlight = Promise.resolve();
-  closed = false;
-  constructor(opts) {
-    this.postClient = opts.postClient;
-    this.messageId = opts.messageId;
-    this.idempotencyKey = opts.idempotencyKey;
-    this.initialText = opts.initialText;
-    this.lastPatchedText = opts.initialText;
-    this.patchIntervalMs = opts.patchIntervalMs;
-    this.maxProgressEdits = opts.maxProgressEdits;
-  }
-  handle(event) {
-    if (this.closed) return;
-    if (event.type === "answer_delta") {
-      this.textBuffer += event.text;
-    } else if (event.type === "answer_snapshot") {
-      this.textBuffer = event.text;
-    } else {
-      return;
-    }
-    this.schedulePatch();
-  }
-  async finalize(opts) {
-    await this.drain();
-    const finalText = normalizeText2(opts.text) || this.initialText;
-    await this.update(finalText, opts.mentions);
-  }
-  async drain() {
-    this.closed = true;
-    if (this.pendingPatch) {
-      clearTimeout(this.pendingPatch);
-      this.pendingPatch = null;
-    }
-    await this.inFlight;
-  }
-  close() {
-    this.closed = true;
-    if (this.pendingPatch) {
-      clearTimeout(this.pendingPatch);
-      this.pendingPatch = null;
-    }
-  }
-  schedulePatch() {
-    if (this.pendingPatch || this.progressEdits >= this.maxProgressEdits) return;
-    this.pendingPatch = setTimeout(() => {
-      this.pendingPatch = null;
-      void this.patchProgress();
-    }, this.patchIntervalMs);
-    this.pendingPatch.unref?.();
-  }
-  async patchProgress() {
-    if (this.closed || this.progressEdits >= this.maxProgressEdits) return;
-    const nextText = progressText(this.textBuffer, this.initialText);
-    if (nextText === this.lastPatchedText) return;
-    this.progressEdits += 1;
-    this.inFlight = this.inFlight.then(() => this.update(nextText)).catch((err) => {
-      console.warn("[post_progress] progress update failed (continuing):", err);
-    });
-    await this.inFlight;
-  }
-  async update(text, mentions = []) {
-    const content = buildPostContent({ text, mentions });
-    await this.postClient.updatePost(this.messageId, content);
-    this.lastPatchedText = text;
-  }
-};
-async function createPostProgressHandle(opts) {
-  const role = "primary";
-  const initialText = normalizeText2(opts.initialText ?? DEFAULT_PLACEHOLDER_TEXT);
-  const idempotencyKey2 = derivePostIdempotencyKey({
-    botId: opts.facts.botId,
-    threadId: opts.facts.threadId,
-    triggerMessageId: opts.facts.triggerMessageId,
-    role,
-    logicalIndex: 0,
-    contentDigest: digestPostContent("live-progress-placeholder")
-  });
-  const sent = await opts.postClient.createPostReply(
-    opts.replyToMessageId,
-    buildPostContent({ text: initialText }),
-    {
-      replyInThread: opts.replyInThread,
-      idempotencyKey: idempotencyKey2
-    }
-  );
-  return new LivePostProgressHandle({
-    postClient: opts.postClient,
-    messageId: sent.messageId,
-    idempotencyKey: idempotencyKey2,
-    initialText,
-    patchIntervalMs: opts.patchIntervalMs ?? DEFAULT_PATCH_INTERVAL_MS2,
-    maxProgressEdits: opts.maxProgressEdits ?? DEFAULT_MAX_PROGRESS_EDITS
-  });
-}
-
-// src/bridge/postBudget.ts
-function scopeKey(scope) {
-  return `${scope.botId}\0${scope.chatId}\0${scope.threadId}`;
-}
-var ResponseSurfacePostBudget = class {
-  buckets = /* @__PURE__ */ new Map();
-  reserve(input) {
-    const nowMs = input.nowMs ?? Date.now();
-    const limit = Math.max(0, Math.floor(input.maxPosts));
-    const windowMs = Math.max(1, Math.floor(input.windowMs));
-    const key = scopeKey(input.scope);
-    const cutoff = nowMs - windowMs;
-    const existing = (this.buckets.get(key) ?? []).filter((ts) => ts > cutoff);
-    if (limit < 1 || existing.length >= limit) {
-      this.buckets.set(key, existing);
-      return {
-        allowed: false,
-        used: existing.length,
-        limit,
-        windowMs,
-        resetAt: existing.length > 0 ? new Date(Math.min(...existing) + windowMs).toISOString() : void 0,
-        reason: "post-window-exhausted"
-      };
-    }
-    const next = [...existing, nowMs];
-    this.buckets.set(key, next);
-    return {
-      allowed: true,
-      used: next.length,
-      limit,
-      windowMs
-    };
-  }
-};
-
 // src/bridge/handler.ts
 var DEFAULT_CARDKIT_RESPONSE_SURFACE_TIMEOUT_MS = 20 * 60 * 1e3;
 function execGit(cwd, args) {
@@ -121021,7 +120775,6 @@ async function createOnlyPostFallback(opts) {
 }
 var BridgeHandler = class {
   deps;
-  responseSurfacePostBudget = new ResponseSurfacePostBudget();
   closed = false;
   constructor(deps) {
     this.deps = deps;
@@ -121134,31 +120887,19 @@ var BridgeHandler = class {
       const isTopLevel = !(typeof parsed.raw.root_id === "string" && parsed.raw.root_id);
       const replyInThread = isTopLevel;
       const prototypeConfig = this.deps.botConfig?.response_surface_prototype;
-      const postOutboundAvailable = isResponseSurfacePostOutboundAvailable(
-        prototypeConfig,
-        { chatId: parsed.chatId, threadId },
-        { postClientAvailable: !!this.deps.postClient }
-      );
       const cardKitAvailable = isResponseSurfaceCardKitAvailable(
         prototypeConfig,
         { chatId: parsed.chatId, threadId },
         { cardKitClientAvailable: !!this.deps.cardKitClient }
       );
-      const surfaceController = SurfaceController.create({
-        prototypeConfig,
-        chatId: parsed.chatId,
-        threadId,
-        postOutboundAvailable: false,
-        postLedgerAvailable: true,
-        visibleFallbackAvailable: true
-      });
       let card;
       let cardKitProgress;
       let cardKitRecord;
       let cardKitStartFailed = false;
-      let progressPost;
-      let progressPostStartFailed = false;
-      if (!cardKitAvailable && surfaceController.shouldStartCardImmediately()) {
+      let legacyCardStartFailed = false;
+      let legacyCardStartFailureReason;
+      let startFailurePostFallbackSent = false;
+      if (!cardKitAvailable) {
         try {
           card = await this.deps.cardRenderer.start(messageId, { replyInThread, threadId });
           await recordEvent({
@@ -121168,6 +120909,8 @@ var BridgeHandler = class {
             reason: "\u5DF2\u4EA4\u7ED9\u672C\u5730 Agent \u5904\u7406\u3002"
           });
         } catch (err) {
+          legacyCardStartFailed = true;
+          legacyCardStartFailureReason = String(err);
           console.error("[bridge.handler] Failed to start card for thread", threadId, err);
           await recordEvent({
             status: "running",
@@ -121183,7 +120926,7 @@ var BridgeHandler = class {
           status: "running",
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           appendPath: "\u5EF6\u8FDF\u521B\u5EFA\u5361\u7247",
-          reason: "response_surface prototype lazy card creation is enabled."
+          reason: "CardKit response surface is available; legacy card is reserved for fallback."
         });
       }
       try {
@@ -121405,72 +121148,34 @@ var BridgeHandler = class {
             }
           }
         }
-        if (!card && !cardKitAvailable && postOutboundAvailable && this.deps.postClient) {
-          const budget = prototypeConfig ? this.responseSurfacePostBudget.reserve({
-            scope: {
-              botId: this.deps.botConfig?.id ?? "v1-default",
-              chatId: parsed.chatId,
-              threadId
-            },
-            maxPosts: prototypeConfig.max_posts_per_window,
-            windowMs: prototypeConfig.post_window_ms
-          }) : void 0;
-          if (budget?.allowed === false) {
-            console.warn("[bridge.handler] post progress budget exhausted; using card fallback");
-            progressPostStartFailed = true;
-          } else {
-            try {
-              progressPost = await createPostProgressHandle({
-                postClient: this.deps.postClient,
-                replyToMessageId: messageId,
-                replyInThread,
-                facts: {
-                  botId: this.deps.botConfig?.id ?? "v1-default",
-                  threadId,
-                  triggerMessageId: messageId
-                },
-                initialText: "\u52AA\u529B\u56DE\u7B54\u4E2D..."
-              });
-              await this.deps.client.removeProcessingReaction?.(messageId);
-              await recordEvent({
-                status: "running",
-                startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-                appendPath: "\u5DF2\u521B\u5EFA post",
-                reason: "response surface \u4F7F\u7528 post \u4F5C\u4E3A\u672C\u8F6E\u4E3B\u56DE\u590D\u9762\u3002"
-              });
-            } catch (err) {
-              progressPostStartFailed = true;
-              console.warn("[bridge.handler] create progress post failed; using card fallback:", err);
-            }
-          }
-        }
-        if (!card && (progressPostStartFailed || cardKitStartFailed)) {
+        if (!card && cardKitStartFailed) {
           try {
             card = await this.deps.cardRenderer.start(messageId, { replyInThread, threadId });
             await this.deps.client.removeProcessingReaction?.(messageId);
             await recordEvent({
               status: "running",
               startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-              appendPath: cardKitStartFailed ? "CardKit \u5931\u8D25\uFF0C\u5DF2\u521B\u5EFA\u5361\u7247" : "post \u5931\u8D25\uFF0C\u5DF2\u521B\u5EFA\u5361\u7247",
-              reason: cardKitStartFailed ? "CardKit \u4E3B\u9762\u521B\u5EFA\u5931\u8D25\uFF0Cbridge \u4F7F\u7528\u53EF\u89C1\u5361\u7247\u515C\u5E95\u3002" : "post \u4E3B\u9762\u521B\u5EFA\u5931\u8D25\uFF0Cbridge \u4F7F\u7528\u53EF\u89C1\u5361\u7247\u515C\u5E95\u3002"
+              appendPath: "CardKit \u5931\u8D25\uFF0C\u5DF2\u521B\u5EFA\u5361\u7247",
+              reason: "CardKit \u4E3B\u9762\u521B\u5EFA\u5931\u8D25\uFF0Cbridge \u4F7F\u7528\u53EF\u89C1\u5361\u7247\u515C\u5E95\u3002"
             });
           } catch (err) {
             console.error(
               "[bridge.handler] visible card fallback start failed after primary surface start failure:",
               err
             );
-            await createOnlyPostFallback({
+            const postFallback = await createOnlyPostFallback({
               postClient: this.deps.postClient,
               replyToMessageId: messageId,
               replyInThread,
               botId: this.deps.botConfig?.id ?? "v1-default",
               threadId,
               triggerMessageId: messageId,
-              finalText: cardKitStartFailed ? "CardKit \u4E3B\u56DE\u590D\u9762\u521B\u5EFA\u5931\u8D25, legacy \u53EF\u89C1\u5361\u7247\u515C\u5E95\u4E5F\u521B\u5EFA\u5931\u8D25\u3002" : "post \u4E3B\u56DE\u590D\u9762\u521B\u5EFA\u5931\u8D25, legacy \u53EF\u89C1\u5361\u7247\u515C\u5E95\u4E5F\u521B\u5EFA\u5931\u8D25\u3002",
+              finalText: "CardKit \u4E3B\u56DE\u590D\u9762\u521B\u5EFA\u5931\u8D25, legacy \u53EF\u89C1\u5361\u7247\u515C\u5E95\u4E5F\u521B\u5EFA\u5931\u8D25\u3002",
               failureReason: String(err),
               title: "Larkway fallback",
               logPrefix: "[bridge.handler]"
             });
+            if (postFallback) startFailurePostFallbackSent = true;
             await this.deps.client.removeProcessingReaction?.(messageId);
             await recordEvent({
               status: "running",
@@ -121560,7 +121265,6 @@ var BridgeHandler = class {
             for await (const ev of handle.events) {
               if (cardKitProgress) cardKitProgress.handle(ev);
               else if (card) card.handle(ev);
-              else progressPost?.handle(ev);
               if (ev.type === "system_init") {
                 sessionId = ev.sessionId;
               }
@@ -121707,7 +121411,6 @@ var BridgeHandler = class {
                 }
               }
             } else {
-              await progressPost?.drain();
               const surfaceDispatch = await dispatchResponseSurface({
                 state: reportedState,
                 prototypeConfig,
@@ -121725,80 +121428,90 @@ var BridgeHandler = class {
                 postOutboundAvailable: false,
                 postLedgerAvailable: true,
                 visibleFallbackAvailable: true,
-                postClient: this.deps.postClient,
-                livePost: progressPost ? {
-                  messageId: progressPost.messageId,
-                  idempotencyKey: progressPost.idempotencyKey,
-                  role: progressPost.role
-                } : void 0,
-                postBudget: prototypeConfig ? {
-                  reserve: () => this.responseSurfacePostBudget.reserve({
-                    scope: {
-                      botId: this.deps.botConfig?.id ?? "v1-default",
-                      chatId: parsed.chatId,
-                      threadId
-                    },
-                    maxPosts: prototypeConfig.max_posts_per_window,
-                    windowMs: prototypeConfig.post_window_ms
-                  })
-                } : void 0
+                postClient: this.deps.postClient
               });
               if (surfaceDispatch.card) {
                 if (!card) {
-                  card = await this.deps.cardRenderer.start(messageId, { replyInThread, threadId });
                   try {
-                    await writeCardFile(worktreePath, {
-                      messageId: card.messageId,
-                      chatId: parsed.chatId,
-                      threadId,
-                      botId: this.deps.botConfig?.id ?? "",
-                      replyInThread,
-                      createdAt: (/* @__PURE__ */ new Date()).toISOString()
-                    });
-                  } catch (err) {
-                    console.warn("[bridge.handler] writeCardFile(late) failed (continuing):", err);
-                  }
-                }
-                await card.finalize(surfaceDispatch.card);
-                let keepCardFileForRetry = false;
-                if (surfaceDispatch.post?.requiresFallbackLedgerMark) {
-                  try {
-                    await markPostLedgerFallbackVisible(
-                      worktreePath,
-                      surfaceDispatch.post.idempotencyKey,
-                      {
-                        fallbackCardMessageId: card.messageId,
-                        error: surfaceDispatch.post.fallbackError ?? surfaceDispatch.card.failureReason ?? "post outbound failed; visible card fallback used"
-                      }
-                    );
+                    card = await this.deps.cardRenderer.start(messageId, { replyInThread, threadId });
+                    try {
+                      await writeCardFile(worktreePath, {
+                        messageId: card.messageId,
+                        chatId: parsed.chatId,
+                        threadId,
+                        botId: this.deps.botConfig?.id ?? "",
+                        replyInThread,
+                        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+                      });
+                    } catch (err) {
+                      console.warn("[bridge.handler] writeCardFile(late) failed (continuing):", err);
+                    }
                   } catch (err) {
-                    keepCardFileForRetry = true;
-                    console.warn(
-                      "[bridge.handler] fallback ledger mark failed after visible card finalize; keeping card.json for retry:",
+                    console.error(
+                      "[bridge.handler] late visible card fallback start failed; creating post fallback:",
                       err
                     );
+                    const failureReason2 = [
+                      legacyCardStartFailed ? `initial legacy visible card start failed: ${legacyCardStartFailureReason ?? "unknown"}` : void 0,
+                      `late legacy visible card fallback start failed: ${String(err)}`
+                    ].filter((part) => !!part).join("; ");
+                    const postFallback = await createOnlyPostFallback({
+                      postClient: this.deps.postClient,
+                      replyToMessageId: messageId,
+                      replyInThread,
+                      botId: this.deps.botConfig?.id ?? "v1-default",
+                      threadId,
+                      triggerMessageId: messageId,
+                      finalText: surfaceDispatch.card.finalText ?? "Larkway completed but no visible card was available.",
+                      failureReason: failureReason2,
+                      title: surfaceDispatch.card.titleOverride ?? "Larkway fallback",
+                      logPrefix: "[bridge.handler]"
+                    });
+                    if (!postFallback) throw err;
                   }
                 }
-                if (surfaceDispatch.post?.requiresPolicyLedgerMark) {
-                  try {
-                    await markPostLedgerPolicyBlockedVisible(
-                      worktreePath,
-                      surfaceDispatch.post.idempotencyKey,
-                      {
-                        fallbackCardMessageId: card.messageId,
-                        error: surfaceDispatch.post.policyError ?? surfaceDispatch.card.failureReason ?? "mention policy blocked; visible card fallback used"
-                      }
-                    );
-                  } catch (err) {
-                    keepCardFileForRetry = true;
-                    console.warn(
-                      "[bridge.handler] policy-blocked ledger mark failed after visible card finalize; keeping card.json for retry:",
-                      err
-                    );
+                if (card) {
+                  await card.finalize(surfaceDispatch.card);
+                  let keepCardFileForRetry = false;
+                  if (surfaceDispatch.post?.requiresFallbackLedgerMark) {
+                    try {
+                      await markPostLedgerFallbackVisible(
+                        worktreePath,
+                        surfaceDispatch.post.idempotencyKey,
+                        {
+                          fallbackCardMessageId: card.messageId,
+                          error: surfaceDispatch.post.fallbackError ?? surfaceDispatch.card.failureReason ?? "post outbound failed; visible card fallback used"
+                        }
+                      );
+                    } catch (err) {
+                      keepCardFileForRetry = true;
+                      console.warn(
+                        "[bridge.handler] fallback ledger mark failed after visible card finalize; keeping card.json for retry:",
+                        err
+                      );
+                    }
+                  }
+                  if (surfaceDispatch.post?.requiresPolicyLedgerMark) {
+                    try {
+                      await markPostLedgerPolicyBlockedVisible(
+                        worktreePath,
+                        surfaceDispatch.post.idempotencyKey,
+                        {
+                          fallbackCardMessageId: card.messageId,
+                          error: surfaceDispatch.post.policyError ?? surfaceDispatch.card.failureReason ?? "mention policy blocked; visible card fallback used"
+                        }
+                      );
+                    } catch (err) {
+                      keepCardFileForRetry = true;
+                      console.warn(
+                        "[bridge.handler] policy-blocked ledger mark failed after visible card finalize; keeping card.json for retry:",
+                        err
+                      );
+                    }
+                  }
+                  if (!keepCardFileForRetry) {
+                    await deleteCardFile(worktreePath);
                   }
-                }
-                if (!keepCardFileForRetry) {
-                  await deleteCardFile(worktreePath);
                 }
               }
             }
@@ -121877,25 +121590,10 @@ var BridgeHandler = class {
             }
           }
         }
-        if (!card && progressPost) {
-          try {
-            await progressPost.finalize({
-              text: `\u6267\u884C\u5931\u8D25: ${String(err)}`
-            });
-          } catch (postFinalizeErr) {
-            console.error(
-              "[bridge.handler] progress post failure update failed; creating card fallback:",
-              postFinalizeErr
-            );
-            try {
-              card = await this.deps.cardRenderer.start(messageId, { replyInThread, threadId });
-            } catch (cardStartErr) {
-              console.error("[bridge.handler] failure card start also failed:", cardStartErr);
-              await createHardFailurePostFallback(
-                `progress post failure update failed: ${String(postFinalizeErr)}; legacy visible card fallback also failed: ${String(cardStartErr)}`
-              );
-            }
-          }
+        if (!card && !cardKitProgress && !startFailurePostFallbackSent) {
+          await createHardFailurePostFallback(
+            legacyCardStartFailed ? `legacy visible card was unavailable before agent failure: ${legacyCardStartFailureReason ?? "unknown"}` : "no visible response surface was available before agent failure"
+          );
         }
         if (card) {
           try {
@@ -126045,127 +125743,104 @@ function buildCodexEnv(botGitIdentity, gitlabToken) {
   }
   return env;
 }
-function sandboxFlag(mode) {
-  switch (mode) {
-    case "bypassPermissions":
-      return ["--dangerously-bypass-approvals-and-sandbox"];
-    case "acceptEdits":
-      return ["--dangerously-bypass-approvals-and-sandbox"];
-    case "ask":
-      return ["--sandbox", "read-only"];
-  }
+function buildCodexCommand(opts, codexBinPath = "codex") {
+  void opts;
+  return [codexBinPath, ["app-server", "--stdio"]];
 }
-function resumePermissionFlag(mode) {
-  return mode === "bypassPermissions" || mode === "acceptEdits" ? ["--dangerously-bypass-approvals-and-sandbox"] : [];
+function codexThreadSandboxMode(mode) {
+  return mode === "ask" ? "read-only" : "danger-full-access";
 }
-function buildCodexCommand(opts, codexBinPath = "codex") {
-  const mode = opts.permissionMode ?? "acceptEdits";
-  const commonFlags = [
-    "--json",
-    "--skip-git-repo-check",
-    ...sandboxFlag(mode)
-  ];
-  if (opts.resumeSessionId != null) {
-    const resumeFlags = [
-      "--json",
-      "--skip-git-repo-check",
-      ...resumePermissionFlag(mode)
-    ];
-    return [
-      codexBinPath,
-      ["exec", "resume", opts.resumeSessionId, ...resumeFlags, "-"]
-    ];
-  }
-  const freshFlags = opts.cwd != null ? ["-C", opts.cwd, ...commonFlags] : commonFlags;
-  return [codexBinPath, ["exec", ...freshFlags]];
+function codexTurnSandboxPolicy(mode) {
+  if (mode === "ask") return { type: "readOnly", networkAccess: false };
+  return { type: "dangerFullAccess" };
+}
+function codexApprovalPolicy(mode) {
+  return mode === "ask" ? "on-request" : "never";
 }
-var CodexLineParser = class {
+var CodexAppServerLineParser = class {
   answerExtractor = new AnswerChannelExtractor();
-  *parseLine(line) {
-    const trimmed = line.trim();
-    if (trimmed === "") return;
-    let obj;
-    try {
-      obj = JSON.parse(trimmed);
-    } catch {
-      yield { type: "raw", raw: trimmed };
-      return;
-    }
+  *parseMessage(obj) {
     if (typeof obj !== "object" || obj === null) {
       yield { type: "raw", raw: obj };
       return;
     }
     const record = obj;
-    const topType = record["type"];
-    if (topType === "thread.started" && typeof record["thread_id"] === "string") {
-      yield { type: "system_init", sessionId: record["thread_id"], raw: obj };
+    const method = record["method"];
+    if (typeof method !== "string") {
+      yield { type: "raw", raw: obj };
       return;
     }
-    if (topType === "turn.completed") {
+    const params = asRecord(record["params"]);
+    if (method === "thread/started") {
+      const thread = asRecord(params?.["thread"]);
+      const threadId = typeof thread?.["id"] === "string" ? thread["id"] : void 0;
+      if (threadId) yield { type: "system_init", sessionId: threadId, raw: obj };
+      return;
+    }
+    if (method === "turn/completed") {
       yield { type: "result", stopReason: "end_turn", raw: obj };
       return;
     }
-    const agentMessageText = agentMessageTextFrom(record);
-    if (agentMessageText !== void 0) {
-      if (topType === "item.completed") {
-        yield* this.answerExtractor.ingestSnapshot(agentMessageText, obj);
-        return;
-      }
-      yield* this.answerExtractor.ingestGrowingSnapshot(agentMessageText, obj);
+    if (method === "item/agentMessage/delta") {
+      const delta = typeof params?.["delta"] === "string" ? params["delta"] : "";
+      yield* this.answerExtractor.ingestDelta(delta, obj);
       return;
     }
-    if (topType === "item.started") {
-      const item = record["item"];
-      if (typeof item === "object" && item !== null) {
-        const itemRecord = item;
-        if (itemRecord["type"] === "command_execution" && typeof itemRecord["command"] === "string") {
-          yield {
-            type: "tool_use",
-            toolName: "shell",
-            toolInput: { command: itemRecord["command"] },
-            raw: obj
-          };
-          return;
-        }
+    if (method === "item/started") {
+      const item = asRecord(params?.["item"]);
+      if (item?.["type"] === "commandExecution" && typeof item["command"] === "string") {
+        yield {
+          type: "tool_use",
+          toolName: "shell",
+          toolInput: { command: item["command"] },
+          raw: obj
+        };
+        return;
       }
-      yield { type: "raw", raw: obj };
       return;
     }
-    if (topType === "item.completed") {
-      const item = record["item"];
-      if (typeof item === "object" && item !== null) {
-        const itemRecord = item;
-        if (itemRecord["type"] === "command_execution") {
-          yield { type: "tool_result", raw: obj };
-          return;
-        }
+    if (method === "item/completed") {
+      const item = asRecord(params?.["item"]);
+      if (item?.["type"] === "commandExecution") {
+        yield { type: "tool_result", raw: obj };
+        return;
+      }
+      if (item?.["type"] === "agentMessage" && typeof item["text"] === "string") {
+        yield* this.answerExtractor.ingestSnapshot(item["text"], obj);
+        return;
       }
-      yield { type: "raw", raw: obj };
       return;
     }
     yield { type: "raw", raw: obj };
   }
 };
-function agentMessageTextFrom(record) {
-  const item = record["item"];
-  if (typeof item !== "object" || item === null) return void 0;
-  const itemRecord = item;
-  if (itemRecord["type"] !== "agent_message") return void 0;
-  const text = itemRecord["text"];
-  return typeof text === "string" ? text : void 0;
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function extractThreadIdFromThreadResponse(obj) {
+  const record = asRecord(obj);
+  const result = asRecord(record?.["result"]);
+  const thread = asRecord(result?.["thread"]);
+  const threadId = thread?.["id"];
+  return typeof threadId === "string" ? threadId : void 0;
 }
 function runCodex(opts, codexBinPath = "codex") {
   const timeoutMs = opts.timeoutMs ?? 15 * 60 * 1e3;
   const [bin, args] = buildCodexCommand(opts, codexBinPath);
   const env = buildCodexEnv(opts.botGitIdentity, opts.gitlabToken);
+  const mode = opts.permissionMode ?? "acceptEdits";
+  const requestById = /* @__PURE__ */ new Map();
+  let nextRequestId = 1;
   const child = spawn3(bin, args, {
     env,
     stdio: ["pipe", "pipe", "pipe"],
     ...opts.cwd != null ? { cwd: opts.cwd } : {}
   });
-  if (child.stdin != null) {
-    child.stdin.write(opts.prompt, "utf8");
-    child.stdin.end();
+  function sendRequest(method, params) {
+    const id = nextRequestId++;
+    requestById.set(id, method);
+    child.stdin?.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
+    return id;
   }
   let discoveredSessionId;
   let killScheduled = false;
@@ -126179,6 +125854,10 @@ function runCodex(opts, codexBinPath = "codex") {
     }, SIGKILL_GRACE_MS2);
     killTimer.unref();
   }
+  function stopAppServerAfterTurn() {
+    if (child.killed || killScheduled) return;
+    child.kill("SIGTERM");
+  }
   const TOTAL_TIMEOUT_EXTRA_MS = SIGKILL_GRACE_MS2 + 2e3;
   let totalTimeoutFallbackHandle;
   let _forceFinalizeForTimeout = () => {
@@ -126201,6 +125880,8 @@ function runCodex(opts, codexBinPath = "codex") {
   const stderrChunks = [];
   child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
   const rlAbortController = new AbortController();
+  let finishAppServerTurn;
+  let failAppServerTurn;
   const done = new Promise(
     (resolve2, reject) => {
       let settled = false;
@@ -126230,6 +125911,17 @@ stderr: ${stderr}` : "")
         }
         resolve2({ exitCode, sessionId: discoveredSessionId });
       };
+      const finalizeReject = (err) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeoutHandle);
+        clearTimeout(killTimer);
+        clearTimeout(totalTimeoutFallbackHandle);
+        rlAbortController.abort();
+        reject(err);
+      };
+      finishAppServerTurn = finalizeResolve;
+      failAppServerTurn = finalizeReject;
       _forceFinalizeForTimeout = () => {
         if (settled) return;
         console.warn(
@@ -126277,15 +125969,76 @@ stderr: ${stderr}` : "")
       crlfDelay: Infinity,
       signal: rlAbortController.signal
     });
-    const parser = new CodexLineParser();
+    const parser = new CodexAppServerLineParser();
+    let turnCompleted = false;
+    sendRequest("initialize", {
+      clientInfo: { name: "larkway", version: "0.3" },
+      capabilities: {}
+    });
     try {
       for await (const line of rl) {
-        for (const event of parser.parseLine(line)) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let obj;
+        try {
+          obj = JSON.parse(trimmed);
+        } catch {
+          yield { type: "raw", raw: trimmed };
+          continue;
+        }
+        const response = asRecord(obj);
+        if (typeof response?.["id"] === "number") {
+          const id = response["id"];
+          const method = requestById.get(id);
+          requestById.delete(id);
+          const error = asRecord(response["error"]);
+          if (error) {
+            const message = typeof error["message"] === "string" ? error["message"] : JSON.stringify(error);
+            failAppServerTurn?.(new Error(`codex app-server ${method ?? "request"} failed: ${message}`));
+            stopAppServerAfterTurn();
+            return;
+          }
+          if (method === "initialize") {
+            const threadMethod = opts.resumeSessionId != null ? "thread/resume" : "thread/start";
+            const threadParams = opts.resumeSessionId != null ? { threadId: opts.resumeSessionId } : { ephemeral: false, sessionStartSource: "startup" };
+            if (opts.cwd != null) threadParams["cwd"] = opts.cwd;
+            threadParams["approvalPolicy"] = codexApprovalPolicy(mode);
+            threadParams["sandbox"] = codexThreadSandboxMode(mode);
+            sendRequest(threadMethod, threadParams);
+            continue;
+          }
+          if (method === "thread/start" || method === "thread/resume") {
+            const threadId = extractThreadIdFromThreadResponse(obj);
+            if (threadId) {
+              discoveredSessionId = threadId;
+              yield { type: "system_init", sessionId: threadId, raw: obj };
+              const turnParams = {
+                threadId,
+                input: [{ type: "text", text: opts.prompt, text_elements: [] }],
+                approvalPolicy: codexApprovalPolicy(mode),
+                sandboxPolicy: codexTurnSandboxPolicy(mode)
+              };
+              if (opts.cwd != null) turnParams["cwd"] = opts.cwd;
+              sendRequest("turn/start", turnParams);
+            }
+            continue;
+          }
+          continue;
+        }
+        for (const event of parser.parseMessage(obj)) {
           if (event.type === "system_init") {
             discoveredSessionId = event.sessionId;
           }
+          if (event.type === "result") {
+            turnCompleted = true;
+          }
           yield event;
         }
+        if (turnCompleted) {
+          stopAppServerAfterTurn();
+          finishAppServerTurn?.(0);
+          return;
+        }
       }
     } catch (err) {
       const isAbort = err instanceof Error && (err.name === "AbortError" || err.code === "ABORT_ERR");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larkway",
-  "version": "0.3.26",
+  "version": "0.3.27",
   "description": "Thin bridge: Feishu thread to local Claude Code CLI",
   "license": "MIT",
   "author": "Chuck Wu (chuckwu0)",