@adhdev/daemon-core 0.9.52 → 0.9.54

package/dist/shared-types.d.ts

@@ -13,6 +13,8 @@ export type { ProviderErrorReason } from './providers/provider-instance.js';
 import type { ActiveChatData as _ActiveChatData, ProviderErrorReason as _ProviderErrorReason } from './providers/provider-instance.js';
 import type { WorkspaceEntry } from './config/workspaces.js';
 import type { ProviderResumeCapability } from './providers/contracts.js';
+import type { GitCompactSummary, GitWorkspaceUpdate, WorkspaceGitSubscriptionParams } from './git/git-types.js';
+export type { GitCommandName, GitCompactSummary, GitDiffSummary, GitFailureReason, GitFileChange, GitFileChangeStatus, GitRepoIdentity, GitRepoStatus, GitSnapshot, GitSnapshotCompareSummary, GitSnapshotReason, GitWorkspaceUpdate, WorkspaceGitSubscriptionParams, } from './git/git-types.js';
 export interface SessionActiveChatData extends Omit<_ActiveChatData, 'messages'> {
     messages?: _ActiveChatData['messages'];
 }
@@ -132,7 +134,7 @@ export interface SessionHostDiagnosticsSnapshot {
     recentRequests: SessionHostRequestTrace[];
     recentTransitions: SessionHostRuntimeTransition[];
 }
