@sema-agent/client-core 0.112.1 → 0.113.0

package/dist/attachmentOutcome.d.ts

@@ -0,0 +1,35 @@
+import type { UserAttachment } from '@sema-agent/sdk';
+import type { UiLanguage } from './env/uiLanguage.js';
+import { type CORE_USER_ATTACHMENT_SUPPLIES } from './generated/engineFactTables.js';
+import { type HumanInputAttachmentDeclinedByView, type HumanInputAttachmentView } from './ownKey.js';
+import type { UserAttachmentRefusalDetail } from './wireRefusalCopy.js';
+export declare const ATTACHMENT_OUTCOMES: readonly ["attached", "partial", "not_attached", "refused", "unknown"];
+export type AttachmentOutcome = (typeof ATTACHMENT_OUTCOMES)[number];
+export type AttachmentSupply = (typeof CORE_USER_ATTACHMENT_SUPPLIES)[number];
+export interface AttachmentOutcomeRow {
+    readonly uuid: string;
+    readonly outcome: AttachmentOutcome;
+    readonly supply: AttachmentSupply;
+    readonly engineOutcome?: string;
+    readonly kind?: string;
+    readonly declinedBy?: HumanInputAttachmentDeclinedByView;
+    readonly named?: true;
+}
+export interface AttachmentOutcomesSent {
+    readonly userAttachments?: readonly UserAttachment[];
+    readonly userAttachmentOrdinals?: readonly string[];
+    readonly inputId?: string;
+}
+export interface AttachmentOutcomesReport {
+    readonly rows?: readonly HumanInputAttachmentView[];
+    readonly refusal?: UserAttachmentRefusalDetail | null;
+    readonly inputId?: string;
+}
+export declare function attachmentOutcomesOf(sent: AttachmentOutcomesSent, report: AttachmentOutcomesReport): {
+    rows: readonly AttachmentOutcomeRow[];
+    refusalNoteFacts?: {
+        index: number;
+        namedSupply: AttachmentSupply;
+    };
+};
+export declare function attachmentOutcomeText(row: AttachmentOutcomeRow, lang?: UiLanguage): string;

package/dist/attachmentOutcome.js

