@parall/parel-channel 1.42.0 → 1.43.0

package/dist/channel-capability.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Channel-capability credential injection — the parel-native form of the
+ * feishu-cli broker (multi-channel-architecture-design §8.3).
+ *
+ * Bridges deliver the capability as a PATH pointer shim that mints a fresh
+ * short-lived tenant token per lark-cli invocation. In parel we control
+ * neither the sandbox PATH nor a bridge process — but we DO control the
+ * per-turn invocation context, which sandbox-e2b flattens into every exec's
+ * env. So the connector mints at emit time and injects the official
+ * LARKSUITE_CLI_* env set: bare `lark-cli` works ambiently for the whole
+ * turn (turn length ≪ token TTL ~2h), the app secret never leaves the
+ * platform, and revocation bites on the next emit's mint (403 → no env).
+ *
+ * The mint endpoint IS the gate (the platform re-evaluates connection state
+ * + flag on every request — the no-drift invariant), so the connector needs
+ * no declaration-plane fetch: a 403 is the revocation signal and is
+ * negative-cached briefly to keep a revoked grant from adding one 403 per
+ * turn.
+ */
+import type { ConnectorContext } from '@parel/plugin-sdk';
+/** Test hook: the cache is module-level state, so suites reset it between cases. */
+export declare function resetChannelCapabilityCache(): void;
+/**
+ * Returns the feishu-cli env set to spread into an envelope's invocation
+ * context, or null when the capability is not granted (or the mint degraded
+ * — a transient platform error must never block a dispatch emit).
+ */
+export declare function channelCapabilityEnv(ctx: ConnectorContext): Promise<Record<string, string> | null>;
+//# sourceMappingURL=channel-capability.d.ts.map

package/dist/channel-capability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-capability.d.ts","sourceRoot":"","sources":["../src/channel-capability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAkC1D,oFAAoF;AACpF,wBAAgB,2BAA2B,IAAI,IAAI,CAElD;AAcD;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,CA2CxC"}

package/dist/channel-capability.js