-export type TransportTopic = 'session.chat_tail' | 'session.runtime_output' | 'machine.runtime' | 'session_host.diagnostics' | 'session.modal' | 'daemon.metadata';
+export type TransportTopic = 'session.chat_tail' | 'session.runtime_output' | 'machine.runtime' | 'session_host.diagnostics' | 'session.modal' | 'daemon.metadata' | 'workspace.git';
 export interface SessionChatTailSubscriptionParams extends ReadChatCursor {
     targetSessionId: string;
     historySessionId?: string;
@@ -213,6 +215,7 @@ export interface TopicUpdateEnvelopeMap {
     'session_host.diagnostics': SessionHostDiagnosticsUpdate;
     'session.modal': SessionModalUpdate;
     'daemon.metadata': DaemonMetadataUpdate;
+    'workspace.git': GitWorkspaceUpdate;
 }
 export type TopicUpdateEnvelope = TopicUpdateEnvelopeMap[TransportTopic];
 export interface SubscribeRequestMap {
@@ -222,6 +225,7 @@ export interface SubscribeRequestMap {
     'session_host.diagnostics': SessionHostDiagnosticsSubscriptionParams;
     'session.modal': SessionModalSubscriptionParams;
     'daemon.metadata': DaemonMetadataSubscriptionParams;
+    'workspace.git': WorkspaceGitSubscriptionParams;
 }
 export type SubscribeRequest = {
     [K in TransportTopic]: {
@@ -255,6 +259,7 @@ export interface SessionEntry {
     status: SessionStatus;
     title: string;
     workspace?: string | null;
+    git?: GitCompactSummary;
     runtimeKey?: string;
     runtimeDisplayName?: string;
     runtimeWorkspaceLabel?: string;
@@ -305,6 +310,7 @@ export interface CompactSessionEntry {
     status: SessionStatus;
     title: string;
     workspace: string | null;
+    git?: GitCompactSummary;
     cdpConnected?: boolean;
     runtimeKey?: string;
     runtimeDisplayName?: string;

package/dist/status/builders.d.ts

@@ -8,11 +8,13 @@
  * Consolidates ProviderState→ManagedEntry mapping logic.
  */
 import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { GitCompactSummary } from '../git/git-types.js';
 import type { SessionEntry } from '../shared-types.js';
 import type { ProviderState } from '../providers/provider-instance.js';
 export type SessionEntryProfile = 'full' | 'live' | 'metadata';
 export interface SessionEntryBuildOptions {
     profile?: SessionEntryProfile;
+    getGitSummaryForWorkspace?: (workspace: string) => GitCompactSummary | null | undefined;
 }
 /**
  * Find a CDP manager by key. Supports single-window (`cursor`) and full multi-window keys (`cursor_<targetId>`).

package/dist/status/snapshot.d.ts

@@ -6,6 +6,7 @@
  * - daemon-standalone HTTP/WS status responses
  */
 import type { DaemonCdpManager } from '../cdp/manager.js';
+import type { GitCompactSummary } from '../git/git-types.js';
 import { type SessionEntryProfile } from './builders.js';
 import type { ProviderState } from '../providers/provider-instance.js';
 import type { AvailableProviderInfo, MachineInfo, RecentSessionBucket, StatusReportPayload } from '../shared-types.js';
@@ -45,6 +46,7 @@ export interface StatusSnapshotOptions {
     p2p?: StatusReportPayload['p2p'];
     machineNickname?: string | null;
     profile?: SessionEntryProfile;
+    getGitSummaryForWorkspace?: (workspace: string) => GitCompactSummary | null | undefined;
 }
 export type StatusSnapshot = StatusReportPayload;
 export interface RecentReadDebugSnapshot {

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.9.52",
+  "version": "0.9.54",
   "description": "ADHDev local session host core \u2014 session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.52",
+  "version": "0.9.54",
   "description": "ADHDev daemon core \u2014 CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/chat-commands.ts

@@ -869,6 +869,33 @@ function getStateLastSignature(state: any): string {
     return `${last.role || ''}:${String(last.content || '').replace(/\s+/g, ' ').trim()}`;
 }
 
+function toNonNegativeNumber(value: any): number {
+    const numeric = Number(value ?? 0);
+    return Number.isFinite(numeric) ? Math.max(0, numeric) : 0;
+}
+
+function getCliVisibleTranscriptCount(adapter: any): number {
+    const adapterStatus = adapter?.getStatus?.() || {};
+    const adapterMessages = Array.isArray(adapterStatus.messages) ? adapterStatus.messages : [];
+    let parsedRecord: Record<string, any> | null = null;
+    if (typeof adapter?.getScriptParsedStatus === 'function') {
+        try {
+            const parsed = parseMaybeJson(adapter.getScriptParsedStatus());
+            parsedRecord = parsed && typeof parsed === 'object' ? parsed as Record<string, any> : null;
+        } catch {
+            parsedRecord = null;
+        }
+    }
+    const parsedMessages = Array.isArray(parsedRecord?.messages) ? parsedRecord.messages : [];
+    if (!parsedRecord) return adapterMessages.length;
+    const parsedIsProviderAuthoritative = parsedRecord.transcriptAuthority === 'provider'
+        || parsedRecord.coverage === 'full';
+    const shouldPreferAdapterMessages = !parsedIsProviderAuthoritative
+        && adapterMessages.length > 0
+        && adapterMessages.length > parsedMessages.length;
+    return shouldPreferAdapterMessages ? adapterMessages.length : parsedMessages.length;
+}
+
 async function getStableExtensionBaseline(h: CommandHelpers): Promise<any | null> {
     const first = await readExtensionChatState(h);
     if (getStateMessageCount(first) > 0 || getStateLastSignature(first)) return first;
@@ -899,11 +926,11 @@ export async function handleChatHistory(h: CommandHelpers, args: any): Promise<C
         const provider = h.getProvider(agentType);
         const agentStr = provider?.type || agentType || getCurrentProviderType(h);
         const transport = getTargetTransport(h, provider);
-        let excludeRecentCount = Math.max(0, Number(args?.excludeRecentCount || 0));
-        if (isCliLikeTransport(transport)) {
+        const hasExplicitExcludeRecentCount = args?.excludeRecentCount !== undefined && args?.excludeRecentCount !== null;
+        let excludeRecentCount = toNonNegativeNumber(args?.excludeRecentCount);
+        if (!hasExplicitExcludeRecentCount && isCliLikeTransport(transport)) {
             const adapter = getTargetedCliAdapter(h, args, provider?.type);
-            const status = adapter?.getStatus?.();
-            const visibleCount = Array.isArray(status?.messages) ? status.messages.length : 0;
+            const visibleCount = getCliVisibleTranscriptCount(adapter);
             if (visibleCount > excludeRecentCount) excludeRecentCount = visibleCount;
         }
         const workspace = typeof args?.workspace === 'string'

package/src/commands/handler.ts

@@ -32,6 +32,7 @@ import * as Cdp from './cdp-commands.js';
 import * as Stream from './stream-commands.js';
 import * as WorkspaceCmd from './workspace-commands.js';
 import { getWorkspaceState } from '../config/workspaces.js';
+import { handleGitCommand, isGitCommandName, type GitCommandServices } from '../git/git-commands.js';
 
 export interface CommandResult {
     success: boolean;
@@ -48,6 +49,7 @@ export interface CommandContext {
     sessionRegistry?: SessionRegistry;
     onProviderSettingChanged?: (providerType: string, key: string, value: any) => Promise<void> | void;
     onProviderSourceConfigChanged?: () => Promise<void> | void;
+    gitCommandServices?: GitCommandServices;
 }
 
 /**
@@ -377,6 +379,13 @@ export class DaemonCommandHandler implements CommandHelpers {
         this._currentRoute = this.resolveRoute(args);
         const startedAt = Date.now();
         this.logCommandStart(cmd, args);
+        let result: CommandResult;
+
+        if (isGitCommandName(cmd)) {
+            result = await handleGitCommand(cmd, args, this._ctx.gitCommandServices);
+            this.logCommandEnd(cmd, result, startedAt);
+            return result;
+        }
 
         const sessionScopedCommands = new Set([
             'read_chat',
@@ -406,7 +415,6 @@ export class DaemonCommandHandler implements CommandHelpers {
         }
 
         // Commands without ideType CDP silently fail (prevent P2P retry spam)
-        let result: CommandResult;
         if (!this._currentRoute.session && !this._currentRoute.managerKey && !this._currentRoute.providerType) {
             const cdpCommands = ['send_chat', 'read_chat', 'list_chats', 'new_chat', 'switch_chat', 'set_mode', 'change_model', 'set_thought_level', 'resolve_action'];
             if (cdpCommands.includes(cmd)) {

package/src/config/chat-history.ts

@@ -1141,6 +1141,11 @@ export class ChatHistoryWriter {
  * the newest N messages are skipped so older-history pagination can avoid
  * duplicating the live transcript tail already shown in the UI.
  */
+function normalizePaginationNumber(value: number, fallback: number, min: number): number {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? Math.max(min, numeric) : fallback;
+}
+
 function pageHistoryRecords(
     agentType: string,
     records: HistoryMessage[],
@@ -1163,9 +1168,12 @@ function pageHistoryRecords(
         if (message.role !== 'system') lastTurn = message;
     }
     const collapsed = collapseReplayAssistantTurns(chronological, historyBehavior);
-    const boundedLimit = Math.max(1, limit);
-    const boundedOffset = Math.max(0, offset);
-    const boundedExclude = Math.max(0, Math.min(excludeRecentCount, collapsed.length));
+    const boundedLimit = normalizePaginationNumber(limit, 30, 1);
+    const boundedOffset = normalizePaginationNumber(offset, 0, 0);
+    const boundedExclude = Math.min(
+        normalizePaginationNumber(excludeRecentCount, 0, 0),
+        collapsed.length,
+    );
     const endExclusive = Math.max(0, collapsed.length - boundedExclude - boundedOffset);
     const startInclusive = Math.max(0, endExclusive - boundedLimit);
     const sliced = collapsed.slice(startInclusive, endExclusive);

package/src/git/git-commands.ts

@@ -0,0 +1,385 @@
+import * as path from 'node:path';
+
+import { getGitDiffSummary, getGitFileDiff } from './git-diff.js';
+import { GitCommandError, isPathInside, resolveGitRepository, runGit } from './git-executor.js';
+import { createGitSnapshotStore } from './git-snapshot-store.js';
+import { getGitRepoStatus } from './git-status.js';
+import type {
+  GitCommandName,
+  GitDiffSummary,
+  GitFailureReason,
+  GitRepoIdentity,
+  GitRepoStatus,
+  GitSnapshot,
+  GitSnapshotCompareSummary,
+  GitSnapshotReason,
+} from './git-types.js';
+
+export interface GitFileDiff extends GitRepoIdentity {
+  path: string;
+  oldPath?: string;
+  staged?: boolean;
+  diff: string;
+  binary?: boolean;
+  truncated?: boolean;
+  lastCheckedAt: number;
+}
+
+export interface GitLogEntry {
+  commit: string;
+  message: string;
+  authorName?: string;
+  authorEmail?: string;
+  authoredAt?: number;
+  committedAt?: number;
+}
+
+export interface GitLogResult extends GitRepoIdentity {
+  entries: GitLogEntry[];
+  limit: number;
+  truncated: boolean;
+  lastCheckedAt: number;
+}
+
+export interface GitCommandServices {
+  getStatus?: (params: { workspace: string }) => Promise<GitRepoStatus> | GitRepoStatus;
+  getDiffSummary?: (params: { workspace: string; staged?: boolean }) => Promise<GitDiffSummary> | GitDiffSummary;
+  getDiffFile?: (params: { workspace: string; path: string; staged?: boolean }) => Promise<GitFileDiff> | GitFileDiff;
+  createSnapshot?: (params: {
+    workspace: string;
+    reason: GitSnapshotReason;
+    sessionId?: string;
+    turnId?: string;
+  }) => Promise<GitSnapshot> | GitSnapshot;
+  compareSnapshots?: (params: {
+    workspace: string;
+    beforeSnapshotId: string;
+    afterSnapshotId: string;
+  }) => Promise<GitSnapshotCompareSummary> | GitSnapshotCompareSummary;
+  getLog?: (params: {
+    workspace: string;
+    limit: number;
+    path?: string;
+    since?: string;
+    until?: string;
+  }) => Promise<GitLogResult> | GitLogResult;
+}
+
+type GitCommandFailure = {
+  success: false;
+  reason: GitFailureReason;
+  error: string;
+};
+
+type GitCommandSuccess =
+  | { success: true; status: GitRepoStatus }
+  | { success: true; diffSummary: GitDiffSummary }
+  | { success: true; diff: GitFileDiff }
+  | { success: true; snapshot: GitSnapshot }
+  | { success: true; compare: GitSnapshotCompareSummary }
+  | { success: true; log: GitLogResult };
+
+export type GitCommandResult = GitCommandSuccess | GitCommandFailure;
+
+const GIT_COMMAND_NAMES = new Set<GitCommandName>([
+  'git_status',
+  'git_diff_summary',
+  'git_diff_file',
+  'git_snapshot_create',
+  'git_snapshot_compare',
+  'git_log',
+  'git_checkpoint',
+  'git_stash_push',
+  'git_stash_pop',
+  'git_checkout_files',
+]);
+
+const MUTATING_COMMAND_NAMES = new Set<GitCommandName>([
+  'git_checkpoint',
+  'git_stash_push',
+  'git_stash_pop',
+  'git_checkout_files',
+]);
+
+const SNAPSHOT_REASONS = new Set<GitSnapshotReason>([
+  'session_baseline',
+  'before_user_input_dispatch',
+  'before_agent_work',
+  'after_agent_work',
+  'manual',
+]);
+
+const FAILURE_REASONS = new Set<GitFailureReason>([
+  'not_git_repo',
+  'git_not_installed',
+  'timeout',
+  'path_outside_repo',
+  'dirty_index_required',
+  'conflict',
+  'invalid_args',
+  'git_command_failed',
+]);
+
+function failure(reason: GitFailureReason, error: string): GitCommandFailure {
+  return { success: false, reason, error };
+}
+
+function serviceNotImplemented(command: string): GitCommandFailure {
+  return failure('invalid_args', `${command} is not implemented: daemon-core Git service is not configured`);
+}
+
+const defaultSnapshotStore = createGitSnapshotStore({
+  getStatus: (workspace) => getGitRepoStatus(workspace),
+  getDiffSummary: (workspace) => getGitDiffSummary(workspace),
+});
+
+export function createDefaultGitCommandServices(): GitCommandServices {
+  return {
+    getStatus: ({ workspace }) => getGitRepoStatus(workspace),
+    getDiffSummary: ({ workspace }) => getGitDiffSummary(workspace),
+    getDiffFile: ({ workspace, path: filePath }) => getGitFileDiff(workspace, filePath),
+    createSnapshot: ({ workspace, reason, sessionId, turnId }) => defaultSnapshotStore.create({
+      workspace,
+      reason,
+      sessionId,
+      turnId,
+    }),
+    compareSnapshots: ({ beforeSnapshotId, afterSnapshotId }) => defaultSnapshotStore.compare(beforeSnapshotId, afterSnapshotId),
+    getLog: ({ workspace, limit, path: filePath, since, until }) => getGitLog(workspace, { limit, path: filePath, since, until }),
+  };
+}
+
+const defaultGitCommandServices = createDefaultGitCommandServices();
+
+function validateWorkspace(args: any): { workspace: string } | GitCommandFailure {
+  if (typeof args?.workspace !== 'string') {
+    return failure('invalid_args', 'workspace must be a non-empty absolute path');
+  }
+
+  const workspace = args.workspace.trim();
+  if (!workspace || !path.isAbsolute(workspace)) {
+    return failure('invalid_args', 'workspace must be a non-empty absolute path');
+  }
+
+  return { workspace };
+}
+
+function validateRepoPath(args: any): { path: string } | GitCommandFailure {
+  if (typeof args?.path !== 'string' || !args.path.trim()) {
+    return failure('invalid_args', 'path must be a non-empty repository-relative path');
+  }
+  return { path: args.path.trim() };
+}
+
+function validateSnapshotId(args: any, key: 'beforeSnapshotId' | 'afterSnapshotId'): string | GitCommandFailure {
+  if (typeof args?.[key] !== 'string' || !args[key].trim()) {
+    return failure('invalid_args', `${key} must be a non-empty string`);
+  }
+  return args[key].trim();
+}
+
+function parseSnapshotReason(args: any): GitSnapshotReason | GitCommandFailure {
+  if (args?.reason === undefined || args?.reason === null || args?.reason === '') {
+    return 'manual';
+  }
+  if (typeof args.reason !== 'string' || !SNAPSHOT_REASONS.has(args.reason as GitSnapshotReason)) {
+    return failure('invalid_args', 'reason must be a valid GitSnapshotReason');
+  }
+  return args.reason as GitSnapshotReason;
+}
+
+function optionalString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function optionalBoolean(value: unknown): boolean | undefined {
+  return typeof value === 'boolean' ? value : undefined;
+}
+
+function boundedLogLimit(value: unknown): number {
+  if (value === undefined || value === null || value === '') return 50;
+  const numeric = typeof value === 'number' ? value : Number(value);
+  if (!Number.isFinite(numeric)) return 50;
+  return Math.max(1, Math.min(200, Math.floor(numeric)));
+}
+
+function failureReasonFromError(error: any): GitFailureReason {
+  return typeof error?.reason === 'string' && FAILURE_REASONS.has(error.reason)
+    ? error.reason
+    : 'git_command_failed';
+}
+
+async function runService<T>(fn: () => Promise<T> | T): Promise<T | GitCommandFailure> {
+  try {
+    return await fn();
+  } catch (error: any) {
+    return failure(failureReasonFromError(error), error?.message || 'Git command failed');
+  }
+}
+
+export function isGitCommandName(command: string): command is GitCommandName {
+  return GIT_COMMAND_NAMES.has(command as GitCommandName);
+}
+
+export async function handleGitCommand(
+  command: GitCommandName,
+  args: any,
+  services?: GitCommandServices,
+): Promise<GitCommandResult>;
+export async function handleGitCommand(
+  command: string,
+  args: any,
+  services?: GitCommandServices,
+): Promise<GitCommandResult>;
+export async function handleGitCommand(
+  command: string,
+  args: any,
+  services: GitCommandServices = defaultGitCommandServices,
+): Promise<GitCommandResult> {
+  if (!isGitCommandName(command)) {
+    return failure('invalid_args', `Unknown Git command: ${command}`);
+  }
+
+  if (MUTATING_COMMAND_NAMES.has(command)) {
+    return failure('invalid_args', `${command} is not implemented in daemon-core read-only Git routing`);
+  }
+
+  const workspaceResult = validateWorkspace(args);
+  if ('success' in workspaceResult) return workspaceResult;
+  const { workspace } = workspaceResult;
+
+  switch (command) {
+    case 'git_status': {
+      if (!services.getStatus) return serviceNotImplemented(command);
+      const status = await runService(() => services.getStatus!({ workspace }));
+      return 'success' in status ? status : { success: true, status };
+    }
+
+    case 'git_diff_summary': {
+      if (!services.getDiffSummary) return serviceNotImplemented(command);
+      const diffSummary = await runService(() => services.getDiffSummary!({ workspace, staged: optionalBoolean(args?.staged) }));
+      return 'success' in diffSummary ? diffSummary : { success: true, diffSummary };
+    }
+
+    case 'git_diff_file': {
+      if (!services.getDiffFile) return serviceNotImplemented(command);
+      const pathResult = validateRepoPath(args);
+      if (typeof pathResult !== 'object' || 'success' in pathResult) return pathResult;
+      const diff = await runService(() => services.getDiffFile!({
+        workspace,
+        path: pathResult.path,
+        staged: optionalBoolean(args?.staged),
+      }));
+      return 'success' in diff ? diff : { success: true, diff };
+    }
+
+    case 'git_snapshot_create': {
+      if (!services.createSnapshot) return serviceNotImplemented(command);
+      const reason = parseSnapshotReason(args);
+      if (typeof reason !== 'string') return reason;
+      const snapshot = await runService(() => services.createSnapshot!({
+        workspace,
+        reason,
+        sessionId: optionalString(args?.sessionId),
+        turnId: optionalString(args?.turnId),
+      }));
+      return 'success' in snapshot ? snapshot : { success: true, snapshot };
+    }
+
+    case 'git_snapshot_compare': {
+      if (!services.compareSnapshots) return serviceNotImplemented(command);
+      const beforeSnapshotId = validateSnapshotId(args, 'beforeSnapshotId');
+      if (typeof beforeSnapshotId !== 'string') return beforeSnapshotId;
+      const afterSnapshotId = validateSnapshotId(args, 'afterSnapshotId');
+      if (typeof afterSnapshotId !== 'string') return afterSnapshotId;
+      const compare = await runService(() => services.compareSnapshots!({ workspace, beforeSnapshotId, afterSnapshotId }));
+      return 'success' in compare ? compare : { success: true, compare };
+    }
+
+    case 'git_log': {
+      if (!services.getLog) {
+        return failure('invalid_args', 'git_log is not implemented: bounded daemon-core Git log service is not configured');
+      }
+      const log = await runService(() => services.getLog!({
+        workspace,
+        limit: boundedLogLimit(args?.limit),
+        path: optionalString(args?.path),
+        since: optionalString(args?.since),
+        until: optionalString(args?.until),
+      }));
+      return 'success' in log ? log : { success: true, log };
+    }
+
+    default:
+      return failure('invalid_args', `Unknown Git command: ${command}`);
+  }
+}
+
+function formatOptionalGitLogRangeArg(flag: '--since' | '--until', value: string | undefined): string[] {
+  return value ? [`${flag}=${value}`] : [];
+}
+
+async function getGitLog(
+  workspace: string,
+  options: { limit: number; path?: string; since?: string; until?: string },
+): Promise<GitLogResult> {
+  const lastCheckedAt = Date.now();
+  const repo = await resolveGitRepository(workspace);
+  const repoRoot = repo.repoRoot!;
+  const boundedLimit = Math.max(1, Math.min(200, Math.floor(options.limit || 50)));
+  const selectedPath = options.path ? validateGitLogPath(repoRoot, options.path) : undefined;
+  const result = await runGit(
+    repo,
+    [
+      'log',
+      `--max-count=${boundedLimit}`,
+      '--format=%H%x00%an%x00%ae%x00%at%x00%ct%x00%s',
+      ...formatOptionalGitLogRangeArg('--since', options.since),
+      ...formatOptionalGitLogRangeArg('--until', options.until),
+      '--',
+      ...(selectedPath ? [selectedPath] : []),
+    ],
+    { cwd: repoRoot },
+  );
+
+  const entries = result.stdout
+    .split('\n')
+    .filter((line) => line.trim().length > 0)
+    .map((line): GitLogEntry => {
+      const [commit = '', authorName, authorEmail, authoredAt, committedAt, ...messageParts] = line.split('\0');
+      return {
+        commit,
+        message: messageParts.join('\0'),
+        authorName: authorName || undefined,
+        authorEmail: authorEmail || undefined,
+        authoredAt: authoredAt ? Number.parseInt(authoredAt, 10) * 1000 : undefined,
+        committedAt: committedAt ? Number.parseInt(committedAt, 10) * 1000 : undefined,
+      };
+    })
+    .filter((entry) => entry.commit.length > 0);
+
+  return {
+    workspace: repo.workspace,
+    repoRoot,
+    isGitRepo: true,
+    entries,
+    limit: boundedLimit,
+    truncated: entries.length >= boundedLimit,
+    lastCheckedAt,
+  };
+}
+
+function validateGitLogPath(repoRoot: string, filePath: string): string {
+  if (!filePath.trim() || filePath.includes('\0')) {
+    throw new GitCommandError('invalid_args', 'path must be a non-empty repository-relative path');
+  }
+  if (path.isAbsolute(filePath)) {
+    throw new GitCommandError('invalid_args', 'path must be repository-relative');
+  }
+  const normalized = path.normalize(filePath).split(path.sep).join('/');
+  const absolutePath = path.resolve(repoRoot, normalized);
+  if (!isPathInside(repoRoot, absolutePath) || normalized.startsWith('../') || normalized === '..') {
+    throw new GitCommandError('path_outside_repo', 'Git log path is outside the repository root');
+  }
+  return normalized;
+}