@parall/parel-channel 1.41.0 → 1.42.0

package/dist/inbound.js

@@ -3,7 +3,7 @@ import { parallApiUrl, parallOrgId, requireAgk, sandboxEnabled } from './connect
 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, conversationKey, createErrorStep, fetchMainSessionFresh, createInputStep, createTraceStep, createTypedInputStep, ensureChildSession, ensureSession, invalidateChildSession, invalidateSession, markDispatchReceived, patchSession, reportingEnabled, SESSION_CACHE_KEY, TURN_ENVELOPE_KEY, } from './session.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';
 /**
  * Connection-local hook serialization. The parel ConnectorHost dispatches
@@ -212,6 +212,25 @@ async function catchUpParallInner(ctx) {
     }
     return effects;
 }
+/**
+ * Turn-in-flight guard for redelivery (catch-up sweep AND repeated
+ * dispatch.new pushes). Main-path rows stay live (not acked) for the whole
+ * turn now, and GET /dispatch lists pending AND received rows — so redelivery
+ * re-sees every in-flight source. Skip any row whose attempt fence is younger
+ * than EMIT_TTL_MS, REGARDLESS of row status: a transiently-failed
+ * /dispatch/received leaves the row `pending` while the emit succeeded (fence
+ * written), and re-emitting it inside the TTL would duplicate the in-flight
+ * turn — complete-sources resolves pending rows just as well, so the fence
+ * alone is the truth. Past the TTL (crashed emit, lost turn events) fall
+ * through and re-emit with a fresh attempt-suffixed envelope id. Brand-new
+ * sources have no fence and never skip; fork-handled rows never write a
+ * fence (their ack machinery owns redelivery there).
+ * Design: parel-reply-contract-alignment.md §5.3.
+ */
+async function shouldSkipLiveRow(ctx, sourceType, sourceId) {
+    const active = await readActiveEmit(ctx, sourceType, sourceId);
+    return active !== null && ctx.now() - active.at < EMIT_TTL_MS;
+}
 async function effectsForDispatch(data, ctx) {
     const sourceType = String(data.source_type ?? '');
     const sourceId = data.source_id ? String(data.source_id) : undefined;
@@ -220,7 +239,9 @@ async function effectsForDispatch(data, ctx) {
     if (sourceType === 'channel_message' && sourceId) {
         // External IM message (chat_id is NULL by design — the conversation
         // lives on the provider, not in a Parall chat).
-        return effectsForChannelDispatch(sourceId, dispatchId, ctx);
+        if (await shouldSkipLiveRow(ctx, sourceType, sourceId))
+            return [];
+        return effectsForChannelDispatch(sourceId, ctx);
     }
     const eventType = String(data.event_type ?? '');
     if (sourceId && isTypedEventType(eventType)) {
@@ -233,10 +254,13 @@ async function effectsForDispatch(data, ctx) {
             return [];
         }
         // Conversational-only deployments (no sandbox → no `parall` CLI) cannot
-        // act on CLI-only typed work — emitting AND acking it would silently
-        // consume real work. Keep it pending (same posture as unknown types);
-        // approval_decided is exempt (it lives in a chat, replies auto-deliver).
-        if (!sandboxEnabled(ctx) && eventType !== 'approval_decided') {
+        // act on typed work AT ALL under the CLI-only reply contract — nothing
+        // auto-delivers anymore, approval_decided included — so emitting AND
+        // acking would silently consume real work. Keep it pending (same
+        // posture as unknown types). Defensive-only: the server's mandatory
+        // sandbox gate (422 PAREL_SANDBOX_REQUIRED) means no such managed
+        // agent can be provisioned.
+        if (!sandboxEnabled(ctx)) {
             return [];
         }
         return effectsForTypedDispatch(data, ctx);
@@ -252,6 +276,8 @@ async function effectsForDispatch(data, ctx) {
         // A message dispatch with no chat can never be routed or replied to.
         return [ackEffect(ctx, sourceType, sourceId)];
     }
+    if (await shouldSkipLiveRow(ctx, sourceType, sourceId))
+        return [];
     const apiUrl = parallApiUrl(ctx);
     const agk = requireAgk(ctx);
     const orgId = parallOrgId(ctx);
@@ -306,7 +332,11 @@ async function effectsForDispatch(data, ctx) {
         text,
         attachments,
     });
-    const envelopeId = dispatchId || `${sourceType}:${sourceId}`;
+    // Deterministic source-derived envelope id (+ attempt suffix on re-emits):
+    // complete-sources strips the suffix back to the source, and every re-emit
+    // is globally unique so parel's dedupe (either way) can't strand a retry.
+    const priorEmit = await readActiveEmit(ctx, sourceType, sourceId);
+    const envelopeId = nextEnvelopeId(sourceType, sourceId, priorEmit);
     // Input-step summary must never be empty (attachment-only messages).
     const stepText = text || `[${attachments.length} attachment(s)]`;
     // Thread-aware conversation identity: F2 grouping / F3 injection / fork
@@ -321,9 +351,16 @@ async function effectsForDispatch(data, ctx) {
     // Per-turn invocation context: parel snapshots this at turn start and
     // consume-gated plugins receive it — sandbox-e2b flattens it into per-exec
     // env, so `parall` CLI calls inside the sandbox land on the right chat.
+    // The PRLL_DISPATCH_SOURCE_* pair is the CLI's by-source ledger binding: a
+    // send back into the exact trigger (chat, thread) carries dispatch_source
+    // 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.)
     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 } : {}),
     };
     const envelope = {
@@ -494,15 +531,16 @@ async function effectsForDispatch(data, ctx) {
         }
         // fall through: black-holed spawn rides main below.
     }
-    // Main path. Progress reporting (best-effort,
-    // parall-runtime-indicator-plan.md §3): received lights the pending ring,
-    // the active+trigger patch arms the done signal, the input step flips the
-    // ring to processing. received MUST settle before this function returns —
-    // the ack effect below moves the dispatch row out of 'pending', and
-    // MarkReceived only transitions pending rows. It is deliberately NOT gated
-    // on the session resolving: it only touches the dispatch row, and a
-    // transient session failure must not also cost the pending ring (a later
-    // successful turn's idle clears agent-level pendings).
+    // Main path. Progress reporting (best-effort): received flips the row out
+    // of 'pending' and lights the indicator (dispatch.received → active); the
+    // row then STAYS 'received' for the whole turn — resolution comes from the
+    // CLI reply's dispatch_source or the turn event's complete-sources, never
+    // from an ack here (the old ack-on-emit is what killed the indicator
+    // early; parel-reply-contract-alignment.md §1.1). received still settles
+    // before this function returns so a same-batch reply can never race the
+    // pending→received transition. It is deliberately NOT gated on the
+    // session resolving: a transient session failure must not also cost the
+    // indicator.
     const receivedSettled = markDispatchReceived(ctx, sourceType, sourceId);
     let sessionId = await ensureSession(ctx);
     if (sessionId) {
@@ -540,7 +578,20 @@ async function effectsForDispatch(data, ctx) {
         }
     }
     await receivedSettled;
-    return [{ type: 'emitEvent', event: envelope }, ackEffect(ctx, sourceType, sourceId)];
+    // Arm the attempt fence BEFORE the emit effect is returned: turn events
+    // complete a source only while `active:{source}` matches their envelope id
+    // exactly, and the redelivery-skip window starts at this timestamp. Only
+    // the main path writes it — fork paths keep their own ack machinery.
+    // Deliberate ordering tradeoff: a crash between this write and the host
+    // executing the emit leaves an armed fence for an un-emitted source, so
+    // the reconnect sweep hides it until the TTL re-emit (≤30min delay). The
+    // reverse order (fence after emit) would instead double-emit on a crash —
+    // a duplicate agent turn. Delay heals; duplicates don't.
+    await writeActiveEmit(ctx, sourceType, sourceId, envelopeId);
+    // No ack effect: the row stays 'received' until the reply (dispatch
+    // _source) or the turn event (complete-sources) resolves it — the
+    // indicator's whole lifecycle rides on that.
+    return [{ type: 'emitEvent', event: envelope }];
 }
 /**
  * Typed (non-message) dispatch → main-session envelope. The heavy lifting
@@ -613,9 +664,11 @@ async function effectsForTypedDispatch(data, ctx) {
                 replyRoute: {
                     kind: 'provider_http',
                     connectionId: ctx.connectionId,
-                    // approval_decided replies deliver to its chat; every other typed
-                    // event has no delivery target (deliver() only runs the redundant
-                    // idle off envelopeId) — the agent acts via its sandbox CLI.
+                    // Replies are CLI-only for every typed event (nothing
+                    // auto-delivers). chatId — only approval_decided has one — merely
+                    // routes deliver()'s suppressed turn-end audit step to the chat;
+                    // chat-less routes carry just the envelopeId for the redundant
+                    // ledger close + idle.
                     data: plan.chatId
                         ? { chatId: plan.chatId, messageId: sourceId, envelopeId }
                         : { envelopeId },
@@ -765,6 +818,20 @@ async function handleParallAgentEventInner(event, ctx) {
         if (!chatId)
             return [];
         if (event.type === 'turn_completed' || event.type === 'turn_failed') {
+            // Ledger close FIRST, fenced per source — deliberately NOT behind the
+            // agent-global marker guard below: that guard protects the shared
+            // session's idle (last-emit-wins), while the ledger rows are
+            // per-source facts that must close whenever THEIR envelope is the one
+            // this turn consumed (a concurrent conversation-B emit must not leave
+            // conversation-A's resolution hanging). The attempt fence inside
+            // completeFencedEnvelopes drops late events from a superseded attempt
+            // (the TTL re-emit took the source over) AND fork-handled envelopes
+            // (no fence written), so it can never close the in-flight retry's
+            // work nor double-close fork acks. F3-absorbed envelopes appear in
+            // the absorbing turn's envelopeIds and settle here naturally. The
+            // server decides reply broad-cover vs no_action per batch; turn_failed
+            // sweeps the same way with the error step below as the visible record.
+            await completeFencedEnvelopes(ctx, event.envelopeIds);
             // Staleness guard: only idle if this event's turn covers the AGENT'S
             // latest emitted envelope (the marker is agent-global — all chats share
             // the one main session, so a done signal for chat A's turn must not

package/dist/session.d.ts

@@ -242,4 +242,71 @@ export declare function ackByIdEffect(ctx: ConnectorContext, dispatchId: string)
  * means the ring never appears.
  */
 export declare function markDispatchReceived(ctx: ConnectorContext, sourceType: string, sourceId: string): Promise<void>;
