macro-agent 0.1.8 → 0.1.11

package/src/cli/acp.ts

@@ -34,6 +34,10 @@ async function main() {
   try {
     const system = await bootV2({
       cwd: defaultCwd,
+      // `--instance-id` picks the on-disk compartment under ~/.macro-agent/
+      // so multiple runs with the same id share state. Omit to auto-derive
+      // from the cwd hash. See `BootV2Config.instanceId`.
+      ...(options.instanceId ? { instanceId: options.instanceId } : {}),
       // Enable ACP WebSocket server if port is specified (server mode)
       ...(options.port
         ? {

package/src/cli/index.ts

@@ -498,6 +498,67 @@ program
     }
   });
 
+// ─────────────────────────────────────────────────────────────────
+// Run Team Command (Phase 10)
+// ─────────────────────────────────────────────────────────────────
+
+program
+  .command("run <teamName>")
+  .description("Boot the system, start a team by name, and optionally prompt the root agent")
+  .option("--task <task>", "Task to prompt the root agent with")
+  .option("--cwd <path>", "Working directory for agents")
+  .option("--base-path <path>", "Base path for team YAML lookup (default: cwd)")
+  .action(async (teamName: string, options: { task?: string; cwd?: string; basePath?: string }) => {
+    const cwd = options.cwd ?? process.cwd();
+    console.log(chalk.blue(`Booting macro-agent and starting team: ${teamName}`));
+
+    let system: Awaited<ReturnType<typeof bootV2>> | null = null;
+    try {
+      system = await bootV2({ cwd });
+      console.log(chalk.green("System booted."));
+
+      // Construct & install a TeamManagerV2; start the requested team.
+      const { TeamManagerV2 } = await import("../teams/team-manager-v2.js");
+      const teamManager = new TeamManagerV2({
+        agentManager: system.agentManager,
+        inboxAdapter: system.inboxAdapter,
+        tasksAdapter: system.tasksAdapter,
+      });
+      teamManager.install();
+
+      const instanceId = await teamManager.startTeam(teamName, options.basePath ?? cwd);
+      console.log(chalk.green(`Team started: ${teamName} (instance ${instanceId})`));
+
+      // Find the root agent (first spawned agent in the instance)
+      const agents = system.agentStore.listAgents({ state: "running" });
+      const root = agents[0];
+
+      if (options.task && root) {
+        console.log(chalk.gray(`Prompting root agent (${root.id}) with task...`));
+        const iter = system.agentManager.prompt(root.id, options.task);
+        for await (const chunk of iter) {
+          process.stdout.write(typeof chunk === "string" ? chunk : JSON.stringify(chunk));
+        }
+        console.log();
+      } else if (!root) {
+        console.log(chalk.yellow("No root agent found to prompt."));
+      }
+
+      console.log(chalk.gray("Press Ctrl+C to shut down."));
+
+      // Graceful shutdown on SIGINT
+      process.on("SIGINT", async () => {
+        console.log(chalk.yellow("\nShutting down..."));
+        if (system) await system.shutdown();
+        process.exit(0);
+      });
+    } catch (error) {
+      console.error(chalk.red(`Failed to run team: ${error}`));
+      if (system) await system.shutdown();
+      process.exit(1);
+    }
+  });
+
 // ─────────────────────────────────────────────────────────────────
 // Parse and Run
 // ─────────────────────────────────────────────────────────────────

package/src/cognitive/macro-agent-backend.ts

@@ -240,6 +240,46 @@ export class MacroAgentBackend {
     const timeout = config.timeout;
     let softTimer: ReturnType<typeof setTimeout> | undefined;
     let hardTimer: ReturnType<typeof setTimeout> | undefined;
+    let completionNotified = false;
+
+    // Helper: fire the completion callback + inbox notification exactly once.
+    // Called from both the hard-timer path and the finally block to avoid a
+    // race where waitForSession returns (state != "running") before finally
+    // runs and fires the callback.
+    const notifyCompletion = async (): Promise<void> => {
+      if (completionNotified) return;
+      if (session.state !== "completed" && session.state !== "failed") return;
+      completionNotified = true;
+
+      const completeEvent: SessionCompleteEvent = {
+        sessionId: session.id,
+        agentId: agentId as string,
+        state: session.state,
+        duration_ms: session.endTime
+          ? session.endTime.getTime() - session.startTime.getTime()
+          : 0,
+        message_count: session.messages.length,
+        tool_call_count: session.toolCalls.length,
+      };
+
+      this.onSessionComplete?.(completeEvent);
+
+      if (this.inboxAdapter) {
+        try {
+          await this.inboxAdapter.send(
+            agentId as string,
+            agentId as string,
+            {
+              type: "session.complete",
+              sessionId: session.id,
+              state: session.state,
+              duration_ms: completeEvent.duration_ms,
+              outcome: session.state === "completed" ? "success" : "failure",
+            },
+          );
+        } catch { /* best-effort */ }
+      }
+    };
 
     try {
       if (timeout && timeout > 0) {
@@ -263,6 +303,9 @@ export class MacroAgentBackend {
           session.state = "failed";
           session.error = "Timeout exceeded";
           session.endTime = new Date();
+          // Fire completion callback immediately — the finally block's
+          // deferred callback could race with waitForSession returning.
+          void notifyCompletion();
           this.agentManager.terminate(agentId, "timeout").catch(() => {});
         }, timeout);
       }
@@ -307,35 +350,8 @@ export class MacroAgentBackend {
       }
 
       // Notify completion (no trajectory extraction — OpenHive handles that via sessionlog)
-      if (session.state === "completed" || session.state === "failed") {
-        const completeEvent: SessionCompleteEvent = {
-          sessionId: session.id,
-          agentId: agentId as string,
-          state: session.state,
-          duration_ms: session.endTime
-            ? session.endTime.getTime() - session.startTime.getTime()
-            : 0,
-          message_count: session.messages.length,
-          tool_call_count: session.toolCalls.length,
-        };
-
-        this.onSessionComplete?.(completeEvent);
-
-        if (this.inboxAdapter) {
-          await this.inboxAdapter.send(
-            agentId as string,
-            agentId as string,
-            {
-              type: "session.complete",
-              sessionId: session.id,
-              state: session.state,
-              duration_ms: completeEvent.duration_ms,
-              outcome: session.state === "completed" ? "success" : "failure",
-            },
-            { subject: "session.complete" },
-          ).catch(() => {});
-        }
-      }
+      // This is a no-op if the hard-timer path already fired it.
+      await notifyCompletion();
 
       // Clean up agent process
       if (session.state !== "running") {

package/src/integrations/skilltree.ts

@@ -55,6 +55,7 @@ async function loadSkillTree(): Promise<any> {
   _loadAttempted = true;
 
   try {
+    // @ts-ignore - optional peer dependency, may not be installed
     _skillTreeModule = await import("skill-tree");
     return _skillTreeModule;
   } catch {

package/src/lifecycle/__tests__/cascade-consolidation.test.ts

@@ -0,0 +1,240 @@
+/**
+ * Consolidation-through-tracker tests (A3 follow-up).
+ *
+ * Verifies `terminateWithChangeConsolidation` prefers
+ * `workspaceManager.mergeStream()` when both workspaces carry stream ids —
+ * so the merge fires `x-cascade/stream.merged` and propagates to the hub —
+ * and cleanly falls back to raw `git merge` when streams aren't available.
+ *
+ * Unit-only: stubs workspaces + agent manager. No git invocations.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { terminateWithChangeConsolidation } from '../cascade.js';
+import type {
+  CascadeAgentManager,
+  WorkspaceProvider,
+} from '../cascade.js';
+import type { Workspace, WorkspaceManager } from '../../workspace/types.js';
+import * as cleanupModule from '../cleanup.js';
+
+function mkWorkspace(overrides: Partial<Workspace> = {}): Workspace {
+  return {
+    agentId: 'agent',
+    path: '/tmp/wt',
+    branch: 'stream/s',
+    streamId: 's',
+    role: 'worker' as any,
+    createdAt: Date.now(),
+    ...overrides,
+  };
+}
+
+function mkAgentManager(): CascadeAgentManager {
+  return {
+    getChildren: vi.fn(() => []),
+    terminate: vi.fn(async () => {}),
+  };
+}
+
+describe('terminateWithChangeConsolidation', () => {
+  let attemptMergeSpy: ReturnType<typeof vi.spyOn>;
+  let getCurrentBranchSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    // Default: branch matches so the "parent on expected branch" warning doesn't fire.
+    getCurrentBranchSpy = vi
+      .spyOn(cleanupModule, 'getCurrentBranch')
+      .mockReturnValue('stream/parent');
+    attemptMergeSpy = vi.spyOn(cleanupModule, 'attemptMerge');
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('routes through workspaceManager.mergeStream when both workspaces have stream ids', async () => {
+    const mergeStream = vi.fn(() => ({ success: true, newHead: 'abc123' }));
+    const ws = { mergeStream } as unknown as WorkspaceManager;
+    const provider: WorkspaceProvider = {
+      getWorkspace: (id) =>
+        id === 'child'
+          ? mkWorkspace({ agentId: 'child', streamId: 'child-s', branch: 'stream/child' })
+          : mkWorkspace({ agentId: 'parent', streamId: 'parent-s', branch: 'stream/parent', path: '/tmp/parent' }),
+    };
+    const am = mkAgentManager();
+
+    const result = await terminateWithChangeConsolidation(
+      'child' as any,
+      'parent' as any,
+      am,
+      provider,
+      undefined,
+      ws,
+    );
+
+    expect(result).toEqual({ success: true, merged: true, mergeCommit: 'abc123' });
+    expect(mergeStream).toHaveBeenCalledWith({
+      sourceStreamId: 'child-s',
+      targetStreamId: 'parent-s',
+      agentId: 'parent',
+      worktree: '/tmp/parent',
+      metadata: undefined,
+    });
+    // Raw-git path must NOT be touched when the tracker handled it.
+    expect(attemptMergeSpy).not.toHaveBeenCalled();
+    expect(am.terminate).toHaveBeenCalledWith('child', 'changes_consolidated');
+  });
+
+  it('threads a provided taskRef into the mergeStream metadata', async () => {
+    const mergeStream = vi.fn(() => ({ success: true, newHead: 'def456' }));
+    const ws = { mergeStream } as unknown as WorkspaceManager;
+    const provider: WorkspaceProvider = {
+      getWorkspace: (id) =>
+        mkWorkspace({
+          agentId: id,
+          streamId: `${id}-s`,
+          branch: `stream/${id}`,
+        }),
+    };
+
+    const taskRef = { resource_id: 'res-a1', node_id: 'task-a1' };
+    await terminateWithChangeConsolidation(
+      'child' as any,
+      'parent' as any,
+      mkAgentManager(),
+      provider,
+      undefined,
+      ws,
+      taskRef,
+    );
+
+    expect(mergeStream).toHaveBeenCalledWith(
+      expect.objectContaining({ metadata: { task_ref: taskRef } }),
+    );
+  });
+
+  it('surfaces tracker conflicts without falling back to raw git', async () => {
+    const mergeStream = vi.fn(() => ({
+      success: false,
+      conflicts: ['shared.ts'],
+    }));
+    const ws = { mergeStream } as unknown as WorkspaceManager;
+    const provider: WorkspaceProvider = {
+      getWorkspace: (id) =>
+        mkWorkspace({
+          agentId: id,
+          streamId: `${id}-s`,
+          branch: `stream/${id}`,
+        }),
+    };
+    const am = mkAgentManager();
+
+    const result = await terminateWithChangeConsolidation(
+      'child' as any,
+      'parent' as any,
+      am,
+      provider,
+      undefined,
+      ws,
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.conflicts).toEqual(['shared.ts']);
+    expect(attemptMergeSpy).not.toHaveBeenCalled();
+    expect(am.terminate).toHaveBeenCalledWith('child', 'merge_conflict');
+  });
+
+  it('falls back to raw git when workspaceManager is not provided', async () => {
+    attemptMergeSpy.mockReturnValue({
+      success: true,
+      mergeCommit: 'rawabc',
+    });
+    const provider: WorkspaceProvider = {
+      getWorkspace: (id) =>
+        mkWorkspace({
+          agentId: id,
+          streamId: `${id}-s`,
+          branch: `stream/${id}`,
+        }),
+    };
+    const am = mkAgentManager();
+
+    const result = await terminateWithChangeConsolidation(
+      'child' as any,
+      'parent' as any,
+      am,
+      provider,
+      undefined,
+      // No workspaceManager argument.
+    );
+
+    expect(result).toEqual({ success: true, merged: true, mergeCommit: 'rawabc' });
+    expect(attemptMergeSpy).toHaveBeenCalledOnce();
+  });
+
+  it('falls back to raw git when the child workspace lacks a stream id', async () => {
+    attemptMergeSpy.mockReturnValue({ success: true, mergeCommit: 'legacyabc' });
+    const mergeStream = vi.fn();
+    const ws = { mergeStream } as unknown as WorkspaceManager;
+    const provider: WorkspaceProvider = {
+      getWorkspace: (id) =>
+        id === 'child'
+          ? mkWorkspace({ agentId: 'child', streamId: '', branch: 'feat/legacy' })
+          : mkWorkspace({ agentId: 'parent', streamId: 'parent-s', branch: 'stream/parent' }),
+    };
+
+    const result = await terminateWithChangeConsolidation(
+      'child' as any,
+      'parent' as any,
+      mkAgentManager(),
+      provider,
+      undefined,
+      ws,
+    );
+
+    expect(result.success).toBe(true);
+    expect(mergeStream).not.toHaveBeenCalled();
+    expect(attemptMergeSpy).toHaveBeenCalledOnce();
+  });
+
+  it('falls back to raw git when tracker.mergeStream throws', async () => {
+    const mergeStream = vi.fn(() => {
+      throw new Error('stream not found');
+    });
+    attemptMergeSpy.mockReturnValue({ success: true, mergeCommit: 'fallbackabc' });
+    const ws = { mergeStream } as unknown as WorkspaceManager;
+    const provider: WorkspaceProvider = {
+      getWorkspace: (id) =>
+        mkWorkspace({
+          agentId: id,
+          streamId: `${id}-s`,
+          branch: `stream/${id}`,
+        }),
+    };
+
+    const result = await terminateWithChangeConsolidation(
+      'child' as any,
+      'parent' as any,
+      mkAgentManager(),
+      provider,
+      undefined,
+      ws,
+    );
+
+    expect(result.success).toBe(true);
+    expect(mergeStream).toHaveBeenCalledOnce();
+    expect(attemptMergeSpy).toHaveBeenCalledOnce();
+  });
+
+  it('preserves legacy "no workspace provider" behavior', async () => {
+    const am = mkAgentManager();
+    const result = await terminateWithChangeConsolidation(
+      'child' as any,
+      'parent' as any,
+      am,
+    );
+    expect(result).toEqual({ success: true, merged: false });
+    expect(am.terminate).toHaveBeenCalledWith('child', 'parent_stopped');
+  });
+});

package/src/lifecycle/cascade.ts

@@ -129,11 +129,24 @@ export interface WorkspaceProvider {
  * If a merge conflict occurs, the merge is aborted and the child is
  * terminated with a "merge_conflict" reason.
  *
+ * When a `workspaceManager` is provided AND both workspaces carry stream
+ * ids, the merge is routed through `workspaceManager.mergeStream()` so
+ * it flows through git-cascade's tracker — gaining a `stream.merged`
+ * cascade event that propagates to the hub via CascadeBridge. This is
+ * the primary observability win of A3 in the integration plan.
+ *
+ * Falls back to raw `attemptMerge` (unchanged behavior) when either
+ * workspace lacks a stream id or no manager is passed — so
+ * programmatic/legacy callers keep working unchanged.
+ *
  * @param childId - Child agent to terminate
  * @param parentId - Parent agent to consolidate changes into
  * @param agentManager - Agent manager for operations
  * @param workspaceProvider - Optional workspace provider for getting agent workspaces
  * @param options - Optional consolidation options
+ * @param workspaceManager - Optional workspace manager; enables cascade-
+ *   event emission on the consolidation merge when both workspaces are
+ *   stream-backed.
  * @returns ConsolidationResult indicating success or failure
  */
 export async function terminateWithChangeConsolidation(
@@ -141,7 +154,15 @@ export async function terminateWithChangeConsolidation(
   parentId: AgentId,
   agentManager: CascadeAgentManager,
   workspaceProvider?: WorkspaceProvider,
-  options?: ConsolidationOptions
+  options?: ConsolidationOptions,
+  workspaceManager?: WorkspaceManager,
+  /**
+   * Optional task reference inherited from the parent agent's metadata.
+   * When provided + routing through the tracker, threaded into the
+   * `x-cascade/stream.merged` emit so the hub's cascade_merges row records
+   * which task drove the consolidation.
+   */
+  taskRef?: { resource_id: string; node_id: string }
 ): Promise<ConsolidationResult> {
   // If no workspace provider, just terminate normally
   if (!workspaceProvider) {
@@ -171,7 +192,61 @@ export async function terminateWithChangeConsolidation(
     // Continue with merge anyway - use the actual current branch
   }
 
-  // Attempt to merge child branch into parent's worktree
+  // Attempt to merge child branch into parent's worktree.
+  //
+  // Preferred path: route through workspaceManager.mergeStream when both
+  // workspaces have stream ids. Goes via git-cascade's tracker.mergeStream,
+  // which fires `x-cascade/stream.merged` with source/target stream ids so
+  // the hub's cascade projection + the source stream's `merged` status
+  // update in lockstep with the actual git operation.
+  if (
+    workspaceManager &&
+    childWorkspace.streamId &&
+    parentWorkspace.streamId
+  ) {
+    try {
+      const result = workspaceManager.mergeStream({
+        sourceStreamId: childWorkspace.streamId,
+        targetStreamId: parentWorkspace.streamId,
+        agentId: parentId,
+        worktree: parentWorkspace.path,
+        metadata: taskRef ? { task_ref: taskRef } : undefined,
+      });
+      if (result.success) {
+        await agentManager.terminate(childId, "changes_consolidated");
+        return {
+          success: true,
+          merged: true,
+          mergeCommit: result.newHead,
+        };
+      }
+      if (result.conflicts && result.conflicts.length > 0) {
+        // Tracker already aborted; emit and terminate with conflict reason.
+        console.warn(
+          `[cascade] Merge conflict consolidating ${childId} -> ${parentId} via tracker: ${result.conflicts.join(", ")}`
+        );
+        await agentManager.terminate(childId, "merge_conflict");
+        return {
+          success: false,
+          merged: false,
+          conflicts: result.conflicts,
+        };
+      }
+      // Tracker returned a non-conflict failure — fall through to raw
+      // git path so we don't regress the consolidation semantics for
+      // cases the tracker can't handle (e.g., stream in unexpected
+      // status, detached HEAD, branch-name mismatches).
+    } catch (err) {
+      console.warn(
+        `[cascade] tracker.mergeStream failed consolidating ${childId} -> ${parentId}; falling back to raw git: ${err instanceof Error ? err.message : String(err)}`
+      );
+      // Fall through to raw-git path below.
+    }
+  }
+
+  // Fallback: raw git merge. Preserves pre-A3 behavior when streams
+  // aren't available (programmatic callers, legacy role-shaped
+  // workspaces) or when the tracker path bailed.
   const mergeMessage =
     options?.mergeMessage ??
     `Merge changes from ${childId} (${childBranch})`;

package/src/lifecycle/cleanup.ts

@@ -124,15 +124,45 @@ export function detectCleanupStatus(
 // =============================================================================
 
 /**
- * Commit all uncommitted changes in a workspace
+ * Optional handle for routing commits through git-cascade so the resulting
+ * commit gets a Change-Id trailer and emits an `x-cascade/stream.committed`
+ * event. When omitted, commits are made via raw git (no Change-Id, no
+ * cascade event) — used by legacy/null-workspace paths.
+ */
+export interface TrackedCommitHandle {
+  /** WorkspaceManager-style commitChanges signature */
+  commitChanges(opts: {
+    streamId: string;
+    agentId: string;
+    worktree: string;
+    message: string;
+    metadata?: Record<string, unknown>;
+  }): { commit: string; changeId: string };
+  /** Stream this commit belongs to */
+  streamId: string;
+  /** Agent making the commit */
+  agentId: string;
+  /** Optional metadata threaded into the cascade event (e.g. `{ task_ref }`) */
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Commit all uncommitted changes in a workspace.
+ *
+ * When a `TrackedCommitHandle` is supplied, the commit goes through
+ * git-cascade's tracker — gaining a stable Change-Id trailer and emitting
+ * `x-cascade/stream.committed` so OpenHive sees the work. Without a handle,
+ * falls back to raw git (legacy behavior).
  *
  * @param workspacePath - Path to the workspace
  * @param message - Commit message
+ * @param tracked - Optional handle to commit via the cascade tracker
  * @returns Commit hash if successful, undefined if nothing to commit
  */
 export function commitChanges(
   workspacePath: string,
-  message: string
+  message: string,
+  tracked?: TrackedCommitHandle
 ): string | undefined {
   try {
     // Check if there are changes to commit
@@ -140,7 +170,26 @@ export function commitChanges(
       return undefined;
     }
 
-    // Stage all changes
+    // Tracked path: stage + commit through git-cascade so Change-Id +
+    // x-cascade events fire.
+    if (tracked) {
+      try {
+        const { commit } = tracked.commitChanges({
+          streamId: tracked.streamId,
+          agentId: tracked.agentId,
+          worktree: workspacePath,
+          message,
+          metadata: tracked.metadata,
+        });
+        return commit;
+      } catch {
+        // Fall through to raw-git path on tracker failure (e.g., stream
+        // conflicted) so callers still get a commit. Caveat: no Change-Id
+        // and no cascade event in this fallback.
+      }
+    }
+
+    // Raw-git path: stage all changes
     execFileSync("git", ["add", "--all"], {
       cwd: workspacePath,
       encoding: "utf-8",

package/src/lifecycle/handlers-v2.ts

@@ -22,8 +22,9 @@ import type {
   CleanupStatus,
   DoneHandlerResult,
 } from "./types.js";
-import { commitChanges, attemptMerge, abortMerge } from "./cleanup.js";
+import { commitChanges, attemptMerge, abortMerge, type TrackedCommitHandle } from "./cleanup.js";
 import type { MergeQueueInterface } from "../workspace/merge-queue/types.js";
+import type { WorkspaceManager } from "../workspace/types.js";
 import {
   getAllDescendants,
   needsCascadeTermination,
@@ -40,6 +41,40 @@ export interface HandlerDepsV2 {
   agentManager: AgentManager;
   taskMode?: "push" | "pull";
   mergeQueue?: MergeQueueInterface;
+  /**
+   * Optional workspace manager. When provided AND `context.streamId` is set,
+   * commits route through the cascade tracker (Change-Id + x-cascade events).
+   * Without it, commits use raw git (legacy / null-workspace path).
+   */
+  workspaceManager?: WorkspaceManager;
+}
+
+// =============================================================================
+// Tracked Commit Helper
+// =============================================================================
+
+/**
+ * Build a TrackedCommitHandle when the agent has a streamId + workspaceManager.
+ * Returns undefined if either is missing — caller falls back to raw git.
+ */
+function buildTrackedHandle(
+  context: LifecycleContext,
+  deps: HandlerDepsV2
+): TrackedCommitHandle | undefined {
+  if (!context.streamId || !deps.workspaceManager) return undefined;
+  const ws = deps.workspaceManager;
+  // Build metadata with task_ref if known. Empty object is fine — the hub
+  // ignores unknown fields, and back-fill kicks in if task_ref appears later.
+  const metadata: Record<string, unknown> = {};
+  if (context.taskRef) {
+    metadata.task_ref = context.taskRef;
+  }
+  return {
+    streamId: context.streamId,
+    agentId: context.agentId,
+    metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+    commitChanges: (opts) => ws.commitChanges(opts),
+  };
 }
 
 // =============================================================================
@@ -110,10 +145,12 @@ async function handleWorkerDone(
         ? `WIP: ${args.summary}`
         : `WIP: Auto-commit from done() with ${uncommittedCount} uncommitted file(s)`;
 
-      const commitHash = commitChanges(context.workspacePath, commitMessage);
+      const tracked = buildTrackedHandle(context, deps);
+      const commitHash = commitChanges(context.workspacePath, commitMessage, tracked);
       if (commitHash) {
+        const via = tracked ? "tracker" : "raw-git";
         cleanupActions.push(
-          `Committed ${uncommittedCount} file(s): ${commitHash.slice(0, 8)}`
+          `Committed ${uncommittedCount} file(s) via ${via}: ${commitHash.slice(0, 8)}`
         );
       } else {
         warnings.push("Failed to auto-commit uncommitted changes");