@deepseek-ai/dsh-api-session-controller 0.1.6-alpha.2 → 0.1.7-alpha.1

package/lib/types/client/sessions/session.js

@@ -43,6 +43,7 @@ export class Session {
     jumpTargetSeq = null;
     /** The running jump loop's completion, shared by retargeting callers. */
     jumpPromise = null;
+    pendingHistory = null;
     stopObservingInbox;
     assistantStream = new ClientAssistantStream();
     running = false;
@@ -56,7 +57,7 @@ export class Session {
     promptAttempted = false;
     /** A first accepted prompt stays in the engaging phase until its turn is observable. */
     firstPromptPendingTurn = false;
-    /** Empty-log mirror (see ConversationSnapshot.blank); unknown bare sessions begin conservatively blank. */
+    /** New Session display state; unknown bare sessions begin conservatively blank. */
     blankBit = true;
     removed = false;
     promptError = null;
@@ -72,8 +73,9 @@ export class Session {
      * Per-session projection value store (push model; see the session-projection
      * subsystem page, docs/subsystems/session-projection.md): finished whole
      * values computed on the Host, seeded by the tail page's
-     * projections block and updated by Session Controller control frames under the
-     * one higher-seq-wins rule. Keys are read via `projections.faceOf(key)`
+     * projections block and updated by Session Controller control frames;
+     * Host-sequenced writes merge under higher-seq-wins and cached list blocks
+     * yield to them (projection-store.ts). Keys are read via `projections.faceOf(key)`
      * (the useProjection resolution face); the conversation snapshot never
      * carries projection values, and no client-side domain folding exists.
      * Manager-owned when constructed through SessionManager (frames route and
@@ -140,16 +142,15 @@ export class Session {
      */
     beginSubmission(input) {
         const requestId = randomUUID();
+        const placement = this.running ? input.mode === 'steer' ? 'steering' : 'queued' : 'transcript';
         this.pendingSubmissions = [...this.pendingSubmissions, {
                 requestId,
-                placement: this.running
-                    ? input.mode === 'steer' ? 'steering' : 'queued'
-                    : 'transcript',
+                placement,
                 time: Date.now(),
                 text: input.text,
                 attachments: input.attachments,
             }];
-        this.submissionSettlements.set(requestId, { onRetire: input.onRetire, retiring: false });
+        this.submissionSettlements.set(requestId, { placement, onRetire: input.onRetire, retiring: false });
         // The blank → engaging edge flips here, ahead of prompt(): the composer
         // docks and the echo renders on the click's own frame.
         this.promptAttempted = true;
@@ -213,19 +214,12 @@ export class Session {
             this.notifier.markDirty();
             return result;
         }
-        // Blank flips on ACCEPTANCE, not attempt: an accepted prompt starts the
-        // conversation's first turn on the host (the host criterion — a logged
-        // turn/start — is fact, not optimism; standalone command and projection
-        // events never flip it), while a rejected first prompt must keep the
-        // session blank — the client-side blank mirror only ever lowers, so
-        // flipping early on a failure would surface the session forever and
-        // strip its connectWorkspace reuse eligibility against the host's
-        // authority.
+        // Rejection must leave a first prompt blank and eligible for workspace reuse.
         if (this.blankBit) {
             this.blankBit = false;
-            this.options.onEngaged?.(this);
             this.notifier.markDirty();
         }
+        this.options.onEngaged?.(this);
         return result;
     }
     /**
@@ -347,6 +341,15 @@ export class Session {
         // loop starts here.
         if (this.loadingOlder)
             return Promise.resolve();
+        const events = this.events;
+        if (events === undefined)
+            return Promise.resolve();
+        const pending = {
+            beforeSeq: this.baseSeq,
+            hasMore: this.hasMore,
+            pages: [],
+        };
+        this.pendingHistory = pending;
         this.jumpTargetSeq = seq;
         this.loadingOlder = true;
         this.notifier.markDirty();
@@ -356,17 +359,14 @@ export class Session {
         const generation = this.openGeneration;
         this.jumpPromise = (async () => {
             try {
-                while (this.hasMore && this.jumpTargetSeq !== null && this.baseSeq > this.jumpTargetSeq) {
+                while (pending.hasMore && this.jumpTargetSeq !== null && pending.beforeSeq > this.jumpTargetSeq) {
                     if (generation !== this.openGeneration)
                         return;
-                    const events = this.events;
-                    if (events === undefined)
-                        return;
-                    const before = this.baseSeq;
-                    await events.prepend({ beforeSeq: this.baseSeq, maxMessages: JUMP_PAGE_MESSAGES });
+                    const before = pending.beforeSeq;
+                    await events.prepend({ beforeSeq: before, maxMessages: JUMP_PAGE_MESSAGES });
                     // No-progress guard: an empty or dropped page that still claims more
                     // history must end the loop, not spin it.
-                    if (this.baseSeq >= before)
+                    if (pending.beforeSeq >= before)
                         return;
                 }
             }
@@ -378,7 +378,11 @@ export class Session {
             finally {
                 this.jumpTargetSeq = null;
                 this.jumpPromise = null;
+                this.pendingHistory = null;
                 this.loadingOlder = false;
+                if (generation === this.openGeneration && pending.pages.length > 0) {
+                    this.prependWindow(pending.pages.reverse().flat(), pending.hasMore);
+                }
                 this.notifier.markDirty();
             }
         })();
@@ -424,8 +428,7 @@ export class Session {
      * @param running - the new running state.
      */
     handleRunning(running) {
-        // Turn-start conversion: a blank session never runs, so the first
-        // running:true proves another side's first message landed.
+        // Running converts display state without establishing durable turn history.
         if (running && this.blankBit) {
             this.blankBit = false;
             this.notifier.markDirty();
@@ -465,13 +468,15 @@ export class Session {
         this.notifier.markDirty();
     }
     /**
-     * Blank-bit relay from the authoritative summary source (`session.list` and
-     * `api-session/added`). Monotone: once any signal (local first send,
-     * running flip, an earlier summary) cleared it, a stale true never
-     * re-blanks.
-     * @param blank - the summary's derived empty-log bit.
+     * Apply the Manager's effective display blank, further reconciled with the
+     * current `sessionListMetadata` projection. Local send attempts and current
+     * running state prevent re-blanking; an earlier false summary alone does not.
+     * The Manager retains acceptance and earlier running observations across
+     * Session-object replacement.
+     * @param blank - New Session display state after Manager reconciliation.
      */
     handleBlank(blank) {
+        blank = blank && this.projections.values().sessionListMetadata?.blank !== false;
         if (blank === this.blankBit)
             return;
         if (blank && (this.promptAttempted || this.running))
@@ -570,13 +575,31 @@ export class Session {
         const visible = this.assistantStream.replace(entries, assistantStream);
         this.baseSeq = SessionLogOffset(entries[0]?.event.seq ?? 0);
         this.hasMore = hasMore;
+        if (this.pendingHistory !== null) {
+            this.pendingHistory.beforeSeq = this.baseSeq;
+            this.pendingHistory.hasMore = hasMore;
+            this.pendingHistory.pages.length = 0;
+        }
         if (visible.some(entry => entry.event.type === 'turn/start'))
             this.firstPromptPendingTurn = false;
         if (projections !== undefined)
             this.projections.seed(projections);
         this.eventSource.replace(visible, hasMore);
+        // A new follow baseline replaces optimistic steering with Host-owned rows.
+        // Receipt-backed inputs are accepted, not failed, even if their history is outside this window.
+        if (projections !== undefined) {
+            for (const [requestId, { receipt }] of this.submissionSettlements) {
+                if (receipt !== undefined && receipt.seq <= projections.asOfSeq) {
+                    this.scheduleObservedRetirement(requestId, receipt.attachments);
+                }
+            }
+        }
         for (const entry of visible)
             this.observeSubmissionEvent(entry.event);
+        if (projections !== undefined) {
+            const inbox = projections.values.inbox;
+            this.observeSteeringInsertions(inbox?.['next-step'] ?? [], 0, projections.asOfSeq);
+        }
         this.notifier.markDirty();
     }
     publishAssistantEntry(result) {
@@ -609,6 +632,13 @@ export class Session {
     }
     /** Prepend one stream-validated history page. */
     prependWindow(entries, hasMore) {
+        if (this.pendingHistory !== null) {
+            const pending = this.pendingHistory;
+            pending.beforeSeq = entries[0] === undefined ? pending.beforeSeq : SessionLogOffset(entries[0].event.seq);
+            pending.hasMore = hasMore;
+            pending.pages.push(entries);
+            return;
+        }
         this.baseSeq = entries[0] === undefined ? this.baseSeq : SessionLogOffset(entries[0].event.seq);
         this.hasMore = hasMore;
         this.eventSource.prepend(entries, hasMore);
@@ -631,37 +661,66 @@ export class Session {
         if (this.submissionSettlements.size === 0)
             return;
         if (event.type === 'agent/inbox/spliced') {
-            const splice = event.data;
-            if (Array.isArray(splice?.inserted)) {
-                for (const message of splice.inserted)
-                    this.observeSubmissionEvent({ type: 'user/message', data: message });
+            const { target, start, removedCount = 0, inserted, outcome } = event.data;
+            if (target === 'next-step') {
+                for (const [requestId, settlement] of this.submissionSettlements) {
+                    const receipt = settlement.receipt;
+                    if (receipt === undefined || receipt.index === null || receipt.seq >= event.seq)
+                        continue;
+                    const removed = receipt.index >= start && receipt.index < start + removedCount;
+                    if (removed && outcome === 'canceled')
+                        this.retireFailedSubmission(requestId);
+                    else
+                        settlement.receipt = {
+                            ...receipt,
+                            seq: event.seq,
+                            index: removed ? null : receipt.index < start ? receipt.index : receipt.index + inserted.length - removedCount,
+                        };
+                }
+                this.observeSteeringInsertions(inserted, start, event.seq);
+            }
+            for (const message of inserted)
+                this.observeSubmissionMessage(message, false);
+            return;
+        }
+        if (event.type === 'request/context' || event.type === 'turn/end') {
+            for (const [requestId, settlement] of this.submissionSettlements) {
+                if (settlement.receipt?.index === null && settlement.receipt.seq < event.seq)
+                    this.retireFailedSubmission(requestId);
             }
             return;
         }
-        if (event.type !== 'user/message')
+        if (event.type === 'user/message')
+            this.observeSubmissionMessage(event.data, true);
+    }
+    observeSteeringInsertions(messages, start, seq) {
+        for (const [index, message] of messages.entries()) {
+            const source = message.source;
+            if (source.kind !== 'user' || !('rpcId' in source))
+                continue;
+            const settlement = this.submissionSettlements.get(source.rpcId);
+            if (settlement?.placement !== 'steering' || settlement.retiring || (settlement.receipt?.seq ?? -1) > seq)
+                continue;
+            settlement.receipt = { seq, index: start + index, attachments: attachmentRefsIn(message.content) };
+        }
+    }
+    observeSubmissionMessage(message, admitted) {
+        const source = message.source;
+        if (source.kind !== 'user' || !('rpcId' in source))
             return;
-        // Structural read: window entries may be compact history records, so the
-        // fields are narrowed rather than trusted (same posture as Conversation
-        // assembly matchers).
-        const data = event.data;
-        const source = data?.source;
-        if (source?.kind !== 'user' || typeof source.rpcId !== 'string')
+        if (!admitted && this.submissionSettlements.get(source.rpcId)?.placement === 'steering')
             return;
-        this.scheduleObservedRetirement(source.rpcId, attachmentRefsIn(data?.content));
+        this.scheduleObservedRetirement(source.rpcId, attachmentRefsIn(message.content));
     }
-    /** Retire local echoes when their accepted messages appear in the durable Inbox projection. */
+    /** Retire non-steering echoes when the Inbox accepts their queue occurrences. */
     observeSubmissionInbox() {
         if (this.submissionSettlements.size === 0)
             return;
         const inbox = this.projections.get('inbox');
         if (inbox === undefined)
             return;
-        for (const message of [...inbox['next-turn'], ...inbox['next-step']]) {
-            const source = message.source;
-            if (source.kind === 'user' && 'rpcId' in source) {
-                this.scheduleObservedRetirement(source.rpcId, attachmentRefsIn(message.content));
-            }
-        }
+        for (const message of [...inbox['next-turn'], ...inbox['next-step']])
+            this.observeSubmissionMessage(message, false);
     }
     /**
      * Latch one observed settlement and remove the echo an animation frame
@@ -710,6 +769,7 @@ export class Session {
         this.notifier.markDirty();
     }
     buildSnapshot() {
+        const identity = this.projections.values().subagent;
         return {
             sessionId: this.sessionId,
             pendingSubmissions: this.pendingSubmissions,
@@ -717,7 +777,9 @@ export class Session {
             subagent: this.address === undefined
                 ? null
                 : {
-                    address: this.address,
+                    address: this.address.mode === 'unknown' && identity != null
+                        ? { ...this.address, mode: identity.mode }
+                        : this.address,
                     ...(this.parentAvailable === undefined ? {} : { parentAvailable: this.parentAvailable }),
                 },
             removed: this.removed,

package/lib/types/commands.d.ts

@@ -32,8 +32,10 @@ export declare class SessionCommandController {
      */
     rename(request: SessionRenameRequest): Promise<SessionRenameValue>;
     /**
-     * Create a new ordinary Session from one completed-turn prefix.
-     * @param request - source Session and optional event anchor.
+     * Create a new ordinary Session from an exact event prefix. An explicit
+     * `atSeq` is the inclusive cut; an omitted value selects the latest
+     * completed-turn prefix. An open cut receives synthetic fork closers.
+     * @param request - source Session and optional exact event boundary.
      * @returns the new Session identity.
      */
     fork(request: SessionForkRequest): Promise<SessionForkValue>;

package/lib/types/commands.js

@@ -55,6 +55,7 @@ import { randomUUID } from 'node:crypto';
 import { brandString } from '@deepseek-ai/dsh-brand';
 import { AttachmentError } from '@deepseek-ai/dsh-attachment';
 import { ReasoningEffortId, assistantStreamChunks, createUserMessage, freezeMessage, } from '@deepseek-ai/dsh-llm';
+import { buildForkSeed } from '@deepseek-ai/dsh-session/fork';
 import { SessionLogOffset, SessionSeq } from '@deepseek-ai/dsh-session';
 import { SessionQueryError } from '@deepseek-ai/dsh-session-query';
 import { SessionTitleInvalidError } from '@deepseek-ai/dsh-session-title';
@@ -65,6 +66,23 @@ import { ApiSessionCwdConflict, ApiSessionNotFound, ApiSessionPresetConflict, Ap
 function hasPromptContent(content) {
     return content.some(part => part.type !== 'text' || part.text.trim().length > 0);
 }
+/**
+ * Resolve the omitted-`atSeq` default to the latest completed-turn prefix,
+ * including standalone events before the next turn begins.
+ */
+function latestCompletedPrefixBoundary(events) {
+    const lastTurnEnd = events.findLast(event => event.type === 'turn/end');
+    if (lastTurnEnd === undefined)
+        return undefined;
+    let boundary = lastTurnEnd.seq;
+    for (const next of events.slice(boundary + 1)) {
+        if (next.type === 'turn/start' || (next.type === 'user/message' && next.surfaceOp === 'append')
+            || next.type === 'agent/inbox/spliced')
+            break;
+        boundary = next.seq;
+    }
+    return boundary;
+}
 /** Implements Session business commands delegated by the Session Controller Remote service. */
 export class SessionCommandController {
     ctx;
@@ -180,8 +198,10 @@ export class SessionCommandController {
         }
     }
     /**
-     * Create a new ordinary Session from one completed-turn prefix.
-     * @param request - source Session and optional event anchor.
+     * Create a new ordinary Session from an exact event prefix. An explicit
+     * `atSeq` is the inclusive cut; an omitted value selects the latest
+     * completed-turn prefix. An open cut receives synthetic fork closers.
+     * @param request - source Session and optional exact event boundary.
      * @returns the new Session identity.
      */
     async fork(request) {
@@ -208,20 +228,13 @@ export class SessionCommandController {
                 throw new RemoteError('gateway/internal', `fork source unavailable for session "${request.sessionId}": ${String(error)}`, {});
             }
             const source = __addDisposableResource(env_1, observed, false);
-            const lastSeq = source.events.at(-1)?.seq ?? -1;
-            const anchoredBoundary = atSeq === undefined
-                ? undefined
-                : source.events.find(event => event.type === 'turn/end' && event.seq >= atSeq);
-            const boundary = anchoredBoundary
-                ?? (atSeq === undefined || atSeq > lastSeq
-                    ? source.events.findLast(event => event.type === 'turn/end')
-                    : undefined);
-            if (boundary === undefined) {
-                throw new RemoteError('session/fork-unavailable', atSeq !== undefined && atSeq <= lastSeq
-                    ? `session "${request.sessionId}" has not completed the turn containing event ${String(atSeq)}`
-                    : `session "${request.sessionId}" has no completed turn to fork from`, { sessionId: request.sessionId });
+            const boundary = atSeq ?? latestCompletedPrefixBoundary(source.events);
+            if (boundary === undefined || source.events[boundary]?.seq !== boundary) {
+                throw new RemoteError('session/fork-unavailable', request.atSeq === undefined
+                    ? `session "${request.sessionId}" has no completed turn to fork from`
+                    : `event ${String(request.atSeq)} does not exist in session "${request.sessionId}" (last seq: ${String(source.events.at(-1)?.seq ?? 'none')})`, { sessionId: request.sessionId });
             }
-            const cut = SessionLogOffset(boundary.seq + 1);
+            const seed = buildForkSeed(source.events, boundary);
             let workspace;
             try {
                 workspace = await this.forkWorkspace(source.header);
@@ -235,8 +248,8 @@ export class SessionCommandController {
                 const { provider, model } = this.ctx.agentDefaultModel.currentSelection();
                 await this.ctx.agents.create({
                     sessionId: childId,
-                    seed: source.events.slice(0, cut),
-                    inheritedEventCount: cut,
+                    seed,
+                    inheritedEventCount: SessionLogOffset(boundary + 1),
                     meta: {
                         ...(source.header.cwd === undefined ? {} : { cwd: source.header.cwd }),
                         parentSession: source.header.id,
@@ -383,6 +396,7 @@ export class SessionCommandController {
      */
     async updateQueue(request) {
         if (request.action.kind === 'edit') {
+            // oxlint-disable-next-line typescript/no-unnecessary-condition -- Remote callers can submit untyped JSON.
             if (request.action.content.some(block => block.type !== 'text')) {
                 throw new RemoteError('session/attachment-invalid', 'queue edits accept text content only', { reason: 'QUEUE_EDIT_NON_TEXT' });
             }
@@ -471,6 +485,9 @@ export class SessionCommandController {
     rejectCreation(sessionId, error) {
         if (remoteErrorOf(error) !== undefined)
             throw error;
+        if (error instanceof Error && error.name === 'SessionAlreadyOwnedError') {
+            throw new RemoteError('session/writer-held', error.message, { sessionId });
+        }
         if (error instanceof ApiSessionPresetConflict) {
             throw new RemoteError('agent-preset/conflict', error.message, {
                 sessionId: error.sessionId,
@@ -554,33 +571,52 @@ function imageBlockIn(content, match) {
             if (match(ref))
                 return ref;
         }
-        if (block.type === 'tool-result') {
-            const nested = imageBlockIn(block.content, match);
-            if (nested !== undefined)
-                return nested;
-        }
     }
     return undefined;
 }
+/** Read only first-party declared content fields; unknown event payloads stay opaque. */
 function imageInEvent(event, match) {
     const data = event.data;
-    const direct = imageBlockIn(data.content, match);
-    if (direct !== undefined)
-        return direct;
-    const message = imageBlockIn(data.message?.content, match);
-    if (message !== undefined)
-        return message;
-    for (const inserted of data.inserted ?? []) {
-        const found = imageBlockIn(inserted.content, match);
-        if (found !== undefined)
-            return found;
-    }
-    if (event.type === 'assistant/message' || event.type === 'assistant/attempt') {
-        for (const chunk of assistantStreamChunks(event.data.stream, 'block-end')) {
-            const found = imageBlockIn([chunk.block], match);
+    // First-party event payloads can be present without their producer plugin mounted.
+    const type = event.type;
+    switch (type) {
+        case 'user/message':
+        case 'tool/ptc-dispatch':
+            return imageBlockIn(data.content, match);
+        case 'system/message':
+        case 'developer/message':
+        case 'tool/result':
+        case 'team/message/queued':
+            return imageBlockIn(data.message?.content, match);
+        case 'agent/inbox/spliced': {
+            const messages = data.inserted;
+            if (!Array.isArray(messages))
+                return undefined;
+            for (const message of messages) {
+                if (typeof message !== 'object' || message === null || Array.isArray(message))
+                    continue;
+                const found = imageBlockIn(message.content, match);
+                if (found !== undefined)
+                    return found;
+            }
+            return undefined;
+        }
+        case 'compaction/summary':
+            return imageBlockIn(data.summary, match) ?? imageBlockIn(data.rawOutput, match);
+        case 'assistant/message': {
+            const found = imageBlockIn(data.message?.content, match);
             if (found !== undefined)
                 return found;
+            break;
         }
+        case 'assistant/attempt': break;
+        default: return undefined;
+    }
+    const assistant = event;
+    for (const chunk of assistantStreamChunks(assistant.data.stream, 'block-end')) {
+        const found = imageBlockIn([chunk.block], match);
+        if (found !== undefined)
+            return found;
     }
     return undefined;
 }

package/lib/types/control.d.ts

@@ -1,11 +1,11 @@
-/** Live Session jobs and projection state with reconnect baselines. */
+/** Live Session projection state with reconnect baselines. */
 import type { Context } from '@deepseek-ai/cordis';
 import type { SessionControlFrame } from './types.ts';
 /** Owns the Host-wide Session control stream. */
 export declare class SessionControlController {
     private readonly ctx;
     private readonly streams;
-    /** @param ctx - Host context carrying live Agent, projection, and jobs services. */
+    /** @param ctx - Host context carrying live Agent and projection services. */
     constructor(ctx: Context);
     /**
      * Open one generation of Host-wide live control state.
@@ -15,8 +15,6 @@ export declare class SessionControlController {
     control(signal: AbortSignal): AsyncIterable<SessionControlFrame>;
     private baseline;
     private projectionBaseline;
-    private onJobsChanged;
-    private jobsFor;
     private broadcast;
 }
 //# sourceMappingURL=control.d.ts.map

package/lib/types/control.js

@@ -1,10 +1,10 @@
-/** Live Session jobs and projection state with reconnect baselines. */
+/** Live Session projection state with reconnect baselines. */
 import { Deque } from '@deepseek-ai/dsh-deque';
 /** Owns the Host-wide Session control stream. */
 export class SessionControlController {
     ctx;
     streams = new Set();
-    /** @param ctx - Host context carrying live Agent, projection, and jobs services. */
+    /** @param ctx - Host context carrying live Agent and projection services. */
     constructor(ctx) {
         this.ctx = ctx;
         ctx.sessionProjections.onChanged((session, key, value, seq) => {
@@ -16,14 +16,6 @@ export class SessionControlController {
                 seq,
             });
         });
-        ctx.inject(['jobs'], (jobsCtx) => {
-            jobsCtx.jobs.onJobsChanged((owner) => { this.onJobsChanged(owner); });
-        });
-        ctx.on('session/created', (session) => {
-            const jobs = this.jobsFor(this.ctx.agents.get(session.id));
-            if (jobs.length > 0)
-                this.broadcast({ type: 'jobs', sessionId: session.id, jobs });
-        });
         ctx.effect(() => () => {
             for (const stream of this.streams)
                 stream.end();
@@ -50,13 +42,7 @@ export class SessionControlController {
     }
     baseline() {
         const sessions = this.ctx.sessions.list();
-        const jobs = Object.create(null);
-        for (const session of sessions) {
-            const agent = this.ctx.agents.get(session.id);
-            jobs[session.id] = this.jobsFor(agent);
-        }
         return {
-            jobs,
             projections: this.projectionBaseline(sessions),
         };
     }
@@ -72,23 +58,6 @@ export class SessionControlController {
         }
         return blocks;
     }
-    onJobsChanged(owner) {
-        if (owner !== undefined) {
-            this.broadcast({ type: 'jobs', sessionId: owner.id, jobs: this.jobsFor(owner) });
-            return;
-        }
-        for (const session of this.ctx.sessions.list()) {
-            this.broadcast({
-                type: 'jobs',
-                sessionId: session.id,
-                jobs: this.jobsFor(this.ctx.agents.get(session.id)),
-            });
-        }
-    }
-    jobsFor(agent) {
-        const jobs = this.ctx.get('jobs');
-        return jobs === undefined ? [] : jobs.list(agent).map(jobView);
-    }
     broadcast(frame) {
         for (const stream of this.streams)
             stream.push(frame);
@@ -135,15 +104,4 @@ class ControlQueue {
         }
     }
 }
-function jobView(job) {
-    return {
-        id: job.id,
-        kind: job.kind,
-        label: job.label,
-        status: job.status,
-        ...(job.detail === undefined ? {} : { detail: job.detail }),
-        startedAt: job.startedAt,
-        ...(job.finishedAt === undefined ? {} : { finishedAt: job.finishedAt }),
-    };
-}
 //# sourceMappingURL=control.js.map

package/lib/types/history.js

@@ -370,7 +370,7 @@ function validateAddress(address, header, inheritedEventCount, projections) {
             reason: 'unsupported',
         });
     }
-    if (identity.mode !== address.mode) {
+    if (address.mode !== 'unknown' && identity.mode !== address.mode) {
         throw new RemoteError('subagent/unauthorized', 'subagent mode does not match the supplied address', {
             childSessionId: address.childSessionId,
         });