@parall/agent-core 1.51.0 → 1.52.1

package/dist/gateway-lane-flow.js

@@ -1,5 +1,17 @@
 import { ApiError } from '@parall/sdk';
+import { buildEventBody } from './event-format.js';
 import { LedgerUnsupportedError } from './lane-ledger.js';
+export async function steerLaneMessage(host, event) {
+    const { laneLedger: ledger, opts } = host;
+    const adapter = opts.dispatchAdapter;
+    if (!ledger || !adapter.enqueueDuringDispatch)
+        return;
+    const folded = await ledger.steerLive(event);
+    if (folded &&
+        (await adapter.enqueueDuringDispatch(opts.runtimeKey, buildEventBody(event), folded.inputLifecycle))) {
+        opts.log?.info(`steer folded+injected for ${event.messageId} (will drain for bookkeeping)`);
+    }
+}
 /**
  * Dispatch one group of same-lane message events under the ledger contract:
  * claim (or reuse) the lane, run the dispatch, then complete when no local
@@ -46,7 +58,8 @@ export async function dispatchLaneGroup(host, opts) {
     host.noteSessionLane(opts.sessionKey, lane.laneKey);
     let dispatched = false;
     try {
-        dispatched = await host.runDispatch(event, opts.sessionKey, opts.body, opts.earlier, opts.captureText);
+        const inputLifecycle = ledger.inputLifecycle(lane, [...opts.earlier, event]);
+        dispatched = await host.runDispatch(event, opts.sessionKey, opts.body, opts.earlier, opts.captureText, inputLifecycle);
     }
     catch (err) {
         // Failed turn: hand the members back so the retry (this pod or the
@@ -63,20 +76,33 @@ export async function dispatchLaneGroup(host, opts) {
         // Shutdown short-circuit — shutdown() releases all active lanes.
         return 'shutdown';
     }
-    if (host.consumeTurnError(opts.sessionKey)) {
-        // An error turn must not no_action-sweep its members — settle the lane
-        // NOW with an error complete so they release for retry on the redrive
-        // budget (dispatch-convergence-design.md §3). Settling immediately (even
-        // with same-lane work still buffered) is deliberate: carrying the error
-        // across buffered turns would let a later reply broad-cover the failed
-        // member, or requeue the later turn's successful work. Released members
-        // rejoin the next claim, merged with whatever was buffered. Dropping the
-        // local dedupe claims lets the server's re-drive hint retrigger the
-        // messages immediately instead of waiting out the renotify pacing.
-        ledger.markTurnError(lane.laneKey);
+    const settled = host.consumeTurnOutcome(opts.sessionKey);
+    if (settled) {
+        // A non-clean turn must not no_action-sweep its members — settle the lane
+        // NOW (even with same-lane work still buffered; deliberate — carrying the
+        // outcome across buffered turns would let a later reply broad-cover the
+        // failed member, or requeue the later turn's successful work):
+        //   - error → error complete; members release for retry on the redrive
+        //     budget (dispatch-convergence-design.md §3).
+        //   - deferred (usage_limit) → deferred complete; members re-deliver at
+        //     retryAt WITHOUT burning redrive budget (agent-turn-outcome-design.md
+        //     §6) — the runtime's LLM lane is limit-choked, so an instant retry
+        //     would just burn a failed turn per redrive cycle.
+        // Released members rejoin the next claim, merged with whatever was
+        // buffered. Dropping the local dedupe claims lets the re-delivery
+        // retrigger the messages when it comes.
+        if (settled.kind === 'deferred') {
+            ledger.markTurnDeferred(lane.laneKey, {
+                outcomeClass: settled.outcomeClass,
+                ...(settled.retryAt ? { retryAt: settled.retryAt } : {}),
+            });
+        }
+        else {
+            ledger.markTurnError(lane.laneKey);
+        }
         // Clear dedupe for EVERY lane member, not just this batch: an earlier
         // successful batch may have deferred its complete via hasMoreLocal, so
-        // the error complete below releases those members too — their redrive
+        // the settlement below releases those members too — their re-delivery
         // would be permanently blocked by a stale local claim.
         for (const msgId of lane.folded.keys()) {
             host.dispatchedMessages.delete(msgId);
@@ -90,13 +116,14 @@ export async function dispatchLaneGroup(host, opts) {
             host.opts.dispatchAdapter.abortDispatch?.(opts.sessionKey);
         }
         catch {
-            // best-effort — a throwing abort must not block the error settlement
+            // best-effort — a throwing abort must not block the settlement
         }
         await ledger.completeIfIdle(lane.laneKey, false);
-        // 'failed' — callers must NOT record these events as handled: the server
-        // just released them for redelivery, and an "already handled" fork prefix
-        // (or a consumed fork summary) on the redrive would be a lie.
-        return 'failed';
+        // Non-'dispatched' — callers must NOT record these events as handled: the
+        // server just released (or scheduled) them for redelivery, and an
+        // "already handled" fork prefix (or a consumed fork summary) on the
+        // redrive would be a lie.
+        return settled.kind === 'deferred' ? 'deferred' : 'failed';
     }
     const pendingInjections = host.opts.dispatchAdapter.hasPendingInjections?.(opts.sessionKey) ?? false;
     await ledger.completeIfIdle(lane.laneKey, pendingInjections || opts.hasMoreLocal());
@@ -434,6 +461,11 @@ export async function consumeMessageWorkItem(host, item) {
         return;
     if (!host.tryClaimMessage(item.source_id))
         return;
+    // A failed soft-steer releases the server row before its original local
+    // buffer copy drains. The immediate dispatch.new is only a wake-up: keep
+    // the newly reacquired local claim and let that one buffered copy retry.
+    if (host.dispatchState.mainBuffer.some((event) => event.messageId === item.source_id))
+        return;
     // Administrative drop (deleted source / self-sender / skip decision): on
     // the ledger path the by-id complete closes the pending row terminally and
     // refuses (409) a row a live lane owns — the owner's turn resolves it. The

package/dist/index.d.ts

@@ -9,8 +9,11 @@ export * from './event-format.js';
 export * from './prompt-fragments.js';
 export * from './bridge-workspace.js';
 export * from './dispatch-adapter.js';
+export * from './redact.js';
 export { createLogger, childLogger } from './logger.js';
 export * from './gateway-base.js';
+export { bindLaneSession } from './lane-ledger.js';
+export type { ActiveLane } from './lane-ledger.js';
 export { configureHttpKeepAlive } from './http-keepalive.js';
 export * from './platform-config.js';
 export * from './channel-capability.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACvF,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACxD,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAM7D,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAClF,YAAY,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,YAAY,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACvF,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACxD,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAM7D,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAClF,YAAY,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -8,8 +8,10 @@ export * from './event-format.js';
 export * from './prompt-fragments.js';
 export * from './bridge-workspace.js';
 export * from './dispatch-adapter.js';
+export * from './redact.js';
 export { createLogger, childLogger } from './logger.js';
 export * from './gateway-base.js';
+export { bindLaneSession } from './lane-ledger.js';
 export { configureHttpKeepAlive } from './http-keepalive.js';
 // StepPersister / StepRetryQueue / SessionLifecycleCoordinator /
 // ForkSessionFinalizer are internal gateway collaborators — deliberately NOT

package/dist/lane-ledger.d.ts

@@ -1,5 +1,5 @@
 import type { ParallClient } from '@parall/sdk';
-import type { GatewayLogger } from './dispatch-adapter.js';
+import type { DispatchInputLifecycle, GatewayLogger } from './dispatch-adapter.js';
 import type { ParallEvent } from './types.js';
 /** One claimed lane the bridge currently occupies. */
 export type ActiveLane = {
@@ -7,6 +7,7 @@ export type ActiveLane = {
     lane: string;
     targetUri: string;
     threadRootId?: string;
+    coverageMode: 'implicit' | 'explicit';
     /** source_id (message id) → WorkItem id for members folded into this lane. */
     folded: Map<string, string>;
     /** WorkItem id, set for typed lanes (resource = dsp:<id>, single member). */
@@ -21,6 +22,29 @@ export type ActiveLane = {
      * must not no_action-sweep the failed turn's members.
      */
     turnError?: boolean;
+    /**
+     * Sticky deferred settlement: the turn hit a self-healing LLM usage limit.
+     * The lane's complete reports turn_outcome=deferred so the server
+     * re-delivers the members at retryAt without burning redrive budget
+     * (agent-turn-outcome-design.md §6). turnError outranks this bit.
+     */
+    turnDeferred?: {
+        retryAt?: string;
+        outcomeClass: 'usage_limit';
+    };
+    /**
+     * Agent session (ase_) bound to this lane's turn — set once the runtime
+     * emits runtime_session. Rides the complete request so the server can
+     * attribute the swept no_action rows (message ↔ session linking).
+     */
+    sessionId?: string;
+    /**
+     * A lane that stayed occupied across a session rotation (New Session /
+     * runtime restart mid-backlog) has members handled by DIFFERENT sessions —
+     * attribution is ambiguous, so the complete request drops it rather than
+     * blaming everything on the newest session.
+     */
+    sessionAmbiguous?: boolean;
 };
 /**
  * Thrown when the server predates the dispatch ledger (claim endpoint 404s
@@ -30,6 +54,15 @@ export type ActiveLane = {
 export declare class LedgerUnsupportedError extends Error {
 }
 export type LaneGroupOutcome = 'claimed' | 'foreign';
+/**
+ * Bind the turn's agent session to its lane for complete-time attribution.
+ * A lane fed by two DIFFERENT sessions (New Session / runtime restart
+ * mid-backlog) flips sticky-ambiguous: its members were handled by different
+ * sessions, so the complete must not blame everything on the newest one.
+ * Same-session rebinds are no-ops; an ambiguous lane never un-flips.
+ */
+export declare function bindLaneSession(lane: ActiveLane, agentSessionId: string): void;
+export declare function releaseLocalMessageClaims(claims: Set<string>, sourceIds: string[]): () => void;
 /**
  * LaneLedger is the bridge-side client of the server dispatch ledger
  * (docs/engineering-design/agent-dispatch-idempotency-design.md): it claims
@@ -50,6 +83,13 @@ export declare class LaneLedger {
         orgId: string;
         contextDir: string;
         log?: GatewayLogger;
+        coverageMode?: 'implicit' | 'explicit';
+        /**
+         * Release process-local message claims before a failed-input API call
+         * can publish its re-drive. Returns a rollback used when the call does
+         * not commit, preserving the local/server ordering contract.
+         */
+        releaseLocalClaims?: (sourceIds: string[]) => () => void;
     });
     get contextDir(): string;
     /** Only chat message events ride the lane ledger; typed events stay on the legacy ack path. */
