@sema-agent/client-core 0.98.0 → 0.99.0

package/dist/ownKey.d.ts

@@ -24,5 +24,12 @@ 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;

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)

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';

package/dist/panelReduce.js

@@ -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) {
@@ -625,9 +628,10 @@ 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);
@@ -861,7 +865,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 +906,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 +956,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 +1231,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 });

package/dist/permissionRuleIssue.js

@@ -2,6 +2,7 @@ import { capForDisplay, escapeDisplayControlChars } from './fleetTaskDesc.js';
 export const PERMISSION_RULE_ISSUE_CODES = Object.freeze([
     'invalid.empty_tool',
     'invalid.paren',
+    'invalid.tool_name',
     'invalid.param_split',
     'invalid.primary_field',
     'invalid.cap_exceeded',
@@ -21,6 +22,7 @@ const ISSUE_MESSAGE_MAX = 200;
 const ISSUE_SENTENCES = Object.freeze({
     'invalid.empty_tool': 'this rule is invalid: it names no tool',
     'invalid.paren': 'this rule is invalid: its parentheses do not parse (escape a literal one as \\( or \\))',
+    'invalid.tool_name': "this rule is invalid: its tool name is not spelled as a tool name (blanks around the rule, an invisible or disallowed character in the name or before the parenthesis, a leading '-', or the wildcard '*', which names no tool), so it would reach no tool or the wrong one",
     'invalid.param_split': 'this rule is invalid: its parentheses do not hold a parameter rule written name:pattern',
     'invalid.primary_field': "this rule is invalid: it patterns the tool's primary field, which matches the whole trimmed string rather than a prefix",
     'invalid.cap_exceeded': 'this rule set is invalid: it is over one of the deployment caps (rule count, rule length, pattern length, or star count); this client cannot tell which from the code alone',

package/dist/permissionRulesWriteCapability.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export type PermissionRulesWriteReading = {
     kind: 'unobserved';
 } | {
@@ -12,4 +13,4 @@ export type PermissionRulesWriteReading = {
 export declare function projectPermissionRulesWriteCapability(caps: unknown): PermissionRulesWriteReading | undefined;
 export declare function observedPermissionRulesWrite(baseUrl?: string | undefined): PermissionRulesWriteReading;
 export declare function permissionRulesWriteAvailable(reading: PermissionRulesWriteReading): boolean;
-export declare function permissionRulesWriteDoctorDetail(reading: PermissionRulesWriteReading): string;
+export declare function permissionRulesWriteDoctorDetail(reading: PermissionRulesWriteReading, lang?: UiLanguage): string;

package/dist/permissionRulesWriteCapability.js

@@ -1,5 +1,6 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField } from './ownKey.js';
 export function projectPermissionRulesWriteCapability(caps) {
     try {
@@ -28,17 +29,18 @@ export function observedPermissionRulesWrite(baseUrl = engineWireTarget()?.baseU
 export function permissionRulesWriteAvailable(reading) {
     return reading.kind === 'present';
 }
-export function permissionRulesWriteDoctorDetail(reading) {
+export function permissionRulesWriteDoctorDetail(reading, lang) {
+    const subject = msg('notice.capability.subject.permissionRulesWrite');
     switch (reading.kind) {
         case 'unreadable':
-            return unreadableReadingDetail('permission-rule write entry');
+            return unreadableReadingDetail(renderMessage(subject, lang), lang);
         case 'unobserved':
-            return 'permission-rule write entry not observed — the engine reports it on /v1/capabilities (permissionRulesWrite); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
+            return renderMessage(msg('notice.capability.unobserved', { subject, key: 'permissionRulesWrite' }), lang);
         case 'not_reported':
-            return 'permission-rule write entry not reported by this engine — this binary predates the entry itself; hide it rather than calling it';
+            return renderMessage(msg('notice.capability.permissionRulesWrite.notReported'), lang);
         case 'absent':
-            return 'permission-rule write entry unreachable for this call — either the rules lane is not open on this deployment, or this call cannot bring a verifiable identity; the engine reports one bit for both, so this client cannot tell which';
+            return renderMessage(msg('notice.capability.permissionRulesWrite.absent'), lang);
         case 'present':
-            return 'permission-rule write entry reachable for this call — a per-call attempt still answers for itself whether the direction, text, and scope are accepted';
+            return renderMessage(msg('notice.capability.permissionRulesWrite.present'), lang);
     }
 }

package/dist/pluginHooksWire.d.ts

@@ -1,10 +1,11 @@
 import type { WireHooksConfig } from './finalVerifyWire.js';
-import type { PluginHookSource } from './host.js';
+import type { PluginHookSource, SessionHookOrigin, SessionHookSource } from './host.js';
+import { type HooksSalvageDrop, type HooksSalvageMask, type HooksSalvageRejection } from './settingsHooksSalvage.js';
 export declare const ENGINE_FIRED_HOOK_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "PreCompact", "PostCompact", "Stop", "StopFailure", "UserPromptSubmit"];
 export type EngineFiredHookEvent = (typeof ENGINE_FIRED_HOOK_EVENTS)[number];
 export declare const PLUGIN_HOOK_DISPOSITIONS: readonly ["engine", "shell", "not_run"];
 export type PluginHookDisposition = (typeof PLUGIN_HOOK_DISPOSITIONS)[number];
-export declare const PLUGIN_HOOK_REASONS: readonly ["projected", "shell_event", "no_executor", "engine_not_local", "engine_locality_unknown", "engine_capability_absent", "engine_capability_unknown", "not_command", "sensitive_options", "engine_limit", "shell_form_user_config", "user_config_unset", "malformed_entry", "engine_hooks_off", "engine_hooks_unknown", "engine_type_skipped", "engine_llm_limit", "engine_unconfirmed", "engine_elsewhere"];
+export declare const PLUGIN_HOOK_REASONS: readonly ["projected", "shell_event", "no_executor", "engine_not_local", "engine_locality_unknown", "engine_capability_absent", "engine_capability_unknown", "not_command", "sensitive_options", "engine_limit", "shell_form_user_config", "user_config_unset", "malformed_entry", "engine_hooks_off", "engine_hooks_unknown", "engine_type_skipped", "engine_llm_limit", "engine_unconfirmed", "engine_elsewhere", "hooks_module", "scope_unsupported", "source_incomplete"];
 export type PluginHookReason = (typeof PLUGIN_HOOK_REASONS)[number];
 export declare const PLUGIN_HOOK_EXCLUSION_REASONS: readonly ["workspace_untrusted", "governance_unreadable", "policy_disable_all", "startup_mode", "managed_plugins_only", "prompt_not_user_authored"];
 export type PluginHookExclusionReason = (typeof PLUGIN_HOOK_EXCLUSION_REASONS)[number];
@@ -48,6 +49,28 @@ export interface SettingsHookExclusion {
     readonly hookIndex: number;
     readonly reason: PluginHookExclusionReason;
 }
+export interface SettingsHooksSalvageRow {
+    readonly source: HookSettingsSource;
+    readonly outcome: 'loaded-partial' | 'rejected';
+    readonly dropped: readonly HooksSalvageDrop[];
+    readonly rejections: readonly HooksSalvageRejection[];
+    readonly notice: string;
+}
+export interface PluginHookModuleVerdict {
+    readonly pluginId: string;
+    readonly pluginName: string;
+    readonly disposition: PluginHookDisposition;
+    readonly reason: PluginHookReason;
+}
+export interface SessionHookVerdict {
+    readonly origin: SessionHookOrigin;
+    readonly name: string;
+    readonly event: string;
+    readonly groupIndex: number;
+    readonly hookIndex: number;
+    readonly disposition: PluginHookDisposition;
+    readonly reason: PluginHookReason;
+}
 export interface HooksWireEngineFacts {
     readonly ownedByThisShell: boolean | null;
     readonly pluginHooksCapable: boolean | null;
@@ -62,6 +85,11 @@ export interface HooksWirePlan {
     readonly settingsDropped: readonly SettingsHookDrop[];
     readonly settingsVerdicts: readonly SettingsHookVerdict[];
     readonly settingsExcluded: readonly SettingsHookExclusion[];
+    readonly settingsSalvage: readonly SettingsHooksSalvageRow[];
+    readonly moduleVerdicts: readonly PluginHookModuleVerdict[];
+    readonly sessionVerdicts: readonly SessionHookVerdict[];
+    readonly sessionReader: PluginHookReaderState;
+    readonly closedBy: Extract<PluginHookExclusionReason, 'workspace_untrusted' | 'governance_unreadable' | 'policy_disable_all'> | null;
     readonly wire: WireHooksConfig | undefined;
 }
 export interface HooksWirePlanOptions {
@@ -70,7 +98,9 @@ export interface HooksWirePlanOptions {
     readonly shellHookEvents?: readonly string[];
     readonly shellHookTypesByEvent?: Readonly<Record<string, readonly string[]>>;
     readonly promptAuthoredByUser?: boolean;
+    readonly suppressedLocally?: readonly string[];
 }
+export declare function hooksWirePlanShapeOf(v: unknown): 'plan' | 'not' | 'threw';
 export declare const ENGINE_HOOK_LIMITS: {
     readonly maxGroupsPerEvent: 16;
     readonly maxEntriesPerEvent: 32;
@@ -102,15 +132,27 @@ export interface PluginHookDecisionInput {
     readonly shellRuns: ShellRunsHook;
     readonly promptAuthoredByUser: boolean;
     readonly occupied: ReadonlyMap<string, EventOccupancy>;
+    readonly suppressedLocally?: ReadonlySet<string>;
 }
 export interface PluginHookDecision {
     readonly verdicts: readonly PluginHookVerdict[];
+    readonly modules: readonly PluginHookModuleVerdict[];
     readonly excluded: readonly PluginHookExclusion[];
     readonly projected: ReadonlyMap<string, readonly WireHookGroup[]>;
     readonly unreadable: number;
 }
 export declare function decidePluginHooks(input: PluginHookDecisionInput): PluginHookDecision;
-export declare function filterSettingsHookGroups(source: HookSettingsSource, event: string, groups: readonly WireHookGroup[], execFormCapable: boolean, shellRunsType: (type: string | undefined) => boolean, judge: SettingsHookJudge): SettingsHookFilterResult;
+export interface SessionHookDecisionInput {
+    readonly sources: readonly SessionHookSource[];
+    readonly engine: HooksWireEngineFacts;
+    readonly shellRuns: ShellRunsHook;
+    readonly promptAuthoredByUser: boolean;
+}
+export declare function decideSessionHooks(input: SessionHookDecisionInput): {
+    readonly verdicts: readonly SessionHookVerdict[];
+    readonly unreadable: number;
+};
+export declare function filterSettingsHookGroups(source: HookSettingsSource, event: string, groups: readonly WireHookGroup[], execFormCapable: boolean, shellRunsType: (type: string | undefined) => boolean, judge: SettingsHookJudge, mask?: HooksSalvageMask): SettingsHookFilterResult;
 export interface SettingsHookFilterResult {
     readonly groups: WireHookGroup[];
     readonly drops: SettingsHookDrop[];
@@ -140,4 +182,5 @@ export declare function pluginHookReasonText(reason: PluginHookReason): string;
 export declare function settingsHookDropText(reason: SettingsHookDropReason): string;
 export declare function pluginHookExecutorLabel(v: PluginHookVerdict): string;
 export declare function hooksNotRunNotice(plan: HooksWirePlan): readonly string[];
+export declare function userPromptSubmitExecutorOf(plan: HooksWirePlan): 'shell' | 'engine' | 'unknown' | 'none';
 export {};