@sema-agent/client-core 0.101.0 → 0.103.0

package/dist/memoryEntriesWire.d.ts

@@ -38,10 +38,17 @@ export declare function scopeExternalOriginVerdict(reading: MemoryExportReading,
     originAware: boolean;
 }): ScopeExternalOriginVerdict;
 export type { MemoryErasedBinding };
+export type MemoryErasedBindingReading = Exclude<MemoryErasedBinding, {
+    state: 'bound';
+}> | (Omit<Extract<MemoryErasedBinding, {
+    state: 'bound';
+}>, 'slug'> & {
+    slug?: string;
+});
 export interface MemoryErasedRow {
     id: string;
     rev: string;
-    binding: MemoryErasedBinding | null;
+    binding: MemoryErasedBindingReading | null;
 }
 export interface MemoryEraseNotFoundRow {
     id: string;
@@ -54,6 +61,31 @@ export interface MemoryEraseConflictRow {
     id: string;
     reason: string;
 }
+declare const MEMORY_ERASE_CARRIER_CLASSES: readonly ["projection", "shadow", "indexLine", "quarantineCopy", "planArchive", "planWorkbook", "evidenceBinding", "backendDerived"];
+export type MemoryEraseCarrierClass = (typeof MEMORY_ERASE_CARRIER_CLASSES)[number];
+export type MemoryEraseCarrierReading = {
+    removed: number;
+    remaining: number;
+} | {
+    unverified: true;
+};
+declare const ERASE_REPLAY_OF_LANE: Readonly<{
+    readonly journal: "converges";
+    readonly none: "unsupported";
+}>;
+export interface MemoryEraseResidualsReading {
+    carriers: Record<MemoryEraseCarrierClass, MemoryEraseCarrierReading>;
+    replay: (typeof ERASE_REPLAY_OF_LANE)[keyof typeof ERASE_REPLAY_OF_LANE];
+    propagation: 'local-store-only';
+}
+export type MemoryErasePartialCause = {
+    kind: 'entries_pending';
+} | {
+    kind: 'carriers_residual';
+    carriers: MemoryEraseCarrierClass[];
+} | {
+    kind: 'unknown';
+};
 export type MemoryEraseUnreadableCause = 'body_unreadable' | 'envelope_absent' | 'version_absent' | 'unsupported_version' | 'envelope_unreadable' | 'too_many_rows' | 'erased_rows_unreadable' | 'not_found_rows_unreadable' | 'conflict_rows_unreadable' | 'erased_previously_rows_unreadable';
 export type MemoryEraseReceiptReading = {
     kind: 'malformed';
@@ -73,6 +105,8 @@ export type MemoryEraseReceiptReading = {
     erasedPreviouslyDropped: number;
     conflicts: MemoryEraseConflictRow[];
     conflictsDropped: number;
+    residuals: MemoryEraseResidualsReading | null;
+    partialCause: MemoryErasePartialCause | null;
 };
 export declare function readMemoryEraseReceipt(body: unknown): MemoryEraseReceiptReading;
 export type MemoryEraseCounts = {

package/dist/memoryEntriesWire.js

@@ -38,12 +38,6 @@ function snapshotArray(v) {
     }
     return { items, unreadable, tooLarge: false };
 }
-function arrayLengthOrNull(v) {
-    const snap = snapshotArray(v);
-    if (snap === null || snap.tooLarge)
-        return null;
-    return snap.items.length + snap.unreadable;
-}
 function originMarkOf(row) {
     if (ownPresent(row, 'origin'))
         return 'marked';
@@ -175,7 +169,24 @@ export function scopeExternalOriginVerdict(reading, asked) {
     }
     return { kind: 'none_in_this_scope', scope: reading.scope };
 }
-const MEMORY_ERASE_RECEIPT_VERSION = 1;
+const MEMORY_ERASE_CARRIER_CLASSES = Object.freeze([
+    'projection',
+    'shadow',
+    'indexLine',
+    'quarantineCopy',
+    'planArchive',
+    'planWorkbook',
+    'evidenceBinding',
+    'backendDerived',
+]);
+const MEMORY_ERASE_CARRIER_CLASS_SET = new Set(MEMORY_ERASE_CARRIER_CLASSES);
+const ERASE_REPLAY_OF_LANE = Object.freeze({ journal: 'converges', none: 'unsupported' });
+const _eraseResidualsPin = true;
+void _eraseResidualsPin;
+const ERASE_RECEIPT_VERSIONS = new Map([
+    [1, Object.freeze({ boundSlug: 'required', carrierTable: false })],
+    [2, Object.freeze({ boundSlug: 'optional', carrierTable: true })],
+]);
 function eraseStatusOf(v) {
     return v === 'complete' || v === 'partial' ? v : null;
 }
@@ -185,7 +196,7 @@ function eraseEvidenceCapabilityOf(v) {
 function eraseCustodyStateOf(v) {
     return v === 'complete' || v === 'damaged' || v === 'capability-absent' ? v : null;
 }
-function erasedBindingOf(v) {
+function erasedBindingOf(v, slugRule) {
     if (!plainObject(v))
         return null;
     const state = v.state;
@@ -194,10 +205,75 @@ function erasedBindingOf(v) {
     if (state !== 'bound')
         return null;
     const scope = v.scope;
+    if (!nonEmptyString(scope))
+        return null;
+    const slugPresent = Object.hasOwn(v, 'slug');
+    if (!slugPresent)
+        return slugRule === 'optional' ? { state: 'bound', scope } : null;
     const slug = v.slug;
-    if (!nonEmptyString(scope) || !nonEmptyString(slug))
+    return nonEmptyString(slug) ? { state: 'bound', scope, slug } : null;
+}
+function carrierAnswerOf(v) {
+    if (!plainObject(v))
+        return null;
+    const unverified = readThrownSlot(v, 'unverified', 'data');
+    const removed = readThrownSlot(v, 'removed', 'data');
+    const remaining = readThrownSlot(v, 'remaining', 'data');
+    if (unverified !== undefined)
+        return unverified === true && removed === undefined && remaining === undefined ? { unverified: true } : null;
+    return nonNegativeInt(removed) && nonNegativeInt(remaining) ? { removed, remaining } : null;
+}
+function eraseResidualsOf(o, lane) {
+    try {
+        const raw = readThrownSlot(o, 'residuals', 'data');
+        if (!plainObject(raw))
+            return null;
+        const rawCarriers = readThrownSlot(raw, 'carriers', 'data');
+        const replay = readThrownSlot(raw, 'replay', 'data');
+        const propagation = readThrownSlot(raw, 'propagation', 'data');
+        if (!plainObject(rawCarriers) || replay !== ERASE_REPLAY_OF_LANE[lane] || propagation !== 'local-store-only')
+            return null;
+        if (Reflect.ownKeys(rawCarriers).some((k) => typeof k !== 'string' || !MEMORY_ERASE_CARRIER_CLASS_SET.has(k)))
+            return null;
+        const carriers = {};
+        for (const cls of MEMORY_ERASE_CARRIER_CLASSES) {
+            const answer = carrierAnswerOf(readThrownSlot(rawCarriers, cls, 'data'));
+            if (answer === null)
+                return null;
+            carriers[cls] = answer;
+        }
+        return { carriers, replay: ERASE_REPLAY_OF_LANE[lane], propagation };
+    }
+    catch {
         return null;
-    return { state: 'bound', scope, slug };
+    }
+}
+function erasePartialCauseOf(f) {
+    if (f.status === 'complete')
+        return null;
+    if (f.conflicts.length > 0)
+        return { kind: 'entries_pending' };
+    if (f.dropped > 0 || f.pinnedIds === null)
+        return { kind: 'unknown' };
+    const claimed = new Set([...f.erased.map((r) => r.id), ...(f.erasedPreviously ?? []).map((r) => r.id)]);
+    const notFound = new Set(f.notFound.map((r) => r.id));
+    let historyUnknown = false;
+    for (const id of f.pinnedIds) {
+        if (claimed.has(id))
+            continue;
+        if (!notFound.has(id))
+            return { kind: 'entries_pending' };
+        if (f.custodyState !== 'complete')
+            historyUnknown = true;
+    }
+    if (historyUnknown || f.residuals === null)
+        return { kind: 'unknown' };
+    const carriers = f.residuals.carriers;
+    const residual = MEMORY_ERASE_CARRIER_CLASSES.filter((c) => {
+        const a = carriers[c];
+        return 'unverified' in a || a.remaining > 0;
+    });
+    return residual.length > 0 ? { kind: 'carriers_residual', carriers: residual } : { kind: 'unknown' };
 }
 export function readMemoryEraseReceipt(body) {
     let o;
@@ -229,8 +305,10 @@ export function readMemoryEraseReceipt(body) {
         return { kind: 'malformed', why: 'envelope_absent' };
     if (rawV === undefined)
         return { kind: 'malformed', why: 'version_absent' };
-    if (rawV !== MEMORY_ERASE_RECEIPT_VERSION)
+    const rule = ERASE_RECEIPT_VERSIONS.get(rawV);
+    if (rule === undefined)
         return { kind: 'malformed', why: 'unsupported_version' };
+    const slugRule = rule.boundSlug;
     const status = eraseStatusOf(rawStatus);
     const evidenceCapability = eraseEvidenceCapabilityOf(rawEvidence);
     const custodyState = eraseCustodyStateOf(rawCustody);
@@ -241,13 +319,13 @@ export function readMemoryEraseReceipt(body) {
     let notFoundSnap;
     let conflictsSnap;
     let previouslySnap;
-    let selectedIds;
+    let selectedSnap;
     try {
         erasedSnap = snapshotArray(rawErased);
         notFoundSnap = snapshotArray(rawNotFound);
         conflictsSnap = snapshotArray(rawConflicts);
         previouslySnap = rawPreviously === undefined ? null : snapshotArray(rawPreviously);
-        selectedIds = arrayLengthOrNull(rawSelected);
+        selectedSnap = snapshotArray(rawSelected);
     }
     catch {
         return { kind: 'malformed', why: 'body_unreadable' };
@@ -255,6 +333,10 @@ export function readMemoryEraseReceipt(body) {
     if (erasedSnap === null || notFoundSnap === null || conflictsSnap === null) {
         return { kind: 'malformed', why: 'envelope_unreadable' };
     }
+    const selectedIds = selectedSnap === null || selectedSnap.tooLarge ? null : selectedSnap.items.length + selectedSnap.unreadable;
+    const pinnedIds = selectedSnap !== null && !selectedSnap.tooLarge && selectedSnap.unreadable === 0 && selectedSnap.items.every(nonEmptyString)
+        ? selectedSnap.items
+        : null;
     if (rawPreviously !== undefined && previouslySnap === null) {
         return { kind: 'malformed', why: 'envelope_unreadable' };
     }
@@ -277,7 +359,7 @@ export function readMemoryEraseReceipt(body) {
                 continue;
             }
             erasedSeen.add(id);
-            erased.push({ id, rev, binding: erasedBindingOf(item.binding) });
+            erased.push({ id, rev, binding: erasedBindingOf(item.binding, slugRule) });
         }
         catch {
             erasedDropped++;
@@ -367,6 +449,18 @@ export function readMemoryEraseReceipt(body) {
         }
         erasedPreviously = rows;
     }
+    const residuals = rule.carrierTable ? eraseResidualsOf(o, evidenceCapability) : null;
+    const partialCause = erasePartialCauseOf({
+        status,
+        custodyState,
+        pinnedIds,
+        erased,
+        erasedPreviously,
+        notFound,
+        conflicts,
+        dropped: erasedDropped + notFoundDropped + erasedPreviouslyDropped + conflictsDropped,
+        residuals,
+    });
     return {
         kind: 'present',
         requestId: rawRequestId,
@@ -382,6 +476,8 @@ export function readMemoryEraseReceipt(body) {
         erasedPreviouslyDropped,
         conflicts,
         conflictsDropped,
+        residuals,
+        partialCause,
     };
 }
 export function memoryEraseCounts(reading) {

package/dist/modsFace.d.ts

@@ -0,0 +1,8 @@
+import type { WiringManifestModRefusedView } from './adapter/downstream/eventToSdkMessage.js';
+import type { EngineNoticeChromeEvent } from './seam.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare const MOD_LOADER_VERBS: readonly ["list", "load", "unload", "status"];
+export type ModLoaderVerb = (typeof MOD_LOADER_VERBS)[number];
+export declare function readModRegistrationRefusedNotice(ev: EngineNoticeChromeEvent): WiringManifestModRefusedView | undefined;
+export declare function modCardSentence(input: object | null | undefined, lang?: UiLanguage): string | undefined;
+export declare function modLoaderFailureSentence(name: string, error: unknown, lang?: UiLanguage): string;

package/dist/modsFace.js

@@ -0,0 +1,63 @@
+import { modRowsOf } from './adapter/downstream/wiringManifestView.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { displayUntrusted } from './displayUntrusted.js';
+import { WIRE_FAILURE_UNRENDERABLE_TEXT, wireFailureTextsOf } from './wireFailureShape.js';
+import { gateOutcomeOf, isDeniedGate, rewriteExtensionNamesOf, toolInputRewriteOf } from './gateOutcome.js';
+import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue, toolResultBlockOf } from './ownKey.js';
+const isCardRecordObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+export const MOD_LOADER_VERBS = Object.freeze(['list', 'load', 'unload', 'status']);
+const modRowOf = (r) => modRowsOf([r])?.[0];
+const MODS_REGISTRATION_REFUSED_NOTICE_CODE = 'mods.registration_refused';
+export function readModRegistrationRefusedNotice(ev) {
+    try {
+        if (!isCardRecordObject(ev))
+            return undefined;
+        if (readOwnDataValue(ev, 'code') !== MODS_REGISTRATION_REFUSED_NOTICE_CODE)
+            return undefined;
+        const row = modRowOf(readOwnDataValue(ev, 'detail'));
+        return row !== undefined && 'refusedBy' in row ? row : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const MOD_NAME_SHOWN_MAX = 64;
+const MOD_REASON_SHOWN_MAX = 160;
+const shownName = (s) => displayUntrusted(s, { blanks: true, max: MOD_NAME_SHOWN_MAX });
+const shownReason = (s) => displayUntrusted(s, { max: MOD_REASON_SHOWN_MAX });
+export function modCardSentence(input, lang) {
+    try {
+        if (!isCardRecordObject(input))
+            return undefined;
+        if (toolResultBlockOf(input) !== undefined) {
+            const by = readOwnDataNonEmptyString(input, '_sema_answered_by');
+            if (by === undefined) {
+                const names = rewriteExtensionNamesOf(toolInputRewriteOf({ rewrite: readOwnDataValue(input, '_sema_rewrite') }));
+                if (names.length === 0)
+                    return undefined;
+                return renderMessage(msg('config.mods.rewrite.inputBy', { by: names.map(shownName).join(', ') }), lang);
+            }
+            const gate = gateOutcomeOf({ gate: readOwnDataValue(input, '_sema_gate') });
+            return isDeniedGate(gate)
+                ? renderMessage(msg('config.mods.refusal.by', { by: shownName(by) }), lang)
+                : renderMessage(msg('config.mods.rewrite.resultInPlace', { by: shownName(by) }), lang);
+        }
+        const row = modRowOf(input);
+        if (row === undefined)
+            return undefined;
+        if ('refusedBy' in row) {
+            return renderMessage(msg('config.mods.card.refused', { name: shownName(row.name), refusedBy: shownName(row.refusedBy), reason: shownReason(row.reason) }), lang);
+        }
+        return renderMessage(msg('config.mods.card.mounted', { name: shownName(row.name) }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function modLoaderFailureSentence(name, error, lang) {
+    const shown = guardedRead(() => (typeof name === 'string' ? shownName(name) : undefined)) ?? '';
+    const { reason } = wireFailureTextsOf(error);
+    if (reason === WIRE_FAILURE_UNRENDERABLE_TEXT)
+        return renderMessage(msg('config.mods.loader.failedNoReason', { name: shown }), lang);
+    return renderMessage(msg('config.mods.loader.failed', { name: shown, reason: shownReason(reason) }), lang);
+}

package/dist/ownKey.d.ts

@@ -6,6 +6,7 @@ export declare function readOwnDataFiniteNumber(v: object | null | undefined, ke
 export declare function readOwnDataValue<T>(v: object | null | undefined, key: string): T | undefined;
 export declare function carriesAnswerText(text: string): boolean;
 export declare function appendOwnElement<T>(list: T[], value: T): void;
+export declare function toolResultBlockOf(record: object): object | undefined;
 export declare function guardedRead<T>(read: () => T | undefined): T | undefined;
 export declare function ownDataField(v: object, key: string): unknown;
 export declare function ownSendableField(v: object, key: string): unknown;

package/dist/ownKey.js

@@ -40,6 +40,21 @@ export function carriesAnswerText(text) {
 export function appendOwnElement(list, value) {
     Object.defineProperty(list, list.length, { value, writable: true, enumerable: true, configurable: true });
 }
+export function toolResultBlockOf(record) {
+    const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+    const message = ownDataField(record, 'message');
+    if (!isRecord(message))
+        return undefined;
+    const content = ownDataField(message, 'content');
+    if (!Array.isArray(content))
+        return undefined;
+    for (let i = 0; i < content.length; i++) {
+        const block = ownDataField(content, String(i));
+        if (isRecord(block) && ownDataField(block, 'type') === 'tool_result')
+            return block;
+    }
+    return undefined;
+}
 export function guardedRead(read) {
     try {
         return read();

package/dist/postureKnob.js

@@ -1,5 +1,5 @@
 import { capForDisplay } from './fleetTaskDesc.js';
-export const POSTURE_SOURCE_WORDS = Object.freeze(['env', 'center', 'posture', 'engine-default']);
+export const POSTURE_SOURCE_WORDS = Object.freeze(['env', 'center', 'lane', 'posture', 'engine-default']);
 export function postureSourceIsOperatorPinned(source) {
     return source === 'env' || source === 'center';
 }

package/dist/prepareRefusal.d.ts

@@ -6,4 +6,3 @@ export interface PrepareRefusalNoteFacts {
 }
 export declare function prepareRefusalNoteOf(code: string | undefined, facts?: PrepareRefusalNoteFacts): string | undefined;
 export declare function prepareRefusalCodeOf(failure: {} | null | undefined): PrepareRefusalCode | undefined;
-export declare function imageInvalidFailureNoteOf(code: string | undefined): string | undefined;

package/dist/prepareRefusal.js

@@ -85,6 +85,3 @@ export function prepareRefusalCodeOf(failure) {
         return undefined;
     }
 }
-export function imageInvalidFailureNoteOf(code) {
-    return code === CONFIG_IMAGE_INVALID ? prepareRefusalNoteOf(code) : undefined;
-}

package/dist/printToolResultFrame.js

@@ -41,7 +41,7 @@ export function toolEndResultToUserFrame(arm) {
         parent_tool_use_id: parent,
         ...(isCcToolDenialKind(arm._sema_denial_kind) ? { _sema_denial_kind: arm._sema_denial_kind } : {}),
         ...(gateView !== undefined ? { _sema_gate: gateView } : {}),
-        ...toolResultRowFlagParts(arm),
+        ...toolResultRowFlagParts(arm, gateView),
         ...(Object.hasOwn(envelope, 'tool_use_result') ? { tool_use_result: envelope.tool_use_result } : {}),
         ...(Object.hasOwn(envelope, '_sema_degraded') ? { _sema_degraded: envelope._sema_degraded } : {}),
         uuid: rowIdentity.uuid,

package/dist/promptProfileWireCaps.d.ts

@@ -1,4 +1,2 @@
-import type { TaskRequest } from '@sema-agent/sdk';
 import { type EnvLike } from './hostEnv.js';
-export type PromptProfile = NonNullable<TaskRequest['promptProfile']>;
-export declare function promptProfileFromEnv(env?: EnvLike): PromptProfile | undefined;
+export declare function promptLeanFromEnv(env?: EnvLike): false | undefined;

package/dist/promptProfileWireCaps.js

@@ -1,7 +1,7 @@
 import { hostEnv } from './hostEnv.js';
 const PROMPT_PROFILE_ENV = 'SEMA_PROMPT_PROFILE';
-export function promptProfileFromEnv(env = hostEnv()) {
+export function promptLeanFromEnv(env = hostEnv()) {
     const raw = env[PROMPT_PROFILE_ENV];
     const s = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
-    return s === 'simple' || s === 'classic' ? s : undefined;
+    return s === 'classic' ? false : undefined;
 }

package/dist/request/printNotification.js

@@ -16,7 +16,7 @@ export const PRINT_NOTIFICATION_FIELD_MATRIX = [
     { field: '_sema_partial', from: 'partial', cc: false, why: 'server 1.258:被终止子代的残果(消费方须渲成不完整,不得当完整结果)' },
     { field: '_sema_exit_code', from: 'exitCode', cc: false, why: '后台 bash 退出码(137=OOM 这类归因只在这一位上)' },
     { field: '_sema_diagnostics', from: 'diagnostics', cc: false, why: '引擎侧诊断串(UNTRUSTED,service 已 redact)' },
-    { field: '_sema_result', from: 'result', cc: false, why: '完成结果正文(#49 C1:帧带 result 必入 XML,print 出口同理不得独漏)' },
+    { field: '_sema_result', from: 'result', cc: false, why: '完成结果正文(帧带 result 必入 XML,print 出口同理不得独漏)' },
     { field: '_sema_lines', from: 'lines', cc: false, why: '尾部输出行(UNTRUSTED);交互面折进 <output-lines>' },
     { field: '_sema_recent_steps', from: 'recentSteps', cc: false, why: '结构化残局步骤 {tool,target,outcome}[] —— **原样透传**,不降级成交互面那份显示串(SDK 消费方要结构)' },
     { field: '_sema_edited_files', from: 'editedFiles', cc: false, why: '结构化改档清单 {path,edits}[];同上原样透传' },

package/dist/request/taskRequest.d.ts

@@ -1,4 +1,5 @@
 import type { TaskRequest, UserAttachment } from '@sema-agent/sdk';
+import { type ThinkingLatchState } from '../thinkingLatchWords.js';
 import { type ApprovalFrameFamiliesReading, type ApprovalFrameFamiliesWithheld } from '../approvalFrameFamilies.js';
 import { type OutputStyleSeatReading } from '../outputStyleSeatCapability.js';
 import { type ApprovalReachWord } from '../approvalReachWire.js';
@@ -38,7 +39,7 @@ export interface TaskRequestInput {
     selfOrchestration?: boolean;
     deferTools?: readonly string[];
     retainBackgroundProcesses?: boolean;
-    promptProfile?: string;
+    promptLean?: boolean;
     enableFork?: boolean;
     attachments?: Record<string, unknown>;
     attachmentIds?: readonly string[];
@@ -66,6 +67,8 @@ export interface TaskRequestInput {
     repo?: string;
     hostSettings: HostTurnSettings;
     approvalFrameFamiliesReading?: ApprovalFrameFamiliesReading;
+    thinkingLatch?: 'on' | 'off';
+    reasoningFloor?: string;
     settings?: {
         ultracode?: boolean;
     };
@@ -84,6 +87,23 @@ export interface TaskRequestAssembly {
     readonly omitted: readonly TaskRequestOmission[];
     readonly host: HostTurnSettings;
     readonly approvalFrameFamiliesWithheld?: ApprovalFrameFamiliesWithheld;
+    readonly thinking: ThinkingTurnProjection;
+}
+export interface ThinkingTurnInput {
+    readonly submission: RequestLane | SubmissionIdentity;
+    readonly live: boolean;
+    readonly latch?: 'on' | 'off';
+    readonly strength?: unknown;
+    readonly floor?: string;
+    readonly ultracode?: boolean;
+}
+export interface ThinkingTurnProjection {
+    readonly word?: unknown;
+    readonly verdict: 'utility_lane' | 'off' | 'strength';
+    readonly latch: ThinkingLatchState;
+    readonly ultracodeStamped: boolean;
+    readonly floorApplied?: true;
+    readonly strengthOverruled?: unknown;
 }
 export type TaskRequestSeatReading = {
     readonly seat: 'seated';
@@ -136,6 +156,7 @@ export type MaxCostUsdParse = {
 export declare function parseMaxCostUsd(text: unknown): MaxCostUsdParse;
 export declare function assembleTaskRequest(input: TaskRequestInput, laneOrIdentity: RequestLane | SubmissionIdentity): TaskRequestAssembly;
 export declare function buildTaskRequest(input: TaskRequestInput, laneOrIdentity: RequestLane | SubmissionIdentity): TaskRequestLike;
+export declare function thinkingTurnProjection(input: ThinkingTurnInput): ThinkingTurnProjection;
 export interface LiveDefaultsInput {
     cwd?: string;
     additionalDirectories?: readonly string[];