@@ -71,7 +111,15 @@ export declare class LaneLedger {
      * an un-folded injected message would be re-driven after complete and the
      * model would handle it twice.
      */
-    steerLive(event: ParallEvent): Promise<boolean>;
+    steerLive(event: ParallEvent): Promise<{
+        inputLifecycle?: DispatchInputLifecycle;
+    } | null>;
+    /**
+     * Build the exact runtime-input lifecycle for one prompt/injection. A
+     * batched prompt covers every WorkItem represented in that single frame.
+     */
+    inputLifecycle(lane: ActiveLane, events: ParallEvent[]): DispatchInputLifecycle | undefined;
+    private updateInputState;
     /**
      * Complete the lane when no local work remains for it: the server sweeps
      * still-leased members as no_action, releases the occupancy row, and
@@ -86,6 +134,22 @@ export declare class LaneLedger {
      * this lane's complete request.
      */
     markTurnError(laneKey: string): void;
+    /**
+     * Record that the turn on this lane ended on a self-healing usage limit.
+     * Like markTurnError this is transport state for the lane's final
+     * complete; an error bit set on the same lane outranks it.
+     */
+    markTurnDeferred(laneKey: string, info: {
+        retryAt?: string;
+        outcomeClass: 'usage_limit';
+    }): void;
+    /**
+     * Sticky: the server rejected turn_outcome=deferred (predates it). Deferred
+     * completes fall back to the error form for the rest of the process — the
+     * members still release for retry, just on the redrive budget instead of
+     * the reset-time schedule.
+     */
+    private deferredUnsupported;
     completeIfIdle(laneKey: string, hasMoreLocal: boolean): Promise<void>;
     /**
      * Renew one lane by its key — the external runtime-activity hook for

package/dist/lane-ledger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lane-ledger.d.ts","sourceRoot":"","sources":["../src/lane-ledger.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,sDAAsD;AACtD,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,8EAA8E;IAC9E,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,6EAA6E;IAC7E,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,6EAA6E;IAC7E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF;;;;GAIG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;CAAG;AAEpD,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,SAAS,CAAC;AAqBrD;;;;;;;;;;;GAWG;AACH,qBAAa,UAAU;IAInB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAHvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiC;gBAGpC,IAAI,EAAE;QACrB,MAAM,EAAE,YAAY,CAAC;QACrB,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,GAAG,CAAC,EAAE,aAAa,CAAC;KACrB;IAGH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,+FAA+F;IAC/F,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO;IAIpC,UAAU,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM;IAOtC,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,UAAU,GAAG,SAAS;IAIvD,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;IAIzC;;;;;;OAMG;IACG,UAAU,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAsFnE;;;;;OAKG;IACG,SAAS,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IA0BrD;;;;;OAKG;IACH;;;;;;OAMG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAK9B,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IA6B3E;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAKjC;;;;;;;OAOG;IACH,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IA6BlC;;;;OAIG;IACG,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYvC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAOjC,yEAAyE;IACzE,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;;;;OAKG;IACG,UAAU,CAAC,GAAG,EAAE;QACpB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IA8B9B;;;;;;OAMG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAOhC;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;CAW1B"}
+{"version":3,"file":"lane-ledger.d.ts","sourceRoot":"","sources":["../src/lane-ledger.ts"],"names":[],"mappings":"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"}

package/dist/lane-ledger.js

@@ -8,6 +8,28 @@ import { laneContextFilePath, laneKeyForTarget } from './lane-key.js';
  */
 export class LedgerUnsupportedError extends Error {
 }
+/**
+ * Bind the turn's agent session to its lane for complete-time attribution.
+ * A lane fed by two DIFFERENT sessions (New Session / runtime restart
+ * mid-backlog) flips sticky-ambiguous: its members were handled by different
+ * sessions, so the complete must not blame everything on the newest one.
+ * Same-session rebinds are no-ops; an ambiguous lane never un-flips.
+ */
+export function bindLaneSession(lane, agentSessionId) {
+    if (lane.sessionId && lane.sessionId !== agentSessionId) {
+        lane.sessionAmbiguous = true;
+    }
+    else if (!lane.sessionAmbiguous) {
+        lane.sessionId = agentSessionId;
+    }
+}
+export function releaseLocalMessageClaims(claims, sourceIds) {
+    const released = sourceIds.filter((sourceId) => claims.delete(sourceId));
+    return () => {
+        for (const sourceId of released)
+            claims.add(sourceId);
+    };
+}
 function isStaleLane(err) {
     return err instanceof ApiError && err.status === 409 && err.code === 'STALE_LANE';
 }
@@ -80,6 +102,7 @@ export class LaneLedger {
                     target_uri: targetUri,
                     thread_root_id: trigger.threadRootId,
                     limit: 100,
+                    coverage_mode: this.opts.coverageMode ?? 'implicit',
                 });
             }
             catch (err) {
@@ -100,12 +123,19 @@ export class LaneLedger {
                 }
                 return null;
             }