@@ -0,0 +1,192 @@
+import { USER_ATTACHMENT_INVALID_ERROR_CODE } from './engineErrorCodes.js';
+import { CORE_USER_ATTACHMENT_KINDS } from './generated/engineFactTables.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { appendOwnElement, guardedRead, humanInputAttachmentsOf, ownDataField, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { showAttachmentName } from './userAttachmentEnvelope.js';
+export const ATTACHMENT_OUTCOMES = Object.freeze(['attached', 'partial', 'not_attached', 'refused', 'unknown']);
+const _engineWordsPinned = true;
+const _contentKindsPinned = true;
+void _engineWordsPinned;
+void _contentKindsPinned;
+const SENT_ENTRIES_MAX = 256;
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function supplyOf(entry) {
+    if (!isRecord(entry))
+        return undefined;
+    const isPath = typeof readOwnDataValue(entry, 'path') === 'string';
+    const isText = typeof readOwnDataValue(entry, 'text') === 'string';
+    const image = readOwnDataValue(entry, 'image');
+    const isImage = typeof image === 'object' && image !== null;
+    if (Number(isPath) + Number(isText) + Number(isImage) !== 1)
+        return undefined;
+    return isPath ? 'path' : isText ? 'content_text' : 'content_image';
+}
+function sentEntriesOf(sent) {
+    try {
+        if (!isRecord(sent))
+            return [];
+        const ua = readOwnDataValue(sent, 'userAttachments');
+        const ord = readOwnDataValue(sent, 'userAttachmentOrdinals');
+        if (!Array.isArray(ua) || !Array.isArray(ord))
+            return [];
+        const n = readOwnDataFiniteNumber(ua, 'length');
+        const k = readOwnDataFiniteNumber(ord, 'length');
+        if (n === undefined || n !== k || !Number.isSafeInteger(n) || n > SENT_ENTRIES_MAX)
+            return [];
+        const out = [];
+        for (let i = 0; i < n; i += 1) {
+            const uuid = readOwnDataNonEmptyString(ord, String(i));
+            const supply = supplyOf(readOwnDataValue(ua, String(i)));
+            if (uuid === undefined || supply === undefined)
+                return [];
+            appendOwnElement(out, Object.freeze({ uuid, supply }));
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+function refusalReadingOf(refusal) {
+    try {
+        if (refusal === undefined || refusal === null)
+            return { state: 'none' };
+        if (!isRecord(refusal) || readOwnDataValue(refusal, 'code') !== USER_ATTACHMENT_INVALID_ERROR_CODE)
+            return { state: 'bad' };
+        const index = readOwnDataFiniteNumber(refusal, 'index');
+        return { state: 'refused', index: index !== undefined && Number.isSafeInteger(index) && index >= 0 ? index : undefined };
+    }
+    catch {
+        return { state: 'bad' };
+    }
+}
+function identityOf(holder) {
+    try {
+        if (!isRecord(holder))
+            return { state: 'absent' };
+        const raw = readOwnDataValue(holder, 'inputId');
+        if (raw === undefined)
+            return { state: 'absent' };
+        return typeof raw === 'string' && raw !== '' ? { state: 'id', id: raw } : { state: 'bad' };
+    }
+    catch {
+        return { state: 'bad' };
+    }
+}
+function identityMismatch(a, b) {
+    if (a.state === 'bad' || b.state === 'bad')
+        return true;
+    return a.state === 'id' && b.state === 'id' && a.id !== b.id;
+}
+function engineWordOf(raw) {
+    switch (raw) {
+        case 'attached':
+            return 'attached';
+        case 'partial':
+            return 'partial';
+        case 'not_attached':
+            return 'not_attached';
+        default:
+            return undefined;
+    }
+}
+function kindOpposesSupply(kind, supply) {
+    if (kind === undefined)
+        return false;
+    if (kind === 'client_text' || kind === 'client_image')
+        return supply === 'path';
+    return CORE_USER_ATTACHMENT_KINDS.includes(kind) && supply !== 'path';
+}
+const rowOf = (fields) => Object.freeze(fields);
+const rowsOf = (rows) => Object.freeze(rows);
+const unknownRow = (e) => rowOf({ uuid: e.uuid, outcome: 'unknown', supply: e.supply });
+function rowsFromReport(entries, rows) {
+    if (rows === undefined)
+        return entries.map(unknownRow);
+    for (const r of rows) {
+        const at = entries[r.ordinal - 1];
+        if (at === undefined || kindOpposesSupply(r.kind, at.supply))
+            return entries.map(unknownRow);
+    }
+    return entries.map((e, i) => {
+        const hits = rows.filter((r) => r.ordinal === i + 1);
+        const first = hits[0];
+        if (first === undefined || hits.some((h) => h.outcome !== first.outcome))
+            return unknownRow(e);
+        const word = engineWordOf(first.outcome);
+        if (word === undefined)
+            return rowOf({ uuid: e.uuid, outcome: 'unknown', supply: e.supply, engineOutcome: first.outcome, ...(first.kind !== undefined ? { kind: first.kind } : {}) });
+        return rowOf({
+            uuid: e.uuid,
+            outcome: word,
+            supply: e.supply,
+            ...(first.kind !== undefined ? { kind: first.kind } : {}),
+            ...(word === 'not_attached' && first.declinedBy !== undefined ? { declinedBy: first.declinedBy } : {}),
+        });
+    });
+}
+export function attachmentOutcomesOf(sent, report) {
+    try {
+        const entries = sentEntriesOf(sent);
+        if (entries.length === 0)
+            return Object.freeze({ rows: rowsOf([]) });
+        let rawRefusal;
+        try {
+            rawRefusal = isRecord(report) ? ownDataField(report, 'refusal') : undefined;
+        }
+        catch {
+            return Object.freeze({ rows: rowsOf(entries.map(unknownRow)) });
+        }
+        const refusal = refusalReadingOf(rawRefusal);
+        if (refusal.state === 'bad')
+            return Object.freeze({ rows: rowsOf(entries.map(unknownRow)) });
+        if (refusal.state === 'refused') {
+            const { index } = refusal;
+            const rows = rowsOf(entries.map((e, i) => rowOf({ uuid: e.uuid, outcome: 'refused', supply: e.supply, ...(i === index ? { named: true } : {}) })));
+            const named = index === undefined ? undefined : entries[index];
+            return index !== undefined && named !== undefined ? Object.freeze({ rows, refusalNoteFacts: Object.freeze({ index, namedSupply: named.supply }) }) : Object.freeze({ rows });
+        }
+        if (identityMismatch(identityOf(sent), identityOf(report)))
+            return Object.freeze({ rows: rowsOf(entries.map(unknownRow)) });
+        const raw = guardedRead(() => (isRecord(report) ? readOwnDataValue(report, 'rows') : undefined));
+        const read = raw === undefined ? undefined : humanInputAttachmentsOf({ attachments: raw });
+        return Object.freeze({ rows: rowsOf(rowsFromReport(entries, read)) });
+    }
+    catch {
+        return Object.freeze({ rows: rowsOf([]) });
+    }
+}
+function outcomeOfRow(row) {
+    const raw = guardedRead(() => (isRecord(row) ? readOwnDataNonEmptyString(row, 'outcome') : undefined));
+    return ATTACHMENT_OUTCOMES.find((w) => w === raw) ?? 'unknown';
+}
+function namedOfRow(row) {
+    return guardedRead(() => (isRecord(row) ? readOwnDataValue(row, 'named') === true : undefined)) === true;
+}
+function declinerNameOf(row) {
+    return guardedRead(() => {
+        const d = isRecord(row) ? readOwnDataValue(row, 'declinedBy') : undefined;
+        return isRecord(d) && readOwnDataValue(d, 'kind') === 'extension' ? readOwnDataNonEmptyString(d, 'name') : undefined;
+    });
+}
+export function attachmentOutcomeText(row, lang) {
+    try {
+        switch (outcomeOfRow(row)) {
+            case 'attached':
+                return renderMessage(msg('attachments.outcome.attached.row'), lang);
+            case 'partial':
+                return renderMessage(msg('attachments.outcome.partial.row'), lang);
+            case 'not_attached': {
+                const name = declinerNameOf(row);
+                return name !== undefined ? renderMessage(msg('attachments.outcome.notAttachedDeclined.row', { name: showAttachmentName(name) }), lang) : renderMessage(msg('attachments.outcome.notAttached.row'), lang);
+            }
+            case 'refused':
+                return namedOfRow(row) ? renderMessage(msg('attachments.outcome.refusedNamed.row'), lang) : renderMessage(msg('attachments.outcome.refused.row'), lang);
+            default:
+                return renderMessage(msg('attachments.outcome.unknown.row'), lang);
+        }
+    }
+    catch {
+        return renderMessage(msg('attachments.outcome.unknown.row'), lang);
+    }
+}

package/dist/attachmentPathPlan.d.ts

@@ -0,0 +1,67 @@
+import type { UserAttachment } from '@sema-agent/sdk';
+import type { UserAttachmentSeatLimits, UserAttachmentSeatReading } from './userAttachmentSeat.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+import { type AttachmentRouteLeg, type AttachmentWithheldReason, type ToolsLocation } from './attachmentRoute.js';
+export type UserAttachmentPathEntry = Extract<UserAttachment, {
+    path: string;
+}>;
+export type AttachmentPathOverflow = 'seat_count' | 'lines_invalid' | 'path_invalid';
+export type AttachmentPathPlan = {
+    readonly admitted: readonly {
+        readonly uuid: string;
+        readonly entry: UserAttachmentPathEntry;
+    }[];
+    readonly overflow: readonly {
+        readonly uuid: string;
+        readonly why: AttachmentPathOverflow;
+    }[];
+} | {
+    readonly reject: 'malformed_input' | 'duplicate_uuid';
+};
+export type PathEntryVerdict = {
+    readonly entry: UserAttachmentPathEntry;
+} | {
+    readonly why: 'path_invalid' | 'lines_invalid';
+};
+export declare function pathEntryOf(o: object): PathEntryVerdict;
+export declare function presentSeatLimitsOf(reading: UserAttachmentSeatReading | {} | null | undefined): UserAttachmentSeatLimits | undefined;
+export declare function attachmentPathPlanOf(input: {
+    readonly seat?: UserAttachmentSeatReading | undefined;
+    readonly candidates: readonly (UserAttachmentPathEntry & {
+        readonly uuid: string;
+    })[];
+}): AttachmentPathPlan;
+export declare function attachmentPathOverflowText(why: AttachmentPathOverflow, lang?: UiLanguage): string | undefined;
+export interface AttachmentRouteBatch {
+    readonly toolsLocation: ToolsLocation;
+    readonly seat?: UserAttachmentSeatReading;
+    readonly scenario?: {} | null;
+    readonly lane: 'objective' | 'steer';
+    readonly items: readonly ({
+        readonly uuid: string;
+        readonly leg: AttachmentRouteLeg;
+    } & Partial<UserAttachmentPathEntry>)[];
+}
+export type AttachmentRouteStep = {
+    readonly uuid: string;
+    readonly action: 'send_path';
+    readonly entry: UserAttachmentPathEntry;
+} | {
+    readonly uuid: string;
+    readonly action: 'read_local';
+    readonly localCopy: boolean;
+    readonly pathFallback?: AttachmentPathOverflow;
+} | {
+    readonly uuid: string;
+    readonly action: 'withhold';
+    readonly reason: AttachmentWithheldReason;
+    readonly pathFallback?: AttachmentPathOverflow;
+};
+export type AttachmentRoutePlan = {
+    readonly ok: true;
+    readonly steps: readonly AttachmentRouteStep[];
+} | {
+    readonly ok: false;
+    readonly reject: 'malformed_input' | 'duplicate_uuid';
+};
+export declare function attachmentRoutePlanOf(batch: AttachmentRouteBatch): AttachmentRoutePlan;

package/dist/attachmentPathPlan.js

@@ -0,0 +1,203 @@
+import { CORE_USER_ATTACHMENT_LABEL_MAX } from './generated/engineFactTables.js';
+import { appendOwnElement } from './ownKey.js';
+import { attachmentRouteOf } from './attachmentRoute.js';
+import { msg, renderMessage } from './i18n/translate.js';
+function isPlainObject(x) {
+    if (x === null || typeof x !== 'object' || Array.isArray(x))
+        return false;
+    const p = Object.getPrototypeOf(x);
+    return p === Object.prototype || p === null;
+}
+function slotOf(o, key) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(o, key);
+        if (d === undefined)
+            return { value: undefined };
+        return Object.hasOwn(d, 'value') ? { value: d.value } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const positiveSafeInt = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v >= 1;
+export function pathEntryOf(o) {
+    const pathSlot = slotOf(o, 'path');
+    const path = pathSlot?.value;
+    if (typeof path !== 'string' || path.length === 0 || path.length > CORE_USER_ATTACHMENT_LABEL_MAX)
+        return { why: 'path_invalid' };
+    const linesSlot = slotOf(o, 'lines');
+    if (linesSlot === undefined)
+        return { why: 'lines_invalid' };
+    const lines = linesSlot.value;
+    if (lines === undefined)
+        return { entry: { path } };
+    if (!isPlainObject(lines))
+        return { why: 'lines_invalid' };
+    const start = slotOf(lines, 'start')?.value;
+    const endSlot = slotOf(lines, 'end');
+    if (!positiveSafeInt(start) || endSlot === undefined)
+        return { why: 'lines_invalid' };
+    const end = endSlot.value;
+    if (end === undefined)
+        return { entry: { path, lines: { start } } };
+    if (!positiveSafeInt(end) || end < start)
+        return { why: 'lines_invalid' };
+    return { entry: { path, lines: { start, end } } };
+}
+export function presentSeatLimitsOf(reading) {
+    try {
+        if (reading === null || typeof reading !== 'object' || Array.isArray(reading))
+            return undefined;
+        if (slotOf(reading, 'kind')?.value !== 'present')
+            return undefined;
+        const limits = slotOf(reading, 'limits')?.value;
+        if (!isPlainObject(limits))
+            return undefined;
+        const maxEntries = slotOf(limits, 'maxEntries')?.value;
+        const maxRenderedTextChars = slotOf(limits, 'maxRenderedTextChars')?.value;
+        return positiveSafeInt(maxEntries) && positiveSafeInt(maxRenderedTextChars) ? { maxEntries, maxRenderedTextChars } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function ownElements(x) {
+    try {
+        if (!Array.isArray(x))
+            return undefined;
+        const n = slotOf(x, 'length')?.value;
+        if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
+            return undefined;
+        const out = [];
+        for (let i = 0; i < n; i += 1) {
+            const d = Object.getOwnPropertyDescriptor(x, i);
+            if (d === undefined || !Object.hasOwn(d, 'value'))
+                return undefined;
+            appendOwnElement(out, d.value);
+        }
+        return out;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function attachmentPathPlanOf(input) {
+    try {
+        if (!isPlainObject(input))
+            return { reject: 'malformed_input' };
+        const seatSlot = slotOf(input, 'seat');
+        const limits = seatSlot === undefined ? undefined : presentSeatLimitsOf(seatSlot.value);
+        const candidatesSlot = slotOf(input, 'candidates');
+        const raw = candidatesSlot === undefined ? undefined : ownElements(candidatesSlot.value);
+        if (raw === undefined)
+            return { reject: 'malformed_input' };
+        const read = [];
+        const seen = new Set();
+        for (const c of raw) {
+            if (!isPlainObject(c))
+                return { reject: 'malformed_input' };
+            const uuid = slotOf(c, 'uuid')?.value;
+            if (typeof uuid !== 'string' || uuid.length === 0)
+                return { reject: 'malformed_input' };
+            if (seen.has(uuid))
+                return { reject: 'duplicate_uuid' };
+            seen.add(uuid);
+            read.push({ uuid, verdict: pathEntryOf(c) });
+        }
+        const admitted = [];
+        const overflow = [];
+        for (const { uuid, verdict } of read) {
+            if ('why' in verdict)
+                appendOwnElement(overflow, { uuid, why: verdict.why });
+            else if (admitted.length >= (limits?.maxEntries ?? 0))
+                appendOwnElement(overflow, { uuid, why: 'seat_count' });
+            else
+                appendOwnElement(admitted, { uuid, entry: verdict.entry });
+        }
+        return { admitted, overflow };
+    }
+    catch {
+        return { reject: 'malformed_input' };
+    }
+}
+const OVERFLOW_ROW_KEYS = {
+    seat_count: 'attachments.pathOverflow.seatCount.row',
+    lines_invalid: 'attachments.pathOverflow.linesInvalid.row',
+    path_invalid: 'attachments.pathOverflow.pathInvalid.row',
+};
+export function attachmentPathOverflowText(why, lang) {
+    if (typeof why !== 'string' || !Object.hasOwn(OVERFLOW_ROW_KEYS, why))
+        return undefined;
+    return renderMessage(msg(OVERFLOW_ROW_KEYS[why]), lang);
+}
+function rejectPlan(reject) {
+    const plan = { ok: false, reject };
+    return Object.freeze(plan);
+}
+function fallbackStep(uuid, fallback, why) {
+    const tail = why === undefined ? {} : { pathFallback: why };
+    const step = fallback.route === 'attach_content' ? { uuid, action: 'read_local', localCopy: fallback.localCopy, ...tail } : { uuid, action: 'withhold', reason: fallback.reason, ...tail };
+    return Object.freeze(step);
+}
+const valueOf = (slot) => slot?.value;
+function factsOf(leg, toolsLocation, seat, scenario, lane) {
+    return {
+        leg: leg,
+        toolsLocation: toolsLocation,
+        ...(seat !== undefined ? { seat: seat } : {}),
+        ...(scenario !== undefined ? { scenario: scenario } : {}),
+        ...(lane !== undefined ? { lane: lane } : {}),
+    };
+}
+export function attachmentRoutePlanOf(batch) {
+    try {
+        if (!isPlainObject(batch))
+            return rejectPlan('malformed_input');
+        const itemsSlot = slotOf(batch, 'items');
+        const raw = itemsSlot === undefined ? undefined : ownElements(itemsSlot.value);
+        if (raw === undefined)
+            return rejectPlan('malformed_input');
+        const toolsLocation = valueOf(slotOf(batch, 'toolsLocation'));
+        const seat = valueOf(slotOf(batch, 'seat'));
+        const scenario = valueOf(slotOf(batch, 'scenario'));
+        const lane = valueOf(slotOf(batch, 'lane'));
+        const read = [];
+        const seen = new Set();
+        for (const it of raw) {
+            if (!isPlainObject(it))
+                return rejectPlan('malformed_input');
+            const uuid = slotOf(it, 'uuid')?.value;
+            if (typeof uuid !== 'string' || uuid.length === 0)
+                return rejectPlan('malformed_input');
+            if (seen.has(uuid))
+                return rejectPlan('duplicate_uuid');
+            seen.add(uuid);
+            const linesSlot = slotOf(it, 'lines');
+            read.push({ uuid, leg: slotOf(it, 'leg')?.value, candidate: { uuid, path: slotOf(it, 'path')?.value, lines: linesSlot === undefined ? null : linesSlot.value } });
+        }
+        const routes = read.map((r) => attachmentRouteOf(factsOf(r.leg, toolsLocation, seat, scenario, lane)));
+        const toPlan = read.filter((_, i) => routes[i]?.route === 'attach_path').map((r) => r.candidate);
+        const plan = attachmentPathPlanOf({ ...(seat !== undefined ? { seat: seat } : {}), candidates: toPlan });
+        if ('reject' in plan)
+            return rejectPlan('malformed_input');
+        const admitted = new Map(plan.admitted.map((a) => [a.uuid, a.entry]));
+        const overflow = new Map(plan.overflow.map((o) => [o.uuid, o.why]));
+        const steps = read.map((r, i) => {
+            const route = routes[i];
+            if (route.route !== 'attach_path')
+                return fallbackStep(r.uuid, route, undefined);
+            const entry = admitted.get(r.uuid);
+            if (entry === undefined)
+                return fallbackStep(r.uuid, route.otherwise, overflow.get(r.uuid));
+            if (entry.lines !== undefined)
+                Object.freeze(entry.lines);
+            const step = { uuid: r.uuid, action: 'send_path', entry: Object.freeze(entry) };
+            return Object.freeze(step);
+        });
+        const done = { ok: true, steps: Object.freeze(steps) };
+        return Object.freeze(done);
+    }
+    catch {
+        return rejectPlan('malformed_input');
+    }
+}

package/dist/attachmentRoute.d.ts

@@ -1,4 +1,5 @@
 import type { UiLanguage } from './env/uiLanguage.js';
+import { type UserAttachmentSeatReading } from './userAttachmentSeat.js';
 export declare const TOOLS_LOCATIONS: readonly ["this-machine", "elsewhere", "unconfirmed"];
 export type ToolsLocation = (typeof TOOLS_LOCATIONS)[number];
 export declare const ATTACHMENT_ROUTE_LEGS: readonly ["at_mention", "edited_file", "paste", "ide_selection"];
@@ -6,15 +7,22 @@ export type AttachmentRouteLeg = (typeof ATTACHMENT_ROUTE_LEGS)[number];
 export interface AttachmentRouteFacts {
     readonly leg: AttachmentRouteLeg;
     readonly toolsLocation: ToolsLocation;
+    readonly seat?: UserAttachmentSeatReading;
+    readonly scenario?: {} | null;
+    readonly lane?: 'objective' | 'steer';
 }
 export type AttachmentWithheldReason = 'tools-elsewhere' | 'tools-location-unconfirmed';
-export type AttachmentRoute = {
+export type AttachmentRouteFallback = {
     readonly route: 'attach_content';
     readonly localCopy: boolean;
 } | {
     readonly route: 'withhold';
     readonly reason: AttachmentWithheldReason;
 };
+export type AttachmentRoute = AttachmentRouteFallback | {
+    readonly route: 'attach_path';
+    readonly otherwise: AttachmentRouteFallback;
+};
 export declare function attachmentRouteOf(facts: AttachmentRouteFacts): AttachmentRoute;
 export declare function attachmentWithheldReasonText(reason: AttachmentWithheldReason, lang?: UiLanguage): string;
 export declare function attachmentLocalCopyNote(): string;

package/dist/attachmentRoute.js

@@ -1,5 +1,6 @@
 import { msg, renderMessage } from './i18n/translate.js';
-import { readOwnDataNonEmptyString } from './ownKey.js';
+import { readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { userAttachmentSeatAdmits } from './userAttachmentSeat.js';
 export const TOOLS_LOCATIONS = Object.freeze(['this-machine', 'elsewhere', 'unconfirmed']);
 export const ATTACHMENT_ROUTE_LEGS = Object.freeze(['at_mention', 'edited_file', 'paste', 'ide_selection']);
 const _withheldReasonsPinned = true;
@@ -8,6 +9,8 @@ const ATTACH = Object.freeze({ route: 'attach_content', localCopy: false });
 const ATTACH_LOCAL_COPY = Object.freeze({ route: 'attach_content', localCopy: true });
 const WITHHOLD_ELSEWHERE = Object.freeze({ route: 'withhold', reason: 'tools-elsewhere' });
 const WITHHOLD_UNCONFIRMED = Object.freeze({ route: 'withhold', reason: 'tools-location-unconfirmed' });
+const PATH_OR_WITHHOLD_ELSEWHERE = Object.freeze({ route: 'attach_path', otherwise: WITHHOLD_ELSEWHERE });
+const PATH_OR_WITHHOLD_UNCONFIRMED = Object.freeze({ route: 'attach_path', otherwise: WITHHOLD_UNCONFIRMED });
 const SNAPSHOT_LEGS = new Set(['paste', 'ide_selection']);
 function closedWord(facts, key, words) {
     try {
@@ -20,6 +23,21 @@ function closedWord(facts, key, words) {
         return undefined;
     }
 }
+function enginePathAdmitted(facts) {
+    try {
+        if (typeof facts !== 'object' || facts === null)
+            return false;
+        const seat = readOwnDataValue(facts, 'seat');
+        if (seat === undefined)
+            return false;
+        const scenario = readOwnDataValue(facts, 'scenario');
+        const lane = readOwnDataValue(facts, 'lane');
+        return userAttachmentSeatAdmits(seat, { supply: 'path', ...(scenario === undefined ? {} : { scenario }), ...(lane === undefined ? {} : { lane }) }) === 'yes';
+    }
+    catch {
+        return false;
+    }
+}
 export function attachmentRouteOf(facts) {
     const where = closedWord(facts, 'toolsLocation', TOOLS_LOCATIONS);
     if (where === 'this-machine')
@@ -27,7 +45,10 @@ export function attachmentRouteOf(facts) {
     const leg = closedWord(facts, 'leg', ATTACHMENT_ROUTE_LEGS);
     if (leg !== undefined && SNAPSHOT_LEGS.has(leg))
         return ATTACH_LOCAL_COPY;
-    return where === 'elsewhere' ? WITHHOLD_ELSEWHERE : WITHHOLD_UNCONFIRMED;
+    const elsewhere = where === 'elsewhere';
+    if (leg === 'at_mention' && enginePathAdmitted(facts))
+        return elsewhere ? PATH_OR_WITHHOLD_ELSEWHERE : PATH_OR_WITHHOLD_UNCONFIRMED;
+    return elsewhere ? WITHHOLD_ELSEWHERE : WITHHOLD_UNCONFIRMED;
 }
 export function attachmentWithheldReasonText(reason, lang) {
     return reason === 'tools-elsewhere'

package/dist/declared/supportFloorDeclared.d.ts

@@ -1 +1 @@
-export declare const DECLARED_SUPPORT_FLOOR: Readonly<Record<"server" | "core" | "sdk", string>>;
+export declare const DECLARED_SUPPORT_FLOOR: Readonly<Record<"server" | "core" | "sdk" | "settingsContract", string>>;

package/dist/declared/supportFloorDeclared.js

@@ -2,4 +2,5 @@ export const DECLARED_SUPPORT_FLOOR = Object.freeze({
     server: "7.139.0",
     core: "7.60.0",
     sdk: "25.0.0",
+    settingsContract: "15.1.0",
 });

package/dist/deviceRebind.js

@@ -1,6 +1,6 @@
 import { atMostOnceVerdictOf } from './atMostOnce.js';
 import { readOwnDataValue } from './ownKey.js';
-import { LIMIT_RATE_EXCEEDED } from './engineErrorCodes.js';
+import { LIMIT_RATE_EXCEEDED, ROUTE_NOT_FOUND } from './engineErrorCodes.js';
 import { isDisplayableWireCode, readErrorString, readErrorStrictStringList, readThrownSlot, wireFailureShapeOf } from './wireFailureShape.js';
 import { EXECUTION_PLACEMENT_DEVICE_LANE, EXECUTION_PLACEMENT_ROLES } from './executionPlacementWords.js';
 const LANE_ABSENT = 'capability.device_lane_required';
@@ -8,7 +8,6 @@ const RUN_STORE_ABSENT = 'capability.run_store_required';
 const NOT_FOUND = 'not_found.device';
 const ACTIVE_RUN = 'device.rebind_active_run';
 const SESSION_NOT_FOUND = 'not_found.session';
-const ROUTE_ABSENT = 'not_found.route';
 const SESSION_STORE_ABSENT = 'capability.session_store_required';
 const REV_CONFLICT = 'device.rebind_rev_conflict';
 const SERVICE_TOKEN_REQUIRED = 'auth.service_token_required';
@@ -134,7 +133,7 @@ function placementReadFailureOf(e) {
     const v = atMostOnceVerdictOf(e);
     if (v.status === 404 && v.code === SESSION_NOT_FOUND)
         return { kind: 'not-found' };
-    if (v.status === 404 && v.code === ROUTE_ABSENT)
+    if (v.status === 404 && v.code === ROUTE_NOT_FOUND)
         return { kind: 'unsupported', reason: 'route' };
     if (v.status === 501 && v.code === SESSION_STORE_ABSENT)
         return { kind: 'unsupported', reason: 'capability' };