@asc-agent/runtime 0.1.0

package/dist/core/runtime/session.js

@@ -0,0 +1,281 @@
+// Session lifecycle 오케스트레이션 — 발급부터 인수인계까지.
+// Logical Session은 여러 Physical Run에 걸친다 (OM §6.2): 한 Run이 Checkpoint를 남기고
+// 멈추면 다른 Run이 같은 계약을 이어받는다. 그 승계가 가능한지가 이 파일의 존재 이유다.
+//
+// Attach Pilot(B-11)에서 세션 기능을 처음 만들지 않도록 여기서 미리 검증한다.
+import { Session } from "../model/entities.js";
+import { transitionSession } from "../model/transitions.js";
+import { lookupAuthority } from "../policy/ownership.js";
+import { isWithinScopes, parseScope } from "../policy/scope.js";
+import { applyTransition } from "./store-ops.js";
+/** `unknown`은 값이 아니라 "못 읽었다"는 표시다 (ports/scm.ts). */
+const UNREADABLE = 'unknown';
+/**
+ * 필요한 결정마다 주인이 하나로 정해지는지 본다 (C-04 §1.3).
+ *
+ * **결정 영역을 선언하지 않은 세션은 여기서 아무것도 걸리지 않는다.** 모든 세션이
+ * cross-part 결정을 요구하지는 않으므로, owner가 비었다는 이유만으로 발급을 막지 않는다.
+ * 막는 것은 "정해야 할 것이 있는데 정할 사람이 없거나 둘인" 경우뿐이다.
+ *
+ * 오류 문구가 다음 명령까지 말하는 이유: 무엇이 잘못됐는지만 알려 주면 처음 쓰는 사람은
+ * 여기서 멈춘다. 어떻게 푸는지가 같은 화면에 있어야 한다.
+ */
+function responsibilityFailures(spec, ownership) {
+    const failures = [];
+    for (const domain of spec.decisionDomains ?? []) {
+        if (spec.decisionAuthority?.[domain])
+            continue; // 이번 세션에 한해 사람이 정했다
+        const found = lookupAuthority(ownership, domain);
+        if (found.kind === 'RESOLVED')
+            continue;
+        const how = `--authority ${domain}=<role> 로 이번 세션의 결정권자를 정하거나, Profile ownership 에 적어라`;
+        failures.push({
+            kind: 'RESPONSIBILITY_AMBIGUOUS',
+            detail: found.kind === 'AMBIGUOUS'
+                ? `'${domain}' 의 결정권자가 갈려 있다 (${found.candidates.join(', ')}) — ${how}`
+                : `'${domain}' 의 결정권자가 선언되지 않았다 — ${how}`,
+        });
+    }
+    return failures;
+}
+export class SessionRuntime {
+    #store;
+    #policy;
+    #scm;
+    #canonicalSources;
+    #ownership;
+    #bindings;
+    constructor(store, policy = null, deps = {}) {
+        this.#store = store;
+        this.#policy = policy;
+        this.#scm = deps.scm;
+        this.#canonicalSources = deps.canonicalSources ?? [];
+        this.#ownership = deps.ownership;
+        this.#bindings = deps.bindings;
+    }
+    /**
+     * 이 Physical Run이 그 세션의 기록을 쓸 자격이 있는가 (C-10 §2.3 불변식 ⑤).
+     *
+     * 승계 후 죽지 않은 옛 Host가 계속 쓰면 기록이 오염된다. Progress는 이미 이 검사를
+     * 하고 있었고 checkpoint·handoff만 열려 있었다 — 그 비대칭을 여기서 닫는다.
+     */
+    async #guardOwner(id, physicalSessionId) {
+        if (!this.#bindings)
+            return null;
+        const binding = await this.#bindings.get(id);
+        // binding이 없으면 소유권 개념이 없는 세션이다 — 막지 않는다
+        if (!binding)
+            return null;
+        if (!physicalSessionId) {
+            return {
+                ok: false,
+                reason: 'NOT_OWNER',
+                detail: `${id} 에는 Runtime이 붙어 있다 — owner(${binding.physicalSessionId})만 기록할 수 있다`,
+            };
+        }
+        if (binding.physicalSessionId !== physicalSessionId) {
+            return {
+                ok: false,
+                reason: 'NOT_OWNER',
+                detail: `${id} 의 owner가 아니다 (현재 owner: ${binding.physicalSessionId})`,
+            };
+        }
+        return null;
+    }
+    /**
+     * 지금 정본이 어디에 있는지. source별로 따로 읽는다 — 하나로 뭉개지 않는다.
+     *
+     * Profile이 정본을 선언했는데 읽을 통로가 없으면 실패로 돌려준다. 빈 배열로 넘기면
+     * 이후 대조가 아무것도 비교하지 않고 통과해, 검증이 있는 척만 하는 상태가 된다.
+     */
+    async #readBaselines() {
+        if (this.#canonicalSources.length === 0)
+            return { ok: true, snapshots: [] };
+        if (!this.#scm) {
+            const ids = this.#canonicalSources.map((s) => s.sourceId).join(', ');
+            return { ok: false, detail: `정본(${ids})을 읽을 통로가 없다 — 자격 증명을 확인하라` };
+        }
+        const snapshots = await this.#scm.getBaselines(this.#canonicalSources);
+        const unreadable = snapshots.filter((s) => s.baseline === UNREADABLE).map((s) => s.sourceId);
+        if (unreadable.length > 0)
+            return { ok: false, detail: `정본을 읽지 못했다: ${unreadable.join(', ')}` };
+        return { ok: true, snapshots };
+    }
+    /**
+     * 계약에 적힌 baseline과 지금을 견준다.
+     * 세션 파일의 요약이 아니라 정본을 실제로 다시 읽는다는 것이 이 함수의 존재 이유다 (OM §9).
+     */
+    async #detectDrift(session) {
+        const recorded = session.canonicalSources ?? [];
+        if (recorded.length === 0)
+            return { ok: true, drifts: [] };
+        const current = await this.#readBaselines();
+        // 기록된 baseline이 있는데 지금 읽을 수 없다면, 같은지 다른지 말할 수 없다.
+        if (!current.ok)
+            return current;
+        const drifts = [];
+        for (const before of recorded) {
+            const now = current.snapshots.find((c) => c.sourceId === before.sourceId);
+            if (now && now.baseline !== before.baseline) {
+                drifts.push({ sourceId: before.sourceId, recorded: before.baseline, current: now.baseline });
+            }
+        }
+        return { ok: true, drifts };
+    }
+    /**
+     * Controller가 세션 계약을 발급한다. Session Contract는 Policy hierarchy의 최하위
+     * 계층이므로 상위보다 넓은 권한을 요청할 수 없다 (OM §5.2).
+     * 범위를 벗어난 요청은 조용히 좁히지 않고 거절한다 — 계약서와 실권한이 어긋난 채로
+     * 굴러가는 것이 더 위험하다.
+     */
+    async issue(spec) {
+        const failures = [];
+        if (this.#policy) {
+            const maxScope = this.#policy.roleScopes[spec.role];
+            for (const requested of spec.writeBoundary ?? []) {
+                if (parseScope(requested) === null) {
+                    failures.push({ kind: 'INVALID_SCOPE', detail: `'${requested}' is not valid ASC scope grammar` });
+                }
+                else if (maxScope && !isWithinScopes(requested, maxScope)) {
+                    failures.push({
+                        kind: 'SCOPE_ESCALATION',
+                        detail: `${spec.role} may not write '${requested}' — outside ${maxScope.join(', ')}`,
+                    });
+                }
+            }
+            // Policy Exception은 SOFT DENY 전용이다. HARD DENY를 여기 적는 것은 해제 시도다.
+            for (const exception of spec.policyExceptions ?? []) {
+                if (this.#policy.hardDeny.includes(exception)) {
+                    failures.push({
+                        kind: 'HARD_DENY_ESCAPE',
+                        detail: `'${exception}' is HARD DENY — a session contract cannot grant an exception for it`,
+                    });
+                }
+            }
+        }
+        failures.push(...responsibilityFailures(spec, this.#ownership));
+        if (failures.length > 0)
+            return { ok: false, failures };
+        // 계약이 형식을 어기는 것도 발급 실패다. 예외로 새어 나가면 부르는 쪽마다
+        // 따로 감싸야 하고, CLI에서는 스택 트레이스가 사람에게 튄다.
+        // 발급 시점의 정본을 계약에 박아 둔다. 나중에 무엇을 딛고 시작했는지가 여기 남는다.
+        let canonicalSources = spec.canonicalSources;
+        if (!canonicalSources) {
+            const read = await this.#readBaselines();
+            if (!read.ok)
+                return { ok: false, failures: [{ kind: 'CANONICAL_UNAVAILABLE', detail: read.detail }] };
+            canonicalSources = read.snapshots;
+        }
+        const parsed = Session.safeParse({
+            ...spec,
+            ...(canonicalSources.length > 0 ? { canonicalSources } : {}),
+            version: 0,
+            status: 'READY',
+        });
+        if (!parsed.success) {
+            return {
+                ok: false,
+                failures: parsed.error.issues.map((issue) => ({
+                    kind: 'INVALID_CONTRACT',
+                    detail: `${issue.path.join('.') || '(root)'}: ${issue.message}`,
+                })),
+            };
+        }
+        const session = parsed.data;
+        const created = await this.#store.create('session', session);
+        if (!created.ok) {
+            return { ok: false, failures: [{ kind: 'ALREADY_EXISTS', detail: `session '${spec.id}' already exists` }] };
+        }
+        return { ok: true, session: created.entity };
+    }
+    get(id) {
+        return this.#store.get('session', id);
+    }
+    /**
+     * Physical Run이 계약을 집어 든다. 집기 전에 정본이 그대로인지 본다 —
+     * 바닥이 달라진 채로 이어가면 낡은 전제 위에서 작업하게 된다.
+     */
+    async start(id) {
+        const drift = await this.#guardCanonical(id);
+        if (drift)
+            return drift;
+        return applyTransition(this.#store, 'session', id, (s) => transitionSession(s, 'ACTIVE', 'session'));
+    }
+    /** Run이 끊긴다. Checkpoint 없이는 멈출 수 없다 — 다음 Run이 이어받을 수 없기 때문이다. */
+    async pause(id, checkpoint, physicalSessionId) {
+        const denied = await this.#guardOwner(id, physicalSessionId);
+        if (denied)
+            return denied;
+        return applyTransition(this.#store, 'session', id, (s) => transitionSession(s, 'PAUSED', 'session', { checkpoint }));
+    }
+    /** 다른 Physical Run이 같은 Logical Session을 이어받는다. 여기서도 정본부터 확인한다. */
+    async resume(id) {
+        const drift = await this.#guardCanonical(id);
+        if (drift)
+            return drift;
+        return applyTransition(this.#store, 'session', id, (s) => transitionSession(s, 'ACTIVE', 'session'));
+    }
+    /**
+     * 지금 정본 상태를 읽기 전용으로 판정한다 (C-03 §1.6). ACTIVE 세션을 이어갈 때도
+     * 검증이 필요하지만 상태 전이는 없어야 하므로, 판정 로직을 Operator에 복제하지 않고
+     * 여기서 공개한다.
+     */
+    async checkCanonical(id) {
+        const session = await this.#store.get('session', id);
+        if (!session)
+            return { status: 'NOT_FOUND' };
+        const detected = await this.#detectDrift(session);
+        if (!detected.ok)
+            return { status: 'UNAVAILABLE', detail: detected.detail };
+        return detected.drifts.length > 0 ? { status: 'DRIFT', drifts: detected.drifts } : { status: 'CURRENT' };
+    }
+    async #guardCanonical(id) {
+        const session = await this.#store.get('session', id);
+        if (!session)
+            return null; // 없는 세션은 전이 단계에서 NOT_FOUND로 걸린다
+        const detected = await this.#detectDrift(session);
+        if (!detected.ok)
+            return { ok: false, reason: 'CANONICAL_UNAVAILABLE', detail: detected.detail };
+        return detected.drifts.length > 0 ? { ok: false, reason: 'CANONICAL_DRIFT', drifts: detected.drifts } : null;
+    }
+    /** HARD DENY가 Goal을 막았다 — Controller 판단이 필요하다 (OM §5.3). */
+    block(id) {
+        return applyTransition(this.#store, 'session', id, (s) => transitionSession(s, 'BLOCKED', 'session'));
+    }
+    /** 막힌 사유를 Controller가 해소했다. */
+    unblock(id) {
+        return applyTransition(this.#store, 'session', id, (s) => transitionSession(s, 'ACTIVE', 'controller'));
+    }
+    /**
+     * 세션 종료. Handoff까지가 에이전트 몫이고, state·block·queue 갱신은 Controller가
+     * 회수한 뒤에 한다 (OM §7.2·§9).
+     */
+    async complete(id, handoff, physicalSessionId) {
+        const denied = await this.#guardOwner(id, physicalSessionId);
+        if (denied)
+            return denied;
+        // 끝낸 시점의 정본을 Handoff에 남긴다. 다음 세션이 무엇을 기준으로 이어받는지가 이 값이다.
+        // 여기서는 읽지 못해도 막지 않는다 — 종료를 막으면 Handoff를 남길 길이 없어져 세션이
+        // 갇힌다. 대신 다음 발급·시작이 같은 이유로 멈추므로 모르는 채 이어지지는 않는다.
+        let snapshot = handoff.snapshot;
+        if (snapshot.length === 0) {
+            const read = await this.#readBaselines();
+            if (read.ok)
+                snapshot = read.snapshots;
+        }
+        const outcome = await applyTransition(this.#store, 'session', id, (s) => transitionSession(s, 'DONE', 'session', { handoff: { ...handoff, snapshot } }));
+        if (outcome.ok) {
+            await this.#store.appendHistory({
+                at: handoff.recordedAt,
+                actor: id,
+                kind: 'session_handoff',
+                ref: id,
+                detail: handoff.next,
+            });
+        }
+        return outcome;
+    }
+    fail(id, actor = 'session') {
+        return applyTransition(this.#store, 'session', id, (s) => transitionSession(s, 'FAILED', actor));
+    }
+}

package/dist/core/runtime/store-ops.d.ts

@@ -0,0 +1,22 @@
+import { TransitionError } from '../model/transitions.ts';
+import type { EntityKind, EntityMap, StateStore } from '../../ports/state-store.ts';
+export type ApplyOutcome<T> = {
+    ok: true;
+    entity: T;
+} | {
+    ok: false;
+    reason: 'NOT_FOUND';
+}
+/** 읽은 뒤 값이 바뀌었다. `current`가 호출자에게 무슨 일이 있었는지 설명할 근거다. */
+ | {
+    ok: false;
+    reason: 'CONFLICT';
+    current: T;
+}
+/** 전이 자체가 불가하다 — 잘못된 상태·권한 없는 actor·빠진 필수 항목. */
+ | {
+    ok: false;
+    reason: 'REJECTED';
+    failure: TransitionError;
+};
+export declare function applyTransition<K extends EntityKind>(store: StateStore, kind: K, id: string, mutate: (current: EntityMap[K]) => EntityMap[K]): Promise<ApplyOutcome<EntityMap[K]>>;

package/dist/core/runtime/store-ops.js

@@ -0,0 +1,26 @@
+// 읽기 → 전이 → CAS를 한 묶음으로 수행하는 공통 뼈대.
+// Session·Request·Grant 오케스트레이션이 전부 이 위에 올라간다.
+//
+// 자동 재시도는 없다. 충돌은 "그 사이 누군가 결정했다"는 사실이고, 사람 판단이 걸린
+// 전이를 몰래 다시 시도하면 이미 내려진 결정을 덮어쓴다 (C-01 §8).
+import { TransitionError } from "../model/transitions.js";
+export async function applyTransition(store, kind, id, mutate) {
+    const current = await store.get(kind, id);
+    if (!current)
+        return { ok: false, reason: 'NOT_FOUND' };
+    let next;
+    try {
+        next = mutate(current);
+    }
+    catch (error) {
+        if (error instanceof TransitionError)
+            return { ok: false, reason: 'REJECTED', failure: error };
+        throw error;
+    }
+    const result = await store.compareAndSet(kind, id, current.version, next);
+    if (result.ok)
+        return { ok: true, entity: result.entity };
+    if (result.reason === 'NOT_FOUND')
+        return { ok: false, reason: 'NOT_FOUND' };
+    return { ok: false, reason: 'CONFLICT', current: result.current };
+}

package/dist/core/view/build-view.d.ts

@@ -0,0 +1,36 @@
+import type { ApprovalRequest, ControlState } from '../model/entities.ts';
+import type { ScmPort } from '../../ports/scm.ts';
+import type { CurrentContextOverlay, DecisionSummary, DecisionView, Freshness, StoredPacket, VerificationCoverage } from './decision-view.ts';
+/** 어느 채널에서도 이 문자열로 같은 요청을 지목할 수 있어야 한다 (C-01 §2). */
+export declare function referenceOf(request: ApprovalRequest): string;
+export declare function storedPacketOf(request: ApprovalRequest): StoredPacket;
+export declare function summarize(request: ApprovalRequest, freshness: Freshness): DecisionSummary;
+export type OverlayInput = {
+    control: ControlState;
+    observedAt: string;
+    /** 없으면 외부 상태를 확인할 수 없다 — canonical 비교와 스레드 확인을 건너뛴다. */
+    scm?: ScmPort;
+};
+/**
+ * 조회 시점의 사실을 다시 읽어 만든 Derived View.
+ * 원본 요청도 History도 건드리지 않는다 (C-01 §6-B).
+ */
+export declare function buildOverlay(request: ApprovalRequest, input: OverlayInput): Promise<CurrentContextOverlay>;
+/**
+ * 조회 시점의 신선도와, 그 판단이 무엇을 근거로 했는지 (C-01 §7).
+ *
+ * `CURRENT`는 "아무것도 안 변했다"가 아니라 "확인할 수 있었던 범위에서 안 변했다"이다.
+ * 외부 연결이 없어 원본을 못 본 채 얻은 CURRENT와, 원본까지 확인하고 얻은 CURRENT는
+ * 사용자에게 다른 이야기이므로 verification으로 갈라 말한다.
+ *
+ * 더 무거운 사실이 가벼운 사실을 덮는다: 이미 결정됨 > 원본 변함 > 맥락 변함.
+ * 사용성·사전 경고용이며 게시 직전 Drift Guard를 대신하지 않는다 (OM §11.9).
+ */
+export declare function assess(request: ApprovalRequest, overlay: CurrentContextOverlay, scm?: ScmPort): Promise<{
+    freshness: Freshness;
+    verification: VerificationCoverage;
+}>;
+export declare function assembleView(request: ApprovalRequest, assessment: {
+    freshness: Freshness;
+    verification: VerificationCoverage;
+}, overlay?: CurrentContextOverlay): DecisionView;

package/dist/core/view/build-view.js

@@ -0,0 +1,131 @@
+// ApprovalRequest → Shared Decision View Model 조립.
+//
+// 여기서 지키는 것 하나: 요청이 만들어질 때의 분석(stored)과 지금 다시 읽은 사실(current)을
+// 절대 한 덩어리로 섞지 않는다 (C-01 §6). 14:00에 "S-020에 영향 없음"이라고 적힌 판단은
+// 14:20에도 그때의 판단일 뿐이고, 지금 무슨 일이 벌어지는지는 따로 계산해 나란히 놓는다.
+/** 어느 채널에서도 이 문자열로 같은 요청을 지목할 수 있어야 한다 (C-01 §2). */
+export function referenceOf(request) {
+    return `ASC · ${request.priority} · ${request.id} · ${request.source.reference}`;
+}
+const DECIDED_STATUSES = new Set(['APPROVED', 'QUEUED', 'DEFERRED', 'DISMISSED', 'DONE']);
+export function storedPacketOf(request) {
+    return {
+        status: request.status,
+        type: request.type,
+        priority: request.priority,
+        title: request.title,
+        detectedAt: request.detectedAt,
+        source: request.source.reference,
+        situation: request.situation,
+        context: request.context,
+        interruptRequired: request.impact.interruptRequired,
+        affectedSessions: request.impact.affectedSessions,
+        rationale: request.impact.rationale,
+        recommendation: request.recommendation,
+        ...(request.draft !== undefined ? { draft: request.draft } : {}),
+        snapshot: request.snapshot,
+        ...(request.source.threadLastEventId !== undefined
+            ? { threadLastEventId: request.source.threadLastEventId }
+            : {}),
+    };
+}
+export function summarize(request, freshness) {
+    return {
+        requestId: request.id,
+        reference: referenceOf(request),
+        version: request.version,
+        freshness,
+        status: request.status,
+        priority: request.priority,
+        title: request.title,
+        detectedAt: request.detectedAt,
+    };
+}
+/**
+ * 조회 시점의 사실을 다시 읽어 만든 Derived View.
+ * 원본 요청도 History도 건드리지 않는다 (C-01 §6-B).
+ */
+export async function buildOverlay(request, input) {
+    const notes = [];
+    const activeSessions = input.control.activeSessions;
+    // 생성 당시 "영향 있음"으로 지목된 세션과 지금 도는 세션이 겹치는가.
+    // 요청이 세션을 지목하지 않았다면 판단 근거가 없다 — 없음을 없음이라고 적는다.
+    const affected = request.impact.affectedSessions;
+    let affectsCurrentWork = false;
+    if (affected.length > 0) {
+        affectsCurrentWork = activeSessions.some((id) => affected.includes(id));
+        if (!affectsCurrentWork && activeSessions.length > 0) {
+            notes.push(`알림 당시 기준 세션(${affected.join(', ')})은 지금 활성이 아니다`);
+        }
+    }
+    const canonicalChanges = [];
+    if (input.scm && request.snapshot.length > 0) {
+        const current = await input.scm.getBaselines(request.snapshot.map((s) => ({ sourceId: s.sourceId })));
+        for (const now of current) {
+            const before = request.snapshot.find((s) => s.sourceId === now.sourceId)?.baseline;
+            if (before !== now.baseline)
+                canonicalChanges.push({ sourceId: now.sourceId, before, after: now.baseline });
+        }
+    }
+    // 확인하지 못했다는 사실은 notes가 아니라 verification이 구조적으로 말한다 (assess 참조)
+    return { observedAt: input.observedAt, activeSessions, affectsCurrentWork, canonicalChanges, notes };
+}
+/**
+ * 조회 시점의 신선도와, 그 판단이 무엇을 근거로 했는지 (C-01 §7).
+ *
+ * `CURRENT`는 "아무것도 안 변했다"가 아니라 "확인할 수 있었던 범위에서 안 변했다"이다.
+ * 외부 연결이 없어 원본을 못 본 채 얻은 CURRENT와, 원본까지 확인하고 얻은 CURRENT는
+ * 사용자에게 다른 이야기이므로 verification으로 갈라 말한다.
+ *
+ * 더 무거운 사실이 가벼운 사실을 덮는다: 이미 결정됨 > 원본 변함 > 맥락 변함.
+ * 사용성·사전 경고용이며 게시 직전 Drift Guard를 대신하지 않는다 (OM §11.9).
+ */
+export async function assess(request, overlay, scm) {
+    const hasSourceToCheck = request.snapshot.length > 0 || request.source.threadLastEventId !== undefined;
+    const localContext = request.impact.affectedSessions.length > 0 ? 'VERIFIED' : 'NOT_APPLICABLE';
+    let source = 'NOT_APPLICABLE';
+    if (hasSourceToCheck)
+        source = scm ? 'VERIFIED' : 'UNAVAILABLE';
+    const verify = (freshness) => ({ freshness, verification: { localContext, source } });
+    if (DECIDED_STATUSES.has(request.status))
+        return verify('ALREADY_DECIDED');
+    if (overlay.canonicalChanges.length > 0)
+        return verify('SOURCE_CHANGED');
+    if (scm && request.source.threadLastEventId) {
+        const thread = await scm.getThread(request.source.reference);
+        if (thread.missing || thread.lastEventId !== request.source.threadLastEventId)
+            return verify('SOURCE_CHANGED');
+    }
+    // 알림 당시 지목된 세션이 더는 돌지 않거나 다른 세션이 도는 상황.
+    // 요청 자체는 그대로지만 사용자가 읽는 맥락이 달라졌다.
+    const affected = request.impact.affectedSessions;
+    if (affected.length > 0 && overlay.activeSessions.length > 0 && !overlay.affectsCurrentWork) {
+        return verify('STALE_CONTEXT');
+    }
+    return verify('CURRENT');
+}
+export function assembleView(request, assessment, overlay) {
+    return {
+        requestId: request.id,
+        reference: referenceOf(request),
+        version: request.version,
+        stored: storedPacketOf(request),
+        ...(overlay ? { current: overlay } : {}),
+        freshness: assessment.freshness,
+        verification: assessment.verification,
+        allowedDecisions: request.allowedDecisions,
+        authorizedApprover: request.authorizedApprover,
+        ...(request.expiresAt !== undefined ? { expiresAt: request.expiresAt } : {}),
+        ...(request.decision
+            ? {
+                decided: {
+                    kind: request.decision.kind,
+                    actor: request.decision.actor,
+                    channel: request.decision.channel,
+                    decidedAt: request.decision.decidedAt,
+                },
+            }
+            : {}),
+        ...(request.resultRef !== undefined ? { resultRef: request.resultRef } : {}),
+    };
+}