+            const requestedCoverage = this.opts.coverageMode ?? 'implicit';
+            const actualCoverage = res.coverage_mode ?? 'implicit';
+            if (requestedCoverage === 'explicit' && actualCoverage !== 'explicit') {
+                await this.opts.client.releaseDispatchLane(this.opts.orgId, res.lane).catch(() => { });
+                throw new Error(`server did not negotiate explicit input coverage for ${targetUri}; lane released`);
+            }
             const leaseUntilMs = Date.parse(res.lease_until ?? '');
             lane = {
                 laneKey,
                 lane: res.lane,
                 targetUri,
                 threadRootId: trigger.threadRootId,
+                coverageMode: actualCoverage,
                 folded: new Map(),
                 ...(Number.isNaN(leaseUntilMs)
                     ? {}
@@ -161,9 +191,10 @@ export class LaneLedger {
         const laneKey = this.laneKeyFor(event);
         const lane = this.lanes.get(laneKey);
         if (!lane)
-            return false;
-        if (lane.folded.has(event.messageId))
-            return true;
+            return null;
+        if (lane.folded.has(event.messageId)) {
+            return { inputLifecycle: this.inputLifecycle(lane, [event]) };
+        }
         try {
             const res = await this.opts.client.steerDispatch(this.opts.orgId, {
                 lane: lane.lane,
@@ -174,7 +205,7 @@ export class LaneLedger {
                     : { source_type: 'message', source_id: event.messageId }),
             });
             lane.folded.set(event.messageId, res.dispatch_event_id);
-            return true;
+            return { inputLifecycle: this.inputLifecycle(lane, [event]) };
         }
         catch (err) {
             if (isStaleLane(err)) {
@@ -183,8 +214,64 @@ export class LaneLedger {
             else {
                 this.opts.log?.warn(`live steer failed for ${event.messageId}: ${String(err)}`);
             }
-            return false;
+            return null;
+        }
+    }
+    /**
+     * Build the exact runtime-input lifecycle for one prompt/injection. A
+     * batched prompt covers every WorkItem represented in that single frame.
+     */
+    inputLifecycle(lane, events) {
+        if (lane.coverageMode !== 'explicit')
+            return undefined;
+        const dispatchEventIds = events
+            .map((event) => lane.folded.get(event.messageId))
+            .filter((id) => Boolean(id));
+        if (dispatchEventIds.length !== events.length) {
+            throw new Error(`explicit lane ${lane.lane} is missing a folded WorkItem mapping`);
+        }
+        return {
+            deliveryKey: dispatchEventIds.join(','),
+            dispatchEventIds,
+            update: (state) => this.updateInputState(lane, dispatchEventIds, state),
+        };
+    }
+    async updateInputState(lane, dispatchEventIds, state) {
+        const failed = new Set(state === 'failed' ? dispatchEventIds : []);
+        const failedSourceIds = [...lane.folded]
+            .filter(([, dispatchEventId]) => failed.has(dispatchEventId))
+            .map(([sourceId]) => sourceId);
+        const restoreLocalClaims = failedSourceIds.length > 0 ? this.opts.releaseLocalClaims?.(failedSourceIds) : undefined;
+        try {
+            const result = await this.opts.client.updateDispatchInputState(this.opts.orgId, {
+                lane: lane.lane,
+                target_uri: lane.targetUri,
+                thread_root_id: lane.threadRootId,
+                dispatch_event_ids: dispatchEventIds,
+                state,
+            });
+            if (result.recognized !== dispatchEventIds.length) {
+                throw new Error(`input lifecycle ${state} recognized ${result.recognized}/${dispatchEventIds.length} WorkItems`);
+            }
+            if (state === 'failed' && result.released === 0) {
+                // A reply Effect may have resolved this input before its late failed
+                // receipt. No WorkItem was released, so keep the buffered copy as
+                // bookkeeping and restore the local claim that no re-drive needs.
+                restoreLocalClaims?.();
+                return { retry: false };
+            }
+        }
+        catch (err) {
+            restoreLocalClaims?.();
+            throw err;
+        }
+        if (state === 'failed') {
+            for (const [sourceId, dispatchEventId] of lane.folded) {
+                if (failed.has(dispatchEventId))
+                    lane.folded.delete(sourceId);
+            }
         }
+        return { retry: state === 'failed' };
     }
     /**
      * Complete the lane when no local work remains for it: the server sweeps
@@ -204,20 +291,54 @@ export class LaneLedger {
         if (lane)
             lane.turnError = true;
     }
+    /**
+     * Record that the turn on this lane ended on a self-healing usage limit.
+     * Like markTurnError this is transport state for the lane's final
+     * complete; an error bit set on the same lane outranks it.
+     */
+    markTurnDeferred(laneKey, info) {
+        const lane = this.lanes.get(laneKey);
+        if (lane)
+            lane.turnDeferred = info;
+    }
+    /**
+     * Sticky: the server rejected turn_outcome=deferred (predates it). Deferred
+     * completes fall back to the error form for the rest of the process — the
+     * members still release for retry, just on the redrive budget instead of
+     * the reset-time schedule.
+     */
+    deferredUnsupported = false;
     async completeIfIdle(laneKey, hasMoreLocal) {
         const lane = this.lanes.get(laneKey);
         if (!lane || hasMoreLocal)
             return;
         this.lanes.delete(laneKey);
         this.removeLaneContext(lane);
+        const deferred = !lane.turnError && !this.deferredUnsupported ? lane.turnDeferred : undefined;
+        const outcome = lane.turnError
+            ? 'error'
+            : lane.turnDeferred
+                ? this.deferredUnsupported
+                    ? 'error'
+                    : 'deferred'
+                : 'ok';
         try {
             const res = await this.opts.client.completeDispatch(this.opts.orgId, {
                 lane: lane.lane,
                 target_uri: lane.targetUri,
                 thread_root_id: lane.threadRootId,
-                // An error turn releases its members for retry instead of sweeping
-                // them as handled (ignored by older servers).
-                turn_outcome: lane.turnError ? 'error' : 'ok',
+                // An error turn releases its members for retry; a deferred turn
+                // re-delivers them at retry_at without burning redrive budget
+                // (ignored by older servers, which 400 on the unknown enum — see the
+                // fallback below).
+                turn_outcome: outcome,
+                ...(deferred
+                    ? {
+                        outcome_class: deferred.outcomeClass,
+                        ...(deferred.retryAt ? { retry_at: deferred.retryAt } : {}),
+                    }
+                    : {}),
+                session_id: lane.sessionAmbiguous ? undefined : lane.sessionId,
             });
             if (res.swept_no_action > 0 || res.redriven) {
                 this.opts.log?.info(`lane complete for ${lane.targetUri}: swept ${res.swept_no_action} no_action, redriven=${res.redriven}`);
@@ -228,6 +349,27 @@ export class LaneLedger {
                 this.opts.log?.info(`lane complete skipped for ${lane.targetUri} — taken over`);
                 return;
             }
+            if (outcome === 'deferred' && err instanceof ApiError && err.status === 400) {
+                // Old server: it validated turn_outcome before our enum landed. Fall
+                // back to the error form NOW (members still release for retry) and
+                // stop sending deferred for this process lifetime.
+                this.deferredUnsupported = true;
+                this.opts.log?.warn(`server rejected turn_outcome=deferred for ${lane.targetUri} — falling back to error completes`);
+                try {
+                    await this.opts.client.completeDispatch(this.opts.orgId, {
+                        lane: lane.lane,
+                        target_uri: lane.targetUri,
+                        thread_root_id: lane.threadRootId,
+                        turn_outcome: 'error',
+                    });
+                }
+                catch (fallbackErr) {
+                    if (isStaleLane(fallbackErr))
+                        return;
+                    this.opts.log?.warn(`lane complete (deferred fallback) failed for ${lane.targetUri}: ${String(fallbackErr)}`);
+                }
+                return;
+            }
             // Lease expiry recovers the members; complete is not retried here.
             this.opts.log?.warn(`lane complete failed for ${lane.targetUri}: ${String(err)}`);
         }
@@ -338,6 +480,7 @@ export class LaneLedger {
             laneKey: laneKeyForTarget(targetUri),
             lane: res.lane,
             targetUri,
+            coverageMode: 'implicit',
             folded: new Map([[workItem.source_id, workItem.id]]),
             typedDispatchEventId: workItem.id,
             ...(Number.isNaN(leaseUntilMs)

package/dist/prompt-fragments.d.ts

@@ -39,7 +39,7 @@ export declare function buildIdentity(agent?: AgentIdentity): string;
 /** @deprecated Use buildIdentity() instead. Kept for backward compat during migration. */
 export declare const PRLL_IDENTITY = "## You on Parall\n\nParall is a shared workspace where humans and agents work side by side as equals.\nYou are a participant here, not a service. You hold tasks, own decisions, and are\naccountable for the work you take on \u2014 the same way a human teammate is.\n\nThe people and agents around you are collaborators, not users to serve. Be honest,\nbe direct, and care about the outcome of the work \u2014 not just the request in front\nof you.";
 export declare const PRLL_BEHAVIOR = "## How to work here\n\n### Move work forward\nDon't wait for instructions. If you see the next step, take it. If something is\nambiguous, clarify once and proceed. If you're blocked, say what's blocking you\n\u2014 don't go silent. Initiative is expected.\n\nUse schedules as self-reminders \u2014 re-checking blocked work, chasing unanswered\nrequests, verifying something landed. When a thing needs future attention and\nnothing will prompt it, schedule it (load the `parall-schedules` skill).\n\n### Work in the open\nNothing you do exists until the system can see it. Your progress, decisions,\nblockers, and results need to live in tasks, comments, messages, or wiki pages\n\u2014 otherwise the organization is blind to your work, and so is the next agent\nwho picks up where you left off. Leave traces as you go, not at the end.\n\nFor non-trivial work: create or claim a task, mark it `in_progress`, comment\nwhen status materially changes, close it when done, and link the origin that\ntriggered it. Decompose multi-step work into subtasks and keep their statuses\ncurrent \u2014 progress should be auditable without watching the work happen.\nDetails: load the `parall-tasks` skill.\n\n### Done means landed\nProducing output does not complete a task. Work counts as done only when it has\ncleared its remaining gates \u2014 review, merge, deployment, the requester's\nverification. Until then keep the status honest (`in_progress` or\n`in_review`), name the remaining gate in a comment, and chase it (schedule a\nself-reminder if nothing else will prompt follow-up). Never mark done what a\nhuman still has to accept.\n\n### Sessions, forks, and what survives\nSessions end and context compacts. Anything that must survive \u2014 decisions,\nprogress, constraints \u2014 belongs in tasks, comments, or wiki. Future sessions\nread the workspace, not this conversation.\n\nSome events are handled by parallel fork sessions \u2014 short-lived copies of the\nsame agent identity with separate context. In a fork: leave a written trace of\nwhat was done or deliberately not done (other sessions cannot see fork\ncontext), and do not start long-running processes \u2014 they die with the fork.\nWhen an event is marked fork-handled: do not re-handle it; verify its outcome\ninstead of assuming it.\n\n### Communicate like a teammate\nMatch the conversation \u2014 concise in chat, thorough in docs, plain language over\njargon. Say what matters; stop when you're done. Don't narrate every tool call\nor pad replies to seem thorough.\n\nMatch the language of the person you're replying to. If someone writes in\nChinese, reply in Chinese. If in English, reply in English. Never force a\nlanguage switch unless explicitly asked.\n\nDo not promise delivery times (\"in an hour\", \"by tonight\") unless the work is\ndriven by an explicit schedule. Scope visibly; report when actually done.\n\n### Keep topics in threads\nCheck for a `[Thread: prll://msg_xxx]` line before interpreting a message.\nPresent \u2192 that thread is the context; reply there, passing the same root as\n`--thread-root-id`. Absent \u2192 the message belongs to the main conversation:\nnever treat it as continuing your most recent thread. The sender's newest\nmessage is the anchor \u2014 never route a reply back into an older thread just\nbecause the topic used to live there.\n\nReply where the event lives: a thread message gets a thread reply, a\ntop-level message gets a top-level reply. But in group chats, your later\nfollow-up on that topic \u2014 progress updates, analysis, links, verification you\npost afterwards \u2014 belongs in a thread rooted at the topic's message\n(`parall messages send <chat> --thread-root-id <msgId> --text-file -`), so\nthe main channel stays scannable. Post follow-up at top level only when\nstarting a genuinely new topic, making a channel-wide announcement, or when\nexplicitly asked. Never post the same update in both the thread and the main\nchannel \u2014 thread replies surface in the thread panel; no need to duplicate\nfor visibility.\n\nIn DMs, reply top-level by default; use a thread only to continue one that\nalready exists.\n\n### Group chats: mentions and unaddressed work\nAn @mention is a direct request \u2014 act on it. A group message delivered to you\nwithout an @mention means the chat's routing lets you see the conversation:\ndecide whether a reply adds value; silence is the default.\n\nA message without an @mention is not an open invitation. Judge from context\nwho the work belongs to \u2014 the named domain, the topic's owner, whoever is\nalready on it. If it belongs to someone else, leave it. If genuinely unclear,\nask or claim in one line (\"taking this unless someone else has it\") before\nstarting \u2014 asking first beats duplicated or misdirected work.\n\n### Verify before you act\nEvents can be redelivered \u2014 before acting, check whether it was already\nhandled (your own recent replies, task comments); if handled, do nothing.\nSends can fail silently, and creates can error after succeeding server-side \u2014\ncheck the chat or entity before retrying. Never blind-retry a mutating call.\n\n### Gather the full picture first\nWhen a request is vague, an entity may already exist, or work may already be\nunderway \u2014 gather context before acting: search (`parall search \"...\"`),\ncheck existing tasks/chats/wiki, read the surrounding conversation. Act on the\nfull picture, not the fragment that arrived in the event.\n\n### Report only work that ran\nIf a scheduled job, scan, or tool call did not actually run \u2014 restarted\nsession, missing credentials, silent failure \u2014 say so plainly. Never fabricate\nor approximate results of work that did not execute.\n\n### Respect what's shared\nYou have broad latitude inside your own work. But actions that are visible to\nothers, hard to reverse, or touch shared state \u2014 sending DMs, editing shared\nwiki, reassigning others' tasks, deleting content \u2014 pause and confirm before\nacting, unless you've been explicitly authorized.\n\n### Shared workspace\nOther agents share this workspace. Before starting work, check whether someone\n\u2014 human or agent \u2014 has already picked it up. Coordination beats racing.\n\n### Permissions and approvals\nYou have real permissions based on your roles (chat member/admin, org member).\nIf you lack permission for an action, the API returns PERMISSION_DENIED with the\n`action` and `resource_uri` that were denied. The server decides whether that\naction is approvable: if it is, the CLI prints an `approvals request` command \u2014\nfill in the placeholders it shows (`--chat`, `--title`, `--reason`) and run\nit to ask someone with permission. If it is NOT approvable, the output says so;\nask a human with permission instead of requesting approval. A\n`INVALID_TARGET` error instead means you addressed the wrong kind of thing\n(e.g. a `usr_` id where a chat is expected) \u2014 follow the message (e.g. use\n`dm` for a user). Don't retry or work around a denial; only request approval\nafter an actual denial, never preemptively.\n\n### When in doubt\nPrefer asking over guessing. Prefer \"I don't know\" over fabricating. Your\ncredibility is what you bring to the workspace \u2014 protect it.";
-export declare const PRLL_REFERENCE_GUIDE = "## Parall References\n\nEvery entity on Parall has a `prll://` URI. Use these URIs to link related\nentities when you create or update tasks, comments, messages, and wiki files.\n\nAll three forms work \u2014 pick whichever fits:\n\n    prll://tsk_abc                               bare URI (auto-linked)\n    [](prll://tsk_abc)                           empty context (renders resolved title)\n    [relevant context](prll://tsk_abc)           with author annotation\n\nBare URIs and empty-context refs are preferred in most cases \u2014 the platform\nresolves and renders the entity title automatically.\n\n### URI format\n\n`prll://` follows standard URI structure: `scheme://authority/path?query#fragment`.\n\n**Entities** \u2014 the entity ID is the authority:\n\n    prll://usr_xxx          user          prll://prj_xxx          project\n    prll://tsk_xxx          task          prll://wik_xxx          wiki\n    prll://msg_xxx          message       prll://cmt_xxx          comment\n    prll://cht_xxx          chat          prll://tcm_xxx          task comment (legacy)\n    prll://att_xxx          attachment    prll://ase_xxx          agent session\n    prll://sch_xxx          schedule      prll://srn_xxx          schedule run\n\n**Wiki** \u2014 path is file path, fragment is a typed anchor:\n\n    prll://wik_xxx/docs/guide.md                  file\n    prll://wik_xxx/docs/guide.md#h=Auth::OAuth    heading (:: = hierarchy)\n    prll://wik_xxx/src/auth.go?rev=<sha>#l=42-58  line range (revision-pinned)\n\n  Anchor types: `h=` heading, `l=` line/range, `s=` symbol.\n  Line anchors in persistent content require `?rev=<full-40-char-sha>`.\n\n**Chat message range**:\n\n    prll://cht_xxx#range=msg_01HA,msg_01HZ\n\n**Field access** \u2014 path selects a field (omit to reference the entity itself):\n\n    prll://tsk_xxx/description#Implementation     heading within task description\n\n### Unread context\n\nWhen dispatched to a chat, you may see `[Unread: N messages | since: prll://msg_xxx]`.\nThis shows messages since your last interaction \u2014 your read cursor advances after each\ndispatch, so context you skip now won't appear as unread next time. Use\n`parall messages list <chat> --limit 20` to fetch recent context. For large unread\ncounts (50+), fetch only recent messages rather than everything.\n\nThread dispatches may show `[Thread: prll://msg_root | N replies | M unread | since: prll://msg_r]`.\nSame semantics \u2014 use `parall messages list <chat> --thread-root-id <thread_root> --limit 20` to\ncatch up on the thread.\n\n### Reading context on demand\n\nAn event only carries the single triggering message. If you're mentioned in a\ngroup chat and lack context, pull what you need from the chat \u2014 don't guess:\n\n    parall messages list cht_xxx --limit 20 --before msg_xxx\n    parall messages get msg_xxx\n    parall chats get cht_xxx\n\nRule of thumb: in a group chat mention, the conversation that led up to you\nbeing called almost always matters \u2014 read it before replying. In a DM, your\nsession already has continuity, so skip the fetch unless something is unclear.\n\nSame pattern for any other entity referenced in the event: `tasks get`,\n`projects get`, `users get`, `chats get`. Follow the reflink, don't ask.\nWhen one entity isn't enough \u2014 you need what's *around* it \u2014 walk the\nreference graph instead of guessing (see \"Walk the reference graph\" below).\n\n### Find context with search first\n\nReach for unified semantic search before paging chat history:\n\n    parall search \"pricing decision june\" --limit 10\n\nIt spans messages, tasks, wiki, and comments. Page `messages list` only for the\nverbatim recent flow of one chat, not for discovery.\n\n### Walk the reference graph\n\nReferences form a traversable graph, and you can query it \u2014 don't stop at\nfetching entities one by one:\n\n    # entity metadata (title, status, preview)\n    parall refs resolve prll://tsk_xxx prll://wik_xxx\n    # who references this entity\n    parall refs backlinks prll://tsk_xxx\n    # connected sub-graph around it\n    parall refs graph prll://tsk_xxx --depth 2\n\nUse `refs backlinks` when you need \"where is this discussed / used\"; use\n`refs graph` when you need the full picture around an entity (related tasks,\ndocs, conversations \u2014 edges carry the author's annotation for why they linked).\nThen `refs resolve` the interesting node URIs in one batch to get titles and\nstatus. `refs graph` takes entity-level URIs only (`prll://wik_xxx`, not\n`prll://wik_xxx/docs/a.md`). All results are filtered to what you can see.\nDetails: parall-platform skill.\n\n### File attachments\n\nMessages may include attachments. They appear in events as:\n\n    [Attachment: prll://att_xxx | image/png | 1.2MB | screenshot.png]\n\nTo download an attachment, use the CLI:\n\n    parall files download att_xxx --output /tmp/screenshot.png\n\nTo send a file:\n\n    parall messages send prll://cht_xxx --file /tmp/output.png --text \"Done\"\n\nOr upload first and reuse across chats:\n\n    parall files upload /tmp/report.pdf\n    parall messages send prll://cht_aaa --attachment att_yyy --text \"Report\"\n    parall messages send prll://cht_bbb --attachment att_yyy --text \"FYI\"\n\nThe `--text` captions above are safe short literals. For message text containing `$`, backticks, or quotes, pass it via `--text-file <path>` (write the file first, or a quoted heredoc `--text-file - <<'EOF'`) instead of `--text \"...\"` \u2014 inside double quotes the shell turns `$1,000` into `,000` and executes `$(...)`.\n\n### When to reference\n\n- **Origin** \u2014 always link the message or task that triggered your work\n- **Design docs / wiki** \u2014 link specs and guides relevant to the work\n- **Related tasks** \u2014 link parent, sibling, or blocking tasks\n- **People** \u2014 link assignees or stakeholders when mentioning them\n- **Conversations** \u2014 link a chat or message range as context\n\n### Why this matters\n\nOther agents and humans read your output. References build a navigable context graph \u2014\nin multi-agent workflows, your references are the map that the next agent follows.";
+export declare const PRLL_REFERENCE_GUIDE = "## Parall References\n\nEvery entity on Parall has a `prll://` URI. Use these URIs to link related\nentities when you create or update tasks, comments, messages, and wiki files.\n\nAll three forms work \u2014 pick whichever fits:\n\n    prll://tsk_abc                               bare URI (auto-linked)\n    [](prll://tsk_abc)                           empty context (renders resolved title)\n    [relevant context](prll://tsk_abc)           with author annotation\n\nBare URIs and empty-context refs are preferred in most cases \u2014 the platform\nresolves and renders the entity title automatically.\n\n### Mentioning people and agents\n\nA real member mention is a `prll://usr_...` reference. Plain `@Display Name` is\nonly text: it does not notify a human or trigger an agent.\n\nWhen another member must be notified or an agent explicitly triggered, include\ntheir user reference in the message body. Prefer the empty-context form because\nthe platform resolves the member's current display name:\n\n    [](prll://usr_xxx)\n\nUse `[Display Name](prll://usr_xxx)` when the surrounding sentence needs an\nexplicit label. Find the user ID in the incoming message or with\n`parall members list`. Never substitute plain `@Display Name` when notification\nor agent dispatch matters.\n\n### URI format\n\n`prll://` follows standard URI structure: `scheme://authority/path?query#fragment`.\n\n**Entities** \u2014 the entity ID is the authority:\n\n    prll://usr_xxx          user          prll://prj_xxx          project\n    prll://tsk_xxx          task          prll://wik_xxx          wiki\n    prll://msg_xxx          message       prll://cmt_xxx          comment\n    prll://cht_xxx          chat          prll://tcm_xxx          task comment (legacy)\n    prll://att_xxx          attachment    prll://ase_xxx          agent session\n    prll://sch_xxx          schedule      prll://srn_xxx          schedule run\n\n**Wiki** \u2014 path is file path, fragment is a typed anchor:\n\n    prll://wik_xxx/docs/guide.md                  file\n    prll://wik_xxx/docs/guide.md#h=Auth::OAuth    heading (:: = hierarchy)\n    prll://wik_xxx/src/auth.go?rev=<sha>#l=42-58  line range (revision-pinned)\n\n  Anchor types: `h=` heading, `l=` line/range, `s=` symbol.\n  Line anchors in persistent content require `?rev=<full-40-char-sha>`.\n\n**Chat message range**:\n\n    prll://cht_xxx#range=msg_01HA,msg_01HZ\n\n**Field access** \u2014 path selects a field (omit to reference the entity itself):\n\n    prll://tsk_xxx/description#Implementation     heading within task description\n\n### Unread context\n\nWhen dispatched to a chat, you may see `[Unread: N messages | since: prll://msg_xxx]`.\nThis shows messages since your last interaction \u2014 your read cursor advances after each\ndispatch, so context you skip now won't appear as unread next time. Use\n`parall messages list <chat> --limit 20` to fetch recent context. For large unread\ncounts (50+), fetch only recent messages rather than everything.\n\nThread dispatches may show `[Thread: prll://msg_root | N replies | M unread | since: prll://msg_r]`.\nSame semantics \u2014 use `parall messages list <chat> --thread-root-id <thread_root> --limit 20` to\ncatch up on the thread.\n\n### Reading context on demand\n\nAn event only carries the single triggering message. If you're mentioned in a\ngroup chat and lack context, pull what you need from the chat \u2014 don't guess:\n\n    parall messages list cht_xxx --limit 20 --before msg_xxx\n    parall messages get msg_xxx\n    parall chats get cht_xxx\n\nRule of thumb: in a group chat mention, the conversation that led up to you\nbeing called almost always matters \u2014 read it before replying. In a DM, your\nsession already has continuity, so skip the fetch unless something is unclear.\n\nSame pattern for any other entity referenced in the event: `tasks get`,\n`projects get`, `users get`, `chats get`. Follow the reflink, don't ask.\nWhen one entity isn't enough \u2014 you need what's *around* it \u2014 walk the\nreference graph instead of guessing (see \"Walk the reference graph\" below).\n\n### Find context with search first\n\nReach for unified semantic search before paging chat history:\n\n    parall search \"pricing decision june\" --limit 10\n\nIt spans messages, tasks, wiki, and comments. Page `messages list` only for the\nverbatim recent flow of one chat, not for discovery.\n\n### Walk the reference graph\n\nReferences form a traversable graph, and you can query it \u2014 don't stop at\nfetching entities one by one:\n\n    # entity metadata (title, status, preview)\n    parall refs resolve prll://tsk_xxx prll://wik_xxx\n    # who references this entity\n    parall refs backlinks prll://tsk_xxx\n    # connected sub-graph around it\n    parall refs graph prll://tsk_xxx --depth 2\n\nUse `refs backlinks` when you need \"where is this discussed / used\"; use\n`refs graph` when you need the full picture around an entity (related tasks,\ndocs, conversations \u2014 edges carry the author's annotation for why they linked).\nThen `refs resolve` the interesting node URIs in one batch to get titles and\nstatus. `refs graph` takes entity-level URIs only (`prll://wik_xxx`, not\n`prll://wik_xxx/docs/a.md`). All results are filtered to what you can see.\nDetails: parall-platform skill.\n\n### File attachments\n\nMessages may include attachments. They appear in events as:\n\n    [Attachment: prll://att_xxx | image/png | 1.2MB | screenshot.png]\n\nTo download an attachment, use the CLI:\n\n    parall files download att_xxx --output /tmp/screenshot.png\n\nTo send a file:\n\n    parall messages send prll://cht_xxx --file /tmp/output.png --text \"Done\"\n\nOr upload first and reuse across chats:\n\n    parall files upload /tmp/report.pdf\n    parall messages send prll://cht_aaa --attachment att_yyy --text \"Report\"\n    parall messages send prll://cht_bbb --attachment att_yyy --text \"FYI\"\n\nThe `--text` captions above are safe short literals. For message text containing `$`, backticks, or quotes, pass it via `--text-file <path>` (write the file first, or a quoted heredoc `--text-file - <<'EOF'`) instead of `--text \"...\"` \u2014 inside double quotes the shell turns `$1,000` into `,000` and executes `$(...)`.\n\n### When to reference\n\n- **Origin** \u2014 always link the message or task that triggered your work\n- **Design docs / wiki** \u2014 link specs and guides relevant to the work\n- **Related tasks** \u2014 link parent, sibling, or blocking tasks\n- **People** \u2014 link assignees or stakeholders when mentioning them\n- **Conversations** \u2014 link a chat or message range as context\n\n### Why this matters\n\nOther agents and humans read your output. References build a navigable context graph \u2014\nin multi-agent workflows, your references are the map that the next agent follows.";
 export type PreparedLocalImage = {
     attachmentId: string;
     fileName: string;

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

@@ -1 +1 @@
-{"version":3,"file":"prompt-fragments.d.ts","sourceRoot":"","sources":["../src/prompt-fragments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,+DAA+D;IAC/D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qEAAqE;IACrE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAKD,MAAM,MAAM,WAAW,GAAG,IAAI,CAC5B,gBAAgB,EAChB,IAAI,GAAG,cAAc,GAAG,eAAe,GAAG,gBAAgB,CAC3D,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,WAAW,GAAG,aAAa,CAU7D;AAuBD,wBAAgB,aAAa,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,MAAM,CAqB3D;AAED,0FAA0F;AAC1F,eAAO,MAAM,aAAa,mcAAqB,CAAC;AAEhD,eAAO,MAAM,aAAa,knOAkImC,CAAC;AAE9D,eAAO,MAAM,oBAAoB,uiMAwIkD,CAAC;AAEpF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAC7B,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,CAmBnF;AASD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIjD"}
+{"version":3,"file":"prompt-fragments.d.ts","sourceRoot":"","sources":["../src/prompt-fragments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,+DAA+D;IAC/D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qEAAqE;IACrE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAKD,MAAM,MAAM,WAAW,GAAG,IAAI,CAC5B,gBAAgB,EAChB,IAAI,GAAG,cAAc,GAAG,eAAe,GAAG,gBAAgB,CAC3D,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,WAAW,GAAG,aAAa,CAU7D;AAuBD,wBAAgB,aAAa,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,MAAM,CAqB3D;AAED,0FAA0F;AAC1F,eAAO,MAAM,aAAa,mcAAqB,CAAC;AAEhD,eAAO,MAAM,aAAa,knOAkImC,CAAC;AAE9D,eAAO,MAAM,oBAAoB,+sNAwJkD,CAAC;AAEpF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAC7B,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAEF,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,CAmBnF;AASD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIjD"}

package/dist/prompt-fragments.js

@@ -215,6 +215,22 @@ All three forms work — pick whichever fits:
 Bare URIs and empty-context refs are preferred in most cases — the platform
 resolves and renders the entity title automatically.
 
+### Mentioning people and agents
+
+A real member mention is a \`prll://usr_...\` reference. Plain \`@Display Name\` is
+only text: it does not notify a human or trigger an agent.
+
+When another member must be notified or an agent explicitly triggered, include
+their user reference in the message body. Prefer the empty-context form because
+the platform resolves the member's current display name:
+
+    [](prll://usr_xxx)
+
+Use \`[Display Name](prll://usr_xxx)\` when the surrounding sentence needs an
+explicit label. Find the user ID in the incoming message or with
+\`parall members list\`. Never substitute plain \`@Display Name\` when notification
+or agent dispatch matters.
+
 ### URI format
 
 \`prll://\` follows standard URI structure: \`scheme://authority/path?query#fragment\`.

package/dist/redact.d.ts

@@ -0,0 +1,18 @@
+import type { TurnOutcomeEvent } from './dispatch-adapter.js';
+/**
+ * Two-layer secret redaction for runtime-originated error text, mirroring the
+ * parel connector's policy (parel-channel/src/session.ts — an independent
+ * deploy boundary, so the policy is duplicated rather than imported): exact
+ * known-value replacement first, then credential-shaped pattern masking.
+ * Turn-outcome `detail`/`raw` echo provider error bodies, which can quote the
+ * request's own Authorization material.
+ */
+export declare function redactSecrets(s: string, knownValues?: string[]): string;
+/**
+ * Redact a turn outcome's free-text carriers in place of the original event:
+ * `detail` (human-readable evidence) and every string leaf of `raw` (the
+ * runtime-native discriminator snapshot). Non-string raw leaves pass through
+ * untouched — discriminators like status codes carry no secrets.
+ */
+export declare function redactTurnOutcome(event: TurnOutcomeEvent, knownValues: string[]): TurnOutcomeEvent;
+//# sourceMappingURL=redact.d.ts.map

package/dist/redact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact.d.ts","sourceRoot":"","sources":["../src/redact.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,GAAE,MAAM,EAAO,GAAG,MAAM,CAY3E;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,gBAAgB,EACvB,WAAW,EAAE,MAAM,EAAE,GACpB,gBAAgB,CAYlB"}