@salesforce/sfdx-agent-sdk 0.40.0 → 0.41.0

package/CHANGELOG.md

@@ -3,6 +3,11 @@
 All notable changes to `@salesforce/sfdx-agent-sdk` are documented in this file.
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [0.41.0] - 2026-08-03
+
+### Features
+- **agent-sdk,harnesses**: emit Tier-1 logBus siblings for lifecycle telemetry @W-23547150@ ([#716](https://github.com/forcedotcom/agentic-dx/pull/716))
+
 ## [0.40.0] - 2026-08-03
 
 ### Features

package/README.md

@@ -1546,6 +1546,13 @@ Abandoning the iterator mid-stream emits no terminal telemetry — the stream di
 Harness implementations may emit additional structured logs through their own `LogBus`. Those records surface to
 consumers via the same `onLog` channel.
 
+Selected lifecycle moments are reported on **both** channels: the typed telemetry event, plus a log record carrying the
+same facts for log sinks. On those records `message` is human-readable prose intended for display and may be reworded;
+`context.event_type` carries the matching `TelemetryEvent` type and is the stable field to filter, alert, and join on.
+Records paired this way today are `agent-created`, `agent-destroyed`, `session-created`, `session-destroyed`,
+`chat-stream-completed`, `chat-stream-error`, `tool-execution-completed` (only when `isError` is true), and the harness
+MCP events `mcp-server-discovery-completed`, `mcp-server-discovery-failed`, and `mcp-server-status-changed`.
+
 ## Development
 
 See [DEVELOPING.md](DEVELOPING.md) for build-from-source setup, scripts, E2E testing, and packaging.

package/dist/agent-manager.js

@@ -189,12 +189,20 @@ export class DefaultAgentManager {
         this.wireRouter.registerAgent(agentId);
         const agent = new DefaultAgent(this.harness, agentId, projectRoot, config, runtime.modelConnectivityInfo, runtime.orgConnection, runtime.orgJwt, this.agentConnectivityResolver, this.harnessSupportedProviderHints, this.hooksForAgent, this.identityStore, this.router, agentSlice, { telemetry: this.telemetryBus, log: this.logBus }, this.clock, this.agentIdGenerator);
         this.agents.set(agentId, agent);
+        const agentCreatedAt = this.clock.now();
+        const modelName = runtime.modelConnectivityInfo.model.name;
         this.telemetryBus.emit({
             type: 'agent-created',
-            timestamp: this.clock.now(),
+            timestamp: agentCreatedAt,
             agentId,
             projectRoot,
-            modelName: runtime.modelConnectivityInfo.model.name,
+            modelName,
+        });
+        this.logBus.emit({
+            level: 'info',
+            message: 'Agent created',
+            timestamp: agentCreatedAt,
+            context: { event_type: 'agent-created', agentId, projectRoot, modelName },
         });
         if (options.rehydrateThreads) {
             // If thread enumeration or session attachment fails, the restore is a full failure

package/dist/agent.js

@@ -283,11 +283,18 @@ export class DefaultAgent {
         }
         this.sessions.clear();
         await this.harness.destroyAgent(this.agentId);
+        const agentDestroyedAt = this.clock.now();
         this.telemetryBus.emit({
             type: 'agent-destroyed',
-            timestamp: this.clock.now(),
+            timestamp: agentDestroyedAt,
             agentId: this.agentId,
         });
+        this.logBus.emit({
+            level: 'info',
+            message: 'Agent destroyed',
+            timestamp: agentDestroyedAt,
+            context: { event_type: 'agent-destroyed', agentId: this.agentId },
+        });
         for (const unsub of this.inboundUnsubs)
             unsub();
         for (const unsub of this.parentUnsubs)
@@ -347,12 +354,19 @@ export class DefaultAgent {
         }, getContextWindow, { clock: this.clock, idGenerator: this.idGenerator, persistRememberedRule });
         this.sessions.set(threadId, session);
         this.sessionSliceUnregisters.set(threadId, () => this.router.unregisterSession(threadId));
+        const sessionCreatedAt = this.clock.now();
         this.telemetryBus.emit({
             type: 'session-created',
-            timestamp: this.clock.now(),
+            timestamp: sessionCreatedAt,
             agentId: this.agentId,
             threadId,
         });
+        this.logBus.emit({
+            level: 'info',
+            message: 'Chat session created',
+            timestamp: sessionCreatedAt,
+            context: { event_type: 'session-created', agentId: this.agentId, threadId },
+        });
         return session;
     }
     detachSession(threadId, session) {

package/dist/chat-session.js

@@ -237,6 +237,18 @@ export class DefaultChatSession {
                 durationMs,
                 error: lastError,
             });
+            this.logBus.emit({
+                level: 'error',
+                message: 'Chat stream failed',
+                timestamp: finishedAt,
+                context: {
+                    event_type: 'chat-stream-error',
+                    agentId: this.agentId,
+                    threadId: this.threadId,
+                    durationMs,
+                },
+                error: lastError,
+            });
         }
         else {
             this.telemetryBus.emit({
@@ -247,6 +259,18 @@ export class DefaultChatSession {
                 durationMs,
                 usage: finishUsage,
             });
+            this.logBus.emit({
+                level: 'info',
+                message: 'Chat stream completed',
+                timestamp: finishedAt,
+                context: {
+                    event_type: 'chat-stream-completed',
+                    agentId: this.agentId,
+                    threadId: this.threadId,
+                    durationMs,
+                    ...(finishUsage !== undefined ? { usage: finishUsage } : {}),
+                },
+            });
         }
     }
     /**
@@ -420,12 +444,23 @@ export class DefaultChatSession {
         if (this.disposed) {
             return;
         }
+        const sessionDestroyedAt = this.clock.now();
         this.telemetryBus.emit({
             type: 'session-destroyed',
-            timestamp: this.clock.now(),
+            timestamp: sessionDestroyedAt,
             agentId: this.agentId,
             threadId: this.threadId,
         });
+        this.logBus.emit({
+            level: 'info',
+            message: 'Chat session destroyed',
+            timestamp: sessionDestroyedAt,
+            context: {
+                event_type: 'session-destroyed',
+                agentId: this.agentId,
+                threadId: this.threadId,
+            },
+        });
         for (const unsub of this.inboundUnsubs)
             unsub();
         for (const unsub of this.parentUnsubs)
@@ -436,6 +471,8 @@ export class DefaultChatSession {
         this.disposed = true;
     }
     emitToolApprovalResolved(toolCallId, approved, policyWritten) {
+        // No Tier-1 logBus sibling: tool-approval-resolved fires per gated
+        // tool call — interactive-UI signal, not on-call triage
         this.telemetryBus.emit({
             type: 'tool-approval-resolved',
             timestamp: this.clock.now(),
@@ -476,6 +513,8 @@ export class DefaultChatSession {
     deriveToolTelemetry(event) {
         if (event.type === 'tool-call') {
             this.toolStartMs.set(event.toolCallId, this.clock.now().getTime());
+            // No Tier-1 logBus sibling: tool-execution-started pairs 1:1 with
+            // tool-execution-completed; the completion (isError=true) is the triage signal
             this.telemetryBus.emit({
                 type: 'tool-execution-started',
                 timestamp: this.clock.now(),
@@ -492,19 +531,42 @@ export class DefaultChatSession {
             if (start === undefined)
                 return;
             this.toolStartMs.delete(event.toolCallId);
+            const completedAt = this.clock.now();
+            const durationMs = completedAt.getTime() - start;
+            const isError = event.isError === true;
             this.telemetryBus.emit({
                 type: 'tool-execution-completed',
-                timestamp: this.clock.now(),
+                timestamp: completedAt,
                 agentId: this.agentId,
                 threadId: this.threadId,
                 toolCallId: event.toolCallId,
                 toolName: event.toolName,
-                durationMs: this.clock.now().getTime() - start,
-                isError: event.isError === true,
+                durationMs,
+                isError,
                 ...(event.error ? { error: event.error } : {}),
                 ...(event.annotations ? { annotations: event.annotations } : {}),
                 ...(event.serverName ? { serverName: event.serverName } : {}),
             });
+            // Tier-1 logBus sibling only when isError=true.
+            if (isError) {
+                this.logBus.emit({
+                    level: 'error',
+                    message: 'Tool execution failed',
+                    timestamp: completedAt,
+                    context: {
+                        event_type: 'tool-execution-completed',
+                        agentId: this.agentId,
+                        threadId: this.threadId,
+                        toolCallId: event.toolCallId,
+                        toolName: event.toolName,
+                        durationMs,
+                        isError: true,
+                        ...(event.annotations ? { annotations: event.annotations } : {}),
+                        ...(event.serverName ? { serverName: event.serverName } : {}),
+                    },
+                    ...(event.error ? { error: event.error } : {}),
+                });
+            }
         }
         else if (event.type === 'tool-approval-request') {
             // Record the (toolName, serverName?) so a later settle with
@@ -574,6 +636,7 @@ export class DefaultChatSession {
      */
     emitChatStreamStarted(trigger) {
         const startedAt = this.clock.now();
+        // chat-stream-started pairs 1:1 with chat-stream-completed, which already carries outcomes
         this.telemetryBus.emit({
             type: 'chat-stream-started',
             timestamp: startedAt,
@@ -597,12 +660,25 @@ export class DefaultChatSession {
         this.chatEventBus.emit({ type: 'error', error });
         this.chatEventBus.emit({ type: 'finish', finishReason: 'error' });
         const finishedAt = this.clock.now();
+        const durationMs = finishedAt.getTime() - startedAt.getTime();
         this.telemetryBus.emit({
             type: 'chat-stream-error',
             timestamp: finishedAt,
             agentId: this.agentId,
             threadId: this.threadId,
-            durationMs: finishedAt.getTime() - startedAt.getTime(),
+            durationMs,
+            error,
+        });
+        this.logBus.emit({
+            level: 'error',
+            message: 'Chat stream failed',
+            timestamp: finishedAt,
+            context: {
+                event_type: 'chat-stream-error',
+                agentId: this.agentId,
+                threadId: this.threadId,
+                durationMs,
+            },
             error,
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/sfdx-agent-sdk",
-  "version": "0.40.0",
+  "version": "0.41.0",
   "description": "Harness-agnostic agentic infrastructure for Salesforce developer experience tooling",
   "type": "module",
   "main": "dist/index.js",
@@ -47,9 +47,9 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@salesforce/sfdx-agent-harness-claude": "0.36.0",
-    "@salesforce/sfdx-agent-harness-mastra": "0.39.0",
-    "@salesforce/sfdx-agent-harness-openai": "0.5.0",
+    "@salesforce/sfdx-agent-harness-claude": "0.37.0",
+    "@salesforce/sfdx-agent-harness-mastra": "0.40.0",
+    "@salesforce/sfdx-agent-harness-openai": "0.6.0",
     "@types/node": "^22.20.0",
     "@vitest/coverage-istanbul": "^4.1.10",
     "@vitest/eslint-plugin": "^1.6.22",