+/**
+ * How long an emitted source may stay unresolved before the reconnect sweep
+ * re-emits it (crash / lost turn_completed self-heal — the successor of the
+ * retired turnwatch timer). Must comfortably exceed any legitimate turn.
+ */
+export declare const EMIT_TTL_MS: number;
+/** The current emit attempt for a source: its envelope id + emit time. */
+export type ActiveEmit = {
+    id: string;
+    at: number;
+};
+/**
+ * Per-source attempt fence. Written before emit, cleared by the matching
+ * turn event's complete: a turn event only closes a source whose stored id
+ * EXACTLY matches one of its envelopeIds — a late turn_completed from a
+ * superseded attempt (the source was re-emitted after the TTL) must not
+ * close the in-flight retry's work (codex P2 attempt fence).
+ */
+export declare function readActiveEmit(ctx: ConnectorContext, sourceType: string, sourceId: string): Promise<ActiveEmit | null>;
+export declare function writeActiveEmit(ctx: ConnectorContext, sourceType: string, sourceId: string, envelopeId: string): Promise<void>;
+export declare function clearActiveEmit(ctx: ConnectorContext, sourceType: string, sourceId: string): Promise<void>;
+/**
+ * Deterministic envelope id for a source: `{sourceType}:{sourceId}` on the
+ * first attempt, `…#r{n}` on re-emits. Attempt-suffixed ids are unique per
+ * attempt, so a re-emit is a NEW envelope to parel regardless of any dedupe
+ * behavior — the retry always produces a fresh turn.
+ */
+export declare function nextEnvelopeId(sourceType: string, sourceId: string, prior: ActiveEmit | null): string;
+/** envelope id → source pointer (strips the attempt suffix). */
+export declare function sourceFromEnvelopeId(envelopeId: string): {
+    sourceType: string;
+    sourceId: string;
+} | null;
+/**
+ * Fence-checked turn-end ledger close for a set of envelope ids — the shared
+ * core of BOTH turn-end hooks: onAgentEvent (turn_completed/turn_failed, the
+ * primary) and deliver (the no-observe npm-fallback path, where turn events
+ * never arrive and this is the ONLY terminal ledger hook — without it a
+ * received row would re-emit on every TTL sweep forever). Only sources whose
+ * `active:{source}` store row matches the envelope id EXACTLY are completed
+ * (attempt fence); the fence rows clear on success. Both hooks running is
+ * harmless: whichever completes first consumes the fence, the other skips.
+ */
+export declare function completeFencedEnvelopes(ctx: ConnectorContext, envelopeIds: string[]): Promise<void>;
+/**
+ * Turn-end ledger close: resolves the turn's folded sources on the server —
+ * broad-cover to the turn's reply Effect when one exists, no_action sweep
+ * otherwise (the server decides; POST /dispatch/complete-sources, idempotent).
+ * One immediate retry on failure; a still-failed call leaves the rows
+ * received and the catch-up TTL re-emit self-heals.
+ */
+export declare function completeSources(ctx: ConnectorContext, sources: {
+    source_type: string;
+    source_id: string;
+}[]): Promise<boolean>;
+/**
+ * Turn-end plain text as a suppressed audit step — the runtime-standard
+ * Layer 0 posture (agent-dm-loop-prevention.md): recorded on the session,
+ * never delivered to the chat. No `projection` field, so the server's
+ * projection gate keeps it panel-only; `suppressed: true` is the content
+ * marker the standard bridges write for undelivered text.
+ */
+export declare function createSuppressedTextStep(ctx: ConnectorContext, sessionId: string, args: {
+    subject: string;
+    deliveryId: string;
+    text: string;
+}): Promise<ReportResult>;
 //# sourceMappingURL=session.d.ts.map

