fix(code): apply SessionStart hook env to UI git/gh commands

The Commit and Create PR buttons run git/gh in the main process via
`simple-git` and `execGh`, both of which were inheriting bare `process.env`.
That ignored the env updates the Claude Agent SDK applies for each session
via SessionStart-style hooks (which the SDK writes as
`<event>-hook-N.sh` files under `<CLAUDE_CONFIG_DIR>/session-env/<sessionId>/`
and sources before its own bash tool commands).

Most visibly, when a user has the Secretive code-signing hook installed and
launches PostHog Code from the Dock (so the parent process inherits the
default macOS launchd `SSH_AUTH_SOCK`), the agent can sign commits but the
UI buttons cannot — the same `SSH_AUTH_SOCK` repoint never reached the git
subprocess they spawn.

Mirror the SDK's behavior in the main process:

- New `loadSessionEnvOverrides(sessionId)` util sources the SDK's hook files
  via bash and returns the env diff (skipping shell internals).
- `AgentService.getSessionEnvForTask(taskId)` resolves the most recent active
  session for a task and returns its overrides.
- Plumb an optional `env` through `@posthog/git` (`execGh`, `GitSagaInput`,
  `ExecuteOptions`) so it reaches both the simple-git client and `gh`.
- `GitService.commit` and `createPr` look up the session env when a `taskId`
  is present and thread it through commit / push / publish / `gh pr create`.

Generated-By: PostHog Code
Task-Id: 86938233-5c7d-4285-b996-6bd9cf09b57c

Author: PostHog Code

apps/code/src/main/services/agent/service.ts

@@ -53,6 +53,7 @@ import type { FsService } from "../fs/service";
 import type { McpAppsService } from "../mcp-apps/service";
 import type { PosthogPluginService } from "../posthog-plugin/service";
 import type { ProcessTrackingService } from "../process-tracking/service";
+import { loadSessionEnvOverrides } from "../session-env/loader";
 import type { SleepService } from "../sleep/service";
 import type { AgentAuthAdapter, McpToolInstallations } from "./auth-adapter";
 import { discoverExternalPlugins } from "./discover-plugins";
@@ -983,6 +984,27 @@ When creating pull requests, add the following footer at the end of the PR descr
     return taskId ? all.filter((s) => s.taskId === taskId) : all;
   }
 