@@ -0,0 +1,81 @@
+import { parallApiUrl, parallOrgId, requireAgk } from './connect.js';
+const MINT_TIMEOUT_MS = 5_000;
+// Re-mint this long before the token expires so an env set injected at turn
+// start stays valid through a long turn's tail.
+const EXPIRY_SKEW_MS = 10 * 60 * 1000;
+// After a 403 (no grant / revoked / flag off), skip minting for this long —
+// revocation latency stays bounded while per-turn 403 noise does not.
+const DENIED_TTL_MS = 60 * 1000;
+// A GRANTED result is re-validated on the same cadence: the mint endpoint IS
+// the revocation gate, so a positive cache lasting the token TTL (~2h) would
+// extend revocation latency to hours. Re-minting is cheap (the platform
+// Redis-caches the exchanged token and re-evaluates the gate per request);
+// this cache only absorbs bursty emits within a conversation.
+const GRANTED_TTL_MS = 60 * 1000;
+// Per-connection cache. The plugin isolate is per-connection, so a plain
+// module map keyed by connectionId is effectively single-entry — the key
+// guards against isolate reuse across connections.
+const cache = new Map();
+/** Test hook: the cache is module-level state, so suites reset it between cases. */
+export function resetChannelCapabilityCache() {
+    cache.clear();
+}
+function envFromMint(minted) {
+    return {
+        LARKSUITE_CLI_APP_ID: minted.app_id,
+        LARKSUITE_CLI_BRAND: minted.brand || 'feishu',
+        LARKSUITE_CLI_TENANT_ACCESS_TOKEN: minted.token,
+        // Bot lock: the credential is the app's, not a human's — mirror the
+        // bridge shim's injection exactly (agent-core channel-exec).
+        LARKSUITE_CLI_DEFAULT_AS: 'bot',
+        LARKSUITE_CLI_STRICT_MODE: 'bot',
+    };
+}
+/**
+ * Returns the feishu-cli env set to spread into an envelope's invocation
+ * context, or null when the capability is not granted (or the mint degraded
+ * — a transient platform error must never block a dispatch emit).
+ */
+export async function channelCapabilityEnv(ctx) {
+    const key = ctx.connectionId;
+    const now = Date.now();
+    const hit = cache.get(key);
+    if (hit && hit.validUntil > now)
+        return hit.env;
+    try {
+        const res = await fetch(`${parallApiUrl(ctx)}/api/v1/orgs/${encodeURIComponent(parallOrgId(ctx))}/agents/me/channel-token`, {
+            method: 'POST',
+            headers: {
+                authorization: `Bearer ${requireAgk(ctx)}`,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({ channel_type: 'feishu' }),
+            signal: AbortSignal.timeout(MINT_TIMEOUT_MS),
+        });
+        if (res.status === 403 || res.status === 404) {
+            // No grant (never had it / revoked / flag off) — or an old server
+            // without the endpoint. Same agent-facing outcome: no capability.
+            cache.set(key, { env: null, validUntil: now + DENIED_TTL_MS });
+            return null;
+        }
+        if (!res.ok) {
+            // Transient (5xx/502-mint-upstream): don't cache, don't block the emit.
+            return null;
+        }
+        const minted = (await res.json());
+        if (!minted?.token || !minted.app_id)
+            return null;
+        const env = envFromMint(minted);
+        const expiresAt = Date.parse(minted.expires_at);
+        // Bounded by BOTH the revalidation cadence (revocation latency) and the
+        // token's own remaining life (an injected env must outlive the turn).
+        const tokenBound = Number.isFinite(expiresAt) ? expiresAt - EXPIRY_SKEW_MS : now;
+        const validUntil = Math.max(now + 5_000, Math.min(now + GRANTED_TTL_MS, tokenBound));
+        cache.set(key, { env, validUntil });
+        return env;
+    }
+    catch {
+        // Network failure — degrade to "no env this turn"; the next emit retries.
+        return null;
+    }
+}

package/dist/channel-prompt.d.ts

@@ -16,15 +16,15 @@
  *
  * - The audience is OUTSIDE Parall — no prll:// refs, no internal cards or
  *   attachment links in the reply (dead links there).
- * - The reply goes out through the provider clip's `send_message` command.
- *   A parel agent invokes clips from its sandbox via the parall CLI, so the
- *   hint spells out the concrete `parall clip invoke …` command (agent-core
- *   leaves the invocation mechanism to the bridge's own clip tooling).
- * - Provider metadata is best-effort (the connection lookup can fail) —
- *   never instruct the agent to invoke a made-up clip alias.
+ * - Single-path reply (multi-channel-architecture-design §6): with the
+ *   feishu-cli capability granted, the reply goes out through the official
+ *   lark-cli — auth rides the turn's invocation context env
+ *   (channel-capability.ts), so bare `lark-cli` works in the sandbox.
+ *   Without the grant there is no outbound path and the hint says so (the
+ *   provider clip path is retired).
  * - When the inbound external message id is known, offer the in-thread reply
- *   form ({"message_id": …}) so threaded conversations aren't nudged toward
- *   new top-level messages.
+ *   form so threaded conversations aren't nudged toward new top-level
+ *   messages.
  */
 export interface PromptAttachment {
     id: string;
@@ -52,7 +52,7 @@ export interface ChatPromptArgs {
  */
 export declare function buildChatPrompt(args: ChatPromptArgs): string;
 export interface ChannelPromptArgs {
-    /** Provider name (= clip alias, e.g. "feishu"); undefined when unresolved. */
+    /** Provider name (e.g. "feishu"); undefined when unresolved. */
     provider?: string;
     /** Conversation shape as recorded on the ChannelConversation (dm/group). */
     conversationType?: string;
@@ -61,6 +61,13 @@ export interface ChannelPromptArgs {
     senderName: string;
     /** The inbound message text (raw, un-framed). */
     text: string;
+    /**
+     * Live capability grant: the turn's invocation context carries the minted
+     * LARKSUITE_CLI_* env, so bare `lark-cli` works in the sandbox and is THE
+     * reply path. False → outbound is disabled for this org (no grant); the
+     * hint says so instead of pointing at the retired provider clip.
+     */
+    cliCapable?: boolean;
 }
 export declare function buildChannelPrompt(args: ChannelPromptArgs): string;
 //# sourceMappingURL=channel-prompt.d.ts.map

package/dist/channel-prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"channel-prompt.d.ts","sourceRoot":"","sources":["../src/channel-prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AASH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,WAAW,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAClC;AAmBD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAU5D;AAED,MAAM,WAAW,iBAAiB;IAChC,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAkBlE"}
+{"version":3,"file":"channel-prompt.d.ts","sourceRoot":"","sources":["../src/channel-prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AASH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,WAAW,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAClC;AAmBD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAU5D;AAED,MAAM,WAAW,iBAAiB;IAChC,gEAAgE;IAChE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAkBlE"}

package/dist/channel-prompt.js

@@ -16,15 +16,15 @@
  *
  * - The audience is OUTSIDE Parall — no prll:// refs, no internal cards or
  *   attachment links in the reply (dead links there).
- * - The reply goes out through the provider clip's `send_message` command.
- *   A parel agent invokes clips from its sandbox via the parall CLI, so the
- *   hint spells out the concrete `parall clip invoke …` command (agent-core
- *   leaves the invocation mechanism to the bridge's own clip tooling).
- * - Provider metadata is best-effort (the connection lookup can fail) —
- *   never instruct the agent to invoke a made-up clip alias.
+ * - Single-path reply (multi-channel-architecture-design §6): with the
+ *   feishu-cli capability granted, the reply goes out through the official
+ *   lark-cli — auth rides the turn's invocation context env
+ *   (channel-capability.ts), so bare `lark-cli` works in the sandbox.
+ *   Without the grant there is no outbound path and the hint says so (the
+ *   provider clip path is retired).
  * - When the inbound external message id is known, offer the in-thread reply
- *   form ({"message_id": …}) so threaded conversations aren't nudged toward
- *   new top-level messages.
+ *   form so threaded conversations aren't nudged toward new top-level
+ *   messages.
  */
 function sanitizeMeta(value) {
     return value
@@ -85,16 +85,22 @@ export function buildChannelPrompt(args) {
     return lines.join('\n') + buildChannelReplyHint(args);
 }
 function buildChannelReplyHint(args) {
-    const target = JSON.stringify({
-        chat_id: args.externalConversationId || '<conversation id>',
-        text: '...',
-    });
-    const threadAlt = args.externalMessageId
-        ? ` To reply in-thread to this specific message, use '${JSON.stringify({ message_id: args.externalMessageId, text: '...' })}' instead.`
-        : '';
-    if (args.provider) {
-        const alias = args.provider;
-        return `\n<system-reminder>To reply, invoke the \`${alias}\` clip's \`send_message\` command from your sandbox: \`parall clip invoke ${alias} send_message '${target}'\` — your plain text output is NOT delivered to the external conversation.${threadAlt} The same clip's \`call\` command reaches the wider ${alias} API when needed.</system-reminder>`;
+    // Single-path routing (multi-channel-architecture-design §6/§8.3): with
+    // the feishu-cli grant, the minted LARKSUITE_CLI_* env rides this turn's
+    // invocation context, so the official lark-cli works ambiently in the
+    // sandbox and is THE reply path. Without the grant there is no outbound
+    // path — say so instead of pointing at the retired provider clip.
+    // cliCapable alone decides: the mint is feishu-specific, so a successful
+    // grant implies Feishu even when the cosmetic provider-label lookup failed.
+    if (args.cliCapable) {
+        const convRef = args.externalConversationId
+            ? `chat_id "${args.externalConversationId}"`
+            : 'the conversation id named in this event';
+        const threadAlt = args.externalMessageId
+            ? ` To reply threaded to this specific message, reference message_id "${args.externalMessageId}".`
+            : '';
+        return `\n<system-reminder>To reply, use the official Feishu CLI in your sandbox: send a message to ${convRef} with \`lark-cli im\` (see \`lark-cli im --help\` for send syntax; auth is provisioned in your environment — if lark-cli is missing, install it once with \`npm i -g @larksuite/cli\`).${threadAlt} lark-cli is the ONLY outbound path — your plain text output is NOT delivered to the external conversation.</system-reminder>`;
     }
-    return `\n<system-reminder>To reply, invoke your channel provider clip's \`send_message\` command from your sandbox: \`parall clip invoke <alias> send_message '${target}'\` (find the alias with \`parall clip list\`) — your plain text output is NOT delivered to the external conversation.${threadAlt} The same clip's \`call\` command reaches the wider external platform API when needed.</system-reminder>`;
+    const platform = args.provider ?? 'the external platform';
+    return `\n<system-reminder>This message arrived from ${platform}, but outbound replies are currently disabled for this org (no channel capability granted). Do NOT attempt to reply on the external platform. If action is needed, surface it inside Parall (\`parall messages send\` / \`parall dm\`). Your plain text output is not delivered anywhere.</system-reminder>`;
 }

package/dist/fork.d.ts

@@ -1,5 +1,8 @@
-import type { ConnectorContext } from '@parel/plugin-sdk';
-import type { AgentEventWithChild, ChildSpawnFailedEvent } from './parel-sdk-compat.js';
+import type { AgentEvent, ConnectorContext } from '@parel/plugin-sdk';
+/** The child-spawn failure variant of the sdk's AgentEvent union. */
+type ChildSpawnFailedEvent = Extract<AgentEvent, {
+    type: 'child_spawn_failed';
+}>;
 /** Delay before a failed spawn's messages are re-driven through onTimer. */
 export declare const FORK_RETRY_DELAY_MS = 15000;
 export declare const FORK_RETRY_PREFIX = "forkRetry:";
@@ -99,12 +102,12 @@ export declare function clearForkState(ctx: ConnectorContext): Promise<string[]>
  * Track main-session busyness from the E1 turn stream. Child events (they
  * carry childRef) must NOT feed this — only the main session's turns do.
  */
-export declare function noteMainTurnEvent(ctx: ConnectorContext, event: AgentEventWithChild): Promise<void>;
+export declare function noteMainTurnEvent(ctx: ConnectorContext, event: AgentEvent): Promise<void>;
 /**
  * Resolve a child event's bookkeeping row (by its subject mirror) and fire
  * the pending spawn ack exactly once. Returns the ack request when due.
  */
-export declare function settleChildEvent(ctx: ConnectorContext, event: AgentEventWithChild): Promise<{
+export declare function settleChildEvent(ctx: ConnectorContext, event: AgentEvent): Promise<{
     subject: string;
     pendingAcks: PendingAck[];
 } | null>;
@@ -145,4 +148,5 @@ export declare function handleChildSpawnFailed(ctx: ConnectorContext, event: Chi
  * covers them.
  */
 export declare function buildForkScopePrefix(subject: string, threadRootId?: string): string;
+export {};
 //# sourceMappingURL=fork.d.ts.map

package/dist/fork.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fork.d.ts","sourceRoot":"","sources":["../src/fork.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AA+CxF,4EAA4E;AAC5E,eAAO,MAAM,mBAAmB,QAAS,CAAC;AAS1C,eAAO,MAAM,iBAAiB,eAAe,CAAC;AAW9C,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B,gFAAgF;IAChF,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;2CAEuC;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE;AAClB;oEACoE;GAClE;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GAC1D;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAMxC;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,gBAAgB,EACrB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,YAAY,CAAC,CAwCvB;AAED;;sEAEsE;AACtE,wBAAsB,WAAW,CAC/B,GAAG,EAAE,gBAAgB,EACrB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,IAAI,CAAC,CAQf;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,gBAAgB,EACrB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,UAAU,GACd,OAAO,CAAC,OAAO,CAAC,CASlB;AAED;;;+EAG+E;AAC/E,wBAAsB,aAAa,CAAC,GAAG,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO7F;AAED,0EAA0E;AAC1E,wBAAsB,cAAc,CAClC,GAAG,EAAE,gBAAgB,EACrB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,CAAC,CAGlB;AAED,8EAA8E;AAC9E,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,gBAAgB,EACrB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CAMf;AAED;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,gBAAgB,EACrB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,MAAM,CAAC,CAOjB;AAED,iEAAiE;AACjE,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAoB7E;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,gBAAgB,EACrB,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC,IAAI,CAAC,CAcf;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,gBAAgB,EACrB,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,UAAU,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,CA+BhE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,gBAAgB,EACrB,KAAK,EAAE,qBAAqB,GAC3B,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,UAAU,EAAE,CAAA;CAAE,CAAC,CA2B3E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAYnF"}
+{"version":3,"file":"fork.d.ts","sourceRoot":"","sources":["../src/fork.ts"],"names":[],"mappings":"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"}

package/dist/inbound-channel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inbound-channel.d.ts","sourceRoot":"","sources":["../src/inbound-channel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAiB3E;;;;GAIG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAEhD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,eAAe,EAAE,CAAC,CA6J5B"}
+{"version":3,"file":"inbound-channel.d.ts","sourceRoot":"","sources":["../src/inbound-channel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAkB3E;;;;GAIG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,OAAQ,CAAC;AAEhD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,eAAe,EAAE,CAAC,CAkK5B"}

package/dist/inbound-channel.js

@@ -1,3 +1,4 @@
+import { channelCapabilityEnv } from './channel-capability.js';
 import { buildChannelPrompt } from './channel-prompt.js';
 import { parallApiUrl, parallOrgId, requireAgk } from './connect.js';
 import { ackEffect, createChannelInputStep, ensureSession, invalidateSession, markDispatchReceived, nextEnvelopeId, patchSession, readActiveEmit, REQUEST_TIMEOUT_MS, TURN_ENVELOPE_KEY, writeActiveEmit, } from './session.js';
@@ -116,6 +117,9 @@ export async function effectsForChannelDispatch(sourceId, ctx) {
     }
     await receivedSettled;
     await writeActiveEmit(ctx, 'channel_message', sourceId, envelopeId);
+    // Live capability grant → this turn's lark-cli auth env (mint gate = the
+    // no-drift revocation point) + the hint teaching the single reply path.
+    const capabilityEnv = await channelCapabilityEnv(ctx);
     return [
         {
             type: 'emitEvent',
@@ -140,6 +144,7 @@ export async function effectsForChannelDispatch(sourceId, ctx) {
                         externalMessageId,
                         senderName,
                         text,
+                        cliCapable: capabilityEnv !== null,
                     }),
                     conversationId,
                     channelMessageId: sourceId,
@@ -147,19 +152,19 @@ export async function effectsForChannelDispatch(sourceId, ctx) {
                     externalConversationId,
                     externalMessageId,
                 },
-                // No chatId on purpose: the reply goes out through the provider clip
-                // (agent-invoked), NOT deliver() — deliver only runs the redundant
-                // session idle for channel routes (see delivery.ts).
+                // No chatId on purpose: the reply is the agent's own lark-cli send,
+                // NOT deliver() — deliver only runs the redundant session idle for
+                // channel routes (see delivery.ts).
                 replyRoute: {
                     kind: 'provider_http',
                     connectionId: ctx.connectionId,
                     data: { conversationId, envelopeId },
                 },
-                // No invocation context: PRLL_CHAT_ID must not point CLI defaults at
-                // a chat that doesn't exist, and the reply targets (external ids)
-                // already ride the prompt verbatim. (So no PRLL_DISPATCH_SOURCE_*
-                // either — the external reply goes out through the provider clip,
-                // and this row's ledger close is the turn event's complete-sources.)
+                // Invocation context carries ONLY the capability env: no PRLL_CHAT_ID
+                // (it must not point CLI defaults at a chat that doesn't exist) and
+                // no PRLL_DISPATCH_SOURCE_* (the external reply is a vendor-CLI send,
+                // and this row's ledger close is the turn event's complete-sources).
+                ...(capabilityEnv ? { context: capabilityEnv } : {}),
             },
         },
         // No ack effect — see the message path (inbound.ts): the row stays

package/dist/inbound.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inbound.d.ts","sourceRoot":"","sources":["../src/inbound.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,cAAc,EACf,MAAM,mBAAmB,CAAC;AAuH3B;kDACkD;AAClD,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CASjE;AACD,wBAAgB,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAO9D;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,cAAc,EACrB,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,eAAe,EAAE,CAAC,CAG5B;AAwCD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,EACtB,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,eAAe,EAAE,CAAC,CAE5B;AA8BD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAE/E;AAwpBD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,UAAU,EACjB,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAE7B"}
+{"version":3,"file":"inbound.d.ts","sourceRoot":"","sources":["../src/inbound.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,cAAc,EACf,MAAM,mBAAmB,CAAC;AAkH3B;kDACkD;AAClD,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CASjE;AACD,wBAAgB,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAO9D;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,cAAc,EACrB,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,eAAe,EAAE,CAAC,CAG5B;AAwCD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,EACtB,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,eAAe,EAAE,CAAC,CAE5B;AA8BD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAE/E;AAsqBD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,UAAU,EACjB,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAE7B"}

package/dist/inbound.js

@@ -1,8 +1,8 @@
+import { channelCapabilityEnv } from './channel-capability.js';
 import { buildChatPrompt } from './channel-prompt.js';
 import { parallApiUrl, parallOrgId, requireAgk, sandboxEnabled } from './connect.js';
 import { effectsForChannelDispatch, PROVIDER_LOOKUP_TIMEOUT_MS } from './inbound-channel.js';
 import { buildForkScopePrefix, bumpForkRetryAttempts, childConfirmed, childRefKnown, clearForkState, clearForkSubject, FORK_RETRY_DELAY_MS, FORK_RETRY_PREFIX, handleChildSpawnFailed, MAX_SPAWN_VERIFY_ATTEMPTS, noteMainTurnEvent, planForkDecision, recordSpawn, settleChildEvent, trackFollowUpAck, } from './fork.js';
-import { asChildSpawnFailed, asConnectorEffects, } from './parel-sdk-compat.js';
 import { ackByIdEffect, ackEffect, completeFencedEnvelopes, conversationKey, createErrorStep, fetchMainSessionFresh, createInputStep, createTraceStep, createTypedInputStep, EMIT_TTL_MS, ensureChildSession, ensureSession, invalidateChildSession, invalidateSession, markDispatchReceived, nextEnvelopeId, patchSession, readActiveEmit, reportingEnabled, SESSION_CACHE_KEY, TURN_ENVELOPE_KEY, writeActiveEmit, } from './session.js';
 import { isTypedEventType, planTypedDispatch } from './typed-dispatch.js';
 /**
@@ -356,12 +356,18 @@ async function effectsForDispatch(data, ctx) {
     // so the server resolves this WorkItem in the reply's own transaction.
     // (Fork turns get it too — their rows are legacy-acked so the resolve is a
     // no-op today, and it wires up for free when fork ledger parity lands.)
+    // Channel-capability env (lark-cli auth) rides EVERY turn's invocation
+    // context while granted — Feishu workspace ops (docs/calendar/…) are asked
+    // for from ordinary Parall chats, not only from channel turns. Null when
+    // ungranted or the mint degrades; never blocks the emit.
+    const capabilityEnv = await channelCapabilityEnv(ctx);
     const invocationContext = {
         PRLL_CHAT_ID: chatId,
         PRLL_TRIGGER_MESSAGE_ID: sourceId,
         PRLL_DISPATCH_SOURCE_TYPE: sourceType,
         PRLL_DISPATCH_SOURCE_ID: sourceId,
         ...(threadRootId ? { PRLL_THREAD_ROOT_ID: threadRootId } : {}),
+        ...(capabilityEnv ?? {}),
     };
     const envelope = {
         id: envelopeId,
@@ -445,18 +451,16 @@ async function effectsForDispatch(data, ctx) {
                     source_id: sourceId,
                     chat_id: chatId,
                 });
-                return asConnectorEffects([
-                    { type: 'setTimer', key: retryKey, at: ctx.now() + FORK_RETRY_DELAY_MS },
-                ]);
+                return [{ type: 'setTimer', key: retryKey, at: ctx.now() + FORK_RETRY_DELAY_MS }];
             }
-            return asConnectorEffects([
+            return [
                 { type: 'emitEvent', event: childEnvelope, deliverTo: { childRef: decision.childRef } },
-            ]);
+            ];
         }
-        return asConnectorEffects([
+        return [
             { type: 'emitEvent', event: childEnvelope, deliverTo: { childRef: decision.childRef } },
             ackEffect(ctx, sourceType, sourceId),
-        ]);
+        ];
     }
     if (decision.mode === 'spawn') {
         // Main is mid-turn on another conversation — fork. The opening message
@@ -519,7 +523,14 @@ async function effectsForDispatch(data, ctx) {
             }
             await recordSpawn(ctx, subject, decision.childRef, { dispatchId, sourceId });
             await receivedSettled;
-            return asConnectorEffects([
+            // Known gap: SpawnChildSessionEffect (#140) carries no invocation
+            // context, so the fork's OPENING turn runs without the capability env
+            // (lark-cli workspace ops would need a follow-up turn — those arrive
+            // as deliverTo envelopes, which inherit the full context). Channel
+            // replies are unaffected: channel_message dispatches always ride main.
+            // Fix belongs parel-side (context on spawnChildSession) — tracked as a
+            // parel ask.
+            return [
                 {
                     type: 'spawnChildSession',
                     childRef: decision.childRef,
@@ -527,7 +538,7 @@ async function effectsForDispatch(data, ctx) {
                     subject,
                 },
                 ...timerEffects,
-            ]);
+            ];
         }
         // fall through: black-holed spawn rides main below.
     }
@@ -647,6 +658,15 @@ async function effectsForTypedDispatch(data, ctx) {
             }
         }
     }
+    // Typed turns carry the capability env too: a task or schedule is exactly
+    // where "create the Feishu doc / check the calendar" work is assigned, so
+    // the every-turn capability contract covers them (null when ungranted or
+    // the mint degrades; never blocks the emit).
+    const capabilityEnv = await channelCapabilityEnv(ctx);
+    const typedContext = {
+        ...(plan.chatId ? { PRLL_CHAT_ID: plan.chatId, PRLL_TRIGGER_MESSAGE_ID: sourceId } : {}),
+        ...(capabilityEnv ?? {}),
+    };
     return [
         {
             type: 'emitEvent',
@@ -673,14 +693,7 @@ async function effectsForTypedDispatch(data, ctx) {
                         ? { chatId: plan.chatId, messageId: sourceId, envelopeId }
                         : { envelopeId },
                 },
-                ...(plan.chatId
-                    ? {
-                        context: {
-                            PRLL_CHAT_ID: plan.chatId,
-                            PRLL_TRIGGER_MESSAGE_ID: sourceId,
-                        },
-                    }
-                    : {}),
+                ...(Object.keys(typedContext).length > 0 ? { context: typedContext } : {}),
             },
         },
         ack(),
@@ -765,22 +778,21 @@ export function handleParallAgentEvent(event, ctx) {
     return serialized(() => handleParallAgentEventInner(event, ctx));
 }
 async function handleParallAgentEventInner(event, ctx) {
-    // spawnChildSession's asynchronous error channel — not turn-scoped, pushed
-    // regardless of observe scopes, and shaped outside the published AgentEvent
-    // union (see parel-sdk-compat). Handle it before anything subject-gated.
-    const spawnFailed = asChildSpawnFailed(event);
-    if (spawnFailed) {
+    // spawnChildSession's asynchronous error channel — not turn-scoped and
+    // pushed regardless of observe scopes. Handle it before anything
+    // subject-gated.
+    if (event.type === 'child_spawn_failed') {
         const effects = [];
         try {
-            const outcome = await handleChildSpawnFailed(ctx, spawnFailed);
+            const outcome = await handleChildSpawnFailed(ctx, event);
             if (outcome.cleared) {
                 // The spawn's ase_ was already created active with an input step; no
                 // child turn will ever emit a terminal event for it — settle it here
                 // or the session (and its processing indicator) stays active forever.
-                const orphanAse = await ensureChildSession(ctx, spawnFailed.childRef);
+                const orphanAse = await ensureChildSession(ctx, event.childRef);
                 if (orphanAse)
                     await patchSession(ctx, orphanAse, { status: 'idle' });
-                await invalidateChildSession(ctx, spawnFailed.childRef);
+                await invalidateChildSession(ctx, event.childRef);
             }
             // Re-drive the stranded messages WITHOUT waiting for a reconnect sweep
             // (a healthy long-lived socket never re-runs onOpen): park their
@@ -806,15 +818,14 @@ async function handleParallAgentEventInner(event, ctx) {
         }
         return effects;
     }
-    const withChild = event;
-    if (withChild.childRef) {
-        return handleChildAgentEvent(withChild, ctx);
+    if (event.childRef) {
+        return handleChildAgentEvent(event, ctx);
     }
     const chatId = event.subject;
     try {
         // Best-effort busy classifier for fork-on-busy: only MAIN turns feed it
         // (child events took the branch above).
-        await noteMainTurnEvent(ctx, withChild).catch(() => { });
+        await noteMainTurnEvent(ctx, event).catch(() => { });
         if (!chatId)
             return [];
         if (event.type === 'turn_completed' || event.type === 'turn_failed') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/parel-channel",
-  "version": "1.42.0",
+  "version": "1.43.0",
   "description": "Parall channel plugin for the parel runtime — lets a parel agent treat Parall as a managed_ws channel (receive dispatches, reply via the Parall API)",
   "license": "MIT",
   "repository": {
@@ -23,7 +23,7 @@
     "parel.plugin.json"
   ],
   "dependencies": {
-    "@parel/plugin-sdk": "^0.9.0"
+    "@parel/plugin-sdk": "^0.12.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/src/channel-capability.ts

@@ -0,0 +1,121 @@
+/**
+ * Channel-capability credential injection — the parel-native form of the
+ * feishu-cli broker (multi-channel-architecture-design §8.3).
+ *
+ * Bridges deliver the capability as a PATH pointer shim that mints a fresh
+ * short-lived tenant token per lark-cli invocation. In parel we control
+ * neither the sandbox PATH nor a bridge process — but we DO control the
+ * per-turn invocation context, which sandbox-e2b flattens into every exec's
+ * env. So the connector mints at emit time and injects the official
+ * LARKSUITE_CLI_* env set: bare `lark-cli` works ambiently for the whole
+ * turn (turn length ≪ token TTL ~2h), the app secret never leaves the
+ * platform, and revocation bites on the next emit's mint (403 → no env).
+ *
+ * The mint endpoint IS the gate (the platform re-evaluates connection state
+ * + flag on every request — the no-drift invariant), so the connector needs
+ * no declaration-plane fetch: a 403 is the revocation signal and is
+ * negative-cached briefly to keep a revoked grant from adding one 403 per
+ * turn.
+ */
+import type { ConnectorContext } from '@parel/plugin-sdk';
+import { parallApiUrl, parallOrgId, requireAgk } from './connect.js';
+
+const MINT_TIMEOUT_MS = 5_000;
+// Re-mint this long before the token expires so an env set injected at turn
+// start stays valid through a long turn's tail.
+const EXPIRY_SKEW_MS = 10 * 60 * 1000;
+// After a 403 (no grant / revoked / flag off), skip minting for this long —
+// revocation latency stays bounded while per-turn 403 noise does not.
+const DENIED_TTL_MS = 60 * 1000;
+// A GRANTED result is re-validated on the same cadence: the mint endpoint IS
+// the revocation gate, so a positive cache lasting the token TTL (~2h) would
+// extend revocation latency to hours. Re-minting is cheap (the platform
+// Redis-caches the exchanged token and re-evaluates the gate per request);
+// this cache only absorbs bursty emits within a conversation.
+const GRANTED_TTL_MS = 60 * 1000;
+
+interface MintedToken {
+  app_id: string;
+  brand: string;
+  token: string;
+  expires_at: string;
+}
+
+interface CacheEntry {
+  env: Record<string, string> | null; // null = denied (negative cache)
+  validUntil: number;
+}
+
+// Per-connection cache. The plugin isolate is per-connection, so a plain
+// module map keyed by connectionId is effectively single-entry — the key
+// guards against isolate reuse across connections.
+const cache = new Map<string, CacheEntry>();
+
+/** Test hook: the cache is module-level state, so suites reset it between cases. */
+export function resetChannelCapabilityCache(): void {
+  cache.clear();
+}
+
+function envFromMint(minted: MintedToken): Record<string, string> {
+  return {
+    LARKSUITE_CLI_APP_ID: minted.app_id,
+    LARKSUITE_CLI_BRAND: minted.brand || 'feishu',
+    LARKSUITE_CLI_TENANT_ACCESS_TOKEN: minted.token,
+    // Bot lock: the credential is the app's, not a human's — mirror the
+    // bridge shim's injection exactly (agent-core channel-exec).
+    LARKSUITE_CLI_DEFAULT_AS: 'bot',
+    LARKSUITE_CLI_STRICT_MODE: 'bot',
+  };
+}
+
+/**
+ * Returns the feishu-cli env set to spread into an envelope's invocation
+ * context, or null when the capability is not granted (or the mint degraded
+ * — a transient platform error must never block a dispatch emit).
+ */
+export async function channelCapabilityEnv(
+  ctx: ConnectorContext,
+): Promise<Record<string, string> | null> {
+  const key = ctx.connectionId;
+  const now = Date.now();
+  const hit = cache.get(key);
+  if (hit && hit.validUntil > now) return hit.env;
+
+  try {
+    const res = await fetch(
+      `${parallApiUrl(ctx)}/api/v1/orgs/${encodeURIComponent(parallOrgId(ctx))}/agents/me/channel-token`,
+      {
+        method: 'POST',
+        headers: {
+          authorization: `Bearer ${requireAgk(ctx)}`,
+          'content-type': 'application/json',
+        },
+        body: JSON.stringify({ channel_type: 'feishu' }),
+        signal: AbortSignal.timeout(MINT_TIMEOUT_MS),
+      },
+    );
+    if (res.status === 403 || res.status === 404) {
+      // No grant (never had it / revoked / flag off) — or an old server
+      // without the endpoint. Same agent-facing outcome: no capability.
+      cache.set(key, { env: null, validUntil: now + DENIED_TTL_MS });
+      return null;
+    }
+    if (!res.ok) {
+      // Transient (5xx/502-mint-upstream): don't cache, don't block the emit.
+      return null;
+    }
+    const minted = (await res.json()) as MintedToken;
+    if (!minted?.token || !minted.app_id) return null;
+    const env = envFromMint(minted);
+    const expiresAt = Date.parse(minted.expires_at);
+    // Bounded by BOTH the revalidation cadence (revocation latency) and the
+    // token's own remaining life (an injected env must outlive the turn).
+    const tokenBound = Number.isFinite(expiresAt) ? expiresAt - EXPIRY_SKEW_MS : now;
+    const validUntil = Math.max(now + 5_000, Math.min(now + GRANTED_TTL_MS, tokenBound));
+    cache.set(key, { env, validUntil });
+    return env;
+  } catch {
+    // Network failure — degrade to "no env this turn"; the next emit retries.
+    return null;
+  }
+}

package/src/channel-prompt.ts

@@ -16,15 +16,15 @@
  *
  * - The audience is OUTSIDE Parall — no prll:// refs, no internal cards or
  *   attachment links in the reply (dead links there).
- * - The reply goes out through the provider clip's `send_message` command.
- *   A parel agent invokes clips from its sandbox via the parall CLI, so the
- *   hint spells out the concrete `parall clip invoke …` command (agent-core
- *   leaves the invocation mechanism to the bridge's own clip tooling).
- * - Provider metadata is best-effort (the connection lookup can fail) —
- *   never instruct the agent to invoke a made-up clip alias.
+ * - Single-path reply (multi-channel-architecture-design §6): with the
+ *   feishu-cli capability granted, the reply goes out through the official
+ *   lark-cli — auth rides the turn's invocation context env
+ *   (channel-capability.ts), so bare `lark-cli` works in the sandbox.
+ *   Without the grant there is no outbound path and the hint says so (the
+ *   provider clip path is retired).
  * - When the inbound external message id is known, offer the in-thread reply
- *   form ({"message_id": …}) so threaded conversations aren't nudged toward
- *   new top-level messages.
+ *   form so threaded conversations aren't nudged toward new top-level
+ *   messages.
  */
 
 function sanitizeMeta(value: string): string {
@@ -90,7 +90,7 @@ export function buildChatPrompt(args: ChatPromptArgs): string {
 }
 
 export interface ChannelPromptArgs {
-  /** Provider name (= clip alias, e.g. "feishu"); undefined when unresolved. */
+  /** Provider name (e.g. "feishu"); undefined when unresolved. */
   provider?: string;
   /** Conversation shape as recorded on the ChannelConversation (dm/group). */
   conversationType?: string;
@@ -99,6 +99,13 @@ export interface ChannelPromptArgs {
   senderName: string;
   /** The inbound message text (raw, un-framed). */
   text: string;
+  /**
+   * Live capability grant: the turn's invocation context carries the minted
+   * LARKSUITE_CLI_* env, so bare `lark-cli` works in the sandbox and is THE
+   * reply path. False → outbound is disabled for this org (no grant); the
+   * hint says so instead of pointing at the retired provider clip.
+   */
+  cliCapable?: boolean;
 }
 
 export function buildChannelPrompt(args: ChannelPromptArgs): string {
@@ -122,16 +129,22 @@ export function buildChannelPrompt(args: ChannelPromptArgs): string {
 }
 
 function buildChannelReplyHint(args: ChannelPromptArgs): string {
-  const target = JSON.stringify({
-    chat_id: args.externalConversationId || '<conversation id>',
-    text: '...',
-  });
-  const threadAlt = args.externalMessageId
-    ? ` To reply in-thread to this specific message, use '${JSON.stringify({ message_id: args.externalMessageId, text: '...' })}' instead.`
-    : '';
-  if (args.provider) {
-    const alias = args.provider;
-    return `\n<system-reminder>To reply, invoke the \`${alias}\` clip's \`send_message\` command from your sandbox: \`parall clip invoke ${alias} send_message '${target}'\` — your plain text output is NOT delivered to the external conversation.${threadAlt} The same clip's \`call\` command reaches the wider ${alias} API when needed.</system-reminder>`;
+  // Single-path routing (multi-channel-architecture-design §6/§8.3): with
+  // the feishu-cli grant, the minted LARKSUITE_CLI_* env rides this turn's
+  // invocation context, so the official lark-cli works ambiently in the
+  // sandbox and is THE reply path. Without the grant there is no outbound
+  // path — say so instead of pointing at the retired provider clip.
+  // cliCapable alone decides: the mint is feishu-specific, so a successful
+  // grant implies Feishu even when the cosmetic provider-label lookup failed.
+  if (args.cliCapable) {
+    const convRef = args.externalConversationId
+      ? `chat_id "${args.externalConversationId}"`
+      : 'the conversation id named in this event';
+    const threadAlt = args.externalMessageId
+      ? ` To reply threaded to this specific message, reference message_id "${args.externalMessageId}".`
+      : '';
+    return `\n<system-reminder>To reply, use the official Feishu CLI in your sandbox: send a message to ${convRef} with \`lark-cli im\` (see \`lark-cli im --help\` for send syntax; auth is provisioned in your environment — if lark-cli is missing, install it once with \`npm i -g @larksuite/cli\`).${threadAlt} lark-cli is the ONLY outbound path — your plain text output is NOT delivered to the external conversation.</system-reminder>`;
   }
-  return `\n<system-reminder>To reply, invoke your channel provider clip's \`send_message\` command from your sandbox: \`parall clip invoke <alias> send_message '${target}'\` (find the alias with \`parall clip list\`) — your plain text output is NOT delivered to the external conversation.${threadAlt} The same clip's \`call\` command reaches the wider external platform API when needed.</system-reminder>`;
+  const platform = args.provider ?? 'the external platform';
+  return `\n<system-reminder>This message arrived from ${platform}, but outbound replies are currently disabled for this org (no channel capability granted). Do NOT attempt to reply on the external platform. If action is needed, surface it inside Parall (\`parall messages send\` / \`parall dm\`). Your plain text output is not delivered anywhere.</system-reminder>`;
 }

package/src/fork.ts

@@ -1,5 +1,7 @@
-import type { ConnectorContext } from '@parel/plugin-sdk';
-import type { AgentEventWithChild, ChildSpawnFailedEvent } from './parel-sdk-compat.js';
+import type { AgentEvent, ConnectorContext } from '@parel/plugin-sdk';
+
+/** The child-spawn failure variant of the sdk's AgentEvent union. */
+type ChildSpawnFailedEvent = Extract<AgentEvent, { type: 'child_spawn_failed' }>;
 
 /**
  * Fork-on-busy scheduling (the parall-side half of parel F4, parel-mono #140;
@@ -298,10 +300,7 @@ export async function clearForkState(ctx: ConnectorContext): Promise<string[]> {
  * Track main-session busyness from the E1 turn stream. Child events (they
  * carry childRef) must NOT feed this — only the main session's turns do.
  */
-export async function noteMainTurnEvent(
-  ctx: ConnectorContext,
-  event: AgentEventWithChild,
-): Promise<void> {
+export async function noteMainTurnEvent(ctx: ConnectorContext, event: AgentEvent): Promise<void> {
   if (event.type === 'turn_started') {
     const row: MainTurnRow = { turnId: event.turnId, subject: event.subject, at: ctx.now() };
     await ctx.store?.set(MAIN_TURN_KEY, row).catch(() => {});
@@ -323,7 +322,7 @@ export async function noteMainTurnEvent(
  */
 export async function settleChildEvent(
   ctx: ConnectorContext,
-  event: AgentEventWithChild,
+  event: AgentEvent,
 ): Promise<{ subject: string; pendingAcks: PendingAck[] } | null> {
   const childRef = event.childRef;
   if (!childRef) return null;

package/src/inbound-channel.ts

@@ -1,4 +1,5 @@
 import type { ConnectorContext, ConnectorEffect } from '@parel/plugin-sdk';
+import { channelCapabilityEnv } from './channel-capability.js';
 import { buildChannelPrompt } from './channel-prompt.js';
 import { parallApiUrl, parallOrgId, requireAgk } from './connect.js';
 import {
@@ -154,6 +155,10 @@ export async function effectsForChannelDispatch(
   await receivedSettled;
   await writeActiveEmit(ctx, 'channel_message', sourceId, envelopeId);
 
+  // Live capability grant → this turn's lark-cli auth env (mint gate = the
+  // no-drift revocation point) + the hint teaching the single reply path.
+  const capabilityEnv = await channelCapabilityEnv(ctx);
+
   return [
     {
       type: 'emitEvent',
@@ -178,6 +183,7 @@ export async function effectsForChannelDispatch(
             externalMessageId,
             senderName,
             text,
+            cliCapable: capabilityEnv !== null,
           }),
           conversationId,
           channelMessageId: sourceId,
@@ -185,19 +191,19 @@ export async function effectsForChannelDispatch(
           externalConversationId,
           externalMessageId,
         },
-        // No chatId on purpose: the reply goes out through the provider clip
-        // (agent-invoked), NOT deliver() — deliver only runs the redundant
-        // session idle for channel routes (see delivery.ts).
+        // No chatId on purpose: the reply is the agent's own lark-cli send,
+        // NOT deliver() — deliver only runs the redundant session idle for
+        // channel routes (see delivery.ts).
         replyRoute: {
           kind: 'provider_http',
           connectionId: ctx.connectionId,
           data: { conversationId, envelopeId },
         },
-        // No invocation context: PRLL_CHAT_ID must not point CLI defaults at
-        // a chat that doesn't exist, and the reply targets (external ids)
-        // already ride the prompt verbatim. (So no PRLL_DISPATCH_SOURCE_*
-        // either — the external reply goes out through the provider clip,
-        // and this row's ledger close is the turn event's complete-sources.)
+        // Invocation context carries ONLY the capability env: no PRLL_CHAT_ID
+        // (it must not point CLI defaults at a chat that doesn't exist) and
+        // no PRLL_DISPATCH_SOURCE_* (the external reply is a vendor-CLI send,
+        // and this row's ledger close is the turn event's complete-sources).
+        ...(capabilityEnv ? { context: capabilityEnv } : {}),
       },
     },
     // No ack effect — see the message path (inbound.ts): the row stays

package/src/inbound.ts

@@ -5,6 +5,7 @@ import type {
   ConnectorEffect,
   WebSocketFrame,
 } from '@parel/plugin-sdk';
+import { channelCapabilityEnv } from './channel-capability.js';
 import { buildChatPrompt, type PromptAttachment } from './channel-prompt.js';
 import { parallApiUrl, parallOrgId, requireAgk, sandboxEnabled } from './connect.js';
 import { effectsForChannelDispatch, PROVIDER_LOOKUP_TIMEOUT_MS } from './inbound-channel.js';
@@ -25,12 +26,6 @@ import {
   settleChildEvent,
   trackFollowUpAck,
 } from './fork.js';
-import {
-  type AgentEventWithChild,
-  asChildSpawnFailed,
-  asConnectorEffects,
-  type ExtendedConnectorEffect,
-} from './parel-sdk-compat.js';
 import {
   ackByIdEffect,
   ackEffect,
@@ -496,12 +491,18 @@ async function effectsForDispatch(
   // so the server resolves this WorkItem in the reply's own transaction.
   // (Fork turns get it too — their rows are legacy-acked so the resolve is a
   // no-op today, and it wires up for free when fork ledger parity lands.)
+  // Channel-capability env (lark-cli auth) rides EVERY turn's invocation
+  // context while granted — Feishu workspace ops (docs/calendar/…) are asked
+  // for from ordinary Parall chats, not only from channel turns. Null when
+  // ungranted or the mint degrades; never blocks the emit.
+  const capabilityEnv = await channelCapabilityEnv(ctx);
   const invocationContext: Record<string, string> = {
     PRLL_CHAT_ID: chatId,
     PRLL_TRIGGER_MESSAGE_ID: sourceId,
     PRLL_DISPATCH_SOURCE_TYPE: sourceType,
     PRLL_DISPATCH_SOURCE_ID: sourceId,
     ...(threadRootId ? { PRLL_THREAD_ROOT_ID: threadRootId } : {}),
+    ...(capabilityEnv ?? {}),
   };
 
   const envelope = {
@@ -586,18 +587,16 @@ async function effectsForDispatch(
           source_id: sourceId,
           chat_id: chatId,
         });
-        return asConnectorEffects([
-          { type: 'setTimer', key: retryKey, at: ctx.now() + FORK_RETRY_DELAY_MS },
-        ]);
+        return [{ type: 'setTimer', key: retryKey, at: ctx.now() + FORK_RETRY_DELAY_MS }];
       }
-      return asConnectorEffects([
+      return [
         { type: 'emitEvent', event: childEnvelope, deliverTo: { childRef: decision.childRef } },
-      ]);
+      ];
     }
-    return asConnectorEffects([
+    return [
       { type: 'emitEvent', event: childEnvelope, deliverTo: { childRef: decision.childRef } },
       ackEffect(ctx, sourceType, sourceId),
-    ]);
+    ];
   }
 
   if (decision.mode === 'spawn') {
@@ -625,7 +624,7 @@ async function effectsForDispatch(
     // would leave the message stranded with no timer and no bookkeeping
     // until a reconnect).
     let spawnBlackHoled = false;
-    const timerEffects: ExtendedConnectorEffect[] = [];
+    const timerEffects: ConnectorEffect[] = [];
     if (dispatchId) {
       const retryKey = `${FORK_RETRY_PREFIX}${dispatchId}`;
       const attempts = await bumpForkRetryAttempts(ctx, retryKey, {
@@ -659,7 +658,14 @@ async function effectsForDispatch(
       }
       await recordSpawn(ctx, subject, decision.childRef, { dispatchId, sourceId });
       await receivedSettled;
-      return asConnectorEffects([
+      // Known gap: SpawnChildSessionEffect (#140) carries no invocation
+      // context, so the fork's OPENING turn runs without the capability env
+      // (lark-cli workspace ops would need a follow-up turn — those arrive
+      // as deliverTo envelopes, which inherit the full context). Channel
+      // replies are unaffected: channel_message dispatches always ride main.
+      // Fix belongs parel-side (context on spawnChildSession) — tracked as a
+      // parel ask.
+      return [
         {
           type: 'spawnChildSession',
           childRef: decision.childRef,
@@ -667,7 +673,7 @@ async function effectsForDispatch(
           subject,
         },
         ...timerEffects,
-      ]);
+      ];
     }
     // fall through: black-holed spawn rides main below.
   }
@@ -796,6 +802,16 @@ async function effectsForTypedDispatch(
     }
   }
 
+  // Typed turns carry the capability env too: a task or schedule is exactly
+  // where "create the Feishu doc / check the calendar" work is assigned, so
+  // the every-turn capability contract covers them (null when ungranted or
+  // the mint degrades; never blocks the emit).
+  const capabilityEnv = await channelCapabilityEnv(ctx);
+  const typedContext: Record<string, string> = {
+    ...(plan.chatId ? { PRLL_CHAT_ID: plan.chatId, PRLL_TRIGGER_MESSAGE_ID: sourceId } : {}),
+    ...(capabilityEnv ?? {}),
+  };
+
   return [
     {
       type: 'emitEvent',
@@ -822,14 +838,7 @@ async function effectsForTypedDispatch(
             ? { chatId: plan.chatId, messageId: sourceId, envelopeId }
             : { envelopeId },
         },
-        ...(plan.chatId
-          ? {
-              context: {
-                PRLL_CHAT_ID: plan.chatId,
-                PRLL_TRIGGER_MESSAGE_ID: sourceId,
-              },
-            }
-          : {}),
+        ...(Object.keys(typedContext).length > 0 ? { context: typedContext } : {}),
       },
     },
     ack(),
@@ -932,21 +941,20 @@ async function handleParallAgentEventInner(
   event: AgentEvent,
   ctx: ConnectorContext,
 ): Promise<AgentEventEffect[]> {
-  // spawnChildSession's asynchronous error channel — not turn-scoped, pushed
-  // regardless of observe scopes, and shaped outside the published AgentEvent
-  // union (see parel-sdk-compat). Handle it before anything subject-gated.
-  const spawnFailed = asChildSpawnFailed(event);
-  if (spawnFailed) {
+  // spawnChildSession's asynchronous error channel — not turn-scoped and
+  // pushed regardless of observe scopes. Handle it before anything
+  // subject-gated.
+  if (event.type === 'child_spawn_failed') {
     const effects: AgentEventEffect[] = [];
     try {
-      const outcome = await handleChildSpawnFailed(ctx, spawnFailed);
+      const outcome = await handleChildSpawnFailed(ctx, event);
       if (outcome.cleared) {
         // The spawn's ase_ was already created active with an input step; no
         // child turn will ever emit a terminal event for it — settle it here
         // or the session (and its processing indicator) stays active forever.
-        const orphanAse = await ensureChildSession(ctx, spawnFailed.childRef);
+        const orphanAse = await ensureChildSession(ctx, event.childRef);
         if (orphanAse) await patchSession(ctx, orphanAse, { status: 'idle' });
-        await invalidateChildSession(ctx, spawnFailed.childRef);
+        await invalidateChildSession(ctx, event.childRef);
       }
       // Re-drive the stranded messages WITHOUT waiting for a reconnect sweep
       // (a healthy long-lived socket never re-runs onOpen): park their
@@ -971,15 +979,14 @@ async function handleParallAgentEventInner(
     }
     return effects;
   }
-  const withChild = event as AgentEventWithChild;
-  if (withChild.childRef) {
-    return handleChildAgentEvent(withChild, ctx);
+  if (event.childRef) {
+    return handleChildAgentEvent(event, ctx);
   }
   const chatId = event.subject;
   try {
     // Best-effort busy classifier for fork-on-busy: only MAIN turns feed it
     // (child events took the branch above).
-    await noteMainTurnEvent(ctx, withChild).catch(() => {});
+    await noteMainTurnEvent(ctx, event).catch(() => {});
     if (!chatId) return [];
     if (event.type === 'turn_completed' || event.type === 'turn_failed') {
       // Ledger close FIRST, fenced per source — deliberately NOT behind the
@@ -1065,7 +1072,7 @@ async function handleParallAgentEventInner(
  * turnEnvelope marker or the busy classifier.
  */
 async function handleChildAgentEvent(
-  event: AgentEventWithChild,
+  event: AgentEvent,
   ctx: ConnectorContext,
 ): Promise<AgentEventEffect[]> {
   const childRef = event.childRef ?? '';

package/dist/parel-sdk-compat.d.ts

@@ -1,63 +0,0 @@
-import type { AgentEvent, ChannelEnvelope, ConnectorEffect } from '@parel/plugin-sdk';
-/**
- * Local mirrors of parel host types that shipped in parel-mono #140 (F3
- * injectInFlight / F4 child sessions) but are not yet published in
- * @parel/plugin-sdk (the mirror lives on parel-oss branch
- * feat/channel-child-sessions). The host accepts these shapes today — prod
- * runs #140 — so the connector uses them through this compat layer and casts
- * at the hook boundary.
- *
- * TODO(parel-sdk-#140-types): DELETE this file (and the casts) once
- * @parel/plugin-sdk ships the mirror sitting on parel-oss branch
- * `feat/channel-child-sessions` — check the branch/`@parel/plugin-sdk`
- * changelog on every sdk version bump. Until then the shapes below must stay
- * byte-compatible with parel-mono ts/packages/cloudflare/src/channel-types.ts.
- */
-/**
- * Spawn a fork child session off this connection's main conversation session.
- * Idempotent on childRef (opaque, connector-owned). Host gates: binding must
- * opt in (childSessions) + `main` routing; failures come back asynchronously
- * as a `child_spawn_failed` agent event. The child seeds from the parent
- * transcript at the last turn boundary (never sees in-flight output).
- */
-export interface SpawnChildSessionEffect {
-    type: 'spawnChildSession';
-    childRef: string;
-    input: string;
-    subject?: string;
-}
-/** emitEvent with the #140 deliverTo extension: route to a spawned child. */
-export interface EmitToChildEffect {
-    type: 'emitEvent';
-    event: ChannelEnvelope;
-    deliverTo: {
-        childRef: string;
-    };
-}
-/**
- * Asynchronous error channel for a failed spawnChildSession effect (pushed
- * regardless of observe scopes). codes: disabled | unsupported_routing |
- * no_binding | invalid_request | depth_limit | concurrency_limit |
- * spawn_failed.
- */
-export interface ChildSpawnFailedEvent {
-    type: 'child_spawn_failed';
-    childRef: string;
-    code: string;
-    error: string;
-}
-/** Effect union the #140 host actually executes. */
-export type ExtendedConnectorEffect = ConnectorEffect | SpawnChildSessionEffect | EmitToChildEffect;
-/**
- * Every event from a connector-spawned child carries the childRef it was
- * spawned with (#140: AgentEventBase.childRef). Absent on main-session
- * events and on sdk versions that predate the field.
- */
-export type AgentEventWithChild = AgentEvent & {
-    childRef?: string;
-};
-/** Narrow an incoming agent event to the not-yet-published failure shape. */
-export declare function asChildSpawnFailed(event: unknown): ChildSpawnFailedEvent | null;
-/** Cast helper: the host executes the extended union; the sdk type lags it. */
-export declare function asConnectorEffects(effects: ExtendedConnectorEffect[]): ConnectorEffect[];
-//# sourceMappingURL=parel-sdk-compat.d.ts.map

package/dist/parel-sdk-compat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parel-sdk-compat.d.ts","sourceRoot":"","sources":["../src/parel-sdk-compat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEtF;;;;;;;;;;;;;GAaG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,mBAAmB,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,6EAA6E;AAC7E,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,eAAe,CAAC;IACvB,SAAS,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CACjC;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,oBAAoB,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,oDAAoD;AACpD,MAAM,MAAM,uBAAuB,GAAG,eAAe,GAAG,uBAAuB,GAAG,iBAAiB,CAAC;AAEpG;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAErE,6EAA6E;AAC7E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,qBAAqB,GAAG,IAAI,CAS/E;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,uBAAuB,EAAE,GAAG,eAAe,EAAE,CAExF"}

package/dist/parel-sdk-compat.js

@@ -1,16 +0,0 @@
-/** Narrow an incoming agent event to the not-yet-published failure shape. */
-export function asChildSpawnFailed(event) {
-    const e = event;
-    if (e?.type !== 'child_spawn_failed')
-        return null;
-    return {
-        type: 'child_spawn_failed',
-        childRef: typeof e.childRef === 'string' ? e.childRef : '',
-        code: typeof e.code === 'string' ? e.code : 'unknown',
-        error: typeof e.error === 'string' ? e.error : '',
-    };
-}
-/** Cast helper: the host executes the extended union; the sdk type lags it. */
-export function asConnectorEffects(effects) {
-    return effects;
-}

package/src/parel-sdk-compat.ts

@@ -1,77 +0,0 @@
-import type { AgentEvent, ChannelEnvelope, ConnectorEffect } from '@parel/plugin-sdk';
-
-/**
- * Local mirrors of parel host types that shipped in parel-mono #140 (F3
- * injectInFlight / F4 child sessions) but are not yet published in
- * @parel/plugin-sdk (the mirror lives on parel-oss branch
- * feat/channel-child-sessions). The host accepts these shapes today — prod
- * runs #140 — so the connector uses them through this compat layer and casts
- * at the hook boundary.
- *
- * TODO(parel-sdk-#140-types): DELETE this file (and the casts) once
- * @parel/plugin-sdk ships the mirror sitting on parel-oss branch
- * `feat/channel-child-sessions` — check the branch/`@parel/plugin-sdk`
- * changelog on every sdk version bump. Until then the shapes below must stay
- * byte-compatible with parel-mono ts/packages/cloudflare/src/channel-types.ts.
- */
-
-/**
- * Spawn a fork child session off this connection's main conversation session.
- * Idempotent on childRef (opaque, connector-owned). Host gates: binding must
- * opt in (childSessions) + `main` routing; failures come back asynchronously
- * as a `child_spawn_failed` agent event. The child seeds from the parent
- * transcript at the last turn boundary (never sees in-flight output).
- */
-export interface SpawnChildSessionEffect {
-  type: 'spawnChildSession';
-  childRef: string;
-  input: string;
-  subject?: string;
-}
-
-/** emitEvent with the #140 deliverTo extension: route to a spawned child. */
-export interface EmitToChildEffect {
-  type: 'emitEvent';
-  event: ChannelEnvelope;
-  deliverTo: { childRef: string };
-}
-
-/**
- * Asynchronous error channel for a failed spawnChildSession effect (pushed
- * regardless of observe scopes). codes: disabled | unsupported_routing |
- * no_binding | invalid_request | depth_limit | concurrency_limit |
- * spawn_failed.
- */
-export interface ChildSpawnFailedEvent {
-  type: 'child_spawn_failed';
-  childRef: string;
-  code: string;
-  error: string;
-}
-
-/** Effect union the #140 host actually executes. */
-export type ExtendedConnectorEffect = ConnectorEffect | SpawnChildSessionEffect | EmitToChildEffect;
-
-/**
- * Every event from a connector-spawned child carries the childRef it was
- * spawned with (#140: AgentEventBase.childRef). Absent on main-session
- * events and on sdk versions that predate the field.
- */
-export type AgentEventWithChild = AgentEvent & { childRef?: string };
-
-/** Narrow an incoming agent event to the not-yet-published failure shape. */
-export function asChildSpawnFailed(event: unknown): ChildSpawnFailedEvent | null {
-  const e = event as { type?: unknown; childRef?: unknown; code?: unknown; error?: unknown };
-  if (e?.type !== 'child_spawn_failed') return null;
-  return {
-    type: 'child_spawn_failed',
-    childRef: typeof e.childRef === 'string' ? e.childRef : '',
-    code: typeof e.code === 'string' ? e.code : 'unknown',
-    error: typeof e.error === 'string' ? e.error : '',
-  };
-}
-
-/** Cast helper: the host executes the extended union; the sdk type lags it. */
-export function asConnectorEffects(effects: ExtendedConnectorEffect[]): ConnectorEffect[] {
-  return effects as ConnectorEffect[];
-}