@sema-agent/client-core 0.98.0 → 0.100.0

package/dist/modelIdentityResolvability.js

@@ -1,5 +1,6 @@
 import { engineCapsLandingOf } from './engineCapsCache.js';
 import { engineWireTarget } from './engineWireTarget.js';
+import { msg, renderMessage } from './i18n/translate.js';
 function laneOrder() {
     return ['processEnv', 'settingsEnv', 'modelCatalogFile', 'followedSettingsFile', 'followedProviderEnv'];
 }
@@ -30,6 +31,10 @@ function routeGapOf(reading) {
     const v = own(reading, 'routeGap')?.v;
     return v === 'endpoint_missing' || v === 'lane_credential_missing' || v === 'none' ? v : undefined;
 }
+function catalogAdoptionOf(reading) {
+    const v = own(reading, 'catalogAdoption')?.v;
+    return v === 'absent' || v === 'refused' || v === 'undetermined' ? v : undefined;
+}
 function analyse(reading) {
     try {
         if (!isPlainObject(reading))
@@ -46,25 +51,30 @@ function analyse(reading) {
         const lanesHit = own(reading, 'lanes')?.v;
         const order = laneOrder();
         if (!isPlainObject(lanesHit)) {
-            return { verdict: 'unknown', why: 'lanes', unreadable: [], unreported: [...order], unusable: [], catalogUnconfirmed: null, catalogRefused: false };
+            return { verdict: 'unknown', why: 'lanes', unreadable: [], unreported: [...order], unusable: [], catalogUnconfirmed: null, catalogRefused: null };
         }
         const partial = [];
         const unreadable = [];
         const unreported = [];
         const unusable = [];
-        let catalogRefused = false;
+        let catalogRefused = null;
         let catalogUnconfirmed = null;
         for (const lane of order) {
             const s = laneState(lanesHit, lane);
             if (lane === 'modelCatalogFile') {
                 if (s === 'complete') {
+                    if (catalogAdoptionOf(reading) === 'refused') {
+                        partial.push(lane);
+                        catalogRefused = 'adoption';
+                        continue;
+                    }
                     const bit = own(reading, 'engineAcceptsCatalogDefault');
                     const evidence = catalogDefaultEvidence(s, bit?.v);
                     if (evidence !== undefined)
                         return { verdict: 'resolvable', why: 'catalog_default', evidence };
                     if (bit !== undefined && bit.v === false) {
                         partial.push(lane);
-                        catalogRefused = true;
+                        catalogRefused = 'engine';
                     }
                     else {
                         catalogUnconfirmed = bit === undefined || bit.v === undefined ? 'not_reported' : 'unusable';
@@ -99,19 +109,30 @@ function analyse(reading) {
 export function modelIdentityResolvability(reading) {
     return analyse(reading).verdict;
 }
+const LANE_LABEL_KEYS = Object.freeze({
+    processEnv: 'model.identity.lane.processEnv',
+    settingsEnv: 'model.identity.lane.settingsEnv',
+    modelCatalogFile: 'model.identity.lane.modelCatalogFile',
+    followedSettingsFile: 'model.identity.lane.followedSettingsFile',
+    followedProviderEnv: 'model.identity.lane.followedProviderEnv',
+});
 function laneLabel(lane) {
-    switch (lane) {
-        case 'processEnv':
-            return 'the environment this client was started with';
-        case 'settingsEnv':
-            return "this client's settings file";
-        case 'modelCatalogFile':
-            return 'the local model catalog file';
-        case 'followedSettingsFile':
-            return "another tool's settings file that this client follows";
-        case 'followedProviderEnv':
-            return 'the provider environment variables this client follows';
-    }
+    return renderMessage(msg(LANE_LABEL_KEYS[lane]));
+}
+const ROUTE_GAP_FACT_KEYS = Object.freeze({
+    endpoint_missing: 'model.identity.routeGap.fact.endpointMissing',
+    lane_credential_missing: 'model.identity.routeGap.fact.laneCredentialMissing',
+});
+const isRouteGapKind = (v) => typeof v === 'string' && Object.hasOwn(ROUTE_GAP_FACT_KEYS, v);
+const isLane = (v) => typeof v === 'string' && Object.hasOwn(LANE_LABEL_KEYS, v);
+function routeGapSentenceRef(lane, gap) {
+    return msg('model.identity.routeGap.sentence', { lane: msg(LANE_LABEL_KEYS[lane]), fact: msg(ROUTE_GAP_FACT_KEYS[gap]) });
+}
+export function modelRouteGapSentence(lane, gap, lang) {
+    return isLane(lane) && isRouteGapKind(gap) ? renderMessage(routeGapSentenceRef(lane, gap), lang) : undefined;
+}
+export function modelRouteGapFact(gap, lang) {
+    return isRouteGapKind(gap) ? renderMessage(msg(ROUTE_GAP_FACT_KEYS[gap]), lang) : undefined;
 }
 function joinPhrases(xs) {
     if (xs.length <= 1)
@@ -133,16 +154,19 @@ export function modelIdentityDetail(reading) {
             }
             return `${laneLabel(a.lane)} supplies a model name for the local engine — whether the engine also has a route to reach that model (an endpoint, or credentials for the channel it names) and whether its gateway accepts the name are separate checks`;
         case 'not_resolvable': {
-            if (a.why === 'route_gap') {
-                return a.gap === 'endpoint_missing'
-                    ? `${laneLabel(a.lane)} supplies a model name, but the local engine has no route to reach it — the model rides the OpenAI-compatible route and no gateway address (MODEL_GATEWAY_BASEURL) is set, and the engine refuses to start without one`
-                    : `${laneLabel(a.lane)} supplies a model name, but the local engine has no route to reach it — the anthropic channel is selected (MODEL_PROVIDER=anthropic), neither ANTHROPIC_API_KEY nor ANTHROPIC_AUTH_TOKEN is set, and there is no gateway address (MODEL_GATEWAY_BASEURL) to fall back to, so the engine cannot start on any route`;
-            }
+            if (a.why === 'route_gap')
+                return renderMessage(routeGapSentenceRef(a.lane, a.gap));
             const others = a.catalogRefused ? a.partial.filter((l) => l !== 'modelCatalogFile') : a.partial;
             const partialClause = others.length > 0
                 ? `${joinPhrases(others.map(laneLabel))} ${others.length > 1 ? 'carry' : 'carries'} part of a model configuration (such as a gateway address or a credential) but no model name`
                 : '';
-            if (a.catalogRefused) {
+            if (a.catalogRefused === 'adoption') {
+                const clause = msg('model.identity.catalogAdoption.refused', { lane: msg(LANE_LABEL_KEYS.modelCatalogFile) });
+                return partialClause !== ''
+                    ? renderMessage(msg('model.identity.catalogAdoption.notResolvableWithPartial', { clause, partial: partialClause }))
+                    : renderMessage(msg('model.identity.catalogAdoption.notResolvable', { clause }));
+            }
+            if (a.catalogRefused === 'engine') {
                 return (`no model name is configured for the local engine to start with — ${laneLabel('modelCatalogFile')} names a default model, but the local engine is reported not to accept a catalog default in place of a startup model name` +
                     (partialClause !== '' ? `, and ${partialClause}` : '') +
                     ', and the engine does not start without one');
@@ -170,7 +194,10 @@ export function modelIdentityDetail(reading) {
                 else if (a.catalogUnconfirmed === 'unusable') {
                     parts.push(`${laneLabel('modelCatalogFile')} names a default model, but the report of whether the local engine accepts a catalog default in place of a startup model name gave no usable reading`);
                 }
-                else if (a.catalogRefused) {
+                else if (a.catalogRefused === 'adoption') {
+                    parts.push(renderMessage(msg('model.identity.catalogAdoption.refused', { lane: msg(LANE_LABEL_KEYS.modelCatalogFile) })));
+                }
+                else if (a.catalogRefused === 'engine') {
                     parts.push(`${laneLabel('modelCatalogFile')} names a default model, but the local engine is reported not to accept a catalog default in place of a startup model name`);
                 }
                 return `whether the local engine has a model name is unknown — ${joinPhrases(parts)}, and no other place this client reads provides one`;

package/dist/ownKey.d.ts

@@ -24,5 +24,38 @@ export interface ContextUsageReading {
     sections?: readonly ContextUsageSectionRow[];
 }
 export declare function contextUsageReadingOf(payload: {} | null | undefined): ContextUsageReading | undefined;
+export interface HumanInputAttachmentView {
+    ordinal: number;
+    kind?: string;
+    outcome: string;
+    label?: string;
+}
+export declare function humanInputAttachmentsOf(frame: {} | null | undefined): HumanInputAttachmentView[] | undefined;
 export declare function markMcpSectionDroppedNamedRows(rows: object, dropped: ReadonlyMap<string, number>): void;
 export declare function mcpSectionDroppedNamedRowsOf(rows: object | null | undefined, name: string): number;
+export interface PromptManifestSectionRow {
+    id: string;
+    chars: number;
+    band?: string;
+    locale?: string;
+    variant?: string;
+    contentHash?: string;
+    slot?: string;
+}
+export interface PromptManifestIdentityRow {
+    readonly artifact: string;
+    readonly layers: PromptIdentityLayersRow;
+    readonly epoch: number;
+    readonly activatedBy: string;
+}
+export interface PromptIdentityLayersRow {
+    readonly catalog: string;
+    readonly renderers: Readonly<Record<string, number>>;
+    readonly center?: string;
+    readonly deploy?: string;
+    readonly task?: string;
+    readonly binding: string;
+}
+export declare function promptManifestSectionViewOf(row: object): PromptManifestSectionRow | undefined;
+export declare function promptManifestIdentityOfFrame(frame: object): PromptManifestIdentityRow | undefined;
+export declare function promptManifestIdentityOf(raw: {} | null | undefined): PromptManifestIdentityRow | undefined;

package/dist/ownKey.js

@@ -131,6 +131,40 @@ export function contextUsageReadingOf(payload) {
         return undefined;
     }
 }
+const HUMAN_INPUT_ATTACHMENT_ROWS_MAX = 256;
+export function humanInputAttachmentsOf(frame) {
+    try {
+        if (typeof frame !== 'object' || frame === null || Array.isArray(frame))
+            return undefined;
+        const raw = guardedRead(() => readOwnDataValue(frame, 'attachments'));
+        if (!Array.isArray(raw))
+            return undefined;
+        const n = guardedRead(() => readOwnDataFiniteNumber(raw, 'length'));
+        if (n === undefined)
+            return undefined;
+        const rows = [];
+        for (let i = 0; i < Math.min(n, HUMAN_INPUT_ATTACHMENT_ROWS_MAX); i++) {
+            const row = guardedRead(() => {
+                const r = readOwnDataValue(raw, String(i));
+                if (typeof r !== 'object' || r === null || Array.isArray(r))
+                    return undefined;
+                const ordinal = readOwnDataValue(r, 'ordinal');
+                const outcome = readOwnDataNonEmptyString(r, 'outcome');
+                if (typeof ordinal !== 'number' || !Number.isSafeInteger(ordinal) || ordinal < 1 || outcome === undefined)
+                    return undefined;
+                const kind = readOwnDataNonEmptyString(r, 'kind');
+                const label = readOwnDataNonEmptyString(r, 'label');
+                return { ordinal, ...(kind !== undefined ? { kind } : {}), outcome, ...(label !== undefined ? { label } : {}) };
+            });
+            if (row !== undefined)
+                rows.push(row);
+        }
+        return rows.length > 0 ? rows : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 const DROPPED_NAMED_ROWS = Symbol.for('@sema-agent/client-core/mcpSectionDroppedNamedRows');
 export function markMcpSectionDroppedNamedRows(rows, dropped) {
     if (dropped.size === 0)
@@ -155,3 +189,78 @@ export function mcpSectionDroppedNamedRowsOf(rows, name) {
         return 0;
     }
 }
+export function promptManifestSectionViewOf(row) {
+    const o = row;
+    const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+    const id = str(o.id);
+    const chars = typeof o.chars === 'number' && Number.isFinite(o.chars) && o.chars >= 0 ? o.chars : undefined;
+    if (id === undefined || chars === undefined)
+        return undefined;
+    const band = str(o.band);
+    const locale = str(o.locale);
+    const variant = str(o.variant);
+    const contentHash = band !== undefined ? str(o.contentHash) : undefined;
+    const slot = str(o.slot);
+    return {
+        id,
+        chars,
+        ...(band !== undefined ? { band } : {}),
+        ...(locale !== undefined ? { locale } : {}),
+        ...(variant !== undefined ? { variant } : {}),
+        ...(contentHash !== undefined ? { contentHash } : {}),
+        ...(slot !== undefined ? { slot } : {}),
+    };
+}
+export function promptManifestIdentityOfFrame(frame) {
+    let raw;
+    try {
+        raw = frame.identity;
+    }
+    catch {
+        return undefined;
+    }
+    return promptManifestIdentityOf(typeof raw === 'object' && raw !== null ? raw : undefined);
+}
+export function promptManifestIdentityOf(raw) {
+    try {
+        const plain = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+        const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+        if (!plain(raw))
+            return undefined;
+        const artifact = str(raw.artifact);
+        const activatedBy = str(raw.activatedBy);
+        const epochRaw = raw.epoch;
+        const epoch = typeof epochRaw === 'number' && Number.isInteger(epochRaw) && epochRaw >= 0 ? epochRaw : undefined;
+        const layersRaw = raw.layers;
+        if (artifact === undefined || activatedBy === undefined || epoch === undefined || !plain(layersRaw))
+            return undefined;
+        const catalog = str(layersRaw.catalog);
+        const binding = str(layersRaw.binding);
+        if (catalog === undefined || binding === undefined)
+            return undefined;
+        const optional = {};
+        for (const k of ['center', 'deploy', 'task']) {
+            const v = layersRaw[k];
+            if (v === undefined)
+                continue;
+            const t = str(v);
+            if (t === undefined)
+                return undefined;
+            optional[k] = t;
+        }
+        const renderersRaw = layersRaw.renderers;
+        if (!plain(renderersRaw))
+            return undefined;
+        const entries = [];
+        for (const [k, v] of Object.entries(renderersRaw)) {
+            if (typeof v !== 'number' || !Number.isFinite(v))
+                return undefined;
+            entries.push([k, v]);
+        }
+        const renderers = Object.fromEntries(entries);
+        return { artifact, layers: { catalog, renderers, ...optional, binding }, epoch, activatedBy };
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/panelReduce.d.ts

@@ -31,6 +31,11 @@ export type PanelFrame = EngineAgentPanelEvent | {
     kind: 'anchor';
     taskId: string;
     transcriptId: string;
+} | {
+    kind: 'start';
+    taskId: string;
+    startedAt?: number;
+    workflowRunId?: string;
 };
 export interface PanelRowFields {
     name?: string;
@@ -97,7 +102,7 @@ export interface PanelStep {
     readonly deltas: PanelDelta[];
     readonly facts: PanelFact[];
 }
-export declare function panelEndFact(taskId: string, isError: boolean, extra?: Pick<EndArm, 'report' | 'cycleSeq' | 'startedAt'>): EndArm;
+export declare function panelEndFact(taskId: string, isError: boolean, extra?: Pick<EndArm, 'report' | 'cycleSeq' | 'startedAt' | 'sessionId'>): EndArm;
 export interface EnginePanelTaskIdentity {
     readonly taskId: string;
     readonly origin: 'fleet-row' | 'wire';
@@ -111,6 +116,11 @@ export declare function reducePanelFrame(state: PanelReduceState, frame: PanelFr
 };
 export declare function panelRowSnapshot(state: PanelReduceState): PanelDelta[];
 export declare function panelResolveTaskId(state: PanelReduceState, wireTaskId: string): EnginePanelTaskIdentity;
+export interface PanelSubagentIdentity {
+    readonly key: string;
+    readonly ids: readonly string[];
+}
+export declare function panelSubagentOf(state: PanelReduceState, id: string): PanelSubagentIdentity | undefined;
 export declare function panelIsResident(state: PanelReduceState, taskId: string): boolean;
 export declare function panelAnchorOf(state: PanelReduceState, taskId: string): string | undefined;
 export declare function panelPresenceSize(state: PanelReduceState, sessionKey: string): number;

package/dist/panelReduce.js

@@ -1,6 +1,6 @@
 import { rowIdTail } from './workflow.js';
 import { isSdkFleetTaskTerminal, isSdkFleetTaskTerminalNotSuccess } from './terminalStatuses.js';
-import { carryCycle, cycleEmpty, cycleKeysChanged, cycleOf, cycleOrder, mergeCycle, } from './cycleOrder.js';
+import { carryCycle, cycleEmpty, cycleKeysChanged, cycleOf, cycleOrder, cycleSeqValue, mergeCycle, } from './cycleOrder.js';
 export function isStaleEngineAgentPanelEnd(end, current) {
     return cycleOrder(end, current) === 'before';
 }
@@ -394,6 +394,7 @@ function merge(d, a, b) {
         held: rs.held ?? rl.held,
         resident: rs.resident ?? rl.resident,
         anchor: rs.anchor ?? rl.anchor,
+        startedAt: rs.startedAt ?? rl.startedAt,
         row: merged.row,
     });
     for (const id of idsOf(rl))
@@ -423,6 +424,7 @@ function merge(d, a, b) {
                 mintTerminal(d, key, merged.row.isError === true, merged.row.report, 'end');
         }
     }
+    fillStartedAt(d, s);
     return s;
 }
 function genOf(r) {
@@ -513,6 +515,7 @@ export function panelEndFact(taskId, isError, extra) {
         ...(extra?.cycleSeq !== undefined ? { cycleSeq: extra.cycleSeq } : {}),
         ...(extra?.startedAt !== undefined ? { startedAt: extra.startedAt } : {}),
         ...(extra?.report !== undefined ? { report: extra.report } : {}),
+        ...(typeof extra?.sessionId === 'string' && extra.sessionId.length > 0 ? { sessionId: extra.sessionId } : {}),
     };
 }
 function terminalDelta(key, isError, report, cause) {
@@ -572,10 +575,26 @@ function fullUsage(key, row) {
         return undefined;
     return usageDelta(key, { ...(row.totalTokens !== undefined ? { totalTokens: row.totalTokens } : {}), ...(row.toolUses !== undefined ? { toolUses: row.toolUses } : {}), ...(fin !== undefined ? { final: fin } : {}) });
 }
+function ownDataOf(o, key) {
+    if (typeof o !== 'object' || o === null)
+        return undefined;
+    try {
+        const d = Object.getOwnPropertyDescriptor(o, key);
+        return d !== undefined && 'value' in d ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function publisherFinality(f) {
+    return { ...(ownDataOf(f, 'totalTokens') === true ? { totalTokens: true } : {}), ...(ownDataOf(f, 'toolUses') === true ? { toolUses: true } : {}) };
+}
 function fleetCarrier(ev) {
-    const f = ev.final;
-    const final = { ...(f?.totalTokens === true ? { totalTokens: true } : {}), ...(f?.toolUses === true ? { toolUses: true } : {}) };
-    return { totalTokens: ev.totalTokens, toolUses: ev.toolUses, final };
+    return { totalTokens: ev.totalTokens, toolUses: ev.toolUses, final: publisherFinality(ownDataOf(ev, 'final')) };
+}
+function tickCycleOf(ev) {
+    const c = cycleSeqValue(ownDataOf(ev, 'cycleSeq'));
+    return c === undefined ? undefined : { cycleSeq: c };
 }
 function finalityOf(tokens, toolUses) {
     if (tokens === undefined && toolUses === undefined)
@@ -625,26 +644,30 @@ function announce(d, rid) {
     if (r === undefined || row === undefined || row.announced)
         return;
     const key = keyOf(r);
-    d.put(rid, { consumerKey: key, announceSeq: d.counts.nextAnnounce, row: { ...row, announced: true } });
+    const fields = row.fields.startedAt === undefined && r.startedAt !== undefined ? { ...row.fields, startedAt: r.startedAt } : row.fields;
+    d.put(rid, { consumerKey: key, announceSeq: d.counts.nextAnnounce, row: { ...row, fields, announced: true } });
     d.counts.nextAnnounce++;
-    d.deltas.push({ op: 'upsert', canonicalId: key, created: true, fields: { ...row.fields } });
+    d.deltas.push({ op: 'upsert', canonicalId: key, created: true, fields: { ...fields } });
     const u = fullUsage(key, row);
     if (u !== undefined)
         d.deltas.push(u);
     if (row.phase === 'ended')
         mintTerminal(d, key, row.isError === true, row.report, 'end');
 }
-function foldTick(d, rid, ev, cardBound) {
+function foldTick(d, rid, ev, cardBound, final) {
     const r = d.rec(rid);
     if (r === undefined)
         return;
     const row = r.row;
     const gate = cardBound ? { gateBound: true } : {};
     const wireId = ev.wireTaskId ?? ev.taskId;
-    const attributable = !hasCycleSeq(r.cycle) && (r.currentRun === undefined || r.currentRun === wireId);
+    const tickCycle = tickCycleOf(ev);
+    const attributable = hasCycleSeq(r.cycle)
+        ? tickCycle !== undefined && cycleOrder(tickCycle, r.cycle) === 'same'
+        : r.currentRun === undefined || r.currentRun === wireId;
     if (!attributable)
         d.counts.unattributedTicks++;
-    const carrier = attributable ? { totalTokens: ev.totalTokens, toolUses: ev.toolUses } : {};
+    const carrier = attributable ? { totalTokens: ev.totalTokens, toolUses: ev.toolUses, final } : {};
     if (row === undefined || !row.announced) {
         const base = row !== undefined
             ? { ...row, ...gate, tickSeen: true, fields: { ...row.fields, ...tickFields(ev) } }
@@ -785,28 +808,37 @@ function foldAbsence(d, rid, a) {
     d.deltas.push({ op: 'upsert', canonicalId: keyOf(r), fields: { absence } });
     d.put(rid, { row: { ...row, fields: { ...row.fields, absence } } });
 }
-function stripCardBound(ev) {
-    const { cardBound: _cardBound, ...rest } = ev;
-    void _cardBound;
-    return rest;
+function tickFactBase(ev) {
+    const out = {};
+    for (const k of Reflect.ownKeys(ev)) {
+        if (typeof k !== 'string' || k === 'cardBound' || k === 'final' || k === 'cycleSeq')
+            continue;
+        if (!Object.prototype.propertyIsEnumerable.call(ev, k))
+            continue;
+        out[k] = Reflect.get(ev, k);
+    }
+    return out;
 }
 function emitTick(d, ev) {
     const found = d.find(ev.taskId);
     const fr = found !== undefined ? d.rec(found) : undefined;
     if (fr !== undefined && formerGeneration(fr, ev.taskId))
         return;
+    const tickCycle = tickCycleOf(ev);
+    if (fr !== undefined && tickCycle !== undefined && cycleOrder(tickCycle, genOf(fr)) === 'before')
+        return;
     const rid = found ?? d.create({ id: ev.taskId });
     d.records.touch(rid);
     const r = d.rec(rid);
     if (r === undefined)
         return;
     const key = keyOf(r);
-    const plain = stripCardBound(ev);
+    const plain = { ...tickFactBase(ev), ...(tickCycle !== undefined ? { cycleSeq: tickCycle.cycleSeq } : {}) };
     const fact = key === ev.taskId
         ? { ...plain, taskIdOrigin: 'wire' }
         : { ...plain, taskId: key, wireTaskId: ev.taskId, taskIdOrigin: key === r.tail ? 'fleet-row' : 'wire' };
     d.facts.push({ ch: 'event', ev: fact });
-    foldTick(d, rid, fact, ev.cardBound === true);
+    foldTick(d, rid, fact, ev.cardBound === true, publisherFinality(ownDataOf(ev, 'final')));
 }
 function flushHeld(d, wireTaskId) {
     const held = d.pending.get(wireTaskId);
@@ -861,7 +893,8 @@ function publishFleetRow(d, ev) {
     const stale = order === 'after';
     let newGen = false;
     if (!stale) {
-        const endGen = r.row?.phase === 'ended' ? r.row.endCycle : undefined;
+        const endedHere = r.ended !== undefined && (r.cycle === undefined || cycleOrder(r.ended, r.cycle) === 'same') ? r.ended : undefined;
+        const endGen = r.row?.phase === 'ended' ? (r.row.endCycle ?? endedHere) : undefined;
         newGen = order === 'before' || (endGen !== undefined && cycleOrder(endGen, rowCycle) === 'before');
         if (!newGen && transcript !== undefined && !hasCycleSeq(r.cycle) && !hasCycleSeq(rowCycle) && r.currentRun !== undefined && r.currentRun !== transcript) {
             newGen = true;
@@ -901,6 +934,36 @@ function publishTick(d, ev) {
     }
     d.pending.set(ev.taskId, { ev, beats: 0 });
 }
+function publishStart(d, ev) {
+    if (typeof ev.workflowRunId === 'string' && ev.workflowRunId.length > 0)
+        return;
+    if (typeof ev.taskId !== 'string' || ev.taskId.length === 0)
+        return;
+    const startedAt = typeof ev.startedAt === 'number' && Number.isFinite(ev.startedAt) ? ev.startedAt : undefined;
+    if (startedAt === undefined)
+        return;
+    const found = d.find(ev.taskId);
+    const former = found !== undefined ? d.rec(found) : undefined;
+    if (former !== undefined && formerGeneration(former, ev.taskId))
+        return;
+    if (found === undefined && d.records.size >= MAX_RECORDS)
+        return;
+    const rid = found ?? d.create({ id: ev.taskId });
+    const r = d.rec(rid);
+    if (r === undefined)
+        return;
+    if (r.startedAt === undefined)
+        d.put(rid, { startedAt });
+    fillStartedAt(d, rid);
+}
+function fillStartedAt(d, rid) {
+    const r = d.rec(rid);
+    const row = r?.row;
+    if (r === undefined || r.startedAt === undefined || row === undefined || !row.announced || row.phase !== 'running' || row.fields.startedAt !== undefined)
+        return;
+    d.deltas.push({ op: 'upsert', canonicalId: keyOf(r), fields: { startedAt: r.startedAt } });
+    d.put(rid, { row: { ...row, fields: { ...row.fields, startedAt: r.startedAt } } });
+}
 function releaseHeld(d, rid, endCycle) {
     const held = d.rec(rid)?.held;
     if (held === undefined)
@@ -921,6 +984,15 @@ function settle(d, rid, cycle) {
     d.put(rid, { running: undefined, ended: older ? r.ended : mergeCycle(cycleOf(cycle), r.ended) });
 }
 function publishEnd(d, ev) {
+    const sessionId = typeof ev.sessionId === 'string' && ev.sessionId.length > 0 && ev.sessionId !== ev.taskId ? ev.sessionId : undefined;
+    if (sessionId !== undefined) {
+        const at = d.find(ev.taskId);
+        const ra = at !== undefined ? d.rec(at) : undefined;
+        const evCycle = frameCycleOn(ra, ev.taskId, ev);
+        const provablyOld = ra !== undefined && (isStaleEngineAgentPanelEnd(evCycle, ra.cycle) || isStaleEngineAgentPanelEnd(evCycle, ra.ended));
+        if (!provablyOld)
+            bind(d, ev.taskId, 'tail', sessionId, cycleOf(ev));
+    }
     const pre = d.find(ev.taskId);
     const pr = pre !== undefined ? d.rec(pre) : undefined;
     if (pre !== undefined && pr !== undefined)
@@ -1187,6 +1259,9 @@ export function stepPanelFrame(state, frame) {
         case 'resident-clear-wire':
             clearResidentByWire(d, frame.taskId, frame.cycle);
             break;
+        case 'start':
+            publishStart(d, frame);
+            break;
         case 'anchor':
             if (frame.taskId && frame.transcriptId)
                 d.put(bind(d, frame.taskId, 'unknown', frame.transcriptId, undefined), { anchor: frame.transcriptId });
@@ -1231,6 +1306,10 @@ export function panelResolveTaskId(state, wireTaskId) {
         return { taskId: wireTaskId, origin: 'wire' };
     return { taskId: r.tail, origin: 'fleet-row', ...cycleOf(bindingOf(r, wireTaskId)?.gen) };
 }
+export function panelSubagentOf(state, id) {
+    const r = recordOfId(state, id);
+    return r === undefined ? undefined : { key: keyOf(r), ids: idsOf(r) };
+}
 export function panelIsResident(state, taskId) {
     return recordOfId(state, taskId)?.resident === true;
 }

package/dist/panelStateHolder.d.ts

@@ -1,5 +1,6 @@
 import { type PanelDelta, type PanelFact, type PanelFrame, type PanelReduceState } from './panelReduce.js';
 export declare function panelStateNow(): PanelReduceState;
+export declare function panelSubagentIdsNow(id: string): readonly string[] | undefined;
 export declare function stepEnginePanel(frame: PanelFrame): void;
 export declare function replaceEnginePanelState(fn: (s: PanelReduceState) => PanelReduceState): void;
 export declare function clearEnginePanelIdentity(): void;

package/dist/panelStateHolder.js

@@ -1,9 +1,17 @@
-import { createPanelReduceState, panelClearAnchors, panelClearIdentity, panelClearRows, panelRowSnapshot, stepPanelFrame, } from './panelReduce.js';
+import { createPanelReduceState, panelClearAnchors, panelClearIdentity, panelClearRows, panelRowSnapshot, panelSubagentOf, stepPanelFrame, } from './panelReduce.js';
+import { bindSubagentIdentityReader } from './subagentContentStore.js';
 let state = createPanelReduceState();
 export function panelStateNow() {
     return state;
 }
+export function panelSubagentIdsNow(id) {
+    return panelSubagentOf(state, id)?.ids;
+}
+function bindIdentityReader() {
+    bindSubagentIdentityReader(panelSubagentIdsNow);
+}
 export function stepEnginePanel(frame) {
+    bindIdentityReader();
     const r = stepPanelFrame(state, frame);
     state = r.state;
     if (rowListener !== null)
@@ -18,6 +26,7 @@ export function stepEnginePanel(frame) {
     }
 }
 export function replaceEnginePanelState(fn) {
+    bindIdentityReader();
     state = fn(state);
 }
 export function clearEnginePanelIdentity() {

package/dist/permissionRuleIssue.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export declare const PERMISSION_RULE_ISSUE_CODES: readonly string[];
 export declare const RETIRED_PERMISSION_RULE_ISSUE_CODES: readonly string[];
-export declare function permissionRuleIssueDetail(code: unknown, message: unknown, rule?: string): string;
+export declare function permissionRuleIssueDetail(code: unknown, message: unknown, rule?: string, lang?: UiLanguage): string;