diff --git a/apps/web/src/components/cloud-agent-next/CloudAgentWorkspaceTabs.test.ts b/apps/web/src/components/cloud-agent-next/CloudAgentWorkspaceTabs.test.ts
index b314f22143..ce030b6565 100644
--- a/apps/web/src/components/cloud-agent-next/CloudAgentWorkspaceTabs.test.ts
+++ b/apps/web/src/components/cloud-agent-next/CloudAgentWorkspaceTabs.test.ts
@@ -152,6 +152,17 @@ describe('CloudAgentWorkspaceTabs', () => {
       expect(html).toContain('Selected workspace panel');
     }
   });
+
+  it('keeps workspace navigation limited to chats, terminals, and saved files', () => {
+    const html = renderWorkspaceTabs({
+      terminals: [{ id: 'pty', title: 'Terminal 1', cloudAgentSessionId: 'workspace-one' }],
+      files: [{ path: 'src/file.ts' }],
+    });
+    expect((html.match(/<button\b[^>]*role="tab"/g) ?? []).length).toBe(3);
+    expect(html).not.toContain('View diff');
+    expect(html).not.toContain('Commit');
+  });
+
   it('renders complete grouped chat titles and selects only the current session tab', () => {
     const firstTitle = 'Investigate the complete authentication regression across every provider';
     const secondTitle = 'Fix the separate billing synchronization flow';
diff --git a/apps/web/src/components/cloud-agent-next/CloudChatPage.tsx b/apps/web/src/components/cloud-agent-next/CloudChatPage.tsx
index cd4b9713f7..4556a5f44f 100644
--- a/apps/web/src/components/cloud-agent-next/CloudChatPage.tsx
+++ b/apps/web/src/components/cloud-agent-next/CloudChatPage.tsx
@@ -55,6 +55,7 @@ import type { OrganizationRole } from '@/lib/organizations/organization-types';
 import { CloudAgentWorkspaceTabs } from './CloudAgentWorkspaceTabs';
 import { WorktreeChangesDrawer } from './WorktreeChanges';
 import { WorktreeFilePane } from './WorktreeFilePane';
+import { commitsByMessageAnchor, isCommitSummaryRepresented } from './message-presentation';
 import { Tabs, TabsContent } from '@/components/ui/tabs';
 import { canOpenWorktreeChanges } from './worktree-changes';
 import {
@@ -206,6 +207,7 @@ export default function CloudChatPage({
   const activity = useAtomValue(manager.atoms.activity);
   const cloudStatus = useAtomValue(manager.atoms.cloudStatus);
   const preparationAttempts = useAtomValue(manager.atoms.preparationAttempts);
+  const commits = useAtomValue(manager.atoms.commits);
   const activeQuestion = useAtomValue(manager.atoms.activeQuestion);
   const activePermission = useAtomValue(manager.atoms.activePermission);
   const activeSuggestion = useAtomValue(manager.atoms.activeSuggestion);
@@ -276,6 +278,11 @@ export default function CloudChatPage({
   const fileScope = JSON.stringify([currentUserId, organizationId, sessionIdFromParams, sessionId]);
   const [resolvedFileScope, setResolvedFileScope] = useState(fileScope);
   const filesVisible = canOpenChanges && resolvedFileScope === fileScope;
+  const commitsAfterMessage = useMemo(
+    () =>
+      commitsByMessageAnchor([...staticMessages, ...dynamicMessages], filesVisible ? commits : []),
+    [commits, dynamicMessages, filesVisible, staticMessages]
+  );
   const activeWorkspaceTabId =
     !filesVisible && workspaceTabs.activeTabId.startsWith('file:')
       ? CHAT_TAB_ID
@@ -1008,8 +1015,9 @@ export default function CloudChatPage({
   // A running preparation row already shows live progress inline, so the
   // trailing progress row would repeat the same message beneath it.
   const visibleStatusIndicator =
-    statusIndicator?.type === 'progress' &&
-    preparationAttempts.some(attempt => attempt.status === 'running')
+    (statusIndicator?.type === 'progress' &&
+      preparationAttempts.some(attempt => attempt.status === 'running')) ||
+    isCommitSummaryRepresented(statusIndicator, commitsAfterMessage)
       ? null
       : statusIndicator;
 
@@ -1223,6 +1231,7 @@ export default function CloudChatPage({
                                 dynamicMessages={dynamicMessages}
                                 pendingMessages={pendingMessages}
                                 preparationByMessageId={preparationByMessageId}
+                                commitsAfterMessage={commitsAfterMessage}
                                 getChildMessages={getChildMessages}
                                 onOpenChildSession={handleOpenTopLevelChildSession}
                                 onOpenPreparationDetails={handleOpenPreparationDetails}
diff --git a/apps/web/src/components/cloud-agent-next/CommitCard.tsx b/apps/web/src/components/cloud-agent-next/CommitCard.tsx
new file mode 100644
index 0000000000..944fd8b5f7
--- /dev/null
+++ b/apps/web/src/components/cloud-agent-next/CommitCard.tsx
@@ -0,0 +1,99 @@
+'use client';
+
+import { useState } from 'react';
+import type { SessionCommit } from '@kilocode/cloud-agent-sdk';
+import { GitCommitHorizontal } from 'lucide-react';
+import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip';
+
+export function CommitDetails({ commit }: { commit: SessionCommit }) {
+  const [subject, ...bodyLines] = commit.commitMessage.split('\n');
+  const body = bodyLines.join('\n').replace(/^\n+/, '');
+  const notPushed = commit.pushStatus === 'failed' || commit.pushStatus === 'not_attempted';
+
+  return (
+    <div className="flex flex-col gap-3 wrap-anywhere">
+      <div className="space-y-2">
+        <p className="text-sm leading-5 font-medium">{subject || 'Empty commit message'}</p>
+        {body && (
+          <p className="text-muted-foreground text-xs leading-5 whitespace-pre-wrap">{body}</p>
+        )}
+        {commit.commitMessageTruncated && (
+          <p className="text-muted-foreground text-xs">Message truncated.</p>
+        )}
+      </div>
+      <div className="text-muted-foreground flex flex-col gap-1 text-xs leading-5">
+        <code className="text-[11px] select-all">{commit.commitHash}</code>
+        <div className="flex items-center gap-2">
+          <time dateTime={commit.committedAt} title={new Date(commit.committedAt).toLocaleString()}>
+            {new Date(commit.committedAt).toLocaleString(undefined, {
+              month: 'short',
+              day: 'numeric',
+              hour: 'numeric',
+              minute: '2-digit',
+            })}
+          </time>
+          {notPushed && (
+            <>
+              <span aria-hidden="true">·</span>
+              <span className="whitespace-nowrap">Not pushed</span>
+            </>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export function CommitCard({ commit }: { commit: SessionCommit }) {
+  const [popoverOpen, setPopoverOpen] = useState(false);
+  const [tooltipOpen, setTooltipOpen] = useState(false);
+  const shortHash = commit.commitHash.slice(0, 7);
+  const subject = commit.commitMessage.split('\n', 1)[0];
+
+  return (
+    <Popover
+      open={popoverOpen}
+      onOpenChange={open => {
+        setTooltipOpen(false);
+        setPopoverOpen(open);
+      }}
+    >
+      <Tooltip open={tooltipOpen && !popoverOpen} onOpenChange={setTooltipOpen}>
+        <TooltipTrigger asChild>
+          <PopoverTrigger asChild>
+            <button
+              type="button"
+              className="text-muted-foreground hover:text-foreground focus-visible:ring-ring my-1 flex min-h-6 min-w-0 max-w-full items-center gap-1.5 rounded-sm text-left text-xs focus-visible:ring-2 focus-visible:outline-none [@media(any-pointer:coarse)]:min-h-11"
+              data-commit-hash={commit.commitHash}
+              aria-label={`Commit ${shortHash} details`}
+            >
+              <GitCommitHorizontal className="size-3.5 shrink-0" aria-hidden="true" />
+              <code className="shrink-0">{shortHash}</code>
+              <span className="min-w-0 truncate">{subject || 'Empty commit subject'}</span>
+            </button>
+          </PopoverTrigger>
+        </TooltipTrigger>
+        {!popoverOpen && (
+          <TooltipContent
+            side="top"
+            align="start"
+            sideOffset={4}
+            className="max-h-[min(24rem,var(--radix-tooltip-content-available-height))] w-96 max-w-[calc(100vw-2rem)] overflow-y-auto overscroll-contain p-4 text-left text-wrap"
+          >
+            <CommitDetails commit={commit} />
+          </TooltipContent>
+        )}
+      </Tooltip>
+      <PopoverContent
+        side="top"
+        align="start"
+        onCloseAutoFocus={() => queueMicrotask(() => setTooltipOpen(false))}
+        aria-label={`Commit ${shortHash} details`}
+        className="max-h-[min(24rem,var(--radix-popover-content-available-height))] w-96 max-w-[calc(100vw-2rem)] overflow-y-auto overscroll-contain p-4"
+      >
+        <CommitDetails commit={commit} />
+      </PopoverContent>
+    </Popover>
+  );
+}
diff --git a/apps/web/src/components/cloud-agent-next/ConversationMessages.test.ts b/apps/web/src/components/cloud-agent-next/ConversationMessages.test.ts
index 69e7867fcf..7ddba66b1a 100644
--- a/apps/web/src/components/cloud-agent-next/ConversationMessages.test.ts
+++ b/apps/web/src/components/cloud-agent-next/ConversationMessages.test.ts
@@ -3,6 +3,7 @@ import { renderToStaticMarkup } from 'react-dom/server';
 import { atom } from 'jotai';
 import type {
   PreparationAttempt,
+  SessionCommit,
   SessionManager,
   StandaloneQuestion,
   StandaloneSuggestion,
@@ -11,6 +12,7 @@ import type { AssistantMessage } from '@/types/opencode.gen';
 import type { Part, ReasoningPart, StoredMessage, TextPart, ToolPart } from './types';
 import type * as ToolCardShellModule from './ToolCardShell';
 import { useOptionalManager } from './CloudAgentProvider';
+import { CommitDetails } from './CommitCard';
 
 let mockExpanded = false;
 
@@ -37,6 +39,7 @@ jest.mock('react-markdown', () => ({
 jest.mock('remark-gfm', () => ({ __esModule: true, default: () => undefined }));
 
 import { ConversationMessages } from './ConversationMessages';
+import { commitsByMessageAnchor } from './message-presentation';
 import { PartRenderer } from './PartRenderer';
 
 Object.assign(globalThis, { React });
@@ -108,8 +111,14 @@ function toolPart(
 
 function renderConversation(
   staticMessages: StoredMessage[],
-  overrides: Partial<React.ComponentProps<typeof ConversationMessages>> = {}
+  overrides: Partial<React.ComponentProps<typeof ConversationMessages>> & {
+    commits?: readonly SessionCommit[];
+  } = {}
 ): string {
+  const { commits = [], ...props } = overrides;
+  const commitsAfterMessage =
+    props.commitsAfterMessage ??
+    commitsByMessageAnchor([...staticMessages, ...(props.dynamicMessages ?? [])], commits);
   return renderToStaticMarkup(
     React.createElement(ConversationMessages, {
       active: true,
@@ -119,7 +128,8 @@ function renderConversation(
       pendingMessages: new Map(),
       preparationByMessageId: new Map(),
       onOpenPreparationDetails: jest.fn(),
-      ...overrides,
+      commitsAfterMessage,
+      ...props,
     })
   );
 }
@@ -134,6 +144,169 @@ beforeEach(() => {
 });
 
 describe('ConversationMessages', () => {
+  const commit: SessionCommit = {
+    commitHash: 'a'.repeat(40),
+    commitMessage: 'Fix the actual issue\n\nKeep the complete body accessible.',
+    messageId: 'assistant-1',
+    userMessageId: 'user-1',
+    committedAt: '2026-09-01T10:00:00.000Z',
+    pushStatus: 'failed',
+  };
+
+  it('renders one compact commit line at its anchor without diff actions, preserving later rows', () => {
+    const html = renderConversation(
+      [assistantMessage('assistant-1', [textPart('first', 'First answer')])],
+      {
+        dynamicMessages: [assistantMessage('assistant-2', [textPart('second', 'Later answer')])],
+        commits: [commit, { ...commit }],
+      }
+    );
+    expect(html.match(/data-commit-hash=/g)).toHaveLength(1);
+    const trigger = buttons(html).find(button => button.includes('data-commit-hash='));
+    expect(trigger).toContain(`data-commit-hash="${commit.commitHash}"`);
+    expect(trigger).toContain('Fix the actual issue');
+    expect(trigger).toContain('truncate');
+    expect(trigger).toContain('aria-label="Commit aaaaaaa details"');
+    expect(trigger).toContain('aria-haspopup="dialog"');
+    expect(trigger).toContain('aria-expanded="false"');
+    expect(trigger).toContain('focus-visible:ring-2');
+    expect(trigger).toContain('[@media(any-pointer:coarse)]:min-h-11');
+    expect(trigger).not.toMatch(/\b(?:border|bg-|flex-wrap)/);
+    expect(html).not.toContain('View diff');
+    expect(html).not.toContain('Keep the complete body accessible.');
+    expect(html).not.toContain('Push failed');
+    expect(html).not.toContain('may include changes from other chats');
+    expect(html.indexOf('First answer')).toBeLessThan(html.indexOf('data-commit-hash='));
+    expect(html.indexOf('data-commit-hash=')).toBeLessThan(html.indexOf('Later answer'));
+    expect(html.match(/data-message-role="assistant"/g)).toHaveLength(2);
+  });
+
+  it('shares one combined anchor map across transcript chunks without fallback duplicates', () => {
+    const staticMessages: StoredMessage[] = [
+      {
+        info: {
+          id: 'user-1',
+          role: 'user',
+          sessionID: 'ses-1',
+          time: { created: 0 },
+          agent: 'code',
+          model: { providerID: 'test', modelID: 'test' },
+        },
+        parts: [],
+      },
+      assistantMessage('assistant-1', [textPart('first', 'First answer')]),
+    ];
+    const dynamicMessages = [
+      assistantMessage('assistant-2', [textPart('second', 'Second answer')]),
+    ];
+    const anchoredCommit = { ...commit, messageId: 'assistant-2' };
+    const commitsAfterMessage = commitsByMessageAnchor(
+      [...staticMessages, ...dynamicMessages],
+      [anchoredCommit]
+    );
+    const staticHtml = renderConversation(staticMessages, { commitsAfterMessage });
+    const dynamicHtml = renderConversation([], { dynamicMessages, commitsAfterMessage });
+    expect(staticHtml).not.toContain('data-commit-hash=');
+    expect(dynamicHtml.match(/data-commit-hash=/g)).toHaveLength(1);
+    expect(dynamicHtml.indexOf('Second answer')).toBeLessThan(
+      dynamicHtml.indexOf('data-commit-hash=')
+    );
+    expect(commitsAfterMessage.get('assistant-2')).toEqual([anchoredCommit]);
+  });
+
+  it.each([
+    ['pushed', false],
+    ['failed', true],
+    ['not_attempted', true],
+    ['unknown', false],
+  ] as const)(
+    'keeps commit metadata and shows only a confirmed non-push for %s',
+    (pushStatus, showsNotPushed) => {
+      const html = renderToStaticMarkup(
+        React.createElement(CommitDetails, { commit: { ...commit, pushStatus } })
+      );
+      expect(html).toContain('Fix the actual issue</p>');
+      expect(html).toContain('Keep the complete body accessible.</p>');
+      expect(html).toContain(commit.commitHash);
+      expect(html).toContain(`dateTime="${commit.committedAt}"`);
+      expect(html.includes('>Not pushed<')).toBe(showsNotPushed);
+      expect(html).not.toContain('Workspace commit');
+      expect(html).not.toContain('Push status');
+      expect(html).not.toContain('>Pushed<');
+      expect(html).not.toContain('may include changes from other chats');
+      expect(html).not.toContain('text-destructive');
+      expect(html).not.toContain('View diff');
+    }
+  );
+
+  it('keeps long commit messages as plain text in details without embedding them in the trigger name', () => {
+    const longCommit = {
+      ...commit,
+      commitMessage: `${'Long subject '.repeat(100)}\n\n<script>not markup</script>\n${'Body '.repeat(1000)}`,
+    };
+    const html = renderConversation(
+      [assistantMessage('assistant-1', [textPart('answer', 'Answer')])],
+      { commits: [longCommit] }
+    );
+    expect(html).toContain('aria-label="Commit aaaaaaa details"');
+    expect(html).not.toContain('Body ');
+    const details = renderToStaticMarkup(
+      React.createElement(CommitDetails, { commit: longCommit })
+    );
+    expect(details).toContain('Body '.repeat(1000));
+    expect(details).toContain('&lt;script&gt;not markup&lt;/script&gt;');
+    expect(details).not.toContain('<script>');
+  });
+
+  it('does not append a commit whose known assistant anchor is unloaded', () => {
+    const html = renderConversation(
+      [
+        {
+          info: {
+            id: 'user-1',
+            role: 'user',
+            sessionID: 'ses-1',
+            time: { created: 0 },
+            agent: 'code',
+            model: { providerID: 'test', modelID: 'test' },
+          },
+          parts: [],
+        },
+        assistantMessage('assistant-2', [textPart('later', 'Unrelated later answer')]),
+      ],
+      { commits: [commit] }
+    );
+    expect(html).not.toContain('data-commit-hash=');
+    expect(html).toContain('Unrelated later answer');
+  });
+
+  it('keeps different full SHAs with the same display prefix and defers saved-message truncation to details', () => {
+    const html = renderConversation(
+      [assistantMessage('assistant-1', [textPart('answer', 'Answer')])],
+      {
+        commits: [
+          commit,
+          {
+            ...commit,
+            commitHash: `${'a'.repeat(39)}b`,
+            pushStatus: 'not_attempted',
+            commitMessageTruncated: true,
+          },
+        ],
+      }
+    );
+    expect(html.match(/data-commit-hash=/g)).toHaveLength(2);
+    expect(html).not.toContain('Not pushed');
+    expect(html).not.toContain('Message truncated.');
+    const details = renderToStaticMarkup(
+      React.createElement(CommitDetails, { commit: { ...commit, commitMessageTruncated: true } })
+    );
+    expect(details).toContain('Message truncated.');
+    expect(renderToStaticMarkup(React.createElement(CommitDetails, { commit }))).not.toContain(
+      'Message truncated.'
+    );
+  });
+
   it('shows individual rows in transcript order with collapsed details and metadata after the answer', () => {
     const html = renderConversation([
       assistantMessage('assistant-1', [
diff --git a/apps/web/src/components/cloud-agent-next/ConversationMessages.tsx b/apps/web/src/components/cloud-agent-next/ConversationMessages.tsx
index 9ac9c10db3..e926197d87 100644
--- a/apps/web/src/components/cloud-agent-next/ConversationMessages.tsx
+++ b/apps/web/src/components/cloud-agent-next/ConversationMessages.tsx
@@ -1,19 +1,27 @@
 'use client';
 
 import { memo } from 'react';
-import type { MessageDeliveryState, PreparationAttempt } from '@kilocode/cloud-agent-sdk';
+import type {
+  MessageDeliveryState,
+  PreparationAttempt,
+  SessionCommit,
+} from '@kilocode/cloud-agent-sdk';
 import type { OpenChildSession } from './ChildSessionSection';
 import { MessageBubble } from './MessageBubble';
 import { MessageErrorBoundary } from './MessageErrorBoundary';
 import { PreparationRow } from './PreparationRow';
 import { groupConversationMessages } from './message-presentation';
+import { CommitCard } from './CommitCard';
 import { isMessageStreaming, type StoredMessage } from './types';
 
+const emptyCommitAnchors: ReadonlyMap<string, readonly SessionCommit[]> = new Map();
+
 type ConversationMessageGroupProps = {
   messages: StoredMessage[];
   isStreaming: boolean;
   deliveryState?: MessageDeliveryState;
   preparations?: readonly PreparationAttempt[];
+  commits?: readonly SessionCommit[];
   getChildMessages?: (sessionId: string) => StoredMessage[];
   onOpenChildSession?: OpenChildSession;
   onOpenPreparationDetails: (attemptId: string) => void;
@@ -25,6 +33,7 @@ const ConversationMessageGroup = memo(
     isStreaming,
     deliveryState,
     preparations,
+    commits,
     getChildMessages,
     onOpenChildSession,
     onOpenPreparationDetails,
@@ -53,6 +62,9 @@ const ConversationMessageGroup = memo(
             onOpenDetails={onOpenPreparationDetails}
           />
         ))}
+        {commits?.map(commit => (
+          <CommitCard key={commit.commitHash} commit={commit} />
+        ))}
       </MessageErrorBoundary>
     );
   },
@@ -60,6 +72,7 @@ const ConversationMessageGroup = memo(
     previous.isStreaming === next.isStreaming &&
     previous.deliveryState === next.deliveryState &&
     previous.preparations === next.preparations &&
+    previous.commits === next.commits &&
     previous.getChildMessages === next.getChildMessages &&
     previous.onOpenChildSession === next.onOpenChildSession &&
     previous.onOpenPreparationDetails === next.onOpenPreparationDetails &&
@@ -74,6 +87,7 @@ type ConversationMessagesProps = {
   dynamicMessages: StoredMessage[];
   pendingMessages: ReadonlyMap<string, MessageDeliveryState>;
   preparationByMessageId: ReadonlyMap<string, readonly PreparationAttempt[]>;
+  commitsAfterMessage?: ReadonlyMap<string, readonly SessionCommit[]>;
   getChildMessages?: (sessionId: string) => StoredMessage[];
   onOpenChildSession?: OpenChildSession;
   onOpenPreparationDetails: (attemptId: string) => void;
@@ -86,14 +100,13 @@ export const ConversationMessages = memo(
     dynamicMessages,
     pendingMessages,
     preparationByMessageId,
+    commitsAfterMessage = emptyCommitAnchors,
     getChildMessages,
     onOpenChildSession,
     onOpenPreparationDetails,
   }: ConversationMessagesProps) {
-    const groups = groupConversationMessages(
-      [...staticMessages, ...dynamicMessages],
-      preparationByMessageId
-    );
+    const messages = [...staticMessages, ...dynamicMessages];
+    const groups = groupConversationMessages(messages, preparationByMessageId, commitsAfterMessage);
 
     return groups.map(messages => {
       const first = messages[0];
@@ -107,6 +120,7 @@ export const ConversationMessages = memo(
           isStreaming={isStreaming && isMessageStreaming(last)}
           deliveryState={pendingMessages.get(first.info.id)}
           preparations={preparationByMessageId.get(first.info.id)}
+          commits={commitsAfterMessage.get(last.info.id)}
           getChildMessages={getChildMessages}
           onOpenChildSession={onOpenChildSession}
           onOpenPreparationDetails={onOpenPreparationDetails}
@@ -114,5 +128,6 @@ export const ConversationMessages = memo(
       );
     });
   },
-  (previous, next) => !previous.active && !next.active
+  (previous, next) =>
+    !previous.active && !next.active && previous.commitsAfterMessage === next.commitsAfterMessage
 );
diff --git a/apps/web/src/components/cloud-agent-next/message-presentation.test.ts b/apps/web/src/components/cloud-agent-next/message-presentation.test.ts
index 54fd9cd947..3b0cd00304 100644
--- a/apps/web/src/components/cloud-agent-next/message-presentation.test.ts
+++ b/apps/web/src/components/cloud-agent-next/message-presentation.test.ts
@@ -1,9 +1,15 @@
-import type { PreparationAttempt } from '@kilocode/cloud-agent-sdk';
+import type {
+  PreparationAttempt,
+  SessionCommit,
+  SessionStatusIndicator,
+} from '@kilocode/cloud-agent-sdk';
 import type { AssistantMessage } from '@/types/opencode.gen';
 import type { Part, ReasoningPart, StoredMessage, TextPart, ToolPart } from './types';
 import {
   getVisibleAssistantParts,
   groupConversationMessages,
+  commitsByMessageAnchor,
+  isCommitSummaryRepresented,
   shouldRenderToolPart,
 } from './message-presentation';
 
@@ -198,6 +204,101 @@ describe('groupConversationMessages', () => {
   });
 });
 
+describe('commitsByMessageAnchor', () => {
+  const user: StoredMessage = {
+    info: {
+      id: 'user-1',
+      sessionID: 'ses-1',
+      role: 'user',
+      time: { created: 1 },
+      agent: 'code',
+      model: { providerID: 'test', modelID: 'test' },
+    },
+    parts: [],
+  };
+  const commit = {
+    commitHash: 'a'.repeat(40),
+    commitMessage: 'Actual commit',
+    messageId: 'assistant-2',
+    userMessageId: user.info.id,
+    committedAt: '2026-09-01T10:00:00Z',
+    pushStatus: 'unknown',
+  } satisfies SessionCommit;
+
+  it('waits for a known assistant anchor instead of moving the commit to an older answer', () => {
+    const first = assistantMessage('assistant-1');
+    expect([...commitsByMessageAnchor([user, first], [commit])]).toEqual([]);
+    const anchor = assistantMessage(commit.messageId);
+    expect([...commitsByMessageAnchor([user, first, anchor], [commit])]).toEqual([
+      [anchor.info.id, [commit]],
+    ]);
+  });
+
+  it('places the commit only once across completed and dynamic transcript chunks', () => {
+    const completed = [user, assistantMessage('assistant-1')];
+    const dynamic = [assistantMessage(commit.messageId)];
+    expect([...commitsByMessageAnchor(completed, [commit])]).toEqual([]);
+    expect([...commitsByMessageAnchor(dynamic, [commit])]).toEqual([[commit.messageId, [commit]]]);
+    expect([...commitsByMessageAnchor([...completed, ...dynamic], [commit])]).toEqual([
+      [commit.messageId, [commit]],
+    ]);
+  });
+
+  it('uses user-turn fallback only for an explicit user anchor and after its turn completes', () => {
+    const userAnchored = { ...commit, messageId: user.info.id };
+    const first = assistantMessage('assistant-1');
+    const running = assistantMessage('assistant-2', { time: { created: 3 } });
+    expect([...commitsByMessageAnchor([user, first, running], [userAnchored])]).toEqual([]);
+    expect([...commitsByMessageAnchor([user, first], [userAnchored])]).toEqual([
+      [first.info.id, [userAnchored]],
+    ]);
+  });
+
+  it('deduplicates replay and prevents grouping across the exact commit boundary', () => {
+    const first = assistantMessage(commit.messageId);
+    const second = assistantMessage('assistant-3');
+    const commits = Object.freeze([commit, { ...commit }]);
+    const anchors = commitsByMessageAnchor([first, second], commits);
+    expect([...anchors]).toEqual([[first.info.id, [commit]]]);
+    expect(groupConversationMessages([first, second], noPreparations, anchors)).toEqual([
+      [first],
+      [second],
+    ]);
+  });
+});
+
+describe('commit summary suppression', () => {
+  const commit: SessionCommit = {
+    commitHash: 'a'.repeat(40),
+    messageId: 'assistant',
+    userMessageId: 'user',
+    committedAt: '2026-09-01T10:00:00.000Z',
+    commitMessage: 'Actual message',
+    pushStatus: 'pushed',
+  };
+  const represented = new Map([['assistant', [commit]]]);
+  const indicator: SessionStatusIndicator = {
+    type: 'info',
+    message: 'Committed',
+    timestamp: 1,
+    commitHash: commit.commitHash,
+  };
+
+  it('suppresses only an informational summary represented by the same full-SHA line', () => {
+    expect(isCommitSummaryRepresented(indicator, represented)).toBe(true);
+    expect(isCommitSummaryRepresented(indicator, new Map())).toBe(false);
+    expect(
+      isCommitSummaryRepresented({ ...indicator, commitHash: `${'a'.repeat(39)}b` }, represented)
+    ).toBe(false);
+    expect(isCommitSummaryRepresented({ ...indicator, commitHash: undefined }, represented)).toBe(
+      false
+    );
+    for (const type of ['progress', 'error', 'warning'] as const) {
+      expect(isCommitSummaryRepresented({ ...indicator, type }, represented)).toBe(false);
+    }
+  });
+});
+
 describe.each([
   { status: 'pending', input: {}, raw: '' },
   { status: 'running', input: {}, time: { start: 1 } },
diff --git a/apps/web/src/components/cloud-agent-next/message-presentation.ts b/apps/web/src/components/cloud-agent-next/message-presentation.ts
index fa0641de10..5fe7b93d04 100644
--- a/apps/web/src/components/cloud-agent-next/message-presentation.ts
+++ b/apps/web/src/components/cloud-agent-next/message-presentation.ts
@@ -1,10 +1,15 @@
-import type { PreparationAttempt } from '@kilocode/cloud-agent-sdk';
+import type {
+  PreparationAttempt,
+  SessionCommit,
+  SessionStatusIndicator,
+} from '@kilocode/cloud-agent-sdk';
 import type { Part, StoredMessage, ToolPart } from './types';
 import { isAssistantMessage, shouldRenderReasoningPart } from './types';
 
 export function groupConversationMessages(
   messages: StoredMessage[],
-  preparationByMessageId: ReadonlyMap<string, readonly PreparationAttempt[]>
+  preparationByMessageId: ReadonlyMap<string, readonly PreparationAttempt[]>,
+  commitsAfterMessage: ReadonlyMap<string, readonly SessionCommit[]> = new Map()
 ): StoredMessage[][] {
   const groups: StoredMessage[][] = [];
 
@@ -20,6 +25,7 @@ export function groupConversationMessages(
       previous.info.parentID === message.info.parentID &&
       previous.info.error == null &&
       message.info.error == null &&
+      !commitsAfterMessage.has(previous.info.id) &&
       !preparationByMessageId.get(previous.info.id)?.length &&
       !preparationByMessageId.get(message.info.id)?.length
     ) {
@@ -32,6 +38,63 @@ export function groupConversationMessages(
   return groups;
 }
 
+export function commitsByMessageAnchor(
+  messages: readonly StoredMessage[],
+  commits: readonly SessionCommit[]
+): ReadonlyMap<string, readonly SessionCommit[]> {
+  const messagesById = new Map(messages.map(message => [message.info.id, message]));
+  const byAnchor = new Map<string, SessionCommit[]>();
+  const seen = new Set<string>();
+  const time = (commit: SessionCommit) => {
+    const value = Date.parse(commit.committedAt ?? commit.timestamp ?? '');
+    return Number.isFinite(value) ? value : 0;
+  };
+  const ordered = [...commits].sort(
+    (a, b) => time(a) - time(b) || a.commitHash.localeCompare(b.commitHash)
+  );
+  for (const commit of ordered) {
+    if (seen.has(commit.commitHash)) continue;
+    seen.add(commit.commitHash);
+    const assistant = messagesById.get(commit.messageId);
+    let anchor = assistant?.info.role === 'assistant' ? assistant.info.id : undefined;
+    if (!anchor && commit.messageId === commit.userMessageId) {
+      const user = messagesById.get(commit.userMessageId);
+      if (user?.info.role !== 'user') continue;
+      const turn = messages.filter(
+        message =>
+          message.info.role === 'assistant' &&
+          message.info.parentID === user.info.id &&
+          message.info.sessionID === user.info.sessionID
+      );
+      if (
+        turn.some(
+          message => message.info.role === 'assistant' && message.info.time.completed === undefined
+        )
+      )
+        continue;
+      anchor = turn.at(-1)?.info.id ?? user.info.id;
+    }
+    if (!anchor) continue;
+    const anchored = byAnchor.get(anchor) ?? [];
+    anchored.push(commit);
+    byAnchor.set(anchor, anchored);
+  }
+  return byAnchor;
+}
+
+export function isCommitSummaryRepresented(
+  indicator: SessionStatusIndicator | null,
+  commitsAfterMessage: ReadonlyMap<string, readonly SessionCommit[]>
+): boolean {
+  return (
+    indicator?.type === 'info' &&
+    indicator.commitHash !== undefined &&
+    [...commitsAfterMessage.values()].some(commits =>
+      commits.some(commit => commit.commitHash === indicator.commitHash)
+    )
+  );
+}
+
 export function shouldRenderToolPart(part: ToolPart): boolean {
   if (part.tool === 'plan_enter' || part.tool === 'plan_exit' || part.tool === 'todoread') {
     return false;
diff --git a/apps/web/src/components/cloud-agent-next/terminal-tabs.test.ts b/apps/web/src/components/cloud-agent-next/terminal-tabs.test.ts
index ab31b9739c..0001f271c9 100644
--- a/apps/web/src/components/cloud-agent-next/terminal-tabs.test.ts
+++ b/apps/web/src/components/cloud-agent-next/terminal-tabs.test.ts
@@ -5,7 +5,9 @@ import type { CloudAgentWorkspaceTabs } from './CloudAgentWorkspaceTabs';
 import type { CloudChatPage as CloudChatPageComponent } from './CloudChatPage';
 import type { ChatHeader } from './ChatHeader';
 import type { WorktreeChangesDrawer } from './WorktreeChanges';
-import type { StoredSession } from './types';
+import type { ConversationMessages } from './ConversationMessages';
+import type { StoredMessage, StoredSession } from './types';
+import type { SessionCommit } from '@kilocode/cloud-agent-sdk';
 import {
   CHAT_TAB_ID,
   addTerminalTab,
@@ -23,6 +25,7 @@ Object.assign(globalThis, { React });
 let mockSessionId: string | null = 'ses_recent';
 let mockWorktreeId: string | null = 'worktree_shared';
 let mockTabs: ComponentProps<typeof CloudAgentWorkspaceTabs>;
+let mockConversation: ComponentProps<typeof ConversationMessages>;
 let mockAtomValues: Record<string, unknown>;
 const mockClosedPtys: string[] = [];
 const mockChats = [
@@ -165,7 +168,10 @@ jest.mock('./ChatInput', () => ({
   ChatInput: () => createElement('input', { 'data-composer': true }),
 }));
 jest.mock('./ConversationMessages', () => ({
-  ConversationMessages: () => createElement('section', { 'data-conversation': true }),
+  ConversationMessages: (props: ComponentProps<typeof ConversationMessages>) => {
+    mockConversation = props;
+    return createElement('section', { 'data-conversation': true });
+  },
 }));
 jest.mock('./OlderMessagesHeader', () => ({ OlderMessagesHeader: () => null }));
 jest.mock('./MessageBubble', () => ({ MessageBubble: () => null }));
@@ -371,6 +377,7 @@ describe('CloudChatPage terminal ownership across navigation', () => {
       dynamicMessages: [],
       pendingMessages: new Map(),
       preparationAttempts: [],
+      commits: [],
       chatUI: { shouldAutoScroll: false },
     };
     dom = installTerminalTestDom();
@@ -481,6 +488,94 @@ describe('CloudChatPage terminal ownership across navigation', () => {
     expect(mockTabs.files).toEqual([]);
   });
 
+  function receiveCommit() {
+    const commitHash = 'a'.repeat(40);
+    const commits: SessionCommit[] = [
+      {
+        commitHash,
+        commitMessage: 'Actual commit',
+        messageId: 'assistant',
+        userMessageId: 'user',
+        committedAt: '2026-09-01T10:00:00.000Z',
+        pushStatus: 'pushed',
+      },
+    ];
+    mockAtomValues.commits = commits;
+    mockAtomValues.dynamicMessages = [
+      {
+        info: {
+          id: 'assistant',
+          sessionID: 'ses_recent',
+          role: 'assistant',
+          time: { created: 1, completed: 2 },
+          parentID: 'user',
+          modelID: 'test',
+          providerID: 'test',
+          mode: 'code',
+          agent: 'code',
+          path: { cwd: '/', root: '/' },
+          cost: 0,
+          tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+        },
+        parts: [],
+      },
+    ] satisfies StoredMessage[];
+    render();
+    const anchors = mockConversation.commitsAfterMessage;
+    expect(anchors?.get('assistant')).toEqual(commits);
+    render();
+    expect(mockConversation.commitsAfterMessage).toBe(anchors);
+    return anchors;
+  }
+
+  it('adds commit metadata without changing workspace tabs, chats, the draft, or the mounted PTY', () => {
+    render();
+    const composer = dom.container.querySelector<HTMLInputElement>('[data-composer]');
+    if (!composer) throw new Error('Missing composer');
+    composer.value = 'Unsent draft';
+    const conversation = dom.container.querySelector('[data-conversation]');
+    const terminal = openTerminal();
+    const tabId = mockTabs.activeTabId;
+    const terminals = mockTabs.terminals;
+    const files = mockTabs.files;
+    const switches = mockManager.switchSession.mock.calls.length;
+    receiveCommit();
+    expect(mockTabs.activeTabId).toBe(tabId);
+    expect(mockTabs.terminals).toBe(terminals);
+    expect(mockTabs.files).toBe(files);
+    expect(mockTabs).not.toHaveProperty('commits');
+    expect(dom.container.querySelector('[data-composer]')).toBe(composer);
+    expect(composer.value).toBe('Unsent draft');
+    expect(dom.container.querySelector('[data-conversation]')).toBe(conversation);
+    expect(dom.container.querySelector('[data-pty-owner]')).toBe(terminal);
+    expect(mockSessionId).toBe('ses_recent');
+    expect(mockManager.switchSession.mock.calls.length).toBe(switches);
+    expect(mockClosedPtys).toEqual([]);
+  });
+
+  it('withholds old commit metadata before sibling atoms resolve while preserving the worktree PTY', () => {
+    render();
+    const terminal = openTerminal();
+    receiveCommit();
+    mockSessionId = 'ses_historical';
+    render();
+    expect(mockConversation.commitsAfterMessage?.size).toBe(0);
+    expect(dom.container.querySelector('[data-pty-owner]')).toBe(terminal);
+  });
+
+  it('withholds commit metadata when the organization does not match the loaded session', () => {
+    receiveCommit();
+    render({ organizationId: 'another-organization' });
+    expect(mockConversation.commitsAfterMessage?.size).toBe(0);
+  });
+
+  it('withholds commit metadata when access becomes read-only', () => {
+    receiveCommit();
+    mockAtomValues.isReadOnly = true;
+    render();
+    expect(mockConversation.commitsAfterMessage?.size).toBe(0);
+  });
+
   it('scopes changes to each sibling control session without replacing its worktree terminal', () => {
     render();
     const terminal = openTerminal();
diff --git a/packages/cloud-agent-sdk/src/index.ts b/packages/cloud-agent-sdk/src/index.ts
index 66324e1919..41520054c6 100644
--- a/packages/cloud-agent-sdk/src/index.ts
+++ b/packages/cloud-agent-sdk/src/index.ts
@@ -159,6 +159,7 @@ export type {
   SuggestionAction,
   SuggestionState,
   MessageDeliveryState,
+  SessionCommit,
   PreparationAttempt,
   PreparationAttemptStatus,
   PreparationStepKind,
diff --git a/packages/cloud-agent-sdk/src/normalizer.ts b/packages/cloud-agent-sdk/src/normalizer.ts
index 7749b5be6f..d18c08a566 100644
--- a/packages/cloud-agent-sdk/src/normalizer.ts
+++ b/packages/cloud-agent-sdk/src/normalizer.ts
@@ -156,6 +156,11 @@ export type ServiceEvent =
       skipped?: boolean | undefined;
       commitHash?: string | undefined;
       commitMessage?: string | undefined;
+      userMessageId?: string | undefined;
+      committedAt?: string | undefined;
+      pushStatus?: 'pushed' | 'failed' | 'not_attempted' | 'unknown' | undefined;
+      commitMessageTruncated?: boolean | undefined;
+      timestamp?: string | undefined;
     }
   | { type: 'cloud.status'; cloudStatus: CloudStatus }
   | {
@@ -502,6 +507,10 @@ function normalizeInnerEvent(eventType: string, data: unknown): NormalizedEvent
         skipped: r.data.skipped,
         commitHash: r.data.commitHash,
         commitMessage: r.data.commitMessage,
+        userMessageId: r.data.userMessageId,
+        committedAt: r.data.committedAt,
+        pushStatus: r.data.pushStatus,
+        commitMessageTruncated: r.data.commitMessageTruncated,
       };
     }
 
@@ -614,7 +623,12 @@ export function normalize(raw: CloudAgentEvent): NormalizedEvent | null {
     data = kilo.data.properties;
   }
 
-  return normalizeInnerEvent(eventType, data);
+  const event = normalizeInnerEvent(eventType, data);
+  return event?.type === 'autocommit_completed' &&
+    event.commitHash &&
+    /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(event.commitHash)
+    ? { ...event, timestamp: raw.timestamp }
+    : event;
 }
 
 /**
diff --git a/packages/cloud-agent-sdk/src/schemas.ts b/packages/cloud-agent-sdk/src/schemas.ts
index 54f5cf3807..a1acf78c8e 100644
--- a/packages/cloud-agent-sdk/src/schemas.ts
+++ b/packages/cloud-agent-sdk/src/schemas.ts
@@ -872,6 +872,22 @@ export const autocommitStartedDataSchema = z.object({
 });
 export type AutocommitStartedData = z.infer<typeof autocommitStartedDataSchema>;
 
+const commitPushStatusSchema = z.enum(['pushed', 'failed', 'not_attempted', 'unknown']);
+const maxCommitMessageBytes = 16 * 1024;
+
+export const sessionCommitDataSchema = z.object({
+  commitHash: z.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/),
+  commitMessage: z
+    .string()
+    .max(maxCommitMessageBytes)
+    .refine(value => new TextEncoder().encode(value).byteLength <= maxCommitMessageBytes),
+  messageId: z.string().min(1).max(256),
+  userMessageId: z.string().min(1).max(256),
+  committedAt: z.iso.datetime({ offset: true }),
+  pushStatus: commitPushStatusSchema,
+  commitMessageTruncated: z.literal(true).optional(),
+});
+
 export const autocommitCompletedDataSchema = z.object({
   messageId: z.string(),
   success: z.boolean().catch(false),
@@ -879,6 +895,10 @@ export const autocommitCompletedDataSchema = z.object({
   skipped: z.boolean().optional(),
   commitHash: z.string().optional(),
   commitMessage: z.string().optional(),
+  userMessageId: z.string().optional().catch(undefined),
+  committedAt: sessionCommitDataSchema.shape.committedAt.optional().catch(undefined),
+  pushStatus: commitPushStatusSchema.optional().catch(undefined),
+  commitMessageTruncated: z.boolean().optional().catch(undefined),
 });
 export type AutocommitCompletedData = z.infer<typeof autocommitCompletedDataSchema>;
 
diff --git a/packages/cloud-agent-sdk/src/service-state.test.ts b/packages/cloud-agent-sdk/src/service-state.test.ts
index 1b12f92465..8c05e29836 100644
--- a/packages/cloud-agent-sdk/src/service-state.test.ts
+++ b/packages/cloud-agent-sdk/src/service-state.test.ts
@@ -1,6 +1,8 @@
 import { createServiceState } from './service-state';
 import type { ServiceStateConfig } from './service-state';
 import type { Session, QuestionInfo } from '@kilocode/app-shared/opencode';
+import { autocommitCompletedDataSchema } from './schemas';
+import type { SessionCommit } from './types';
 
 function makeConfig(overrides?: Partial<ServiceStateConfig>): ServiceStateConfig {
   return { rootSessionId: 'root-1', ...overrides };
@@ -1177,6 +1179,95 @@ describe('createServiceState', () => {
   });
 
   describe('autocommit_completed', () => {
+    const localCommit = {
+      commitHash: 'a'.repeat(40),
+      commitMessage: 'Actual commit\n\nPreserve the body.\n',
+      messageId: 'assistant-1',
+      userMessageId: 'user-1',
+      committedAt: '2026-09-01T10:00:00Z',
+      pushStatus: 'failed',
+    } satisfies SessionCommit;
+
+    it('retains the canonical local commit when the operation reports failure', () => {
+      const state = createServiceState(makeConfig());
+      state.process({ type: 'autocommit_completed', success: false, ...localCommit });
+      expect(state.getCommits()).toEqual([localCommit]);
+      expect(state.getStatus()).toMatchObject({
+        type: 'autocommit',
+        step: 'completed',
+        commitHash: localCommit.commitHash,
+      });
+    });
+
+    it('deduplicates immutable facts and keeps multiple commits at one anchor', () => {
+      const state = createServiceState(makeConfig());
+      const second = {
+        ...localCommit,
+        commitHash: 'b'.repeat(40),
+        committedAt: '2026-09-01T10:00:01Z',
+      };
+      state.process({ type: 'autocommit_completed', success: true, ...localCommit });
+      state.process({ type: 'autocommit_completed', success: true, ...second });
+      state.process({
+        type: 'autocommit_completed',
+        success: false,
+        ...localCommit,
+        commitMessage: 'Conflicting replay',
+      });
+      expect(state.getCommits()).toEqual([localCommit, second]);
+      state.clearCommits();
+      state.process({ type: 'autocommit_completed', success: true, ...localCommit });
+      expect(state.getCommits()).toEqual([]);
+      state.reset();
+      state.process({ type: 'autocommit_completed', success: true, ...localCommit });
+      expect(state.getCommits()).toEqual([localCommit]);
+    });
+
+    it.each([
+      { commitHash: 'abc123' },
+      { commitMessage: undefined },
+      { commitMessage: '漢'.repeat(6_000) },
+      { messageId: '' },
+      { messageId: 'a'.repeat(257) },
+      { userMessageId: undefined },
+      { userMessageId: 'u'.repeat(257) },
+      { committedAt: undefined },
+      { committedAt: 'not-a-date' },
+      { pushStatus: undefined },
+      { commitMessageTruncated: false },
+    ])('does not retain a commit from incomplete or invalid metadata: %j', invalid => {
+      const state = createServiceState(makeConfig());
+      state.process({ type: 'autocommit_completed', success: true, ...localCommit, ...invalid });
+      expect(state.getCommits()).toEqual([]);
+    });
+
+    it('preserves offset timestamps and explicit bounded-message truncation through wire parsing', () => {
+      const state = createServiceState(makeConfig());
+      const data = autocommitCompletedDataSchema.parse({
+        ...localCommit,
+        success: false,
+        committedAt: '2026-09-01T12:00:00+02:00',
+        commitMessage: 'x'.repeat(16 * 1024),
+        commitMessageTruncated: true,
+      });
+      state.process({ type: 'autocommit_completed', ...data });
+      expect(state.getCommits()).toEqual([
+        expect.objectContaining({
+          committedAt: '2026-09-01T12:00:00+02:00',
+          commitMessage: data.commitMessage,
+          commitMessageTruncated: true,
+        }),
+      ]);
+    });
+
+    it('never treats a skipped completion as a commit even with stale metadata', () => {
+      const state = createServiceState(makeConfig());
+      state.process({ type: 'autocommit_started', messageId: localCommit.messageId });
+      state.process({ type: 'autocommit_completed', success: true, skipped: true, ...localCommit });
+      expect(state.getCommits()).toEqual([]);
+      expect(state.getStatus()).toEqual({ type: 'idle' });
+    });
+
     it('success sets status to autocommit completed', () => {
       const state = createServiceState(makeConfig());
 
@@ -1214,13 +1305,11 @@ describe('createServiceState', () => {
       });
     });
 
-    it('skipped does not update status', () => {
+    it('skipped clears the running commit indicator', () => {
       const state = createServiceState(makeConfig());
 
       state.process({ type: 'autocommit_started', messageId: 'msg-1', message: 'Committing...' });
 
-      const statusBefore = state.getStatus();
-
       state.process({
         type: 'autocommit_completed',
         messageId: 'msg-1',
@@ -1228,7 +1317,8 @@ describe('createServiceState', () => {
         skipped: true,
       });
 
-      expect(state.getStatus()).toBe(statusBefore);
+      expect(state.getStatus()).toEqual({ type: 'idle' });
+      expect(state.getCommits()).toEqual([]);
     });
   });
 
diff --git a/packages/cloud-agent-sdk/src/service-state.ts b/packages/cloud-agent-sdk/src/service-state.ts
index 89fa27cdc7..41bba709b0 100644
--- a/packages/cloud-agent-sdk/src/service-state.ts
+++ b/packages/cloud-agent-sdk/src/service-state.ts
@@ -7,6 +7,7 @@
  */
 import type { QuestionInfo } from '@kilocode/app-shared/opencode';
 import type { ServiceEvent } from './normalizer';
+import { sessionCommitDataSchema } from './schemas';
 import type {
   SessionInfo,
   SessionActivity,
@@ -19,6 +20,7 @@ import type {
   CloudStatus,
   MessageDeliveryState,
   PreparationAttempt,
+  SessionCommit,
   PreparationStepSnapshot,
 } from './types';
 
@@ -72,6 +74,8 @@ type ServiceState = {
   /** @deprecated Legacy transient setup output. */
   getSetupLog(): readonly string[];
   getPreparationAttempts(): readonly PreparationAttempt[];
+  getCommits(): readonly SessionCommit[];
+  clearCommits(): void;
   getQuestion(): QuestionState | null;
   getPermission(): PermissionState | null;
   getSuggestion(): SuggestionState | null;
@@ -117,6 +121,8 @@ function createServiceState(config: ServiceStateConfig): ServiceState {
   let cloudStatus: CloudStatus | null = null;
   let setupLog: string[] = [];
   let preparationAttempts: PreparationAttempt[] = [];
+  let commits: readonly SessionCommit[] = [];
+  const seenCommits = new Set<string>();
   let sessionInfo: SessionInfo | null = null;
   let questions: readonly QuestionState[] = [];
   let permissions: readonly PermissionState[] = [];
@@ -546,12 +552,30 @@ function createServiceState(config: ServiceStateConfig): ServiceState {
   function processAutocommitCompleted(
     event: Extract<ServiceEvent, { type: 'autocommit_completed' }>
   ): void {
-    if (event.skipped) return;
+    if (event.skipped) {
+      if (status.type === 'autocommit' && status.step === 'started') {
+        status = IDLE_STATUS;
+        notify();
+      }
+      return;
+    }
 
-    if (event.success) {
+    const parsedCommit = sessionCommitDataSchema.safeParse(event);
+    const commitHash = parsedCommit.success ? parsedCommit.data.commitHash : undefined;
+    if (parsedCommit.success) {
+      if (seenCommits.has(parsedCommit.data.commitHash)) return;
+      seenCommits.add(parsedCommit.data.commitHash);
+      commits = [...commits, { ...parsedCommit.data, timestamp: event.timestamp }];
+    }
+    if (event.success || commitHash) {
       const parts = [event.commitHash, event.commitMessage].filter(Boolean);
       const message = parts.length > 0 ? parts.join(' ') : 'Committed';
-      status = { type: 'autocommit', step: 'completed', message };
+      status = {
+        type: 'autocommit',
+        step: 'completed',
+        message,
+        ...(commitHash ? { commitHash } : {}),
+      };
     } else {
       status = { type: 'autocommit', step: 'failed', message: event.message ?? 'Commit failed' };
     }
@@ -873,6 +897,11 @@ function createServiceState(config: ServiceStateConfig): ServiceState {
     getCloudStatus: () => cloudStatus,
     getSetupLog: () => setupLog,
     getPreparationAttempts: () => preparationAttempts,
+    getCommits: () => commits,
+    clearCommits(): void {
+      commits = [];
+      notify();
+    },
     getQuestion: () => questions[0] ?? null,
     getPermission: () => permissions[0] ?? null,
     getSuggestion: () => suggestion,
@@ -890,6 +919,7 @@ function createServiceState(config: ServiceStateConfig): ServiceState {
       cloudStatus,
       setupLog,
       preparationAttempts,
+      commits,
       sessionInfo,
       question: questions[0] ?? null,
       permission: permissions[0] ?? null,
@@ -925,6 +955,8 @@ function createServiceState(config: ServiceStateConfig): ServiceState {
       cloudStatus = null;
       setupLog = [];
       preparationAttempts = [];
+      commits = [];
+      seenCommits.clear();
       sessionInfo = null;
       questions = [];
       permissions = [];
diff --git a/packages/cloud-agent-sdk/src/session-manager.test.ts b/packages/cloud-agent-sdk/src/session-manager.test.ts
index a528fc6b1d..1254b07798 100644
--- a/packages/cloud-agent-sdk/src/session-manager.test.ts
+++ b/packages/cloud-agent-sdk/src/session-manager.test.ts
@@ -99,6 +99,8 @@ const mockSession = {
     getStatus: jest.fn<{ type: 'idle' | 'disconnected' }, []>(() => ({ type: 'idle' })),
     getCloudStatus: jest.fn<CloudStatus | null, []>(() => null),
     getSetupLog: jest.fn<readonly string[], []>(() => []),
+    getCommits: jest.fn(() => []),
+    clearCommits: jest.fn(),
     getQuestion: jest.fn(() => null),
     getSessionInfo: jest.fn(() => null),
     getPermission: jest.fn(() => null),
diff --git a/packages/cloud-agent-sdk/src/session-manager.ts b/packages/cloud-agent-sdk/src/session-manager.ts
index b473f5fed4..48c880e2ea 100644
--- a/packages/cloud-agent-sdk/src/session-manager.ts
+++ b/packages/cloud-agent-sdk/src/session-manager.ts
@@ -57,6 +57,7 @@ import type {
   UserMessage,
   OlderMessagesError,
   PreparationAttempt,
+  SessionCommit,
 } from './types';
 import type { QuestionInfo } from '@kilocode/app-shared/opencode';
 import { splitByContiguousPrefix } from './array-utils';
@@ -82,6 +83,7 @@ type SessionStatusIndicator = {
   type: 'error' | 'warning' | 'info' | 'progress';
   message: string;
   timestamp: number;
+  commitHash?: string;
 };
 type SessionConfig = {
   sessionId: CloudAgentSessionId | KiloSessionId;
@@ -358,6 +360,7 @@ type SessionManagerAtoms = {
   cloudStatus: W<CloudStatus | null>;
   setupLog: W<readonly string[]>;
   preparationAttempts: W<readonly PreparationAttempt[]>;
+  commits: W<readonly SessionCommit[]>;
   sessionConfig: W<SessionConfig | null>;
   sessionType: W<ActiveSessionType | null>;
   chatUI: W<{ shouldAutoScroll: boolean }>;
@@ -653,7 +656,12 @@ function indicatorForStatus(s: AgentStatus): SessionStatusIndicator | null {
   const now = Date.now();
   if (s.type === 'autocommit') {
     const kind = s.step === 'failed' ? 'error' : s.step === 'completed' ? 'info' : 'progress';
-    return { type: kind, message: s.message, timestamp: now } satisfies SessionStatusIndicator;
+    return {
+      type: kind,
+      message: s.message,
+      timestamp: now,
+      ...(s.step === 'completed' && s.commitHash ? { commitHash: s.commitHash } : {}),
+    } satisfies SessionStatusIndicator;
   }
   if (s.type === 'disconnected')
     return { type: 'error', message: 'Agent connection lost', timestamp: now };
@@ -732,6 +740,7 @@ function createSessionManager(config: SessionManagerConfig): SessionManager {
   const cloudStatusAtom = atom<CloudStatus | null>(null);
   const setupLogAtom = atom<readonly string[]>([]);
   const preparationAttemptsAtom = atom<readonly PreparationAttempt[]>([]);
+  const commitsAtom = atom<readonly SessionCommit[]>([]);
   const sessionConfigAtom = atom<SessionConfig | null>(null);
   const sessionTypeAtom = atom<ActiveSessionType | null>(null);
   const chatUIAtom = atom<{ shouldAutoScroll: boolean }>({ shouldAutoScroll: true });
@@ -956,6 +965,7 @@ function createSessionManager(config: SessionManagerConfig): SessionManager {
     store.set(cloudStatusAtom, null);
     store.set(setupLogAtom, []);
     store.set(preparationAttemptsAtom, []);
+    store.set(commitsAtom, []);
     store.set(sessionConfigAtom, null);
     store.set(sessionTypeAtom, null);
     store.set(activeQuestionAtom, null);
@@ -1319,7 +1329,8 @@ function createSessionManager(config: SessionManagerConfig): SessionManager {
     let prevSk = '';
     let prevCsk = '';
     let prevCloudStatusHadIndicator = false;
-    const sKey = (s: AgentStatus) => (s.type === 'autocommit' ? `${s.type}:${s.step}` : s.type);
+    const sKey = (s: AgentStatus) =>
+      s.type === 'autocommit' ? `${s.type}:${s.step}:${s.commitHash ?? ''}` : s.type;
     const csKey = (cs: CloudStatus | null) =>
       cs === null
         ? ''
@@ -1344,6 +1355,7 @@ function createSessionManager(config: SessionManagerConfig): SessionManager {
         preparationAttemptsAtom,
         'getPreparationAttempts' in session.state ? session.state.getPreparationAttempts() : []
       );
+      store.set(commitsAtom, session.state.getCommits());
       store.set(isStreamingAtom, act.type === 'busy');
       store.set(questionAtom, session.state.getQuestion());
       store.set(permissionAtom, session.state.getPermission());
@@ -1415,7 +1427,9 @@ function createSessionManager(config: SessionManagerConfig): SessionManager {
             ind !== null ||
             shouldClearCloudIndicator ||
             (st.type === 'idle' &&
-              (previousStatus.type === 'error' || previousStatus.type === 'interrupted'))
+              (previousStatus.type === 'error' ||
+                previousStatus.type === 'interrupted' ||
+                (previousStatus.type === 'autocommit' && previousStatus.step === 'started')))
           ) {
             setIndicator(ind);
           }
@@ -2193,6 +2207,7 @@ function createSessionManager(config: SessionManagerConfig): SessionManager {
   function clearTranscript(): void {
     if (!currentSession) return;
     currentSession.storage.clear();
+    currentSession.state.clearCommits();
     olderMessagesCursor = null;
     store.set(hasOlderMessagesAtom, false);
     // Reset the retained-history stack so a later `trimRetainedHistory`
@@ -2381,6 +2396,7 @@ function createSessionManager(config: SessionManagerConfig): SessionManager {
       cloudStatus: cloudStatusAtom,
       setupLog: setupLogAtom,
       preparationAttempts: preparationAttemptsAtom,
+      commits: commitsAtom,
       sessionConfig: sessionConfigAtom,
       sessionType: sessionTypeAtom,
       chatUI: chatUIAtom,
diff --git a/packages/cloud-agent-sdk/src/session.test.ts b/packages/cloud-agent-sdk/src/session.test.ts
index 615ba000c8..486f16e1df 100644
--- a/packages/cloud-agent-sdk/src/session.test.ts
+++ b/packages/cloud-agent-sdk/src/session.test.ts
@@ -208,6 +208,88 @@ describe('session pipeline integration', () => {
     });
   });
 
+  describe('immutable commit facts', () => {
+    const completion = {
+      messageId: 'assistant-1',
+      userMessageId: 'user-1',
+      success: true,
+      commitHash: 'a'.repeat(40),
+      commitMessage: 'fix: actual message\n\nFull body',
+      committedAt: '2026-09-01T10:00:00.000Z',
+      pushStatus: 'failed',
+      commitMessageTruncated: true,
+    };
+
+    it.each([true, false])(
+      'retains the local commit on failed push with operation success %s',
+      success => {
+        const { storage, serviceState, feedEvent } = createTestSession();
+        const event = createEvent('autocommit_completed', { ...completion, success });
+        feedEvent(event);
+        expect(serviceState.getCommits()).toEqual([
+          {
+            commitHash: completion.commitHash,
+            commitMessage: completion.commitMessage,
+            messageId: completion.messageId,
+            userMessageId: completion.userMessageId,
+            committedAt: completion.committedAt,
+            pushStatus: 'failed',
+            commitMessageTruncated: true,
+            timestamp: event.timestamp,
+          },
+        ]);
+        expect(storage.getMessageIds()).toEqual([]);
+      }
+    );
+
+    it('deduplicates live and materialized replay by full SHA and preserves the first metadata', () => {
+      const { serviceState, feedEvent } = createTestSession();
+      feedEvent(createEvent('autocommit_completed', completion));
+      const original = serviceState.getCommits()[0];
+      const replay = kilocode('autocommit_completed', {
+        ...completion,
+        commitMessage: 'duplicate',
+      });
+      feedEvent({ ...replay, eventId: 0 });
+      feedEvent(createEvent('connected', {}));
+      feedEvent({ ...replay, eventId: 0 });
+      feedEvent({
+        ...kilocode('autocommit_completed', {
+          ...completion,
+          commitHash: 'b'.repeat(40),
+          committedAt: '2026-09-01T09:00:00.000Z',
+        }),
+        eventId: 0,
+      });
+      expect(serviceState.getCommits()).toHaveLength(2);
+      expect(serviceState.getCommits()[0]).toBe(original);
+    });
+
+    it.each([
+      { success: false, commitHash: undefined },
+      { skipped: true },
+      { commitHash: 'abc1234' },
+      { commitHash: 'not-a-sha' },
+    ])('does not promote skipped or unproven completions: %j', override => {
+      const { serviceState, feedEvent } = createTestSession();
+      feedEvent(createEvent('autocommit_completed', { ...completion, ...override }));
+      expect(serviceState.getCommits()).toEqual([]);
+    });
+
+    it('clears the local collection without resurrecting it on replay; reset permits a fresh load', () => {
+      const { serviceState, feedEvent } = createTestSession();
+      const event = createEvent('autocommit_completed', completion);
+      feedEvent(event);
+      serviceState.clearCommits();
+      feedEvent({ ...event, eventId: 0 });
+      expect(serviceState.getCommits()).toEqual([]);
+      serviceState.reset();
+      expect(serviceState.snapshot().commits).toEqual([]);
+      feedEvent(event);
+      expect(serviceState.getCommits()).toHaveLength(1);
+    });
+  });
+
   describe('autocommit lifecycle', () => {
     it('tracks autocommit started and completed', () => {
       const { serviceState, feedEvent } = createTestSession();
diff --git a/packages/cloud-agent-sdk/src/types.ts b/packages/cloud-agent-sdk/src/types.ts
index 84c2034c18..9b9ac948fd 100644
--- a/packages/cloud-agent-sdk/src/types.ts
+++ b/packages/cloud-agent-sdk/src/types.ts
@@ -100,7 +100,7 @@ export type SessionActivity =
 /** Lifecycle outcome — drives bottom bar content (one thing at a time). */
 export type AgentStatus =
   | { type: 'idle' }
-  | { type: 'autocommit'; step: string; message: string }
+  | { type: 'autocommit'; step: string; message: string; commitHash?: string }
   | { type: 'error'; message: string }
   | { type: 'disconnected' }
   | { type: 'interrupted' };
@@ -164,6 +164,17 @@ export type MessageDeliveryState =
       attempts?: number | undefined;
     };
 
+export type SessionCommit = {
+  commitHash: string;
+  commitMessage: string;
+  messageId: string;
+  userMessageId: string;
+  committedAt: string;
+  timestamp?: string | undefined;
+  pushStatus: 'pushed' | 'failed' | 'not_attempted' | 'unknown';
+  commitMessageTruncated?: true | undefined;
+};
+
 export type PreparationAttemptStatus = 'running' | 'completed' | 'failed';
 export type PreparationStepKind = 'phase' | 'setup_command';
 export type PreparationStepStatus = 'running' | 'completed' | 'failed';
@@ -206,6 +217,7 @@ export type ServiceStateSnapshot = {
   /** @deprecated Legacy transient setup output. v2 preparation uses preparationAttempts. */
   setupLog: readonly string[];
   preparationAttempts: readonly PreparationAttempt[];
+  commits: readonly SessionCommit[];
   sessionInfo: SessionInfo | null;
   question: QuestionState | null;
   permission: PermissionState | null;
diff --git a/packages/worker-utils/package.json b/packages/worker-utils/package.json
index 4463ca04d2..0ad11c5fa1 100644
--- a/packages/worker-utils/package.json
+++ b/packages/worker-utils/package.json
@@ -26,6 +26,7 @@
     "./cloud-agent-next-client": "./src/cloud-agent-next-client.ts",
     "./cloud-agent-session-access": "./src/cloud-agent-session-access.ts",
     "./cloud-agent-worktree-changes": "./src/cloud-agent-worktree-changes.ts",
+    "./cloud-agent-commits": "./src/cloud-agent-commits.ts",
     "./kilo-model-id": "./src/kilo-model-id.ts",
     "./extract-bearer-token": "./src/extract-bearer-token.ts",
     "./cloud-agent-queue-report": "./src/cloud-agent-queue-report.ts",
diff --git a/packages/worker-utils/src/cloud-agent-commits.test.ts b/packages/worker-utils/src/cloud-agent-commits.test.ts
new file mode 100644
index 0000000000..f6ac13f995
--- /dev/null
+++ b/packages/worker-utils/src/cloud-agent-commits.test.ts
@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+import {
+  autoCommitRecordSchema,
+  commitHashSchema,
+  MAX_AUTO_COMMIT_MESSAGE_BYTES,
+} from './cloud-agent-commits.js';
+
+const record = {
+  commitHash: 'a'.repeat(40),
+  commitMessage: 'actual message',
+  userMessageId: 'user',
+  messageId: 'assistant',
+  committedAt: '2026-09-01T10:00:00Z',
+  pushStatus: 'failed',
+};
+
+describe('auto-commit metadata contracts', () => {
+  it('accepts full SHA-1 and SHA-256 only', () => {
+    for (const hash of ['a'.repeat(40), 'b'.repeat(64)])
+      expect(commitHashSchema.safeParse(hash).success).toBe(true);
+    for (const hash of ['abcd123', 'HEAD', '-x', 'a'.repeat(41), 'A'.repeat(40)])
+      expect(commitHashSchema.safeParse(hash).success).toBe(false);
+  });
+
+  it('keeps status data outside the bounded commit record', () => {
+    expect(
+      autoCommitRecordSchema.parse({ ...record, success: false, message: 'Push failed' })
+    ).toEqual(record);
+    expect(autoCommitRecordSchema.safeParse({ ...record, committedAt: 'yesterday' }).success).toBe(
+      false
+    );
+  });
+
+  it('limits messages by UTF-8 bytes', () => {
+    expect(
+      autoCommitRecordSchema.safeParse({
+        ...record,
+        commitMessage: 'é'.repeat(MAX_AUTO_COMMIT_MESSAGE_BYTES / 2),
+      }).success
+    ).toBe(true);
+    expect(
+      autoCommitRecordSchema.safeParse({
+        ...record,
+        commitMessage: 'é'.repeat(MAX_AUTO_COMMIT_MESSAGE_BYTES / 2) + 'a',
+      }).success
+    ).toBe(false);
+  });
+
+  it.each(['userMessageId', 'messageId'] as const)('bounds %s to 256 characters', field => {
+    expect(autoCommitRecordSchema.safeParse({ ...record, [field]: 'a'.repeat(256) }).success).toBe(
+      true
+    );
+    for (const value of ['', 'a'.repeat(257)])
+      expect(autoCommitRecordSchema.safeParse({ ...record, [field]: value }).success).toBe(false);
+  });
+
+  it('accepts only true or absent truncation metadata', () => {
+    expect(autoCommitRecordSchema.parse(record)).not.toHaveProperty('commitMessageTruncated');
+    expect(
+      autoCommitRecordSchema.parse({ ...record, commitMessageTruncated: true })
+    ).toHaveProperty('commitMessageTruncated', true);
+    for (const commitMessageTruncated of [false, null, 'true'])
+      expect(autoCommitRecordSchema.safeParse({ ...record, commitMessageTruncated }).success).toBe(
+        false
+      );
+  });
+});
diff --git a/packages/worker-utils/src/cloud-agent-commits.ts b/packages/worker-utils/src/cloud-agent-commits.ts
new file mode 100644
index 0000000000..aeda1ea816
--- /dev/null
+++ b/packages/worker-utils/src/cloud-agent-commits.ts
@@ -0,0 +1,22 @@
+import { z } from 'zod';
+
+export const MAX_AUTO_COMMIT_MESSAGE_BYTES = 16 * 1024;
+export const commitHashSchema = z.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/);
+
+export const autoCommitRecordSchema = z.object({
+  commitHash: commitHashSchema,
+  commitMessage: z
+    .string()
+    .max(MAX_AUTO_COMMIT_MESSAGE_BYTES)
+    .refine(
+      message => new TextEncoder().encode(message).byteLength <= MAX_AUTO_COMMIT_MESSAGE_BYTES,
+      'Commit message exceeds the size limit'
+    ),
+  userMessageId: z.string().min(1).max(256),
+  messageId: z.string().min(1).max(256),
+  committedAt: z.string().datetime({ offset: true }),
+  pushStatus: z.enum(['pushed', 'failed', 'not_attempted', 'unknown']),
+  commitMessageTruncated: z.literal(true).optional(),
+});
+
+export type AutoCommitRecord = z.infer<typeof autoCommitRecordSchema>;
diff --git a/packages/worker-utils/src/index.ts b/packages/worker-utils/src/index.ts
index 515809b87d..1ba86a155b 100644
--- a/packages/worker-utils/src/index.ts
+++ b/packages/worker-utils/src/index.ts
@@ -241,3 +241,10 @@ export type {
 } from './security-finding-audit.js';
 
 export { hasOrganizationAccess } from './organization-membership.js';
+
+export {
+  MAX_AUTO_COMMIT_MESSAGE_BYTES,
+  commitHashSchema,
+  autoCommitRecordSchema,
+} from './cloud-agent-commits.js';
+export type { AutoCommitRecord } from './cloud-agent-commits.js';
diff --git a/services/cloud-agent-next/src/sandbox-session/SandboxSession.ts b/services/cloud-agent-next/src/sandbox-session/SandboxSession.ts
index a3b77513f8..02d495045d 100644
--- a/services/cloud-agent-next/src/sandbox-session/SandboxSession.ts
+++ b/services/cloud-agent-next/src/sandbox-session/SandboxSession.ts
@@ -900,7 +900,6 @@ export class SandboxSession extends DurableObject<Env> {
     this.ctx.storage.transactionSync(() => {
       this.ctx.storage.kv.put(DELETED_WORKTREE_KEY, worktreeId);
       this.terminalLifecycle.beginDeletion(metadata);
-      this.worktreeChanges.purge();
       const messages = this.ctx.storage.kv.get<MessageRecord[]>(MESSAGES_KEY) ?? [];
       const cancelled = messages.map(message =>
         message.state === 'queued' || message.state === 'accepted'
@@ -911,7 +910,11 @@ export class SandboxSession extends DurableObject<Env> {
     });
     this.deletedWorktreeId = worktreeId;
     for (const socket of this.ctx.getWebSockets()) socket.close(1001, 'Worktree deleted');
-    await this.ctx.storage.deleteAlarm();
+    try {
+      this.ctx.storage.transactionSync(() => this.worktreeChanges.purge());
+    } finally {
+      await this.ctx.storage.deleteAlarm();
+    }
     if (!metadata) return null;
     return cloudAgentWorktreeLocationSchema.parse({
       sandboxId: metadata.workspace?.sandboxId,
@@ -1002,15 +1005,23 @@ export class SandboxSession extends DurableObject<Env> {
     await this.interruptExecution();
     if (this.deletedWorktreeId) throw new Error('worktree_deleting');
     const metadata = this.terminalLifecycle.getStoredMetadata();
-    const records = this.ctx.storage.transactionSync(() => {
-      const records = this.terminalLifecycle.beginDeletion(metadata);
-      this.worktreeChanges.purge();
-      return records;
-    });
+    const records = this.terminalLifecycle.beginDeletion(metadata);
     for (const ws of this.ctx.getWebSockets('stream')) {
       ws.close(1000, 'session access revoked');
     }
-    await this.terminalLifecycle.cleanupSession(metadata, records);
+    const errors: unknown[] = [];
+    try {
+      this.ctx.storage.transactionSync(() => this.worktreeChanges.purge());
+    } catch (error) {
+      errors.push(error);
+    }
+    try {
+      await this.terminalLifecycle.cleanupSession(metadata, records);
+    } catch (error) {
+      errors.push(error);
+    }
+    if (errors.length === 1) throw errors[0];
+    if (errors.length > 1) throw new AggregateError(errors, 'Session cleanup failed');
     await this.ingestPublicationChain.catch(() => undefined);
     if (this.deletedWorktreeId) throw new Error('worktree_deleting');
     await this.ctx.storage.deleteAlarm();
diff --git a/services/cloud-agent-next/src/sandbox-session/sandbox-control-event.test.ts b/services/cloud-agent-next/src/sandbox-session/sandbox-control-event.test.ts
index 1c9cc0546b..13931207cc 100644
--- a/services/cloud-agent-next/src/sandbox-session/sandbox-control-event.test.ts
+++ b/services/cloud-agent-next/src/sandbox-session/sandbox-control-event.test.ts
@@ -14,7 +14,7 @@ describe('persistSandboxControlSessionEvent', () => {
         properties: { info: { id: 'msg_1' } },
         timestamp: '2026-08-20T00:00:00.000Z',
       },
-      eventQueries: { upsert, insert },
+      eventQueries: { upsert, insert, insertUnique: vi.fn() },
       broadcast,
     });
 
@@ -42,13 +42,89 @@ describe('persistSandboxControlSessionEvent', () => {
     persistSandboxControlSessionEvent({
       sessionId: 'agent_1',
       payload: { type: 'session.idle', properties: {} },
-      eventQueries: { upsert, insert },
+      eventQueries: { upsert, insert, insertUnique: vi.fn() },
       broadcast: vi.fn(),
     });
     expect(upsert).not.toHaveBeenCalled();
     expect(insert).toHaveBeenCalledOnce();
   });
 
+  it('inserts a valid local commit even when push failed, without rebroadcasting duplicate metadata', () => {
+    const eventQueries = {
+      upsert: vi.fn(),
+      insert: vi.fn(),
+      insertUnique: vi.fn().mockReturnValueOnce(4).mockReturnValue(null),
+    };
+    const broadcast = vi.fn();
+    const properties = {
+      commitHash: 'a'.repeat(40),
+      commitMessage: 'Actual commit',
+      userMessageId: 'user',
+      messageId: 'assistant',
+      committedAt: '2026-09-01T10:00:00Z',
+      pushStatus: 'failed',
+      success: false,
+      message: 'Push failed',
+    };
+    const input = {
+      sessionId: 'workspace_1',
+      payload: { type: 'autocommit_completed', properties },
+      eventQueries,
+      broadcast,
+    };
+    expect(persistSandboxControlSessionEvent(input)).toEqual({ applied: true });
+    expect(
+      persistSandboxControlSessionEvent({
+        ...input,
+        payload: { ...input.payload, properties: { ...properties, commitMessage: 'Changed' } },
+      })
+    ).toEqual({ applied: true });
+    expect(eventQueries.upsert).not.toHaveBeenCalled();
+    expect(eventQueries.insertUnique).toHaveBeenCalledWith(
+      expect.objectContaining({
+        entityId: `commit/${properties.commitHash}`,
+        timestamp: Date.parse(properties.committedAt),
+      })
+    );
+    expect(broadcast).toHaveBeenCalledTimes(1);
+    expect(broadcast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: 4,
+        payload: JSON.stringify({
+          type: 'autocommit_completed',
+          event: 'autocommit_completed',
+          properties,
+        }),
+      })
+    );
+  });
+
+  it.each([
+    { skipped: true, commitHash: 'a'.repeat(40) },
+    { success: false },
+    { commitHash: 'abcdef1' },
+  ])('preserves old skipped/failure/short-SHA events without a commit identity', properties => {
+    const eventQueries = {
+      upsert: vi.fn().mockReturnValue(3),
+      insert: vi.fn(),
+      insertUnique: vi.fn(),
+    };
+    const result = persistSandboxControlSessionEvent({
+      sessionId: 'workspace_1',
+      payload: {
+        type: 'autocommit_completed',
+        properties: { messageId: 'assistant', ...properties },
+      },
+      eventQueries,
+      broadcast: vi.fn(),
+    });
+    expect(result).toEqual({ applied: true });
+    expect(eventQueries.insertUnique).not.toHaveBeenCalled();
+    expect(eventQueries.upsert).toHaveBeenCalledWith(
+      expect.objectContaining({ entityId: 'autocommit/assistant' })
+    );
+  });
+
   it('broadcasts token deltas without persisting', () => {
     const upsert = vi.fn();
     const insert = vi.fn();
@@ -56,7 +132,7 @@ describe('persistSandboxControlSessionEvent', () => {
     persistSandboxControlSessionEvent({
       sessionId: 'agent_1',
       payload: { type: 'message.part.delta', properties: { text: 'hi' } },
-      eventQueries: { upsert, insert },
+      eventQueries: { upsert, insert, insertUnique: vi.fn() },
       broadcast,
     });
     expect(upsert).not.toHaveBeenCalled();
diff --git a/services/cloud-agent-next/src/sandbox-session/sandbox-control-event.ts b/services/cloud-agent-next/src/sandbox-session/sandbox-control-event.ts
index 0ebb86e46a..9829b94cda 100644
--- a/services/cloud-agent-next/src/sandbox-session/sandbox-control-event.ts
+++ b/services/cloud-agent-next/src/sandbox-session/sandbox-control-event.ts
@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { autoCommitRecordSchema } from '@kilocode/worker-utils/cloud-agent-commits';
 import { extractEntityId } from '../session/ingest-handlers/entity-id.js';
 import type { EventId } from '../types/ids.js';
 import type { StoredEvent } from '../websocket/types.js';
@@ -67,6 +68,14 @@ export function applyPendingInteractionEvent(
 }
 
 export type SandboxControlEventQueries = {
+  insertUnique(params: {
+    executionId: string;
+    sessionId: string;
+    streamEventType: string;
+    payload: string;
+    timestamp: number;
+    entityId: string;
+  }): EventId | null;
   upsert(params: {
     executionId: string;
     sessionId: string;
@@ -96,6 +105,36 @@ export function persistSandboxControlSessionEvent(params: {
   eventQueries: SandboxControlEventQueries;
   broadcast: (event: StoredEvent) => void;
 }): { applied: true } {
+  const commit =
+    params.payload.type === 'autocommit_completed' && params.payload.properties.skipped !== true
+      ? autoCommitRecordSchema.safeParse(params.payload.properties)
+      : undefined;
+  if (commit?.success) {
+    const timestamp = Date.parse(commit.data.committedAt);
+    const payload = JSON.stringify({
+      type: params.payload.type,
+      event: params.payload.type,
+      properties: { ...params.payload.properties, ...commit.data },
+    });
+    const eventId = params.eventQueries.insertUnique({
+      executionId: '',
+      sessionId: params.sessionId,
+      streamEventType: 'kilocode',
+      payload,
+      timestamp,
+      entityId: `commit/${commit.data.commitHash}`,
+    });
+    if (eventId === null) return { applied: true };
+    params.broadcast({
+      id: eventId,
+      execution_id: '',
+      session_id: params.sessionId,
+      stream_event_type: 'kilocode',
+      payload,
+      timestamp,
+    });
+    return { applied: true };
+  }
   const timestamp = params.payload.timestamp ? Date.parse(params.payload.timestamp) : Date.now();
   const payload = JSON.stringify({
     type: params.payload.type,
diff --git a/services/cloud-agent-next/src/shared/protocol.ts b/services/cloud-agent-next/src/shared/protocol.ts
index a6e1517203..ac4c8436b6 100644
--- a/services/cloud-agent-next/src/shared/protocol.ts
+++ b/services/cloud-agent-next/src/shared/protocol.ts
@@ -101,6 +101,10 @@ export type AutocommitCompletedData = {
   skipped?: boolean;
   commitHash?: string;
   commitMessage?: string;
+  userMessageId?: string;
+  committedAt?: string;
+  pushStatus?: 'pushed' | 'failed' | 'not_attempted' | 'unknown';
+  commitMessageTruncated?: true;
 };
 
 /**
diff --git a/services/cloud-agent-next/test/e2e/sandbox-control.ts b/services/cloud-agent-next/test/e2e/sandbox-control.ts
index b10f70aacb..9158c8606e 100644
--- a/services/cloud-agent-next/test/e2e/sandbox-control.ts
+++ b/services/cloud-agent-next/test/e2e/sandbox-control.ts
@@ -136,13 +136,13 @@ function kiloListeners() {
     if (owners.size !== 1) continue;
     const [processId] = owners;
     try {
-      if (path.basename(fs.readlinkSync('/proc/' + processId + '/exe')) !== 'kilo') continue;
+      if (!['kilo', '.kilo', 'rosetta'].includes(path.basename(fs.readlinkSync('/proc/' + processId + '/exe')))) continue;
       const argv = fs.readFileSync('/proc/' + processId + '/cmdline', 'utf8').split('\0');
-      if (path.basename(argv[0]) !== 'kilo' || argv[1] !== 'serve') continue;
+      if (!['kilo', '.kilo'].includes(path.basename(argv[0])) || argv[1] !== 'serve') continue;
       const cwd = fs.readlinkSync('/proc/' + processId + '/cwd');
       const directory = fs.realpathSync(cwd);
       if (!path.isAbsolute(cwd) || cwd !== directory) continue;
-      if (!fs.existsSync(path.join(directory, '.kilo-bootstrap-complete'))) continue;
+      if (!fs.existsSync(path.join(directory, '.kilo-bootstrap-complete')) && !fs.existsSync(path.join(directory, '.git'))) continue;
       listeners.push({ serverUrl, processId, directory });
     } catch {
       continue;
diff --git a/services/cloud-agent-next/test/integration/sandbox-control.test.ts b/services/cloud-agent-next/test/integration/sandbox-control.test.ts
index 2f8e1f087d..347cc5cc20 100644
--- a/services/cloud-agent-next/test/integration/sandbox-control.test.ts
+++ b/services/cloud-agent-next/test/integration/sandbox-control.test.ts
@@ -6781,6 +6781,7 @@ async function worktreeFixture(sessionIdOverride?: `workspace_${string}`) {
   const prompts: RequestFrame[] = [];
   const promptSeen = Promise.withResolvers<void>();
   const aborts: RequestFrame[] = [];
+  const terminalCloses: RequestFrame[] = [];
   let nextAttach: ((request: RequestFrame) => void) | undefined;
 
   function receive(client: WebSocket): void {
@@ -6816,6 +6817,9 @@ async function worktreeFixture(sessionIdOverride?: `workspace_${string}`) {
         result = { status: 'aborted' };
       } else if (request.operation === 'session.detach') {
         result = { detached: true };
+      } else if (request.operation === 'session.terminal.close') {
+        terminalCloses.push(request);
+        result = { success: true };
       } else return;
       client.send(
         JSON.stringify({ type: 'response', requestId: request.requestId, ok: true, result })
@@ -6864,6 +6868,7 @@ async function worktreeFixture(sessionIdOverride?: `workspace_${string}`) {
     captures,
     prompts,
     aborts,
+    terminalCloses,
     noWake,
     promptSeen: promptSeen.promise,
     holdNextAttach(): Promise<RequestFrame> {
@@ -6951,6 +6956,314 @@ function captureRevision(request: RequestFrame): number {
   return (request.payload as { revision: number }).revision;
 }
 
+describe('SandboxSession commit metadata', () => {
+  beforeEach(() => {
+    vi.spyOn(globalThis, 'fetch').mockImplementation(async () => Response.json({ valid: true }));
+  });
+  afterEach(() => vi.restoreAllMocks());
+
+  const hash = 'd'.repeat(40);
+  const nextHash = 'e'.repeat(40);
+  const commit = {
+    commitHash: hash,
+    commitMessage: 'Actual commit message',
+    userMessageId: 'user_turn',
+    messageId: 'assistant_turn',
+    committedAt: '2026-09-01T10:00:00Z',
+    pushStatus: 'failed',
+    success: false,
+    message: 'Push failed',
+  };
+
+  it('preserves the first metadata record and replays each full SHA once after reconstruction', async () => {
+    const f = await worktreeFixture();
+    try {
+      await f.event('autocommit_completed', f.kiloSessionId, commit);
+      const first = await runInDurableObject(f.session, (_instance, state) =>
+        createEventQueries(drizzle(state.storage), state.storage.sql).findByEntityId(
+          `commit/${hash}`
+        )
+      );
+      expect(first).not.toBeNull();
+      expect(first?.timestamp).toBe(Date.parse(commit.committedAt));
+      expect(JSON.parse(first?.payload ?? '{}').properties).toMatchObject(commit);
+      await f.event('autocommit_completed', f.kiloSessionId, {
+        ...commit,
+        commitMessage: 'Changed duplicate',
+        committedAt: '2026-09-02T00:00:00Z',
+      });
+      await f.event('autocommit_completed', f.kiloSessionId, { ...commit, commitHash: nextHash });
+      await f.settled();
+      const replay = await runInDurableObject(f.session, (_instance, state) => {
+        const events = createEventQueries(drizzle(state.storage), state.storage.sql);
+        expect(events.findByEntityId(`commit/${hash}`)).toEqual(first);
+        return events.findByFilters({ materialized: 'updates' });
+      });
+      expect(replay.map(event => JSON.parse(event.payload).properties.commitHash)).toEqual([
+        hash,
+        nextHash,
+      ]);
+      expect(replay[0]?.id).toBeLessThan(replay[1]?.id ?? 0);
+      expect(f.captures).toHaveLength(0);
+      expect(f.noWake.ensureReady).not.toHaveBeenCalled();
+      expect(f.noWake.claimCreate).not.toHaveBeenCalled();
+      await abortAllDurableObjects();
+      const fresh = env.SANDBOX_SESSION.getByName(`${f.userId}:${f.sessionId}`);
+      await runInDurableObject(fresh, (_instance, state) => {
+        const events = createEventQueries(drizzle(state.storage), state.storage.sql);
+        expect(events.findByEntityId(`commit/${hash}`)).toEqual(first);
+        expect(events.findByFilters({ materialized: 'updates' })).toEqual(replay);
+      });
+    } finally {
+      f.close();
+    }
+  });
+});
+
+describe('SandboxSession worktree cleanup fencing', () => {
+  beforeEach(() => {
+    vi.spyOn(globalThis, 'fetch').mockImplementation(async () => Response.json({ valid: true }));
+  });
+  afterEach(() => vi.restoreAllMocks());
+
+  it.each(['session', 'worktree'] as const)(
+    'keeps %s fenced and connections closed after worktree erasure failure, late capture and reconstruction',
+    async action => {
+      const f = await worktreeFixture();
+      const clients: WebSocket[] = [];
+      const servers: WebSocket[] = [];
+      const closed: Promise<CloseEvent>[] = [];
+      let restore: (() => void) | undefined;
+      let held: RequestFrame | undefined;
+      let lateCapture: Promise<unknown> | undefined;
+      let closedBeforePurge = false;
+      try {
+        await runInDurableObject(f.session, (_instance, state) => {
+          state.storage.kv.put(WORKTREE_CHANGES_KEY, savedWorktreeSnapshot);
+          state.storage.kv.put(`${WORKTREE_FILE_PREFIX}changed.ts`, worktreeFileRecord(4));
+          const attachment = {
+            sessionId: f.sessionId,
+            ownerId: f.userId,
+            kiloSessionId: f.kiloSessionId,
+            sandboxId: f.sandboxId,
+            directory: f.directory,
+            wrapperInstanceId: f.wrapperInstanceId,
+          };
+          state.storage.kv.put('terminal_attached_session', attachment);
+          state.storage.kv.put('terminal:pty_worktree', {
+            ...attachment,
+            ptyId: 'pty_worktree',
+            state: 'running',
+          });
+          for (const tag of ['stream', 'terminal', 'terminal']) {
+            const pair = new WebSocketPair();
+            state.acceptWebSocket(pair[1], [tag]);
+            pair[0].accept();
+            clients.push(pair[0]);
+            servers.push(pair[1]);
+            closed.push(
+              new Promise(resolve => pair[0].addEventListener('close', resolve, { once: true }))
+            );
+          }
+        });
+        lateCapture = f.session.refreshWorktreeChanges();
+        held = await f.nextCapture();
+        await runInDurableObject(f.session, (_instance, state) => {
+          const remove = state.storage.kv.delete.bind(state.storage.kv);
+          const spy = vi.spyOn(state.storage.kv, 'delete').mockImplementation(key => {
+            if (key.startsWith(WORKTREE_FILE_PREFIX)) {
+              closedBeforePurge = servers.every(socket => socket.readyState !== WebSocket.OPEN);
+              throw new Error('Injected worktree erasure failure');
+            }
+            return remove(key);
+          });
+          restore = () => spy.mockRestore();
+        });
+        const worktreeInput = {
+          worktreeId: f.worktreeId,
+          kiloSessionId: f.kiloSessionId,
+          ownerId: f.userId,
+        };
+        await runInDurableObject(f.session, async instance => {
+          const failed =
+            action === 'session'
+              ? instance.deleteSession()
+              : instance.beginWorktreeDeletion(worktreeInput);
+          await expect(failed).rejects.toThrow('Injected worktree erasure failure');
+        });
+        expect(closedBeforePurge).toBe(true);
+        expect((await Promise.all(closed)).map(event => event.code)).toEqual(
+          action === 'worktree' ? [1001, 1000, 1000] : [1000, 1000, 1000]
+        );
+        if (action === 'session') {
+          expect(f.terminalCloses).toHaveLength(1);
+          expect(await f.control.listRoutes()).toEqual([]);
+        }
+        await expect(f.session.getCredentialMetadata()).resolves.toBeNull();
+        await expect(f.session.createTerminal()).resolves.toMatchObject({ success: false });
+        expect(
+          (
+            await f.session.fetch(
+              new Request('https://session.test/stream', { headers: { Upgrade: 'websocket' } })
+            )
+          ).status
+        ).toBe(action === 'worktree' ? 410 : 404);
+        await expect(f.session.getWorktreeChanges()).resolves.toEqual({ snapshot: null });
+        f.reply(held, worktreeSnapshotCapture(captureRevision(held)));
+        held = undefined;
+        await expect(lateCapture).resolves.toMatchObject({ status: 'failed' });
+        await f.settled();
+        restore();
+        await runInDurableObject(f.session, () => {
+          for (const client of clients) client.close();
+          clients.length = 0;
+        });
+        await abortAllDurableObjects();
+        const fresh = env.SANDBOX_SESSION.getByName(`${f.userId}:${f.sessionId}`);
+        await expect(fresh.getCredentialMetadata()).resolves.toBeNull();
+        await expect(fresh.createTerminal()).resolves.toMatchObject({ success: false });
+        expect(
+          (
+            await fresh.fetch(
+              new Request('https://session.test/stream', { headers: { Upgrade: 'websocket' } })
+            )
+          ).status
+        ).toBe(action === 'worktree' ? 410 : 404);
+        await expect(fresh.getWorktreeChanges()).resolves.toEqual({ snapshot: null });
+        await expect(
+          fresh.getWorktreeFile({ path: 'changed.ts', expectedRevision: 4 })
+        ).resolves.toEqual({ status: 'not_captured' });
+        await runInDurableObject(fresh, (_instance, state) => {
+          expect(state.storage.kv.get('session_lifecycle_fence')).toMatchObject({
+            state: 'deleted',
+          });
+          expect(state.storage.kv.get(WORKTREE_CHANGES_KEY)).toEqual(savedWorktreeSnapshot);
+          expect(state.storage.kv.get(`${WORKTREE_FILE_PREFIX}changed.ts`)).toEqual(
+            worktreeFileRecord(4)
+          );
+          expect(state.storage.kv.get('terminal:pty_worktree')).toMatchObject({ state: 'ended' });
+          expect(state.storage.kv.get('terminal_attached_session')).toBeUndefined();
+        });
+        if (action === 'session') await fresh.deleteSession();
+        else await fresh.beginWorktreeDeletion(worktreeInput);
+        await runInDurableObject(fresh, (_instance, state) => {
+          expect(state.storage.kv.get(WORKTREE_CHANGES_KEY)).toBeUndefined();
+          expect([...state.storage.kv.list({ prefix: WORKTREE_FILE_PREFIX })]).toEqual([]);
+        });
+      } finally {
+        restore?.();
+        if (held) f.reply(held, worktreeSnapshotCapture(captureRevision(held)));
+        await lateCapture;
+        if (clients.length > 0)
+          await runInDurableObject(f.session, () => {
+            for (const client of clients) client.close();
+            clients.length = 0;
+          });
+        f.close();
+      }
+    }
+  );
+
+  it('reports both worktree erasure and detach failures while keeping deletion retriable', async () => {
+    const f = await worktreeFixture();
+    let restore: (() => void) | undefined;
+    const detach = vi
+      .spyOn(SandboxControl.prototype, 'detachSession')
+      .mockRejectedValue(new Error('Injected detach failure'));
+    try {
+      await runInDurableObject(f.session, async (instance, state) => {
+        state.storage.kv.put(WORKTREE_CHANGES_KEY, savedWorktreeSnapshot);
+        state.storage.kv.put(`${WORKTREE_FILE_PREFIX}changed.ts`, worktreeFileRecord(4));
+        const remove = state.storage.kv.delete.bind(state.storage.kv);
+        const spy = vi.spyOn(state.storage.kv, 'delete').mockImplementation(key => {
+          if (key.startsWith(WORKTREE_FILE_PREFIX))
+            throw new Error('Injected worktree erasure failure');
+          return remove(key);
+        });
+        restore = () => spy.mockRestore();
+        await expect(instance.deleteSession()).rejects.toMatchObject({
+          message: 'Session cleanup failed',
+          errors: [
+            expect.objectContaining({ message: 'Injected worktree erasure failure' }),
+            expect.objectContaining({ message: 'Injected detach failure' }),
+          ],
+        });
+        expect(state.storage.kv.get('session_lifecycle_fence')).toMatchObject({ state: 'deleted' });
+      });
+      expect(detach).toHaveBeenCalled();
+      restore?.();
+      detach.mockRestore();
+      await f.session.deleteSession();
+      await runInDurableObject(f.session, (_instance, state) => {
+        expect(state.storage.kv.get(WORKTREE_CHANGES_KEY)).toBeUndefined();
+        expect([...state.storage.kv.list({ prefix: WORKTREE_FILE_PREFIX })]).toEqual([]);
+      });
+    } finally {
+      restore?.();
+      detach.mockRestore();
+      f.close();
+    }
+  });
+
+  it('fences late worktree capture and access after revocation even if detach fails', async () => {
+    const f = await worktreeFixture();
+    const detach = vi
+      .spyOn(SandboxControl.prototype, 'detachSession')
+      .mockRejectedValue(new Error('Injected detach failure'));
+    let held: RequestFrame | undefined;
+    let lateCapture: Promise<unknown> | undefined;
+    try {
+      await runInDurableObject(f.session, async (instance, state) => {
+        const metadata = await instance.getMetadata();
+        if (!metadata) throw new Error('Missing fixture metadata');
+        state.storage.kv.put(
+          'session_metadata',
+          serializeSessionMetadata({
+            ...metadata,
+            identity: { ...metadata.identity, orgId: 'revoked-org' },
+          })
+        );
+        state.storage.kv.put(WORKTREE_CHANGES_KEY, savedWorktreeSnapshot);
+        state.storage.kv.put(`${WORKTREE_FILE_PREFIX}changed.ts`, worktreeFileRecord(4));
+      });
+      lateCapture = f.session.refreshWorktreeChanges();
+      held = await f.nextCapture();
+      await runInDurableObject(f.session, async instance => {
+        await expect(instance.closeOrgStreams('revoked-org')).rejects.toThrow(
+          'Injected detach failure'
+        );
+      });
+      f.reply(held, worktreeSnapshotCapture(captureRevision(held)));
+      held = undefined;
+      await expect(lateCapture).resolves.toMatchObject({ status: 'failed' });
+      await f.settled();
+      await abortAllDurableObjects();
+      const fresh = env.SANDBOX_SESSION.getByName(`${f.userId}:${f.sessionId}`);
+      await expect(fresh.getCredentialMetadata()).resolves.toBeNull();
+      await expect(fresh.getWorktreeChanges()).resolves.toEqual({ snapshot: null });
+      await expect(
+        fresh.getWorktreeFile({ path: 'changed.ts', expectedRevision: 4 })
+      ).resolves.toEqual({ status: 'not_captured' });
+      await runInDurableObject(fresh, (_instance, state) => {
+        expect(state.storage.kv.get('session_lifecycle_fence')).toMatchObject({ state: 'revoked' });
+        expect(state.storage.kv.get(WORKTREE_CHANGES_KEY)).toEqual(savedWorktreeSnapshot);
+        expect(state.storage.kv.get(`${WORKTREE_FILE_PREFIX}changed.ts`)).toEqual(
+          worktreeFileRecord(4)
+        );
+      });
+      detach.mockRestore();
+      await fresh.closeOrgStreams('revoked-org');
+      const freshControl = env.SANDBOX_CONTROL.getByName(f.sandboxId);
+      expect(await freshControl.listRoutes()).toEqual([]);
+    } finally {
+      detach.mockRestore();
+      if (held) f.reply(held, worktreeSnapshotCapture(captureRevision(held)));
+      await lateCapture;
+      f.close();
+    }
+  });
+});
+
 describe('SandboxSession worktree changes persistence', () => {
   beforeEach(() => {
     vi.spyOn(globalThis, 'fetch').mockImplementation(async () => Response.json({ valid: true }));
@@ -7881,7 +8194,7 @@ describe('SandboxSession worktree changes persistence', () => {
     }
   });
 
-  it('rolls back the deletion fence if synchronous worktree erasure fails, allowing a complete retry', async () => {
+  it('preserves the deletion fence if worktree erasure fails, allowing a complete retry', async () => {
     const fixture = await worktreeFixture();
     let restore: (() => void) | undefined;
     try {
@@ -7899,9 +8212,10 @@ describe('SandboxSession worktree changes persistence', () => {
       await runInDurableObject(fixture.session, async instance => {
         await expect(instance.deleteSession()).rejects.toThrow('Injected worktree erasure failure');
       });
-      await expect(fixture.session.getMetadata()).resolves.not.toBeNull();
+      await expect(fixture.session.getMetadata()).resolves.toBeNull();
+      expect(await fixture.control.listRoutes()).toEqual([]);
       await runInDurableObject(fixture.session, (_instance, state) => {
-        expect(state.storage.kv.get('session_lifecycle_fence')).toBeUndefined();
+        expect(state.storage.kv.get('session_lifecycle_fence')).toMatchObject({ state: 'deleted' });
         expect(state.storage.kv.get(WORKTREE_CHANGES_KEY) !== undefined).toBe(true);
         expect(state.storage.kv.get(`${WORKTREE_FILE_PREFIX}changed.ts`) !== undefined).toBe(true);
       });
diff --git a/services/cloud-agent-next/test/unit/wrapper/auto-commit.test.ts b/services/cloud-agent-next/test/unit/wrapper/auto-commit.test.ts
index a4bd5c218e..94b3d94659 100644
--- a/services/cloud-agent-next/test/unit/wrapper/auto-commit.test.ts
+++ b/services/cloud-agent-next/test/unit/wrapper/auto-commit.test.ts
@@ -7,6 +7,10 @@ import os from 'node:os';
 import path from 'node:path';
 import { afterEach, describe, expect, it, vi, beforeEach } from 'vitest';
 import { createKiloClient } from '@kilocode/sdk';
+import {
+  MAX_AUTO_COMMIT_MESSAGE_BYTES,
+  autoCommitRecordSchema,
+} from '@kilocode/worker-utils/cloud-agent-commits';
 import { runAutoCommit, type AutoCommitOptions } from '../../../wrapper/src/auto-commit.js';
 import { createWrapperKiloClient, type WrapperKiloClient } from '../../../wrapper/src/kilo-api.js';
 import type * as Utils from '../../../wrapper/src/utils.js';
@@ -55,9 +59,6 @@ const createMockKiloClient = (): WrapperKiloClient => ({
   answerPermission: vi.fn(),
   answerQuestion: vi.fn(),
   rejectQuestion: vi.fn(),
-  getSessionStatuses: vi.fn(),
-  getQuestions: vi.fn(),
-  getPermissions: vi.fn(),
   getNetworkWaits: vi.fn(),
   resumeNetworkWait: vi.fn(),
   generateCommitMessage: vi.fn().mockResolvedValue({ message: 'test commit' }),
@@ -110,19 +111,21 @@ function blockCommitMessageRequest() {
   };
 }
 
-/** Configure mocks for a full happy-path commit+push (from git status onward). */
+const commitHash = 'a'.repeat(40);
+const committedAt = '2026-09-01T00:00:00.000Z';
+const raw = (stdout: string): Utils.ExecResult => ({ ...ok(), stdoutBytes: Buffer.from(stdout) });
+const commitObject = (message: string) =>
+  raw(`tree ${'b'.repeat(40)}\ncommitter Test <test@example.com> 1788220800 +0000\n\n${message}`);
+
 function setupHappyPathGit(): void {
-  // git status --porcelain  →  has changes
-  // git add -A              →  ok
-  // git commit -m ...       →  ok
-  // git rev-parse --short HEAD  →  abc1234
-  // git push ...            →  ok
-  mockGit
-    .mockResolvedValueOnce(ok(' M file.ts')) // status
-    .mockResolvedValueOnce(ok()) // add
-    .mockResolvedValueOnce(ok('[main abc1234] test commit')) // commit
-    .mockResolvedValueOnce(ok('abc1234')) // rev-parse
-    .mockResolvedValueOnce(ok()); // push
+  let message = 'test commit';
+  mockGit.mockImplementation(async args => {
+    if (args[0] === 'status') return ok(' M file.ts');
+    if (args[0] === 'commit') message = args.at(-1) ?? '';
+    if (args.includes('reflog')) return raw(`${commitHash}\n`);
+    if (args.includes('cat-file')) return commitObject(message);
+    return ok();
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -131,7 +134,7 @@ function setupHappyPathGit(): void {
 
 describe('runAutoCommit', () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    vi.resetAllMocks();
     mockHasGitUpstream.mockResolvedValue(true);
   });
 
@@ -262,7 +265,10 @@ describe('runAutoCommit', () => {
     // Should have emitted autocommit_started and autocommit_completed (success)
     const completed = events.find(e => e.streamEventType === 'autocommit_completed');
     expect(completed?.data).toEqual(
-      expect.objectContaining({ success: true, message: 'Changes committed and pushed' })
+      expect.objectContaining({
+        success: true,
+        message: 'Changes committed; push command completed',
+      })
     );
   });
 
@@ -276,7 +282,10 @@ describe('runAutoCommit', () => {
     expect(result).toEqual({ success: true });
     const completed = events.find(e => e.streamEventType === 'autocommit_completed');
     expect(completed?.data).toEqual(
-      expect.objectContaining({ success: true, message: 'Changes committed and pushed' })
+      expect.objectContaining({
+        success: true,
+        message: 'Changes committed; push command completed',
+      })
     );
   });
 
@@ -315,13 +324,161 @@ describe('runAutoCommit', () => {
     expect(completed?.data).toEqual(
       expect.objectContaining({
         success: true,
-        message: 'Changes committed and pushed',
-        commitHash: 'abc1234',
+        message: 'Changes committed; push command completed',
+        commitHash,
         commitMessage: 'test commit',
       })
     );
   });
 
+  it.each(['unknown', 'failed'] as const)(
+    'emits a bounded, anchored shared commit fact with push status %s',
+    async pushStatus => {
+      mockGetCurrentBranch.mockResolvedValue('work');
+      setupHappyPathGit();
+      const implementation = mockGit.getMockImplementation();
+      if (!implementation) throw new Error('Missing Git fixture');
+      const actualMessage = 'Hook message\n\n' + '漢'.repeat(MAX_AUTO_COMMIT_MESSAGE_BYTES);
+      mockGit.mockImplementation(async (args, options) => {
+        if (args.includes('cat-file')) return commitObject(actualMessage);
+        if (args[0] === 'push' && pushStatus === 'failed') return { ...ok(), exitCode: 1 };
+        return implementation(args, options);
+      });
+      const { opts, events } = createOpts({ userMessageId: 'user', messageId: 'assistant' });
+      expect(await runAutoCommit(opts)).toEqual({ success: true });
+      const record = autoCommitRecordSchema.parse(events.at(-1)?.data);
+      expect(record).toMatchObject({
+        commitHash,
+        committedAt,
+        userMessageId: 'user',
+        messageId: 'assistant',
+        pushStatus,
+        commitMessageTruncated: true,
+      });
+      expect(Buffer.byteLength(record.commitMessage)).toBeLessThanOrEqual(
+        MAX_AUTO_COMMIT_MESSAGE_BYTES
+      );
+      expect(actualMessage.startsWith(record.commitMessage)).toBe(true);
+      expect(record.commitMessage).not.toContain('�');
+    }
+  );
+
+  it.each(['rejection', 'throw', 'timeout', 'abort'] as const)(
+    'retains immutable local evidence after push %s',
+    async failure => {
+      mockGetCurrentBranch.mockResolvedValue('work');
+      setupHappyPathGit();
+      const implementation = mockGit.getMockImplementation();
+      if (!implementation) throw new Error('Missing Git fixture');
+      const controller = new AbortController();
+      mockGit.mockImplementation(async (args, options) => {
+        if (args.includes('cat-file')) return commitObject('actual hook message\n');
+        if (args[0] === 'push') {
+          if (failure === 'throw') throw new Error('Push spawn failed');
+          if (failure === 'abort') controller.abort();
+          return {
+            ...ok(),
+            exitCode: failure === 'rejection' ? 1 : 124,
+            ...(failure === 'timeout' ? { terminationReason: 'timeout' as const } : {}),
+            ...(failure === 'abort' ? { terminationReason: 'abort' as const } : {}),
+          };
+        }
+        return implementation(args, options);
+      });
+      const { opts, events } = createOpts({
+        messageId: 'assistant',
+        userMessageId: 'user',
+        signal: controller.signal,
+      });
+      expect(await runAutoCommit(opts)).toEqual({ success: true });
+      expect(
+        events
+          .filter(event => event.streamEventType === 'autocommit_completed')
+          .map(event => event.data)
+      ).toEqual([
+        expect.objectContaining({
+          success: true,
+          commitHash,
+          commitMessage: 'actual hook message\n',
+          committedAt,
+          messageId: 'assistant',
+          userMessageId: 'user',
+          pushStatus: failure === 'rejection' ? 'failed' : 'unknown',
+        }),
+      ]);
+    }
+  );
+
+  it.each(['returned', 'throw', 'abort'] as const)(
+    'recovers a commit when its process %s after updating the ref',
+    async completion => {
+      mockGetCurrentBranch.mockResolvedValue('work');
+      setupHappyPathGit();
+      const implementation = mockGit.getMockImplementation();
+      if (!implementation) throw new Error('Missing Git fixture');
+      const controller = new AbortController();
+      mockGit.mockImplementation(async (args, options) => {
+        if (args[0] === 'commit') {
+          controller.abort();
+          if (completion === 'throw') throw new Error('Commit interrupted after ref update');
+          return completion === 'returned'
+            ? ok()
+            : { ...ok(), exitCode: 124, terminationReason: 'abort' };
+        }
+        if (args.includes('reflog') || args.includes('cat-file'))
+          expect(options?.signal).toBeUndefined();
+        return implementation(args, options);
+      });
+      const { opts, events } = createOpts({
+        signal: controller.signal,
+        userMessageId: 'user',
+        messageId: 'assistant',
+      });
+      expect(await runAutoCommit(opts)).toEqual({ success: true });
+      expect(events.at(-1)?.data).toMatchObject({
+        success: true,
+        commitHash,
+        commitMessage: 'test commit',
+        committedAt,
+        pushStatus: 'not_attempted',
+      });
+      expect(mockGit.mock.calls.filter(([args]) => args[0] === 'commit')).toHaveLength(1);
+      expect(mockGit.mock.calls.some(([args]) => args[0] === 'push')).toBe(false);
+    }
+  );
+
+  it.each(['stage', 'commit'] as const)(
+    'does not invent commit evidence on %s failure',
+    async failure => {
+      mockGetCurrentBranch.mockResolvedValue('work');
+      mockGit.mockImplementation(async args => {
+        if (args[0] === 'status') return ok(' M file.ts');
+        if (args.includes('reflog')) return raw('');
+        if (args[0] === 'commit' || (failure === 'stage' && args[0] === 'add'))
+          return { ...ok(), exitCode: 1 };
+        return ok();
+      });
+      const { opts, events } = createOpts();
+      expect((await runAutoCommit(opts)).success).toBe(false);
+      expect(events.at(-1)?.data.commitHash).toBeUndefined();
+      expect(events.at(-1)?.data.success).toBe(false);
+    }
+  );
+
+  it('keeps successful local status without fabricating unreadable metadata', async () => {
+    mockGetCurrentBranch.mockResolvedValue('work');
+    setupHappyPathGit();
+    const implementation = mockGit.getMockImplementation();
+    if (!implementation) throw new Error('Missing Git fixture');
+    mockGit.mockImplementation(async (args, options) =>
+      args.includes('cat-file') ? { ...ok(), exitCode: 1 } : implementation(args, options)
+    );
+    const { opts, events } = createOpts();
+    expect(await runAutoCommit(opts)).toEqual({ success: true });
+    expect(events.at(-1)?.data).toMatchObject({ success: true, commitHash, pushStatus: 'unknown' });
+    expect(events.at(-1)?.data.commitMessage).toBeUndefined();
+  });
+
   it('appends the supplied co-author trailer to generated commit messages', async () => {
     mockGetCurrentBranch.mockResolvedValue('feature/cool-stuff');
     setupHappyPathGit();
@@ -394,8 +551,8 @@ describe('runAutoCommit', () => {
         expect(completed?.data).toEqual(
           expect.objectContaining({
             success: true,
-            message: 'Changes committed and pushed',
-            commitHash: 'abc1234',
+            message: 'Changes committed; push command completed',
+            commitHash,
             commitMessage,
           })
         );
@@ -472,7 +629,8 @@ describe('runAutoCommit', () => {
       .mockResolvedValueOnce(ok(' M file.ts'))
       .mockResolvedValueOnce(ok())
       .mockResolvedValueOnce(ok('[feature/worktree abc1234] test commit'))
-      .mockResolvedValueOnce(ok('abc1234'))
+      .mockResolvedValueOnce(raw(`${commitHash}\n`))
+      .mockResolvedValueOnce(commitObject('test commit'))
       .mockResolvedValueOnce({
         stdout: '',
         stderr: `remote: rejected credential ${secret}`,
@@ -495,7 +653,8 @@ describe('runAutoCommit', () => {
       .mockResolvedValueOnce(ok(' M file.ts'))
       .mockResolvedValueOnce(ok())
       .mockResolvedValueOnce(ok('[feature/cool-stuff abc1234] test commit'))
-      .mockResolvedValueOnce(ok('abc1234'))
+      .mockResolvedValueOnce(raw(`${commitHash}\n`))
+      .mockResolvedValueOnce(commitObject('test commit'))
       .mockResolvedValueOnce({
         stdout: '',
         stderr:
@@ -530,7 +689,8 @@ describe('runAutoCommit', () => {
       const directory = options?.cwd ?? '';
       if (args[0] === 'status') return ok(dirty.has(directory) ? ' M result.txt\n' : '');
       if (args[0] === 'commit') dirty.delete(directory);
-      if (args[0] === 'rev-parse') return ok('abc1234');
+      if (args.includes('reflog')) return raw(`${commitHash}\n`);
+      if (args.includes('cat-file')) return commitObject('test commit');
       if (args[0] === 'push' && directory === workspacePath) {
         pushing.resolve();
         return stopped.promise;
@@ -601,6 +761,228 @@ describe('runAutoCommit', () => {
     }
   });
 
+  it.each(['sha1', 'sha256'] as const)(
+    'uses invocation reflog identity and hook-authored %s metadata despite a later HEAD',
+    async objectFormat => {
+      const actual = await vi.importActual<typeof Utils>('../../../wrapper/src/utils.js');
+      const root = await fs.mkdtemp(path.join(os.tmpdir(), 'owned-commit-'));
+      const env = {
+        PATH: process.env.PATH,
+        HOME: root,
+        GIT_CONFIG_NOSYSTEM: '1',
+        GIT_CONFIG_GLOBAL: '/dev/null',
+      };
+      const run = async (args: string[]) => {
+        const result = await actual.git(args, { cwd: root, env, inheritEnv: false });
+        expect(result.exitCode).toBe(0);
+        return result.stdout.trim();
+      };
+      let ownedHash = '';
+      try {
+        await run(['init', '-b', 'work', `--object-format=${objectFormat}`]);
+        await run(['config', 'user.name', 'Test']);
+        await run(['config', 'user.email', 'test@example.com']);
+        await run(['config', 'commit.gpgsign', 'false']);
+        await fs.writeFile(path.join(root, 'file.txt'), 'owned\n');
+        await fs.writeFile(
+          path.join(root, '.git/hooks/commit-msg'),
+          '#!/bin/sh\nprintf "Hook subject\\n\\nHook body\\n" > "$1"\n',
+          { mode: 0o755 }
+        );
+        mockGetCurrentBranch.mockImplementation(actual.getCurrentBranch);
+        mockHasGitUpstream.mockImplementation(actual.hasGitUpstream);
+        mockGit.mockImplementation(async (args, options) => {
+          const result = await actual.git(args, options);
+          if (args[0] === 'commit') {
+            ownedHash = await run(['rev-parse', 'HEAD']);
+            await fs.writeFile(path.join(root, 'file.txt'), 'later\n');
+            await run(['add', '-A']);
+            await run(['-c', 'core.hooksPath=/dev/null', 'commit', '-m', 'Unrelated later commit']);
+          }
+          return result;
+        });
+        const { opts, events } = createOpts({
+          workspacePath: root,
+          env,
+          userMessageId: 'user',
+          messageId: 'assistant',
+        });
+        expect(await runAutoCommit(opts)).toEqual({ success: true });
+        expect(ownedHash).toHaveLength(objectFormat === 'sha1' ? 40 : 64);
+        expect(await run(['rev-parse', 'HEAD'])).not.toBe(ownedHash);
+        expect(events.at(-1)?.data).toMatchObject({
+          success: true,
+          commitHash: ownedHash,
+          commitMessage: 'Hook subject\n\nHook body\n',
+          userMessageId: 'user',
+          messageId: 'assistant',
+          pushStatus: 'failed',
+        });
+        expect(events.at(-1)?.data.committedAt).toBe(
+          new Date(await run(['show', '-s', '--format=%cI', ownedHash])).toISOString()
+        );
+        expect(autoCommitRecordSchema.safeParse(events.at(-1)?.data).success).toBe(true);
+      } finally {
+        await fs.rm(root, { recursive: true, force: true });
+      }
+    }
+  );
+
+  it.each([true, false])(
+    'does not claim the captured commit was pushed after a non-descendant ref move with tracking=%s',
+    async tracking => {
+      const actual = await vi.importActual<typeof Utils>('../../../wrapper/src/utils.js');
+      const root = await fs.mkdtemp(path.join(os.tmpdir(), 'moved-autocommit-ref-'));
+      const workspacePath = path.join(root, 'workspace');
+      const remote = path.join(root, 'remote.git');
+      const env = {
+        PATH: process.env.PATH,
+        HOME: root,
+        GIT_CONFIG_NOSYSTEM: '1',
+        GIT_CONFIG_GLOBAL: '/dev/null',
+      };
+      const run = async (args: string[], cwd = workspacePath) => {
+        const result = await actual.git(args, { cwd, env, inheritEnv: false });
+        expect(result.exitCode).toBe(0);
+        return result.stdout.trim();
+      };
+      const pushCalls: string[][] = [];
+      let capturedHash = '';
+      try {
+        await fs.mkdir(workspacePath);
+        await run(['init', '--bare', remote]);
+        await run(['init', '-b', 'work']);
+        await run(['config', 'user.name', 'Test']);
+        await run(['config', 'user.email', 'test@example.com']);
+        await run(['config', 'commit.gpgsign', 'false']);
+        await run(['remote', 'add', 'origin', remote]);
+        await fs.writeFile(path.join(workspacePath, 'file.txt'), 'seed\n');
+        await run(['add', '-A']);
+        await run(['commit', '-m', 'seed']);
+        await run(['push', ...(tracking ? ['-u'] : []), 'origin', 'work']);
+        const replacementHash = await run([
+          'commit-tree',
+          'HEAD^{tree}',
+          '-p',
+          'HEAD',
+          '-m',
+          'Unrelated B',
+        ]);
+        await fs.writeFile(path.join(workspacePath, 'file.txt'), 'managed A\n');
+        mockGetCurrentBranch.mockImplementation(actual.getCurrentBranch);
+        mockHasGitUpstream.mockImplementation(actual.hasGitUpstream);
+        mockGit.mockImplementation(async (args, options) => {
+          if (args[0] === 'push') {
+            expect(capturedHash).toMatch(/^[0-9a-f]{40}$/);
+            pushCalls.push(args);
+            await run(['update-ref', 'refs/heads/work', replacementHash, capturedHash]);
+          }
+          const result = await actual.git(args, options);
+          if (args.includes('cat-file') && args.includes('commit'))
+            capturedHash = args.at(-1) ?? '';
+          if (args[0] === 'push') expect(result.exitCode).toBe(0);
+          return result;
+        });
+        const { opts, events } = createOpts({
+          workspacePath,
+          env,
+          userMessageId: 'user',
+          messageId: 'assistant',
+        });
+        expect(await runAutoCommit(opts)).toEqual({ success: true });
+        expect(pushCalls).toEqual([tracking ? ['push'] : ['push', '-u', 'origin', 'work']]);
+        expect(await run(['rev-parse', 'refs/heads/work'], remote)).toBe(replacementHash);
+        expect(
+          (
+            await actual.git(['merge-base', '--is-ancestor', capturedHash, replacementHash], {
+              cwd: workspacePath,
+              env,
+              inheritEnv: false,
+            })
+          ).exitCode
+        ).toBe(1);
+        expect(
+          (
+            await actual.git(['cat-file', '-e', `${capturedHash}^{commit}`], {
+              cwd: remote,
+              env,
+              inheritEnv: false,
+            })
+          ).exitCode
+        ).not.toBe(0);
+        expect(events.at(-1)?.data).toMatchObject({
+          success: true,
+          commitHash: capturedHash,
+          commitMessage: 'test commit\n',
+          userMessageId: 'user',
+          messageId: 'assistant',
+          pushStatus: 'unknown',
+          message: 'Changes committed; push command completed',
+        });
+        expect(autoCommitRecordSchema.safeParse(events.at(-1)?.data).success).toBe(true);
+      } finally {
+        await fs.rm(root, { recursive: true, force: true });
+      }
+    }
+  );
+
+  it('recovers real ref evidence when cancellation kills the post-commit hook', async () => {
+    const actual = await vi.importActual<typeof Utils>('../../../wrapper/src/utils.js');
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'aborted-owned-commit-'));
+    const env = {
+      PATH: process.env.PATH,
+      HOME: root,
+      GIT_CONFIG_NOSYSTEM: '1',
+      GIT_CONFIG_GLOBAL: '/dev/null',
+    };
+    const run = async (args: string[]) => {
+      const result = await actual.git(args, { cwd: root, env, inheritEnv: false });
+      expect(result.exitCode).toBe(0);
+      return result.stdout.trim();
+    };
+    const controller = new AbortController();
+    try {
+      await run(['init', '-b', 'work']);
+      await run(['config', 'user.name', 'Test']);
+      await run(['config', 'user.email', 'test@example.com']);
+      await run(['config', 'commit.gpgsign', 'false']);
+      await fs.writeFile(path.join(root, 'file.txt'), 'owned\n');
+      await fs.writeFile(
+        path.join(root, '.git/hooks/post-commit'),
+        '#!/bin/sh\nprintf "ref-updated\\n"\nsleep 30\n',
+        { mode: 0o755 }
+      );
+      mockGetCurrentBranch.mockImplementation(actual.getCurrentBranch);
+      mockHasGitUpstream.mockImplementation(actual.hasGitUpstream);
+      mockGit.mockImplementation((args, options) =>
+        actual.git(args, {
+          ...options,
+          ...(args[0] === 'commit'
+            ? {
+                terminationGraceMs: 100,
+                onOutput: (_stream, output) => {
+                  if (output.includes('ref-updated')) controller.abort();
+                },
+              }
+            : {}),
+        })
+      );
+      const { opts, events } = createOpts({ workspacePath: root, env, signal: controller.signal });
+      expect(await runAutoCommit(opts)).toEqual({ success: true });
+      expect(controller.signal.aborted).toBe(true);
+      expect(events.at(-1)?.data).toMatchObject({
+        success: true,
+        commitHash: await run(['rev-parse', 'HEAD']),
+        commitMessage: 'test commit\n',
+        pushStatus: 'not_attempted',
+      });
+      expect(mockGit.mock.calls.filter(([args]) => args[0] === 'commit')).toHaveLength(1);
+    } finally {
+      controller.abort();
+      await fs.rm(root, { recursive: true, force: true });
+    }
+  });
+
   it.each([false, true])(
     'serializes same-worktree auto-commit through push with new sibling edits=%s',
     async siblingEdits => {
diff --git a/services/cloud-agent-next/wrapper/src/auto-commit.ts b/services/cloud-agent-next/wrapper/src/auto-commit.ts
index d010eb4686..5085e40e3e 100644
--- a/services/cloud-agent-next/wrapper/src/auto-commit.ts
+++ b/services/cloud-agent-next/wrapper/src/auto-commit.ts
@@ -1,4 +1,6 @@
+import { randomUUID } from 'node:crypto';
 import type { IngestEvent } from '../../src/shared/protocol.js';
+import { FULL_COMMIT_HASH, immutableGit, readCommitObject } from './commit-objects.js';
 import type { WrapperCommitCoAuthor } from '../../src/shared/wrapper-bootstrap.js';
 import type { WrapperKiloClient } from './kilo-api.js';
 import { git, getCurrentBranch, hasGitUpstream, logToFile as writeLog } from './utils.js';
@@ -11,6 +13,15 @@ const GIT_PUSH_TIMEOUT_MS = 60_000;
 /** Timeout for commit message generation API call */
 const COMMIT_MESSAGE_TIMEOUT_MS = 30_000;
 const worktreeAutoCommits = new Map<string, Promise<void>>();
+const COMMIT_EVIDENCE_TIMEOUT_MS = 5_000;
+
+type CommitEvidence = {
+  commitHash: string;
+  commitMessage?: string;
+  committedAt?: string;
+  commitMessageTruncated?: true;
+};
+type PushStatus = 'failed' | 'not_attempted' | 'unknown';
 
 function appendCommitCoAuthor(
   commitMessage: string,
@@ -42,6 +53,7 @@ export type AutoCommitOptions = {
   kiloClient: WrapperKiloClient;
   /** The assistant message ID this autocommit is associated with (for per-message UI rendering) */
   messageId?: string;
+  userMessageId?: string;
   /** If the user explicitly provided an upstream branch via API, pass it here to allow
    *  committing to that branch even if it is main/master. Protection is only bypassed
    *  when the current branch matches this value exactly. */
@@ -71,6 +83,10 @@ function emitCompleted(
     skipped?: boolean;
     commitHash?: string;
     commitMessage?: string;
+    committedAt?: string;
+    userMessageId?: string;
+    pushStatus?: PushStatus;
+    commitMessageTruncated?: true;
   },
   messageId?: string
 ): void {
@@ -82,7 +98,10 @@ function emitCompleted(
 }
 
 export async function runAutoCommit(opts: AutoCommitOptions): Promise<AutoCommitResult> {
-  const { workspacePath, onEvent, kiloClient, messageId, signal, env } = opts;
+  const { workspacePath, onEvent, kiloClient, messageId, userMessageId, signal, env } = opts;
+  let locallyCommitted = false;
+  let evidence: CommitEvidence | undefined;
+  let pushStatus: PushStatus = 'not_attempted';
   const redact = createSecretRedactor(process.env, env ?? {});
   const logToFile = (message: string): void => writeLog(redact(message));
   const released = Promise.withResolvers<void>();
@@ -97,6 +116,75 @@ export async function runAutoCommit(opts: AutoCommitOptions): Promise<AutoCommit
 
   logToFile(`auto-commit: starting workspacePath=${workspacePath}`);
 
+  async function commit(args: string[]) {
+    const action = `kilo-autocommit-${randomUUID()}`;
+    try {
+      const result = await git(args, {
+        cwd: workspacePath,
+        env: { ...(env ?? process.env), GIT_REFLOG_ACTION: action },
+        inheritEnv: false,
+        timeoutMs: GIT_LOCAL_TIMEOUT_MS,
+        signal,
+      });
+      locallyCommitted ||= result.exitCode === 0;
+      return result;
+    } finally {
+      await captureEvidence(action);
+    }
+  }
+
+  async function captureEvidence(action: string): Promise<void> {
+    const deadline = Date.now() + COMMIT_EVIDENCE_TIMEOUT_MS;
+    try {
+      const result = await immutableGit(
+        workspacePath,
+        [
+          'reflog',
+          'show',
+          '--format=%H',
+          `--grep-reflog=^${action}: `,
+          '--max-count=2',
+          'HEAD',
+          '--',
+        ],
+        { timeoutMs: COMMIT_EVIDENCE_TIMEOUT_MS, maxOutputBytes: 256 }
+      );
+      const hashes = result.stdoutBytes?.toString('utf8').trim().split('\n');
+      if (
+        result.exitCode !== 0 ||
+        result.terminationReason ||
+        result.stdoutTruncated ||
+        hashes?.length !== 1 ||
+        !FULL_COMMIT_HASH.test(hashes[0])
+      )
+        return;
+      evidence = { commitHash: hashes[0] };
+      locallyCommitted = true;
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) return;
+      const metadata = await readCommitObject(workspacePath, evidence.commitHash, {
+        timeoutMs: remaining,
+      });
+      evidence = {
+        ...evidence,
+        commitMessage: metadata.commitMessage,
+        committedAt: metadata.committedAt,
+        ...(metadata.commitMessageTruncated ? { commitMessageTruncated: true } : {}),
+      };
+    } catch {
+      logToFile('auto-commit: commit metadata unavailable');
+    }
+  }
+
+  function completeLocalCommit(message: string): AutoCommitResult {
+    emitCompleted(
+      onEvent,
+      { success: true, message, ...evidence, userMessageId, pushStatus },
+      messageId
+    );
+    return { success: true };
+  }
+
   try {
     signal?.throwIfAborted();
     const cancelled = Promise.withResolvers<never>();
@@ -229,21 +317,11 @@ export async function runAutoCommit(opts: AutoCommitOptions): Promise<AutoCommit
 
     // Commit — retry with --no-verify if pre-commit hook fails
     logToFile('auto-commit: committing');
-    let commitResult = await git(['commit', '-m', commitMessage], {
-      cwd: workspacePath,
-      ...(env ? { env, inheritEnv: false } : {}),
-      timeoutMs: GIT_LOCAL_TIMEOUT_MS,
-      signal,
-    });
-    if (commitResult.exitCode !== 0) {
+    let commitResult = await commit(['commit', '-m', commitMessage]);
+    if (!locallyCommitted) {
       logToFile('auto-commit: commit failed, retrying with --no-verify');
-      commitResult = await git(['commit', '--no-verify', '-m', commitMessage], {
-        cwd: workspacePath,
-        ...(env ? { env, inheritEnv: false } : {}),
-        timeoutMs: GIT_LOCAL_TIMEOUT_MS,
-        signal,
-      });
-      if (commitResult.exitCode !== 0) {
+      commitResult = await commit(['commit', '--no-verify', '-m', commitMessage]);
+      if (!locallyCommitted) {
         const msg = `git commit failed: ${redact(commitResult.stderr.trim())}`;
         logToFile(`auto-commit: ${msg}`);
         emitCompleted(onEvent, { success: false, message: msg }, messageId);
@@ -252,27 +330,15 @@ export async function runAutoCommit(opts: AutoCommitOptions): Promise<AutoCommit
     }
     logToFile(`auto-commit: commit succeeded: ${commitResult.stdout.trim()}`);
 
-    // Get commit hash for UI display
-    let commitHash: string | undefined;
-    try {
-      const hashResult = await git(['rev-parse', '--short', 'HEAD'], {
-        cwd: workspacePath,
-        ...(env ? { env, inheritEnv: false } : {}),
-        timeoutMs: GIT_LOCAL_TIMEOUT_MS,
-        signal,
-      });
-      if (hashResult.exitCode === 0 && hashResult.stdout.trim()) {
-        commitHash = hashResult.stdout.trim();
-        logToFile(`auto-commit: commit hash=${commitHash}`);
-      }
-    } catch {
-      logToFile('auto-commit: failed to get commit hash, continuing without it');
+    if (signal?.aborted || commitResult.terminationReason) {
+      return completeLocalCommit('Changes committed (push not attempted)');
     }
 
     // Push
     const pushArgs = trackingUpstream ? ['push'] : ['push', '-u', 'origin', branch];
     logToFile(`auto-commit: pushing with args: git ${pushArgs.join(' ')}`);
 
+    pushStatus = 'unknown';
     const pushResult = await git(pushArgs, {
       cwd: workspacePath,
       ...(env ? { env, inheritEnv: false } : {}),
@@ -284,35 +350,18 @@ export async function runAutoCommit(opts: AutoCommitOptions): Promise<AutoCommit
       const sanitizedPushError = redact(pushResult.stderr.trim());
       const msg = `git push failed: ${sanitizedPushError}`;
       logToFile(`auto-commit: ${msg}`);
-      emitCompleted(
-        onEvent,
-        {
-          success: true,
-          message: `Changes committed (push failed: ${sanitizedPushError})`,
-          commitHash,
-          commitMessage,
-        },
-        messageId
-      );
-      return { success: true };
+      pushStatus =
+        pushResult.terminationReason || pushResult.exitCode === 124 ? 'unknown' : 'failed';
+      return completeLocalCommit(`Changes committed (push failed: ${sanitizedPushError})`);
     }
 
-    logToFile('auto-commit: push succeeded');
+    logToFile('auto-commit: push command completed');
     logToFile('auto-commit: completed successfully');
-    emitCompleted(
-      onEvent,
-      {
-        success: true,
-        message: 'Changes committed and pushed',
-        commitHash,
-        commitMessage,
-      },
-      messageId
-    );
-    return { success: true };
+    return completeLocalCommit('Changes committed; push command completed');
   } catch (error) {
     const errorMsg = redact(error instanceof Error ? error.message : String(error));
     logToFile(`auto-commit: error - ${errorMsg}`);
+    if (locallyCommitted) return completeLocalCommit(`Changes committed (${errorMsg})`);
     emitCompleted(
       onEvent,
       { success: false, message: `Auto-commit failed: ${errorMsg}` },
diff --git a/services/cloud-agent-next/wrapper/src/commit-objects.test.ts b/services/cloud-agent-next/wrapper/src/commit-objects.test.ts
new file mode 100644
index 0000000000..7d792d0e98
--- /dev/null
+++ b/services/cloud-agent-next/wrapper/src/commit-objects.test.ts
@@ -0,0 +1,97 @@
+import { afterEach, describe, expect, it } from 'bun:test';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  MAX_AUTO_COMMIT_MESSAGE_BYTES,
+  autoCommitRecordSchema,
+} from '@kilocode/worker-utils/cloud-agent-commits';
+import { immutableGit, MAX_COMMIT_MESSAGE_BYTES, readCommitObject } from './commit-objects.js';
+
+const directories: string[] = [];
+function run(directory: string, args: string[]): string {
+  const result = Bun.spawnSync({
+    cmd: ['git', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=/dev/null', ...args],
+    cwd: directory,
+    env: {
+      PATH: process.env.PATH,
+      GIT_CONFIG_NOSYSTEM: '1',
+      GIT_CONFIG_GLOBAL: '/dev/null',
+      GIT_AUTHOR_NAME: 'Test',
+      GIT_AUTHOR_EMAIL: 'test@example.com',
+      GIT_COMMITTER_NAME: 'Test',
+      GIT_COMMITTER_EMAIL: 'test@example.com',
+    },
+    stdout: 'pipe',
+    stderr: 'pipe',
+  });
+  if (result.exitCode !== 0)
+    throw new Error(`Fixture Git failed: ${args[0]}: ${result.stderr.toString()}`);
+  return result.stdout.toString();
+}
+async function repo() {
+  const directory = await mkdtemp(join(tmpdir(), 'commit-objects-'));
+  directories.push(directory);
+  run(directory, ['init', '-b', 'work']);
+  return directory;
+}
+afterEach(async () => {
+  await Promise.all(
+    directories.splice(0).map(directory => rm(directory, { recursive: true, force: true }))
+  );
+});
+
+describe('readCommitObject', () => {
+  it.each([-1, 0, 1])(
+    'matches the shared byte limit with an explicit truncation flag at offset %s',
+    async offset => {
+      expect(MAX_COMMIT_MESSAGE_BYTES).toBe(MAX_AUTO_COMMIT_MESSAGE_BYTES);
+      const directory = await repo();
+      const message = 'x'.repeat(MAX_AUTO_COMMIT_MESSAGE_BYTES + offset - 1) + '\n';
+      await writeFile(join(directory, 'message'), message);
+      run(directory, ['add', '-A']);
+      run(directory, ['commit', '--cleanup=verbatim', '-F', 'message']);
+      const hash = run(directory, ['rev-parse', 'HEAD']).trim();
+      const metadata = await readCommitObject(directory, hash, { timeoutMs: 5_000 });
+      expect(metadata.commitMessage).toBe(message.slice(0, MAX_AUTO_COMMIT_MESSAGE_BYTES));
+      expect(metadata.commitMessageTruncated).toBe(offset > 0 ? true : undefined);
+      expect(
+        autoCommitRecordSchema.safeParse({
+          ...metadata,
+          commitHash: hash,
+          userMessageId: 'user',
+          messageId: 'assistant',
+          pushStatus: 'pushed',
+        }).success
+      ).toBe(true);
+    }
+  );
+
+  it('reads exact hook-independent object messages and bounds UTF-8 at 16 KiB', async () => {
+    const directory = await repo();
+    const message = 'Subject\n\n' + '漢'.repeat(MAX_COMMIT_MESSAGE_BYTES);
+    await writeFile(join(directory, 'message'), message);
+    run(directory, ['add', '-A']);
+    run(directory, ['commit', '--cleanup=verbatim', '-F', 'message']);
+    const hash = run(directory, ['rev-parse', 'HEAD']).trim();
+    const metadata = await readCommitObject(directory, hash, { timeoutMs: 5_000 });
+    expect(metadata.commitMessageTruncated).toBe(true);
+    expect(Buffer.byteLength(metadata.commitMessage)).toBeLessThanOrEqual(MAX_COMMIT_MESSAGE_BYTES);
+    expect(message.startsWith(metadata.commitMessage)).toBe(true);
+    expect(metadata.commitMessage).not.toContain('�');
+    expect(
+      autoCommitRecordSchema.safeParse({
+        ...metadata,
+        commitHash: hash,
+        userMessageId: 'user',
+        messageId: 'assistant',
+        pushStatus: 'pushed',
+      }).success
+    ).toBe(true);
+    const raw = await immutableGit(directory, ['cat-file', 'commit', hash], {
+      timeoutMs: 5_000,
+      maxOutputBytes: 512 * 1024,
+    });
+    expect(raw.stdoutBytes?.toString()).toContain(message);
+  });
+});
diff --git a/services/cloud-agent-next/wrapper/src/commit-objects.ts b/services/cloud-agent-next/wrapper/src/commit-objects.ts
new file mode 100644
index 0000000000..4a61b1d60e
--- /dev/null
+++ b/services/cloud-agent-next/wrapper/src/commit-objects.ts
@@ -0,0 +1,87 @@
+import { git, type GitOptions } from './utils.js';
+import { decodeWorktreeUtf8 } from './control/worktree-file-capture.js';
+
+export const FULL_COMMIT_HASH = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+export const MAX_COMMIT_MESSAGE_BYTES = 16 * 1024;
+const MAX_COMMIT_HEADER_BYTES = 64 * 1024;
+
+export function immutableGit(
+  directory: string,
+  args: string[],
+  options: Pick<GitOptions, 'timeoutMs' | 'signal' | 'maxOutputBytes'>,
+  runGit: typeof git = git
+) {
+  return runGit(
+    [
+      '--no-pager',
+      '--no-optional-locks',
+      '-c',
+      'color.ui=false',
+      '-c',
+      'core.quotepath=false',
+      '-c',
+      'core.fsmonitor=false',
+      ...args,
+    ],
+    {
+      cwd: directory,
+      inheritEnv: false,
+      env: {
+        PATH: process.env.PATH,
+        GIT_CONFIG_NOSYSTEM: '1',
+        GIT_CONFIG_GLOBAL: '/dev/null',
+        GIT_TERMINAL_PROMPT: '0',
+        GIT_NO_LAZY_FETCH: '1',
+        GIT_NO_REPLACE_OBJECTS: '1',
+      },
+      terminationGraceMs: 250,
+      rawOutput: true,
+      ...options,
+    }
+  );
+}
+
+export type CommitObject = {
+  commitMessage: string;
+  committedAt: string;
+  commitMessageTruncated?: true;
+};
+
+export async function readCommitObject(
+  directory: string,
+  commitHash: string,
+  options: Pick<GitOptions, 'timeoutMs' | 'signal'>,
+  runGit: typeof git = git
+): Promise<CommitObject> {
+  if (!FULL_COMMIT_HASH.test(commitHash)) throw new Error('Invalid commit hash');
+  const result = await immutableGit(
+    directory,
+    ['cat-file', 'commit', commitHash],
+    { ...options, maxOutputBytes: MAX_COMMIT_HEADER_BYTES + MAX_COMMIT_MESSAGE_BYTES + 1 },
+    runGit
+  );
+  const bytes = result.stdoutBytes;
+  if (result.exitCode !== 0 || result.terminationReason || !bytes) {
+    throw new Error('Commit metadata unavailable');
+  }
+  const separator = bytes.indexOf('\n\n');
+  if (separator < 0 || separator > MAX_COMMIT_HEADER_BYTES) {
+    throw new Error('Commit metadata unavailable');
+  }
+  const headers = decodeWorktreeUtf8(bytes.subarray(0, separator)).split('\n');
+  const committer = headers.find(line => line.startsWith('committer '));
+  const timestamp = committer && / (-?\d+) [+-]\d{4}$/.exec(committer)?.[1];
+  if (!timestamp) throw new Error('Commit metadata unavailable');
+  const committedAt = new Date(Number(timestamp) * 1000).toISOString();
+  const message = bytes.subarray(separator + 2);
+  const truncated = result.stdoutTruncated || message.length > MAX_COMMIT_MESSAGE_BYTES;
+  let end = Math.min(message.length, MAX_COMMIT_MESSAGE_BYTES);
+  if (truncated) {
+    while (end > 0 && (message[end] & 0xc0) === 0x80) end -= 1;
+  }
+  return {
+    committedAt,
+    commitMessage: decodeWorktreeUtf8(message.subarray(0, end)),
+    ...(truncated ? { commitMessageTruncated: true } : {}),
+  };
+}
diff --git a/services/cloud-agent-next/wrapper/src/control/sandbox-control-handlers.test.ts b/services/cloud-agent-next/wrapper/src/control/sandbox-control-handlers.test.ts
index 0853c8e853..c5724155ac 100644
--- a/services/cloud-agent-next/wrapper/src/control/sandbox-control-handlers.test.ts
+++ b/services/cloud-agent-next/wrapper/src/control/sandbox-control-handlers.test.ts
@@ -2594,7 +2594,11 @@ describe('control finalization and compact', () => {
           expect(committed).toMatchObject({
             success: true,
             messageId: 'assistant_1',
-            commitMessage: 'Apply normal control turn',
+            userMessageId: 'msg_1',
+            commitHash: (await git(['rev-parse', 'HEAD'], workspace)).trim(),
+            pushStatus: 'unknown',
+            message: 'Changes committed; push command completed',
+            commitMessage: 'Apply normal control turn\n',
           });
         } else {
           expect(committed).toMatchObject({ success: true, skipped: true });
@@ -2625,6 +2629,8 @@ describe('control finalization and compact', () => {
     const handlerDeps = deps({
       runAutoCommit: async options => {
         expect(options.workspacePath).toBe(session.directory);
+        expect(options.messageId).toBe('assistant_1');
+        expect(options.userMessageId).toBe('msg_1');
         expect(options.signal?.aborted).toBe(false);
         options.onEvent({
           streamEventType: 'autocommit_started',
@@ -2869,6 +2875,46 @@ describe('control finalization and compact', () => {
     expect(events.at(-1)?.properties).toEqual({ messageId: 'msg_1', status: 'completed' });
   });
 
+  it('anchors compact auto-commit metadata to its originating user when no assistant is known', async () => {
+    const events: SessionEventPayload[] = [];
+    const handlerDeps = deps({
+      runAutoCommit: async options => {
+        options.onEvent({
+          streamEventType: 'autocommit_completed',
+          timestamp: '2026-09-01T00:00:00.000Z',
+          data: {
+            success: true,
+            message: 'Changes committed (push not attempted)',
+            commitHash: 'a'.repeat(40),
+            commitMessage: 'Apply changes\n',
+            committedAt: '2026-09-01T00:00:00.000Z',
+            pushStatus: 'not_attempted',
+            messageId: options.messageId,
+            userMessageId: options.userMessageId,
+          },
+        });
+        return { success: true };
+      },
+      emitSessionEvent: (_session, event) => events.push(event),
+    });
+    expect(
+      await handleControlRequest(
+        'session.prompt',
+        session,
+        {
+          ...promptPayload,
+          turn: { type: 'command', command: 'compact', arguments: '' },
+          finalization: { autoCommit: true },
+        },
+        handlerDeps
+      )
+    ).toMatchObject({ ok: true, result: { status: 'accepted' } });
+    await waitForTasks(handlerDeps);
+    const committed = events.find(event => event.type === 'autocommit_completed')?.properties;
+    expect(committed).toMatchObject({ messageId: 'msg_1', userMessageId: 'msg_1' });
+    expect(events.at(-1)?.properties).toEqual({ messageId: 'msg_1', status: 'completed' });
+  });
+
   it('rejects compact without a model and reports an asynchronous summarize failure', async () => {
     const events: SessionEventPayload[] = [];
     const handlerDeps = deps({
diff --git a/services/cloud-agent-next/wrapper/src/control/sandbox-control-handlers.ts b/services/cloud-agent-next/wrapper/src/control/sandbox-control-handlers.ts
index ac26006425..ee63e6959f 100644
--- a/services/cloud-agent-next/wrapper/src/control/sandbox-control-handlers.ts
+++ b/services/cloud-agent-next/wrapper/src/control/sandbox-control-handlers.ts
@@ -1085,6 +1085,7 @@ async function executePrompt(
           kiloClient,
           env,
           messageId: completion?.info.id ?? messageId,
+          userMessageId: messageId,
           signal,
           onEvent: event => emitFinalizationEvent(session, event, deps),
         });