package/dist/session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"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"}

package/dist/session.js

@@ -573,8 +573,10 @@ export function ackByIdEffect(ctx, dispatchId) {
  * means the ring never appears.
  */
 export async function markDispatchReceived(ctx, sourceType, sourceId) {
-    if (!reportingEnabled(ctx))
-        return;
+    // Deliberately NOT gated on reportingEnabled: this is ledger surface, not
+    // session reporting — the URL needs no agent id, and with ack-on-emit gone
+    // the received transition is what keeps the reconnect sweep's TTL window
+    // (and the indicator lifecycle) working even for agent-id-less old configs.
     try {
         const url = `${parallApiUrl(ctx)}/api/v1/orgs/${parallOrgId(ctx)}/dispatch/received`;
         const res = await fetch(url, {
@@ -590,3 +592,165 @@ export async function markDispatchReceived(ctx, sourceType, sourceId) {
         console.error('[parel-channel] mark received failed', err);
     }
 }
+// ── By-source ledger surface ────────────────────────────
+//
+// The connector consumes dispatches without claiming lanes (parel's own
+// queue serializes turns), so its ledger writes address WorkItems by source
+// pointer, and its liveness bookkeeping is a per-source attempt fence in the
+// durable store. Design: parel-reply-contract-alignment.md §5.3.
+/**
+ * How long an emitted source may stay unresolved before the reconnect sweep
+ * re-emits it (crash / lost turn_completed self-heal — the successor of the
+ * retired turnwatch timer). Must comfortably exceed any legitimate turn.
+ */
+export const EMIT_TTL_MS = 30 * 60 * 1000;
+function activeEmitKey(sourceType, sourceId) {
+    return `active:${sourceType}:${sourceId}`;
+}
+/**
+ * Per-source attempt fence. Written before emit, cleared by the matching
+ * turn event's complete: a turn event only closes a source whose stored id
+ * EXACTLY matches one of its envelopeIds — a late turn_completed from a
+ * superseded attempt (the source was re-emitted after the TTL) must not
+ * close the in-flight retry's work (codex P2 attempt fence).
+ */
+export async function readActiveEmit(ctx, sourceType, sourceId) {
+    const raw = await ctx.store?.get(activeEmitKey(sourceType, sourceId)).catch(() => null);
+    if (raw &&
+        typeof raw === 'object' &&
+        typeof raw.id === 'string' &&
+        typeof raw.at === 'number') {
+        return raw;
+    }
+    return null;
+}
+export async function writeActiveEmit(ctx, sourceType, sourceId, envelopeId) {
+    await ctx.store
+        ?.set(activeEmitKey(sourceType, sourceId), { id: envelopeId, at: ctx.now() })
+        .catch(() => { });
+}
+export async function clearActiveEmit(ctx, sourceType, sourceId) {
+    await ctx.store?.delete(activeEmitKey(sourceType, sourceId)).catch(() => { });
+}
+/**
+ * Deterministic envelope id for a source: `{sourceType}:{sourceId}` on the
+ * first attempt, `…#r{n}` on re-emits. Attempt-suffixed ids are unique per
+ * attempt, so a re-emit is a NEW envelope to parel regardless of any dedupe
+ * behavior — the retry always produces a fresh turn.
+ */
+export function nextEnvelopeId(sourceType, sourceId, prior) {
+    const base = `${sourceType}:${sourceId}`;
+    if (!prior)
+        return base;
+    const m = prior.id.match(/#r(\d+)$/);
+    const attempt = m ? Number(m[1]) + 1 : 1;
+    return `${base}#r${attempt}`;
+}
+/** envelope id → source pointer (strips the attempt suffix). */
+export function sourceFromEnvelopeId(envelopeId) {
+    const bare = envelopeId.replace(/#r\d+$/, '');
+    const i = bare.indexOf(':');
+    if (i <= 0 || i === bare.length - 1)
+        return null;
+    return { sourceType: bare.slice(0, i), sourceId: bare.slice(i + 1) };
+}
+/**
+ * Fence-checked turn-end ledger close for a set of envelope ids — the shared
+ * core of BOTH turn-end hooks: onAgentEvent (turn_completed/turn_failed, the
+ * primary) and deliver (the no-observe npm-fallback path, where turn events
+ * never arrive and this is the ONLY terminal ledger hook — without it a
+ * received row would re-emit on every TTL sweep forever). Only sources whose
+ * `active:{source}` store row matches the envelope id EXACTLY are completed
+ * (attempt fence); the fence rows clear on success. Both hooks running is
+ * harmless: whichever completes first consumes the fence, the other skips.
+ */
+export async function completeFencedEnvelopes(ctx, envelopeIds) {
+    const fenced = [];
+    for (const envId of envelopeIds) {
+        const src = sourceFromEnvelopeId(envId);
+        if (!src)
+            continue; // pre-alignment envelope id (dsp_*) — old rows were acked on emit
+        const active = await readActiveEmit(ctx, src.sourceType, src.sourceId);
+        if (active?.id === envId) {
+            fenced.push({ source_type: src.sourceType, source_id: src.sourceId });
+        }
+    }
+    if (fenced.length > 0 && (await completeSources(ctx, fenced))) {
+        for (const src of fenced) {
+            await clearActiveEmit(ctx, src.source_type, src.source_id);
+        }
+    }
+}
+/**
+ * Turn-end ledger close: resolves the turn's folded sources on the server —
+ * broad-cover to the turn's reply Effect when one exists, no_action sweep
+ * otherwise (the server decides; POST /dispatch/complete-sources, idempotent).
+ * One immediate retry on failure; a still-failed call leaves the rows
+ * received and the catch-up TTL re-emit self-heals.
+ */
+export async function completeSources(ctx, sources) {
+    // Ledger surface — not gated on reportingEnabled (see markDispatchReceived).
+    if (sources.length === 0)
+        return true;
+    const url = `${parallApiUrl(ctx)}/api/v1/orgs/${parallOrgId(ctx)}/dispatch/complete-sources`;
+    const attempt = async () => {
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: jsonHeaders(ctx),
+            body: JSON.stringify({ sources }),
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            console.error(`[parel-channel] complete-sources failed (${res.status})`);
+        return res.ok;
+    };
+    try {
+        if (await attempt())
+            return true;
+    }
+    catch {
+        // fall through to the single immediate retry
+    }
+    try {
+        return await attempt();
+    }
+    catch (err) {
+        console.error('[parel-channel] complete-sources failed', err);
+        return false;
+    }
+}
+/**
+ * Turn-end plain text as a suppressed audit step — the runtime-standard
+ * Layer 0 posture (agent-dm-loop-prevention.md): recorded on the session,
+ * never delivered to the chat. No `projection` field, so the server's
+ * projection gate keeps it panel-only; `suppressed: true` is the content
+ * marker the standard bridges write for undelivered text.
+ */
+export async function createSuppressedTextStep(ctx, sessionId, args) {
+    try {
+        const url = `${parallApiUrl(ctx)}/api/v1/orgs/${parallOrgId(ctx)}/agents/${parallAgentId(ctx)}/sessions/${sessionId}/steps`;
+        // Same subject-prefix line the other step writers draw: chv_ turns must
+        // not target 'chat' or the broadcast lands on a channel no client watches.
+        const targetType = args.subject.startsWith('chv_') ? 'channel_conversation' : 'chat';
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: jsonHeaders(ctx),
+            body: JSON.stringify({
+                step_type: 'text',
+                target_type: targetType,
+                target_id: args.subject,
+                idempotency_key: `text:${args.deliveryId}`,
+                content: { text: args.text, suppressed: true },
+            }),
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if (res.ok)
+            return 'ok';
+        console.error(`[parel-channel] suppressed text step failed (${res.status})`);
+        return resultForStatus(res.status);
+    }
+    catch (err) {
+        console.error('[parel-channel] suppressed text step failed', err);
+        return 'failed';
+    }
+}

package/dist/typed-dispatch.d.ts

@@ -19,13 +19,15 @@ import type { ConnectorContext } from '@parel/plugin-sdk';
  *   attached_to_uri legitimately revokes access to a delivered run snapshot;
  *   docs/primitives/schedule.md § Snapshot 不变性) — warn + ack + drop.
  *
- * Reply semantics differ from chat messages ON PURPOSE: a typed turn's
- * turn-end text has no chat to deliver to (deliver() only runs the redundant
- * idle), and the agent acts through its sandbox CLI instead — identical to
- * the standard runtimes, where typed events are answered with CLI actions,
- * not auto-delivered text. approval_decided is the one exception: it lives
- * in a chat, so its plan carries the chatId and the reply auto-delivers
- * there like any chat message.
+ * Reply semantics are uniform with the rest of the connector: NOTHING
+ * auto-delivers (the CLI-only reply contract,
+ * parel-reply-contract-alignment.md). A typed turn's turn-end text is never
+ * posted anywhere; the agent acts through its sandbox CLI — identical to
+ * the standard runtimes, where typed events are answered with CLI actions.
+ * approval_decided differs only in ROUTING metadata: it lives in a chat, so
+ * its plan carries the chatId — that anchors the suppressed turn-end audit
+ * step and tells the agent where to `parall messages send`; the reply
+ * itself is still an explicit CLI send.
  */
 export interface TypedDispatchData {
     id?: unknown;
@@ -55,7 +57,11 @@ export interface TypedEventPlan {
     /** Input-step content bits. */
     triggerType: string;
     summary: string;
-    /** Set only for approval_decided: the reply auto-delivers to this chat. */
+    /**
+     * Set only for approval_decided: anchors the suppressed turn-end audit
+     * step and tells the agent where to `parall messages send` — replies are
+     * CLI-only, nothing auto-delivers.
+     */
     chatId?: string;
 }
 export type TypedDispatchResult = TypedEventPlan

package/dist/typed-dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typed-dispatch.d.ts","sourceRoot":"","sources":["../src/typed-dispatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAI1D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,WAAW,iBAAiB;IAChC,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,kIAQpB,CAAC;AAEX,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED,wEAAwE;AACxE,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,sEAAsE;IACtE,UAAU,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAChD,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,mBAAmB,GAC3B,cAAc;AAChB,2CAA2C;GACzC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE;AACtB,gEAAgE;GAC9D;IAAE,OAAO,EAAE,SAAS,CAAA;CAAE,CAAC;AAY3B;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,iBAAiB,EACvB,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,mBAAmB,CAAC,CAwC9B"}
+{"version":3,"file":"typed-dispatch.d.ts","sourceRoot":"","sources":["../src/typed-dispatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAI1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,MAAM,WAAW,iBAAiB;IAChC,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,kIAQpB,CAAC;AAEX,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED,wEAAwE;AACxE,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,sEAAsE;IACtE,UAAU,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAChD,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,mBAAmB,GAC3B,cAAc;AAChB,2CAA2C;GACzC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE;AACtB,gEAAgE;GAC9D;IAAE,OAAO,EAAE,SAAS,CAAA;CAAE,CAAC;AAY3B;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,iBAAiB,EACvB,GAAG,EAAE,gBAAgB,GACpB,OAAO,CAAC,mBAAmB,CAAC,CAwC9B"}

package/dist/typed-dispatch.js

@@ -140,8 +140,9 @@ async function planTask(ctx, taskId, eventType, actor) {
     };
 }
 /**
- * schedule.fire / external_trigger turns have NO delivery target — the
- * managed-agent base behavior ("your reply auto-delivers") does not apply,
+ * schedule.fire / external_trigger turns have NO conversation attached at
+ * all — plain text output is never delivered anywhere (the CLI-only reply
+ * contract), and unlike chat turns there is no obvious chat to send into,
  * so without this line a normal completion silently disappears.
  */
 function cliOnlyOutputHint(kind) {
@@ -334,7 +335,8 @@ async function planApprovalDecided(ctx, approvalId, chatId, actor) {
     return {
         outcome: 'emit',
         // The decision belongs to the chat conversation it happened in — group
-        // and correlate there, and let the turn-end reply deliver to that chat.
+        // and correlate there; a follow-up reply is the agent's explicit CLI
+        // send into that chat (turn-end text never auto-delivers).
         subject: resolvedChat ?? approval.id,
         body: lines.join('\n'),
         stepTarget: resolvedChat ? { type: 'chat', id: resolvedChat } : null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/parel-channel",
-  "version": "1.41.0",
+  "version": "1.42.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": {

package/src/channel-prompt.ts

@@ -5,9 +5,10 @@
  * chat shares the agent's ONE parel session, so consecutive turns can come
  * from different conversations — each message is framed with its originating
  * chat so the model registers the context switch instead of answering chat B
- * with chat A's thread of thought. No reply hint: the turn-end reply is
- * auto-delivered to the right chat by replyRoute (deliver()), and sandbox CLI
- * calls get the right PRLL_CHAT_ID via per-turn invocation context.
+ * with chat A's thread of thought. No per-message reply hint: the system
+ * prompt teaches the CLI-only reply contract once (SSOT — plain text is
+ * never delivered; reply via `parall messages send`), and per-turn
+ * invocation context presets PRLL_CHAT_ID so the bare send hits this chat.
  *
  * External IM channel messages (buildChannelPrompt, channel_message
  * dispatches). Mirrors agent-core's event-format.ts channel branch, adapted