@cspeach/cli 1.1.18 → 1.1.19

package/dist/tools/transport-fit.js

@@ -0,0 +1,462 @@
+/**
+ * transport-fit — which open requests can take an object of a given package
+ * (fix round 3, item 9e; fix round 4, item 3).
+ *
+ * Live defect: sap_transport_list returned 20 open requests with EMPTY
+ * description / target (the list endpoint does not fill them on this system),
+ * so the model offered S4HK903346 (no target) and S4HK903342 for a ZTEST_LAS
+ * object and SAP refused both: "CTS_WBO_API/048: Request … does not have
+ * transport target CL5". It also offered S4HK903729, which belongs to other
+ * work — its description was invisible to it.
+ *
+ * What the SAP data allows (all read-only, data preview):
+ *   - E070.TARSYSTEM / TRFUNCTION / TRSTATUS — each request's target, type, status;
+ *   - E07T.AS4TEXT — each request's description;
+ *   - TDEVC.PDEVCLASS — the package's transport layer;
+ *   - TCERELE (VERSION, INTSYS, TRANSLAYER → CONSYS) — the layer's
+ *     consolidation target, restricted to the ACTIVE route version
+ *     (TCEVERS ACTIVE = 'A') and this system (the request-number prefix).
+ *     Round 4: round 3 read TCETRAL.CONSYS — TCETRAL has only VERSION +
+ *     TRANSLAYER (verified live on S4H), so there was never a verdict.
+ * A request fits the package when it is a workbench request (K) whose target
+ * equals that consolidation target. When the package target, the request's
+ * target or its type is unknown, NO verdict is given — an unfit request is
+ * never marked as fitting.
+ *
+ * Data preview rejects a query line over 255 characters, so the IN-lists are
+ * chunked (round 4: ~20 requests in one query failed and every field came
+ * back empty). Strictly best-effort: a failed lookup leaves those fields as
+ * SAP returned them, gives no verdict, and writes a CSPEACH_DEBUG line.
+ */
+const TRKORR = /^[A-Z0-9]{1,20}$/;
+const PACKAGE = /^[A-Z0-9_/$]{1,30}$/;
+const REQUEST_SID = /^([A-Z0-9]{3})K\d+$/;
+/** Data preview refuses a query line over 255 chars; stay well under it. */
+export const MAX_QUERY_CHARS = 230;
+function debug(msg) {
+    if (process.env['CSPEACH_DEBUG'] !== '1')
+        return;
+    process.stderr.write(`[transport-fit] ${msg}\n`);
+}
+/** Rows of one query, or null when it failed (logged, never thrown). */
+async function rows(adt, sql, max, what) {
+    try {
+        return (await adt.sqlQuery(sql, max)).rows ?? [];
+    }
+    catch (err) {
+        const why = err instanceof Error ? err.message : String(err);
+        debug(`${what} lookup failed, no ranking from it: ${why.slice(0, 200)}`);
+        return null;
+    }
+}
+/** Build `prefix 'A', 'B' suffix` queries, each at most MAX_QUERY_CHARS long. */
+export function chunkInList(prefix, suffix, keys) {
+    const build = (ks) => `${prefix}${ks.map((k) => `'${k}'`).join(', ')}${suffix}`;
+    const out = [];
+    let cur = [];
+    for (const k of keys) {
+        if (cur.length > 0 && build([...cur, k]).length > MAX_QUERY_CHARS) {
+            out.push({ sql: build(cur), keys: cur });
+            cur = [];
+        }
+        cur.push(k);
+    }
+    if (cur.length > 0)
+        out.push({ sql: build(cur), keys: cur });
+    return out;
+}
+/** sap-client caps any data-preview query at this many rows. */
+const CLIENT_ROW_CAP = 5000;
+/** Chunks run at most this many at a time (round 5). */
+const CHUNK_CONCURRENCY = 4;
+/** Run a chunked IN-list query; returns the rows and the keys whose chunk failed. */
+async function chunkedLookup(adt, prefix, suffix, keys, perKey, what, maxChunks = Infinity) {
+    const all = chunkInList(prefix, suffix, keys);
+    // Round 5b — cap the lookups: keys past the cap are not read (no verdict).
+    const chunks = all.slice(0, maxChunks);
+    const skipped = all.slice(chunks.length);
+    if (skipped.length > 0)
+        debug(`${what}: ${skipped.length} lookup(s) past the cap skipped, those requests get no verdict`);
+    const results = new Array(chunks.length).fill(null);
+    let next = 0;
+    const worker = async () => {
+        while (next < chunks.length) {
+            const i = next++;
+            const c = chunks[i];
+            // Round 5b — ask for one row more than the budget: getting it back (or
+            // hitting the client-wide cap) means rows may be missing — not read.
+            const max = c.keys.length * perKey;
+            const r = await rows(adt, c.sql, max + 1, what);
+            const capped = r !== null && (r.length > max || r.length >= CLIENT_ROW_CAP);
+            if (capped)
+                debug(`${what} lookup hit its row cap (${max}), those requests get no verdict`);
+            results[i] = capped ? null : r;
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(CHUNK_CONCURRENCY, chunks.length) }, worker));
+    const failed = new Set();
+    const out = [];
+    results.forEach((r, i) => {
+        if (r)
+            out.push(...r);
+        else
+            chunks[i].keys.forEach((k) => failed.add(k));
+    });
+    for (const c of skipped)
+        c.keys.forEach((k) => failed.add(k));
+    return { rows: out, failed };
+}
+/** Run a chunked IN-list query; a failed chunk contributes no rows. */
+async function chunkedRows(adt, prefix, suffix, keys, perKey, what) {
+    return (await chunkedLookup(adt, prefix, suffix, keys, perKey, what)).rows;
+}
+/** LIMU piece types that belong to a class: the class name is the first 30 characters. */
+const CLASS_PIECES = new Set(['METH', 'CINC', 'CLSD', 'CPUB', 'CPRO', 'CPRI', 'CDEF', 'CPAK']);
+const OBJ_NAME = /^[A-Z0-9_/$]{1,40}$/;
+/** Round 5b — at most this many TADIR lookups per list; the rest get no verdict. */
+export const MAX_TADIR_CHUNKS = 12;
+/** Round 5b — how many (newest) candidate requests have their contents read. */
+export const MAX_CONTENT_REQUESTS = 12;
+/** A valid function-group name (optional /NAMESPACE/, at most 26 characters after it). */
+const FUGR_NAME = /^(\/[A-Z0-9_]{1,10}\/)?[A-Z0-9_]{1,26}$/;
+/**
+ * The function group of a function-group program name (SAPL<fg> or L<fg>xxx),
+ * if it can be one. Round 5c — only a valid FUGR name is ever derived; it is
+ * used only when TADIR returns that FUGR and has no PROG row for the name.
+ */
+function fugrOfInclude(name) {
+    const m = /^(\/[A-Z0-9_]+\/)?(?:SAPL([A-Z0-9_]+)|L([A-Z0-9_]+)[A-Z0-9$]{3})$/.exec(name);
+    if (!m)
+        return undefined;
+    const fg = `${m[1] ?? ''}${m[2] ?? m[3]}`;
+    return FUGR_NAME.test(fg) ? fg : undefined;
+}
+/** Round 5c — LIMU pieces whose R3TR owner has the same name. */
+const SAME_NAME_OWNER = { TABD: 'TABL', DTED: 'DTEL', DOMD: 'DOMA', VIED: 'VIEW', TTYD: 'TTYP', SHLD: 'SHLP', ENQD: 'ENQU' };
+/** The leading field of a fixed-width E071 key (padded to `width`), or its first token. */
+function keyHead(raw, width) {
+    return (raw.length > width ? raw.slice(0, width) : raw.split(/\s+/)[0] ?? '').trim();
+}
+/** The class of a class-pool include name (ZCL_X=====CCIMP, ZCL_X=====CM001), if it is one. */
+function classOfInclude(name) {
+    const m = /^([^=]+)=+[A-Z0-9]{2,5}$/.exec(name);
+    return m ? m[1] : undefined;
+}
+/**
+ * How an E071 row maps to a package lookup; 'ignore' for rows that are not
+ * package work (CORR entries, documentation); null when it cannot be told —
+ * round 5b: such a row makes the request "not read" (never called clean).
+ */
+function resolveRow(r) {
+    const pgmid = (r['PGMID'] ?? '').trim();
+    const object = (r['OBJECT'] ?? '').trim();
+    const raw = r['OBJ_NAME'] ?? '';
+    if (pgmid === 'CORR' || object === 'DOCU')
+        return 'ignore';
+    let res = null;
+    if (pgmid === 'R3TR')
+        res = { via: 'tadir', object, name: raw.trim() };
+    else if (pgmid === 'LIMU') {
+        if (CLASS_PIECES.has(object))
+            res = { via: 'tadir', object: 'CLAS', name: raw.slice(0, 30).replace(/[= ]+$/, '') };
+        else if (SAME_NAME_OWNER[object])
+            res = { via: 'tadir', object: SAME_NAME_OWNER[object], name: raw.trim() };
+        else if (object === 'INDX')
+            res = { via: 'tadir', object: 'TABL', name: keyHead(raw, 30) };
+        else if (object === 'MESS') {
+            const name = raw.length > 20 ? raw.slice(0, 20).trim() : raw.trim().replace(/\d{3}$/, '').trim();
+            res = { via: 'tadir', object: 'MSAG', name };
+        }
+        else if (object === 'DYNP' || object === 'CUAD') {
+            const prog = object === 'DYNP' ? keyHead(raw, 40) : raw.trim();
+            res = { via: 'tadir', object: 'PROG', name: prog, fugr: fugrOfInclude(prog) };
+        }
+        else if (object === 'REPS' || object === 'REPT') {
+            const name = raw.trim();
+            const cls = classOfInclude(name);
+            // Round 5c — '=' is allowed only here, parsed into the class name; the
+            // value that reaches SQL is the class name and must pass OBJ_NAME.
+            res = cls ? { via: 'tadir', object: 'CLAS', name: cls } : { via: 'tadir', object: 'PROG', name, fugr: fugrOfInclude(name) };
+        }
+        else if (object === 'FUNC')
+            res = { via: 'func', name: raw.trim() };
+    }
+    if (!res || !OBJ_NAME.test(res.name))
+        return null;
+    return res;
+}
+async function requestPackages(adt, requests) {
+    const out = new Map(requests.map((r) => [r, { pkgs: new Set(), complete: true }]));
+    if (requests.length === 0)
+        return out;
+    const rank = new Map(requests.map((r, i) => [r, i]));
+    const notRead = (request, why) => {
+        const h = out.get(request);
+        if (!h)
+            return;
+        if (h.complete)
+            debug(`${request}: ${why}, not called clean`);
+        h.complete = false;
+    };
+    const tasks = await chunkedLookup(adt, 'SELECT TRKORR, STRKORR FROM E070 WHERE STRKORR IN (', ')', requests, 20, 'E070 tasks');
+    const owner = new Map(requests.map((r) => [r, r]));
+    for (const t of tasks.rows) {
+        const task = (t['TRKORR'] ?? '').trim();
+        const parent = (t['STRKORR'] ?? '').trim();
+        if (TRKORR.test(task) && out.has(parent))
+            owner.set(task, parent);
+    }
+    for (const r of tasks.failed)
+        notRead(r, 'tasks not read');
+    const e071 = await chunkedLookup(adt, 'SELECT TRKORR, PGMID, OBJECT, OBJ_NAME FROM E071 WHERE TRKORR IN (', ')', [...owner.keys()], 200, 'E071');
+    for (const k of e071.failed)
+        notRead(owner.get(k), 'objects not read');
+    const items = [];
+    for (const r of e071.rows) {
+        const request = owner.get((r['TRKORR'] ?? '').trim());
+        if (!request)
+            continue;
+        const res = resolveRow(r);
+        if (res === 'ignore')
+            continue;
+        if (!res) {
+            notRead(request, `object ${(r['PGMID'] ?? '').trim()} ${(r['OBJECT'] ?? '').trim()} cannot be resolved`);
+            continue;
+        }
+        items.push({ request, ...res });
+    }
+    items.sort((a, b) => rank.get(a.request) - rank.get(b.request));
+    // Function modules → their function group.
+    const funcs = [...new Set(items.filter((i) => i.via === 'func').map((i) => i.name))];
+    const fm = await chunkedLookup(adt, 'SELECT FUNCNAME, AREA FROM ENLFDIR WHERE FUNCNAME IN (', ')', funcs, 1, 'ENLFDIR', MAX_TADIR_CHUNKS);
+    const groupOf = new Map(fm.rows.map((r) => [(r['FUNCNAME'] ?? '').trim(), (r['AREA'] ?? '').trim()]));
+    const lookups = [];
+    for (const i of items) {
+        if (i.via === 'func') {
+            const fg = groupOf.get(i.name);
+            if (!fg || !OBJ_NAME.test(fg)) {
+                notRead(i.request, `function module ${i.name} not resolved`);
+                continue;
+            }
+            lookups.push({ request: i.request, name: i.name, keys: [{ object: 'FUGR', name: fg }] });
+        }
+        else {
+            const keys = [{ object: i.object, name: i.name }];
+            if (i.fugr && OBJ_NAME.test(i.fugr))
+                keys.push({ object: 'FUGR', name: i.fugr });
+            lookups.push({ request: i.request, name: i.name, keys });
+        }
+    }
+    const names = [...new Set(lookups.flatMap((l) => l.keys.map((k) => k.name)))];
+    const tadir = await chunkedLookup(adt, "SELECT OBJECT, OBJ_NAME, DEVCLASS FROM TADIR WHERE PGMID = 'R3TR' AND OBJ_NAME IN (", ')', names, 10, 'TADIR', MAX_TADIR_CHUNKS);
+    const pkgOf = new Map(tadir.rows.map((r) => [`${(r['OBJECT'] ?? '').trim()} ${(r['OBJ_NAME'] ?? '').trim()}`, (r['DEVCLASS'] ?? '').trim()]));
+    for (const l of lookups) {
+        const pkg = l.keys.map((k) => pkgOf.get(`${k.object} ${k.name}`)).find((p) => !!p);
+        if (pkg) {
+            out.get(l.request).pkgs.add(pkg.toUpperCase());
+            continue;
+        }
+        if (l.keys.some((k) => tadir.failed.has(k.name)))
+            notRead(l.request, `package of ${l.name} not read`);
+        else
+            notRead(l.request, `${l.name} has no TADIR entry`);
+    }
+    return out;
+}
+/** The package's consolidation target, or undefined when unknown / ambiguous. */
+async function packageTarget(adt, pkg, sid) {
+    const name = pkg.toUpperCase().trim();
+    if (!PACKAGE.test(name))
+        return undefined;
+    const dev = await rows(adt, `SELECT DEVCLASS, PDEVCLASS FROM TDEVC WHERE DEVCLASS = '${name}'`, 1, 'TDEVC');
+    const layer = (dev?.[0]?.['PDEVCLASS'] ?? '').trim();
+    if (!layer || !PACKAGE.test(layer)) {
+        if (dev)
+            debug(`package ${name} has no transport layer, no ranking`);
+        return undefined;
+    }
+    let routes = await rows(adt, `SELECT VERSION, INTSYS, CONSYS FROM TCERELE WHERE TRANSLAYER = '${layer}'`, 50, 'TCERELE');
+    if (!routes || routes.length === 0) {
+        if (routes)
+            debug(`layer ${layer} has no consolidation route, no ranking`);
+        return undefined;
+    }
+    const active = await rows(adt, `SELECT VERSION FROM TCEVERS WHERE ACTIVE = 'A'`, 5, 'TCEVERS');
+    // Review M6 — the read failed: a route of an inactive version could pass as
+    // the target, so give no verdict (an empty answer still means "unfiltered").
+    if (active === null)
+        return undefined;
+    const versions = new Set((active ?? []).map((r) => (r['VERSION'] ?? '').trim()).filter(Boolean));
+    if (versions.size > 0)
+        routes = routes.filter((r) => versions.has((r['VERSION'] ?? '').trim()));
+    if (sid) {
+        const mine = routes.filter((r) => (r['INTSYS'] ?? '').trim() === sid);
+        if (mine.length > 0)
+            routes = mine;
+    }
+    const targets = [...new Set(routes.map((r) => (r['CONSYS'] ?? '').trim()).filter((t) => t.length > 0))];
+    if (targets.length !== 1)
+        debug(`layer ${layer} routes to ${targets.length} targets, no ranking`);
+    return targets.length === 1 ? targets[0] : undefined;
+}
+/**
+ * E070-TRFUNCTION request codes (re-review 4). The list endpoint's
+ * `tm:type` may carry other text (e.g. "workbench"); only a real TRFUNCTION
+ * code counts as a known type — anything else is unknown.
+ */
+const TRFUNCTION_CODES = new Set(['K', 'W', 'T', 'S', 'R', 'X', 'Q', 'C', 'O', 'E', 'D', 'M', 'G']);
+function trfunction(type) {
+    const c = (type ?? '').trim().toUpperCase();
+    return TRFUNCTION_CODES.has(c) ? c : undefined;
+}
+/** The request numbers' system prefix (S4HK903731 → S4H) when they all agree. */
+function systemId(numbers) {
+    const ids = new Set();
+    for (const n of numbers) {
+        const m = REQUEST_SID.exec(n);
+        if (m)
+            ids.add(m[1]);
+    }
+    return ids.size === 1 ? [...ids][0] : undefined;
+}
+/**
+ * Round 5b — at most `limit` data-preview queries in flight across a whole
+ * enrichment (the per-lookup concurrency alone let parallel lookups stack).
+ */
+function limited(adt, limit) {
+    let active = 0;
+    const waiting = [];
+    const acquire = async () => {
+        if (active < limit) {
+            active++;
+            return;
+        }
+        await new Promise((r) => waiting.push(r));
+    };
+    const release = () => {
+        const next = waiting.shift();
+        if (next)
+            next();
+        else
+            active--;
+    };
+    return {
+        async sqlQuery(query, maxRows) {
+            await acquire();
+            try {
+                return await adt.sqlQuery(query, maxRows);
+            }
+            finally {
+                release();
+            }
+        },
+    };
+}
+export async function enrichTransportList(rawAdt, transports, pkg) {
+    const adt = limited(rawAdt, CHUNK_CONCURRENCY);
+    const out = transports.map((t) => ({ ...t }));
+    const numbers = out.map((t) => t.transportNumber).filter((n) => TRKORR.test(n));
+    /** Requests whose E070 row was read — their target is known (even when empty). */
+    const e070Known = new Set();
+    if (numbers.length > 0) {
+        // Review I4 — English text first; any language only for requests with no
+        // English text (a request may carry EN and DE rows).
+        const [e070, e07tEn] = await Promise.all([
+            chunkedRows(adt, 'SELECT TRKORR, TARSYSTEM, TRFUNCTION, TRSTATUS FROM E070 WHERE TRKORR IN (', ')', numbers, 1, 'E070'),
+            chunkedRows(adt, 'SELECT TRKORR, AS4TEXT FROM E07T WHERE TRKORR IN (', ") AND LANGU = 'E'", numbers, 1, 'E07T'),
+        ]);
+        const head = new Map(e070.map((r) => [r['TRKORR'] ?? '', r]));
+        const text = new Map();
+        const addTexts = (rs) => {
+            for (const r of rs) {
+                const k = r['TRKORR'] ?? '';
+                const v = (r['AS4TEXT'] ?? '').trim();
+                if (v && !text.has(k))
+                    text.set(k, v);
+            }
+        };
+        addTexts(e07tEn);
+        const missing = numbers.filter((n) => !text.has(n));
+        if (missing.length > 0) {
+            addTexts(await chunkedRows(adt, 'SELECT TRKORR, AS4TEXT FROM E07T WHERE TRKORR IN (', ')', missing, 3, 'E07T'));
+        }
+        for (const t of out) {
+            const h = head.get(t.transportNumber);
+            if (h) {
+                e070Known.add(t.transportNumber);
+                const code = (h['TRFUNCTION'] ?? '').trim();
+                if (!t.target)
+                    t.target = (h['TARSYSTEM'] ?? '').trim();
+                // A real TRFUNCTION code beats list text such as "workbench".
+                if (!trfunction(t.type) && code)
+                    t.type = code;
+                if (!t.status)
+                    t.status = (h['TRSTATUS'] ?? '').trim();
+            }
+            if (!t.description)
+                t.description = text.get(t.transportNumber) ?? t.description;
+        }
+    }
+    if (!pkg)
+        return { transports: out };
+    const target = await packageTarget(adt, pkg, systemId(numbers));
+    if (!target)
+        return { transports: out };
+    // Review I4 — only a workbench request (TRFUNCTION 'K') can take a
+    // repository object; a customizing ('W') or transport-of-copies ('T')
+    // request on the right target is refused by SAP. Round 4 — verdicts only on
+    // what is known: a known wrong type or a known wrong target is unfit; a K
+    // request on the package's target fits; anything else gets no verdict.
+    for (const t of out) {
+        const code = trfunction(t.type);
+        const tgt = (t.target ?? '').trim();
+        const targetKnown = tgt.length > 0 || e070Known.has(t.transportNumber);
+        if (code !== undefined && code !== 'K')
+            t.fits_package = false;
+        else if (targetKnown && tgt !== target)
+            t.fits_package = false;
+        else if (code === 'K' && targetKnown)
+            t.fits_package = true;
+        else
+            delete t.fits_package;
+    }
+    // Round 5 — "belongs to other work": what the candidates already hold.
+    const pkgName = pkg.toUpperCase().trim();
+    // Round 5b — only the newest MAX_CONTENT_REQUESTS candidates are read (the
+    // pick is among them); older ones get no verdict on their contents.
+    const candidates = out.filter((t) => t.fits_package !== false && TRKORR.test(t.transportNumber))
+        .map((t) => t.transportNumber).slice(0, MAX_CONTENT_REQUESTS);
+    const held = await requestPackages(adt, candidates);
+    for (const t of out) {
+        const h = held.get(t.transportNumber);
+        const others = h ? [...h.pkgs].filter((p) => p !== pkgName).sort() : [];
+        if (others.length > 0)
+            t.other_packages = others;
+    }
+    // Stable: clean fitting first, then no verdict, then other work, then
+    // unfit; SAP's order kept inside each group.
+    const other = (t) => (t.other_packages?.length ?? 0) > 0;
+    // Round 5b — among fitting requests, those whose objects were all read
+    // (clean) come before those that could not be read.
+    const read = (t) => held.get(t.transportNumber)?.complete === true;
+    for (const t of out) {
+        if (t.fits_package === false)
+            continue;
+        // Review r7 M-4 — 'clean' only on a request known to fit; a request whose
+        // fit is unknown is never offered for reuse.
+        t.contents = other(t) ? 'other_work' : (read(t) && t.fits_package === true) ? 'clean' : 'not_checked';
+    }
+    const ranked = [
+        ...out.filter((t) => t.fits_package === true && !other(t) && read(t)),
+        ...out.filter((t) => t.fits_package === true && !other(t) && !read(t)),
+        ...out.filter((t) => t.fits_package === undefined && !other(t)),
+        ...out.filter((t) => t.fits_package !== false && other(t)),
+        ...out.filter((t) => t.fits_package === false),
+    ];
+    // The suggested pick: the first fitting request whose objects were read
+    // and all belong to this package (or that holds none).
+    const pick = ranked.find((t) => t.fits_package === true && !other(t) && read(t));
+    if (pick)
+        pick.suggested = true;
+    return { transports: ranked, packageTarget: target };
+}

