@sema-agent/client-core 0.95.0 → 0.96.0

package/dist/engineErrorCodes.js

@@ -1,5 +1,4 @@
 import { frozenSet } from './frozenSet.js';
-import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
 import { SDK_DENY_REASON_ROUTING_FAILURE, SDK_RUN_DEATH_VERDICT_CODES, SDK_STATUS_DERIVED_COARSE_CODES } from './generated/sdkFactTables.js';
 export const LIMITS_MAX_TOKENS_EXCEEDED = 'limits.max_tokens_exceeded';
 export const LIMITS_MAX_COST_EXCEEDED = 'limits.max_cost_exceeded';
@@ -28,20 +27,6 @@ export function imageInvalidFailureNoteOf(code) {
 }
 export const CONFIG_AGENT_UNKNOWN_TOOL = 'config.agent.unknown_tool';
 export const CONFIG_OUTPUT_STYLE_INVALID = 'config.output_style_invalid';
-export const CONFIG_REFUSAL_CODES = frozenSet([
-    CONFIG_LIMIT_INVALID,
-    CONFIG_STRATEGY_FIND_LIMIT_INVALID,
-    CONFIG_STRATEGY_MAX_SIZE_INVALID,
-    CONFIG_LIMIT_UNKNOWN_KEY,
-    CONFIG_DELEGATION_ENTRY_CAPS,
-    CONFIG_MEMORY_PROJECT_KEY_SPELLING,
-    CONFIG_MEMORY_WRITE_SCOPE_MISMATCH,
-    CONFIG_LEGACY_TOOL_NAME,
-    CONFIG_IMAGE_INVALID,
-    CONFIG_AGENT_UNKNOWN_TOOL,
-    CONFIG_OUTPUT_STYLE_INVALID,
-    ...CORE_TOOL_DECLARATION_CODES,
-]);
 export const RULES_LEGACY_TOOL_NAME = 'rules.legacy_tool_name';
 const RULES_ERROR_CODE_PREFIX = 'rules.';
 export function isRulesRefusalCode(code) {
@@ -77,8 +62,35 @@ export function isInterruptedToolEndCode(code) {
     return typeof code === 'string' && TOOL_END_INTERRUPTED_CODES.has(code);
 }
 export const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = 'capability.self_orchestration_required';
+export const CAPABILITY_IMAGE_INDEX_REQUIRED = 'capability.image_index_required';
 export const GATE_PARKED_ERROR_CODE = 'gate.parked';
 export const ACTIVE_RUN_BUSY_ERROR_CODE = 'conflict.session_active_run';
+export function classifyActiveRunBusy(input) {
+    const handle = typeof input.activeTaskId === 'string' && input.activeTaskId.length > 0 ? input.activeTaskId : null;
+    if (input.errorCode === ACTIVE_RUN_BUSY_ERROR_CODE)
+        return { busy: true, handle };
+    if (typeof input.activeTaskId === 'string')
+        return { busy: true, handle };
+    return { busy: false, handle };
+}
+export function activeRunBusyCarrierOf(ev) {
+    if (typeof ev !== 'object' || ev === null || !('type' in ev))
+        return null;
+    const type = ev.type;
+    if (type === 'failed')
+        return ev;
+    if (type !== 'done')
+        return null;
+    const result = ev.result;
+    if (typeof result !== 'object' || result === null)
+        return null;
+    const status = result.status;
+    if (status === 'failed')
+        return result;
+    if (status === undefined && !Array.isArray(result) && Object.hasOwn(result, 'terminal'))
+        return result;
+    return null;
+}
 export const CORRUPT_SESSION_ERROR_CODE = 'corrupt_session';
 export function isCorruptSessionCode(code) {
     return code === CORRUPT_SESSION_ERROR_CODE;
@@ -114,6 +126,14 @@ export const REQUEST_AUTONOMY_LANE_REFUSED = 'request.autonomy_lane_refused';
 export const CHECKPOINT_UNSUPPORTED_VERSION = 'checkpoint.unsupported_version';
 export const CHECKPOINT_WALLTIME_AXIS_RETIRED = 'checkpoint.walltime_axis_retired';
 export const CHECKPOINT_CONFIG_REFUSED = 'checkpoint.config_refused';
+export const CHECKPOINT_REFUSED_PARK_CODES = Object.freeze([
+    CHECKPOINT_UNSUPPORTED_VERSION,
+    CHECKPOINT_WALLTIME_AXIS_RETIRED,
+    CHECKPOINT_CONFIG_REFUSED,
+]);
+export function isRefusedParkCode(code) {
+    return typeof code === 'string' && CHECKPOINT_REFUSED_PARK_CODES.includes(code);
+}
 export function refusalSaysStillPending(err) {
     return refusalRetriableReading(err) === true;
 }
@@ -167,6 +187,7 @@ export const RESUME_OUTCOME_INVALID = 'resume_outcome_invalid';
 export const CHECKPOINT_ALREADY_RESOLVED = 'checkpoint.already_resolved';
 export const NOT_FOUND_APPROVAL = 'not_found.approval';
 export const NOT_FOUND_CHECKPOINT = 'not_found.checkpoint';
+export const NOT_FOUND_BLOB = 'not_found.blob';
 export const DECIDE_ALREADY_RESOLVED_CODES = Object.freeze([
     APPROVAL_STALE,
     CHECKPOINT_ALREADY_RESOLVED,
@@ -177,6 +198,7 @@ export function isDecideAlreadyResolvedCode(code) {
     return typeof code === 'string' && DECIDE_ALREADY_RESOLVED_CODES.includes(code);
 }
 export const ASK_GONE = 'gone.ask';
+export const ASK_GONE_PARKED = 'gone.ask_parked';
 export const ASK_GONE_DENIED_WORD = SDK_DENY_REASON_ROUTING_FAILURE;
 export const RUN_DEATH_VERDICT_CODES = SDK_RUN_DEATH_VERDICT_CODES;
 const _runDeathVerdictCodePin = true;

package/dist/engineNoticeCodes.d.ts

@@ -171,6 +171,7 @@ export type ToolTurnIncompleteCause = (typeof CORE_TOOL_TURN_INCOMPLETE_CAUSES)[
 export interface ToolTurnIncompleteFactsView {
     cause: string;
     count: number;
+    outcome?: string;
     toolCallIds?: readonly string[];
     sessionId: string;
     runId: string;
@@ -201,6 +202,20 @@ export declare function readTurnInterrupted(notice: unknown): TurnInterruptedFac
 export declare function turnInterruptedNotice(facts: Pick<TurnInterruptedFactsView, 'lane'>): string | undefined;
 export type SteerCutVerdict = 'this_input' | 'other_input' | 'user_halt' | 'unattributed' | 'not_a_cut';
 export declare function steerCutVerdict(notice: unknown, messageId: string | undefined): SteerCutVerdict;
+export interface FinishReasonUnknownFactsView {
+    finishReason: string;
+    sessionId: string;
+    runId: string;
+}
+export declare function readFinishReasonUnknown(notice: unknown): FinishReasonUnknownFactsView | undefined;
+export interface StreamEndIgnoredFactsView {
+    statement: string;
+    word: string;
+    frames: number;
+    sessionId: string;
+    runId: string;
+}
+export declare function readStreamEndIgnored(notice: unknown): StreamEndIgnoredFactsView | undefined;
 export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'mcp.injection_dropped': typeof readMcpInjectionDrop;
     readonly 'delegation.ask_unresolvable': typeof readAskUnresolvable;
@@ -223,6 +238,8 @@ export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'task.user_steer_undrained': typeof readUserInputUndrained;
     readonly 'task.user_followup_undrained': typeof readUserInputUndrained;
     readonly 'task.turn_interrupted': typeof readTurnInterrupted;
+    readonly 'route.finish_reason_unknown': typeof readFinishReasonUnknown;
+    readonly 'route.stream_end_ignored': typeof readStreamEndIgnored;
 }>;
 type FactReaderTable = typeof ENGINE_NOTICE_FACT_READERS;
 export type EngineNoticeFactsCode = keyof FactReaderTable;

package/dist/engineNoticeCodes.js

@@ -1,5 +1,6 @@
 import { AUTO_MODE_UNAVAILABLE_CAUSES } from './autoModeUnavailable.js';
 import { displayUntrusted } from './displayUntrusted.js';
+import { currentEngineWord } from './engineWordRenames.js';
 import { CORE_ENGINE_NOTICE_CODES, CORE_MCP_INJECTION_DROP_REASONS, CORE_NOTICE_AUDIENCE, CORE_USER_INPUT_UNDRAINED_FAMILIES, } from './generated/engineNoticeTables.js';
 import { CORE_ASK_UNRESOLVABLE_CAUSES, CORE_DURABLE_MANDATE_SOURCES, CORE_PERMISSION_MODE_FOLD_REASONS, } from './generated/engineFactTables.js';
 export const ENGINE_NOTICE_CODES = CORE_ENGINE_NOTICE_CODES;
@@ -8,13 +9,13 @@ function audienceRow(table, code) {
     return Object.hasOwn(table, code) ? table[code] : undefined;
 }
 export function engineNoticeInCatalog(code) {
-    return typeof code === 'string' && CATALOG.has(code);
+    return typeof code === 'string' && (CATALOG.has(code) || CATALOG.has(currentEngineWord(code)));
 }
 export const ENGINE_NOTICE_AUDIENCE = CORE_NOTICE_AUDIENCE;
 export function noticeAudienceOf(code) {
     if (typeof code !== 'string')
         return 'operator';
-    return audienceRow(ENGINE_NOTICE_AUDIENCE, code) ?? 'operator';
+    return audienceRow(ENGINE_NOTICE_AUDIENCE, code) ?? audienceRow(ENGINE_NOTICE_AUDIENCE, currentEngineWord(code)) ?? 'operator';
 }
 export const MCP_INJECTION_DROP_REASONS = CORE_MCP_INJECTION_DROP_REASONS;
 const DROP_REASONS = new Set(MCP_INJECTION_DROP_REASONS);
@@ -602,12 +603,21 @@ function readToolTurnIncompleteOf(notice) {
     const o = d;
     const cause = nonEmpty(ownSeat(o, 'cause'));
     const count = positiveInt(ownSeat(o, 'count'));
+    const outcome = optionalNonEmpty(o, 'outcome');
     const toolCallIds = optionalNameList(o, 'toolCallIds');
     const sessionId = nonEmpty(ownSeat(o, 'sessionId'));
     const runId = nonEmpty(ownSeat(o, 'runId'));
     if (cause === undefined || count === undefined || sessionId === undefined || runId === undefined)
         return undefined;
-    return { cause, count, ...(toolCallIds !== undefined ? { toolCallIds } : {}), sessionId, runId };
+    return { cause, count, ...(outcome !== undefined ? { outcome } : {}), ...(toolCallIds !== undefined ? { toolCallIds } : {}), sessionId, runId };
+}
+function optionalNonEmpty(o, key) {
+    try {
+        return nonEmpty(ownSeat(o, key));
+    }
+    catch {
+        return undefined;
+    }
 }
 export function readUserInputUndrained(notice) {
     return guardedRead(notice, readUserInputUndrainedOf);
@@ -779,6 +789,48 @@ export function steerCutVerdict(notice, messageId) {
         return 'unattributed';
     return facts.inputId === messageId ? 'this_input' : 'other_input';
 }
+export function readFinishReasonUnknown(notice) {
+    return guardedRead(notice, readFinishReasonUnknownOf);
+}
+function readFinishReasonUnknownOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (ownSeat(n, 'code') !== 'route.finish_reason_unknown')
+        return undefined;
+    const d = ownSeat(n, 'detail');
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const finishReason = nonEmpty(ownSeat(o, 'finishReason'));
+    const sessionId = nonEmpty(ownSeat(o, 'sessionId'));
+    const runId = nonEmpty(ownSeat(o, 'runId'));
+    if (finishReason === undefined || sessionId === undefined || runId === undefined)
+        return undefined;
+    return { finishReason, sessionId, runId };
+}
+export function readStreamEndIgnored(notice) {
+    return guardedRead(notice, readStreamEndIgnoredOf);
+}
+function readStreamEndIgnoredOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (ownSeat(n, 'code') !== 'route.stream_end_ignored')
+        return undefined;
+    const d = ownSeat(n, 'detail');
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const statement = nonEmpty(ownSeat(o, 'statement'));
+    const word = nonEmpty(ownSeat(o, 'word'));
+    const frames = positiveInt(ownSeat(o, 'frames'));
+    const sessionId = nonEmpty(ownSeat(o, 'sessionId'));
+    const runId = nonEmpty(ownSeat(o, 'runId'));
+    if (statement === undefined || word === undefined || frames === undefined || sessionId === undefined || runId === undefined)
+        return undefined;
+    return { statement, word, frames, sessionId, runId };
+}
 export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'mcp.injection_dropped': readMcpInjectionDrop,
     'delegation.ask_unresolvable': readAskUnresolvable,
@@ -801,6 +853,8 @@ export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'task.user_steer_undrained': readUserInputUndrained,
     'task.user_followup_undrained': readUserInputUndrained,
     'task.turn_interrupted': readTurnInterrupted,
+    'route.finish_reason_unknown': readFinishReasonUnknown,
+    'route.stream_end_ignored': readStreamEndIgnored,
 });
 const _factReaderTablePin = true;
 void _factReaderTablePin;

package/dist/engineWordRenames.d.ts

@@ -0,0 +1,8 @@
+export declare const PRIOR_ENGINE_WORD_RENAMES: Readonly<{
+    readonly write_protection_unresolved: "target_unresolved";
+}>;
+export declare const PRIOR_ENGINE_NOTICE_CODE_RENAMES: Readonly<{
+    readonly 'config.write_protection_unresolved': "config.path_view_unresolved";
+}>;
+export type PriorEngineWord = keyof typeof PRIOR_ENGINE_WORD_RENAMES;
+export declare function currentEngineWord(word: string): string;

package/dist/engineWordRenames.js

@@ -0,0 +1,13 @@
+export const PRIOR_ENGINE_WORD_RENAMES = Object.freeze({
+    write_protection_unresolved: 'target_unresolved',
+});
+export const PRIOR_ENGINE_NOTICE_CODE_RENAMES = Object.freeze({
+    'config.write_protection_unresolved': 'config.path_view_unresolved',
+});
+export function currentEngineWord(word) {
+    if (Object.hasOwn(PRIOR_ENGINE_WORD_RENAMES, word))
+        return PRIOR_ENGINE_WORD_RENAMES[word];
+    if (Object.hasOwn(PRIOR_ENGINE_NOTICE_CODE_RENAMES, word))
+        return PRIOR_ENGINE_NOTICE_CODE_RENAMES[word];
+    return word;
+}

package/dist/fileHistoryCaptureCapability.d.ts

@@ -16,5 +16,19 @@ export declare function fileHistoryCaptureMode(reading: FileHistoryCaptureReadin
 export declare function fileHistoryDeclarationField(reading: FileHistoryCaptureReading, captureOff: boolean): {
     fileHistory: 'disabled';
 } | Record<string, never>;
+export declare const FILE_HISTORY_TIGHTEN_VERDICTS: readonly ["not_requested", "declare", "already_off", "unjudged"];
+export type FileHistoryTightenVerdict = (typeof FILE_HISTORY_TIGHTEN_VERDICTS)[number];
+export declare function fileHistoryTightenVerdict(reading: FileHistoryCaptureReading, captureOffByUser: boolean): FileHistoryTightenVerdict;
+export declare function fileHistoryUnjudgedRefusal(reading: FileHistoryCaptureReading, captureOffByUser: boolean): string | undefined;
+export interface FileHistoryTightenJudgement {
+    readonly verdict: FileHistoryTightenVerdict;
+    readonly reading: FileHistoryCaptureReading;
+    readonly refreshed: boolean;
+    readonly refusal: string | undefined;
+}
+export declare function judgeFileHistoryTighten(captureOffByUser: boolean, opts?: {
+    baseUrl?: string;
+    withinMs?: number;
+}): Promise<FileHistoryTightenJudgement>;
 export declare function fileHistoryCaptureDoctorDetail(reading: FileHistoryCaptureReading): string;
 export declare function __resetFileHistoryCaptureReadingsForTests(): void;

package/dist/fileHistoryCaptureCapability.js

@@ -1,6 +1,7 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { refreshEngineCapsOnce } from './engineCapsCache.js';
 import { ownDataField } from './ownKey.js';
 import { FILE_HISTORY_DISABLED } from './request/taskRequest.js';
 export function projectFileHistoryCaptureCapability(caps) {
@@ -52,6 +53,75 @@ export function fileHistoryCaptureMode(reading) {
 export function fileHistoryDeclarationField(reading, captureOff) {
     return captureOff === true && fileHistoryCaptureMode(reading) === 'on-optional' ? { fileHistory: FILE_HISTORY_DISABLED } : {};
 }
+export const FILE_HISTORY_TIGHTEN_VERDICTS = Object.freeze(['not_requested', 'declare', 'already_off', 'unjudged']);
+export function fileHistoryTightenVerdict(reading, captureOffByUser) {
+    if (captureOffByUser !== true)
+        return 'not_requested';
+    const mode = fileHistoryCaptureMode(reading);
+    if (mode === 'on-optional')
+        return 'declare';
+    if (mode === 'off')
+        return 'already_off';
+    return 'unjudged';
+}
+const FILE_HISTORY_UNJUDGED_REFUSAL = 'Nothing was sent: file checkpointing is turned off in your settings, but this engine did not report whether it can ' +
+    'stop recording file history for a session, so sending now could record it anyway. Try again in a moment; to send ' +
+    'regardless and let file history be recorded this time, turn file checkpointing back on in your settings.';
+export function fileHistoryUnjudgedRefusal(reading, captureOffByUser) {
+    return fileHistoryTightenVerdict(reading, captureOffByUser) === 'unjudged' ? FILE_HISTORY_UNJUDGED_REFUSAL : undefined;
+}
+const FILE_HISTORY_REFRESH_WITHIN_MS = 3000;
+export async function judgeFileHistoryTighten(captureOffByUser, opts) {
+    const closed = captureOffByUser === true;
+    const failClosed = () => {
+        const reading = { kind: 'unobserved' };
+        return closed
+            ? { verdict: 'unjudged', reading, refreshed: false, refusal: FILE_HISTORY_UNJUDGED_REFUSAL }
+            : { verdict: 'not_requested', reading, refreshed: false, refusal: undefined };
+    };
+    try {
+        let explicitBase;
+        let withinMs = FILE_HISTORY_REFRESH_WITHIN_MS;
+        if (typeof opts === 'object' && opts !== null) {
+            try {
+                const b = opts.baseUrl;
+                if (b !== undefined) {
+                    if (typeof b !== 'string' || b === '')
+                        return failClosed();
+                    explicitBase = b;
+                }
+            }
+            catch {
+                return failClosed();
+            }
+            try {
+                const w = opts.withinMs;
+                if (w !== undefined)
+                    withinMs = typeof w === 'number' ? w : 0;
+            }
+            catch {
+                withinMs = 0;
+            }
+        }
+        const baseUrl = explicitBase ?? engineWireTarget()?.baseUrl;
+        const first = observedFileHistoryCapture(baseUrl);
+        const v1 = fileHistoryTightenVerdict(first, captureOffByUser);
+        if (v1 !== 'unjudged')
+            return { verdict: v1, reading: first, refreshed: false, refusal: undefined };
+        const outcome = await refreshEngineCapsOnce(baseUrl, { withinMs });
+        const second = observedFileHistoryCapture(baseUrl);
+        const v2 = fileHistoryTightenVerdict(second, captureOffByUser);
+        return {
+            verdict: v2,
+            reading: second,
+            refreshed: outcome !== 'no_probe',
+            refusal: v2 === 'unjudged' ? FILE_HISTORY_UNJUDGED_REFUSAL : undefined,
+        };
+    }
+    catch {
+        return failClosed();
+    }
+}
 const WORD_DETAIL_MAX = 40;
 export function fileHistoryCaptureDoctorDetail(reading) {
     const unobserved = 'file history capture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment captures file history is unknown';

package/dist/fleet/bgSubagentRow.d.ts

@@ -0,0 +1,15 @@
+import type { FleetTaskRow } from '@sema-agent/sdk';
+export declare const DURABLE_AGENT_HANDLE_RE: RegExp;
+export declare function isAgentHandle(rowId: string): boolean;
+export type NonAgentHandleKind = 'background_bash' | 'monitor';
+export declare function nonAgentHandleKind(rowId: string): NonAgentHandleKind | null;
+export type BgSubagentRowFacts = Pick<FleetTaskRow, 'id' | 'parentId' | 'sourceLane'>;
+export declare function isBackgroundSubagentRow(row: BgSubagentRowFacts): boolean;
+export declare function isBackgroundWorkRow(row: BgSubagentRowFacts): boolean;
+export interface BgRowOwnership {
+    readonly scoped: boolean;
+    readonly isOwnRun: (taskIdTail: string) => boolean;
+}
+export declare function liveBgRowOwnership(): BgRowOwnership;
+export declare function liveBgRowOwnershipFor(sessionKey: string): BgRowOwnership;
+export declare function isOwnBackgroundSubagentRow(row: BgSubagentRowFacts, own: BgRowOwnership): boolean;

package/dist/fleet/bgSubagentRow.js

@@ -0,0 +1,67 @@
+import { CORE_DURABLE_AGENT_HANDLE_RE, CORE_TASK_HANDLE_PREFIXES } from '../generated/engineFactTables.js';
+import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
+import { isOwnEngineRun } from '../subagentContentStore.js';
+import { isWorkflowAgentTaskId, rowIdTail } from '../workflow.js';
+import { isFleetSessionScopedFor } from './fleetLedger.js';
+import { wireParentId } from './fleetProjection.js';
+const _taskTypePins = [true, true];
+void _taskTypePins;
+export const DURABLE_AGENT_HANDLE_RE = CORE_DURABLE_AGENT_HANDLE_RE;
+export function isAgentHandle(rowId) {
+    if (typeof rowId !== 'string' || rowId.length === 0)
+        return false;
+    if (rowIdTail(rowId) !== rowId)
+        return false;
+    return DURABLE_AGENT_HANDLE_RE.test(rowId) || isWorkflowAgentTaskId(rowId);
+}
+const NON_AGENT_HANDLE_TYPES = ['background_bash', 'monitor'];
+export function nonAgentHandleKind(rowId) {
+    if (typeof rowId !== 'string')
+        return null;
+    const prefix = /^([a-z])[0-9a-f]{16}$/.exec(rowIdTail(rowId))?.[1];
+    if (prefix === undefined)
+        return null;
+    for (const type of NON_AGENT_HANDLE_TYPES)
+        if (CORE_TASK_HANDLE_PREFIXES[type] === prefix)
+            return type;
+    return null;
+}
+const RUN_LEG_LANE = 'run-leg';
+function isForegroundDelegationRow(row) {
+    return rowIdTail(row.id) !== row.id || row.sourceLane === RUN_LEG_LANE;
+}
+function hasRowId(row) {
+    return typeof row?.id === 'string' && row.id.length > 0;
+}
+export function isBackgroundSubagentRow(row) {
+    if (!hasRowId(row))
+        return false;
+    if (isForegroundDelegationRow(row))
+        return false;
+    if (nonAgentHandleKind(row.id) !== null)
+        return false;
+    if (wireParentId(row) !== undefined)
+        return true;
+    return isAgentHandle(row.id);
+}
+export function isBackgroundWorkRow(row) {
+    if (isBackgroundSubagentRow(row))
+        return true;
+    if (!hasRowId(row))
+        return false;
+    return !isForegroundDelegationRow(row) && nonAgentHandleKind(row.id) !== null;
+}
+export function liveBgRowOwnership() {
+    return liveBgRowOwnershipFor(DEFAULT_SESSION_KEY);
+}
+export function liveBgRowOwnershipFor(sessionKey) {
+    return { scoped: isFleetSessionScopedFor(sessionKey), isOwnRun: isOwnEngineRun };
+}
+export function isOwnBackgroundSubagentRow(row, own) {
+    if (!isBackgroundSubagentRow(row))
+        return false;
+    if (own.scoped)
+        return true;
+    const parentId = wireParentId(row);
+    return own.isOwnRun(rowIdTail(row.id)) || (parentId !== undefined && own.isOwnRun(rowIdTail(parentId)));
+}

package/dist/fleet/fleetLedger.d.ts

@@ -6,6 +6,7 @@ export interface EngineActiveBgTask {
     name?: string;
     status: string;
     parentId?: string;
+    sourceLane?: string;
     retiredByNotification?: boolean;
 }
 export interface EngineActiveBgReading {