+  /**
+   * Resolve env-var overrides set by the SessionStart-style hooks of the most
+   * recently active agent session for `taskId`.
+   *
+   * Used by git/gh operations triggered from the UI (Commit, Create PR) so
+   * they pick up the same hook env the agent itself sees — most importantly
+   * the SSH_AUTH_SOCK that Secretive's hook re-points at the Secretive agent
+   * for commit signing. Returns an empty object when there is no session for
+   * the task or when no hook output is available.
+   */
+  public async getSessionEnvForTask(
+    taskId: string,
+  ): Promise<Record<string, string>> {
+    const candidates = this.listSessions(taskId)
+      .filter((s) => !!s.config.sessionId)
+      .sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+    const session = candidates[0];
+    if (!session?.config.sessionId) return {};
+    return loadSessionEnvOverrides(session.config.sessionId);
+  }
+
   /**
    * Get sessions that were interrupted for a specific reason.
    * Optionally filter by repoPath to get only sessions for a specific repo.

apps/code/src/main/services/git/service.test.ts

@@ -23,6 +23,7 @@ vi.mock("../../utils/logger.js", () => ({
   },
 }));
 
+import type { AgentService } from "../agent/service";
 import type { LlmGatewayService } from "../llm-gateway/service";
 import type { WorkspaceService } from "../workspace/service";
 import { GitService, mapPrState } from "./service";
@@ -32,7 +33,11 @@ describe("GitService.getPrChangedFiles", () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
-    service = new GitService({} as LlmGatewayService, {} as WorkspaceService);
+    service = new GitService(
+      {} as LlmGatewayService,
+      {} as WorkspaceService,
+      { getSessionEnvForTask: async () => ({}) } as unknown as AgentService,
+    );
   });
 
   it("flattens paginated GH API results and maps file statuses", async () => {
@@ -140,7 +145,11 @@ describe("GitService.getGhAuthToken", () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
-    service = new GitService({} as LlmGatewayService, {} as WorkspaceService);
+    service = new GitService(
+      {} as LlmGatewayService,
+      {} as WorkspaceService,
+      { getSessionEnvForTask: async () => ({}) } as unknown as AgentService,
+    );
   });
 
   it("returns the authenticated GitHub CLI token", async () => {
@@ -198,7 +207,11 @@ describe("GitService.getPrUrlForBranch", () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
-    service = new GitService({} as LlmGatewayService, {} as WorkspaceService);
+    service = new GitService(
+      {} as LlmGatewayService,
+      {} as WorkspaceService,
+      { getSessionEnvForTask: async () => ({}) } as unknown as AgentService,
+    );
   });
 
   it("returns the PR URL for a branch via gh pr list", async () => {

apps/code/src/main/services/git/service.ts

@@ -40,6 +40,7 @@ import { inject, injectable } from "inversify";
 import { MAIN_TOKENS } from "../../di/tokens";
 import { logger } from "../../utils/logger";
 import { TypedEventEmitter } from "../../utils/typed-event-emitter";
+import type { AgentService } from "../agent/service";
 import type { LlmGatewayService } from "../llm-gateway/service";
 import type { SidebarPrState } from "../workspace/schemas";
 import type { WorkspaceService } from "../workspace/service";
@@ -134,10 +135,31 @@ export class GitService extends TypedEventEmitter<GitServiceEvents> {
     private readonly llmGateway: LlmGatewayService,
     @inject(MAIN_TOKENS.WorkspaceService)
     private readonly workspaceService: WorkspaceService,
+    @inject(MAIN_TOKENS.AgentService)
+    private readonly agentService: AgentService,
   ) {
     super();
   }
 
+  /**
+   * Resolve env-var overrides set by the agent's SessionStart hooks for the
+   * given task. Used so UI-triggered git/gh operations (Commit, Create PR)
+   * see the same env (notably `SSH_AUTH_SOCK` re-pointed at Secretive) as
+   * the agent's bash tool. Returns `undefined` if there's nothing to apply.
+   */
+  private async getSessionEnv(
+    taskId: string | undefined,
+  ): Promise<Record<string, string> | undefined> {
+    if (!taskId) return undefined;
+    try {
+      const env = await this.agentService.getSessionEnvForTask(taskId);
+      return Object.keys(env).length > 0 ? env : undefined;
+    } catch (err) {
+      log.warn("Failed to load session env for task", { taskId, err });
+      return undefined;
+    }
+  }
+
   private async getStateSnapshot(
     directoryPath: string,
     options?: {
@@ -475,6 +497,7 @@ export class GitService extends TypedEventEmitter<GitServiceEvents> {
     branch?: string,
     setUpstream = false,
     signal?: AbortSignal,
+    env?: Record<string, string>,
   ): Promise<PushOutput> {
     const saga = new PushSaga();
     const result = await saga.run({
@@ -483,6 +506,7 @@ export class GitService extends TypedEventEmitter<GitServiceEvents> {
       branch: branch || undefined,
       setUpstream,
       signal,
+      env,
     });
     if (!result.success) {
       return { success: false, message: result.error };
@@ -532,6 +556,7 @@ export class GitService extends TypedEventEmitter<GitServiceEvents> {
     directoryPath: string,
     remote = "origin",
     signal?: AbortSignal,
+    env?: Record<string, string>,
   ): Promise<PublishOutput> {
     const currentBranch = await getCurrentBranch(directoryPath);
     if (!currentBranch) {
@@ -544,6 +569,7 @@ export class GitService extends TypedEventEmitter<GitServiceEvents> {
       currentBranch,
       true,
       signal,
+      env,
     );
     return {
       success: pushResult.success,
@@ -617,6 +643,8 @@ export class GitService extends TypedEventEmitter<GitServiceEvents> {
       });
     };
 
+    const sessionEnv = await this.getSessionEnv(input.taskId);
+
     const saga = new CreatePrSaga(
       {
         getCurrentBranch: (dir) => getCurrentBranch(dir),
@@ -625,14 +653,16 @@ export class GitService extends TypedEventEmitter<GitServiceEvents> {
         getChangedFilesHead: (dir) => this.getChangedFilesHead(dir),
         generateCommitMessage: (dir) =>
           this.generateCommitMessage(dir, input.conversationContext),
-        commit: (dir, msg, opts) => this.commit(dir, msg, opts),
+        commit: (dir, msg, opts) =>
+          this.commit(dir, msg, { ...opts, envOverride: sessionEnv }),
         getSyncStatus: (dir) => this.getGitSyncStatus(dir),
-        push: (dir) => this.push(dir),
-        publish: (dir) => this.publish(dir),
+        push: (dir) =>
+          this.push(dir, "origin", undefined, false, undefined, sessionEnv),
+        publish: (dir) => this.publish(dir, "origin", undefined, sessionEnv),
         generatePrTitleAndBody: (dir) =>
           this.generatePrTitleAndBody(dir, input.conversationContext),
         createPr: (dir, title, body, draft) =>
-          this.createPrViaGh(dir, title, body, draft),
+          this.createPrViaGh(dir, title, body, draft, sessionEnv),
         onProgress: emitProgress,
       },
       log,
@@ -723,6 +753,8 @@ export class GitService extends TypedEventEmitter<GitServiceEvents> {
       allowEmpty?: boolean;
       stagedOnly?: boolean;
       taskId?: string;
+      /** Pre-resolved session env. Internal — used by createPr to avoid re-loading. */
+      envOverride?: Record<string, string>;
     },
   ): Promise<CommitOutput> {
     const fail = (msg: string): CommitOutput => ({
@@ -734,11 +766,15 @@ export class GitService extends TypedEventEmitter<GitServiceEvents> {
 
     if (!message.trim()) return fail("Commit message is required");
 
+    const { envOverride, ...sagaOptions } = options ?? {};
+    const env = envOverride ?? (await this.getSessionEnv(options?.taskId));
+
     const saga = new CommitSaga();
     const result = await saga.run({
       baseDir: directoryPath,
       message: message.trim(),
-      ...options,
+      env,
+      ...sagaOptions,
     });
 
     if (!result.success) return fail(result.error);
@@ -949,6 +985,7 @@ export class GitService extends TypedEventEmitter<GitServiceEvents> {
     title?: string,
     body?: string,
     draft?: boolean,
+    env?: Record<string, string>,
   ): Promise<{ success: boolean; message: string; prUrl: string | null }> {
     const prFooter =
       "\n\n---\n*Created with [PostHog Code](https://posthog.com/code?ref=pr)*";
@@ -962,7 +999,7 @@ export class GitService extends TypedEventEmitter<GitServiceEvents> {
     }
     if (draft) args.push("--draft");
 
-    const result = await execGh(args, { cwd: directoryPath });
+    const result = await execGh(args, { cwd: directoryPath, env });
     if (result.exitCode !== 0) {
       return {
         success: false,

apps/code/src/main/services/session-env/loader.test.ts

@@ -0,0 +1,135 @@
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { loadSessionEnvOverrides } from "./loader";
+
+describe("loadSessionEnvOverrides", () => {
+  const SESSION_ID = "test-session-id";
+  let configDir: string;
+  let sessionDir: string;
+  let originalConfigDir: string | undefined;
+
+  beforeEach(async () => {
+    configDir = await fs.mkdtemp(path.join(os.tmpdir(), "session-env-test-"));
+    sessionDir = path.join(configDir, "session-env", SESSION_ID);
+    await fs.mkdir(sessionDir, { recursive: true });
+    originalConfigDir = process.env.CLAUDE_CONFIG_DIR;
+    process.env.CLAUDE_CONFIG_DIR = configDir;
+  });
+
+  afterEach(async () => {
+    if (originalConfigDir === undefined) {
+      delete process.env.CLAUDE_CONFIG_DIR;
+    } else {
+      process.env.CLAUDE_CONFIG_DIR = originalConfigDir;
+    }
+    await fs.rm(configDir, { recursive: true, force: true });
+  });
+
+  const writeHook = (name: string, content: string) =>
+    fs.writeFile(path.join(sessionDir, name), content);
+
+  it("returns empty when CLAUDE_CONFIG_DIR is unset", async () => {
+    delete process.env.CLAUDE_CONFIG_DIR;
+    expect(await loadSessionEnvOverrides(SESSION_ID)).toEqual({});
+  });
+
+  it("returns empty when session dir does not exist", async () => {
+    expect(await loadSessionEnvOverrides("missing-session")).toEqual({});
+  });
+
+  it("returns empty when no hook files match", async () => {
+    await writeHook("ignored.txt", "export FOO=bar\n");
+    expect(await loadSessionEnvOverrides(SESSION_ID)).toEqual({});
+  });
+
+  it("parses simple export statements from a SessionStart hook", async () => {
+    await writeHook("sessionstart-hook-0.sh", "export FOO=bar\n");
+    const overrides = await loadSessionEnvOverrides(SESSION_ID);
+    expect(overrides.FOO).toBe("bar");
+  });
+
+  it("captures values produced by `printf %q` shell quoting", async () => {
+    const value = "/Users/alice/Library/foo bar/socket.ssh";
+    await writeHook(
+      "sessionstart-hook-0.sh",
+      `printf 'export SSH_AUTH_SOCK=%q\\n' ${JSON.stringify(value)} | source /dev/stdin\n` +
+        // also test the expected hook output format directly
+        `export SSH_AUTH_SOCK='${value}'\n`,
+    );
+    const overrides = await loadSessionEnvOverrides(SESSION_ID);
+    expect(overrides.SSH_AUTH_SOCK).toBe(value);
+  });
+
+  it("merges exports from multiple hook files in sorted order", async () => {
+    await writeHook("sessionstart-hook-0.sh", "export FIRST=one\n");
+    await writeHook("sessionstart-hook-1.sh", "export SECOND=two\n");
+    await writeHook("setup-hook-0.sh", "export THIRD=three\n");
+    const overrides = await loadSessionEnvOverrides(SESSION_ID);
+    expect(overrides.FIRST).toBe("one");
+    expect(overrides.SECOND).toBe("two");
+    expect(overrides.THIRD).toBe("three");
+  });
+
+  it("ignores files that don't match the SDK hook naming convention", async () => {
+    await writeHook("setup.sh", "export SHOULD_NOT_LOAD=1\n");
+    await writeHook("sessionstart-hook-abc.sh", "export ALSO_NO=1\n");
+    await writeHook("sessionstart-hook-0.sh", "export YES=1\n");
+    const overrides = await loadSessionEnvOverrides(SESSION_ID);
+    expect(overrides).toEqual({ YES: "1" });
+  });
+
+  it("does not return vars that already match the parent process env", async () => {
+    process.env.UNCHANGED_VAR = "same";
+    await writeHook("sessionstart-hook-0.sh", "export UNCHANGED_VAR=same\n");
+    try {
+      const overrides = await loadSessionEnvOverrides(SESSION_ID);
+      expect(overrides.UNCHANGED_VAR).toBeUndefined();
+    } finally {
+      delete process.env.UNCHANGED_VAR;
+    }
+  });
+
+  it("handles paths with spaces and quotes safely", async () => {
+    const dirWithSpaces = path.join(configDir, "session-env", "weird id");
+    await fs.mkdir(dirWithSpaces, { recursive: true });
+    await fs.writeFile(
+      path.join(dirWithSpaces, "sessionstart-hook-0.sh"),
+      "export SPACED=ok\n",
+    );
+    const overrides = await loadSessionEnvOverrides("weird id");
+    expect(overrides.SPACED).toBe("ok");
+  });
+
+  it("returns empty object on bash failure without throwing", async () => {
+    await writeHook("sessionstart-hook-0.sh", "exit 1\nexport NEVER=set\n");
+    // sourcing a script that exits cuts the env -0 short, but we should
+    // gracefully degrade rather than throw.
+    const overrides = await loadSessionEnvOverrides(SESSION_ID);
+    expect(overrides.NEVER).toBeUndefined();
+  });
+
+  it("falls back to empty object if bash is missing", async () => {
+    // Skip this test on systems where bash exists at /bin/bash —
+    // we only smoke-check that errors are swallowed.
+    const realPath = process.env.PATH;
+    process.env.PATH = "";
+    try {
+      const overrides = await loadSessionEnvOverrides(SESSION_ID);
+      // bash may still be found via absolute path; either outcome is fine.
+      expect(typeof overrides).toBe("object");
+    } finally {
+      process.env.PATH = realPath;
+    }
+  });
+
+  it("does not leak BASH_VERSION or other shell internals", async () => {
+    await writeHook("sessionstart-hook-0.sh", "export USEFUL=yes\n");
+    const overrides = await loadSessionEnvOverrides(SESSION_ID);
+    expect(overrides.BASH_VERSION).toBeUndefined();
+    expect(overrides.SHLVL).toBeUndefined();
+    expect(overrides._).toBeUndefined();
+    expect(overrides.USEFUL).toBe("yes");
+  });
+});