package/dist/tools/transport-resolution.js

@@ -21,6 +21,7 @@
  * older mocks without the method) must NEVER block the write.
  */
 import { wasTransportCreatedThisSession } from './transport.js';
+import { describeError } from '../sap-errors/clean-error-text.js';
 /**
  * Resolve the transport for a write against the owning-transport ledger.
  *
@@ -49,7 +50,8 @@ export async function resolveWriteTransport(ctx, objectType, objectName, supplie
         // conflicting-override case below).
         ctx.chunkEmitter?.emit('info', `owning-transport lookup failed for ${objectType} ${objectName} — `
             + `proceeding with ${supplied ?? 'no transport'} `
-            + `(${err instanceof Error ? err.message : String(err)})`);
+            // describeError: an ICM HTML error page must not leak tags/CSS here.
+            + `(${describeError(err)})`);
         return { transport: supplied };
     }
     if (owning?.transport) {

package/dist/tools/transport.js

@@ -17,6 +17,7 @@ import { ERR } from '../errors/codes.js';
 import { presentSafetyConfirmation } from '../repl/safety-confirm.js';
 import { isSafetyConfirmEnabled } from '../repl/safety-mode-state.js';
 import { setCurrentTransport } from '../repl/current-transport.js';
+import { enrichTransportList } from './transport-fit.js';
 // ── Session ledger: transports CREATED by sap_transport_create this session ──
 //
 // Orphan-hint support (third junk transport this month, 2026-06-12 — D15/D20
@@ -57,7 +58,7 @@ registerTool({
         + 'the object is free. '
         + 'Ask the user for the transport description using `ask_question` — DO NOT '
         + 'generate a marketing-style description yourself. When asking, SUGGEST the '
-        + 'Rule 9 session format "ABAPForge <YYYY-MM-DD>: <work summary>" as the default; '
+        + 'Rule 9 session format "<YYYY-MM-DD>: <work summary>" (no product name) as the default; '
         + 'the user may override. Use the user\'s exact answer as the `description` '
         + 'argument AND in your `request_approval` reason (identical strings prevent the '
         + 'approval mismatch failure mode observed live 2026-05-07). '
@@ -221,11 +222,12 @@ registerTool({
             // Rule 9 description format (D20: "Magic fix" accepted verbatim) —
             // non-blocking note when the description doesn't follow the session
             // format. The transport IS created; the user's wording always wins.
-            const rule9Format = /^ABAPForge \d{4}-\d{2}-\d{2}: .+/;
+            // Any leading label (a customer's own prefix) is fine; no product name is suggested.
+            const rule9Format = /^(?:\S.* )?\d{4}-\d{2}-\d{2}: .+/;
             const today = new Date().toISOString().slice(0, 10);
             const rule9Suggestion = rule9Format.test(args.description)
                 ? undefined
-                : `Description does not follow the Rule 9 session format. Suggested: "ABAPForge ${today}: <work summary>". `
+                : `Description does not follow the Rule 9 session format. Suggested: "${today}: <work summary>". `
                     + 'Non-blocking — keep the user\'s wording if they chose it deliberately.';
             return {
                 content: JSON.stringify({
@@ -330,7 +332,20 @@ registerTool({
 registerTool({
     name: 'sap_transport_list',
     description: 'List SAP CTS transport requests. '
-        + 'Optionally filter by owner (user) or status (modifiable | released).',
+        + 'Optionally filter by owner (user) or status (modifiable | released). '
+        + 'When choosing a transport for a write, pass `package`: each request then carries '
+        + '`fits_package` (true = its target matches the transport target of the package) and the '
+        + 'fitting ones come first. Offer the user only requests that fit — SAP refuses the others '
+        + '("does not have transport target …"). A request with `other_packages` already holds '
+        + 'objects of other packages (other work): it ranks lower and must never be pre-selected. '
+        + 'Each request that may fit carries `contents`: "clean" (its objects were read and all belong '
+        + 'to this package, or it holds none), "other_work" (it holds other packages\' objects), or '
+        + '"not_checked" (its objects were not read). `suggested: true` is the tool\'s pick and is '
+        + 'authoritative: present that request first, as the recommendation. Never pre-select or '
+        + 'recommend a request with contents "other_work" or "not_checked" for reuse; list a '
+        + '"not_checked" one as "not checked", never as a clean fit. A description that seems to name '
+        + 'other work may only lower a request in your answer; it never overrides `suggested: true`. '
+        + 'When no request is suggested, offer to create a new transport.',
     isMutating: false,
     requiresSap: true,
     input_schema: {
@@ -338,25 +353,35 @@ registerTool({
         properties: {
             owner: {
                 type: 'string',
-                description: 'Filter by transport owner (SAP user ID). Omit for all owners.',
+                description: 'Owner of the requests: the exact SAP user ID (e.g. MJOHNSON), not a name or part of one. Omit it to list the connected user\'s own requests.',
             },
             status: {
                 type: 'string',
                 enum: ['modifiable', 'released'],
                 description: 'Filter by status. Defaults to "modifiable".',
             },
+            package: {
+                type: 'string',
+                description: 'The package the object will be written to (e.g. ZTEST_LAS). Marks which requests can take it (fits_package).',
+            },
         },
     },
     handler: async (args, ctx) => {
         // transportList(user?, status?)
         try {
             const result = await ctx.adt.transportList(args.owner, args.status);
+            // Fix round 3 (item 9e) — fill the empty target / description from
+            // E070/E07T and, given a package, mark + rank the requests that fit.
+            const enriched = await enrichTransportList(ctx.adt, result.transports, typeof args.package === 'string' && args.package.trim() ? args.package : undefined);
             return {
                 content: JSON.stringify({
                     filter_user: result.filterUser || null,
                     filter_status: result.filterStatus,
-                    count: result.transports.length,
-                    transports: result.transports,
+                    count: enriched.transports.length,
+                    ...(enriched.packageTarget ? { package: String(args.package).toUpperCase(), package_target: enriched.packageTarget } : {}),
+                    transports: enriched.transports,
+                    // Round 5 item 3 — sap-client says when the list may be incomplete.
+                    ...(result.note ? { note: result.note } : {}),
                 }),
             };
         }
@@ -414,6 +439,7 @@ registerTool({
                 what_will_happen: `Releases ${args.transport}; objects move to QA queue, transport becomes immutable.`,
                 rollback_available: false,
                 transport: args.transport,
+                args: { ...args },
             });
             if (!r.confirmed) {
                 return {