@getpaseo/server 0.1.100 → 0.1.102-beta.2

package/dist/server/server/resolve-worktree-creation-intent.js

@@ -64,9 +64,10 @@ async function resolveGitHubPrCheckoutIntent(params) {
     const baseRefName = checkoutTarget?.baseRefName?.trim() ||
         (await resolveDefaultBranch(params.repoRoot, params.deps));
     const localBranchName = buildGitHubPrLocalBranchName({ headRef, checkoutTarget });
-    const pushRemoteUrl = checkoutTarget
+    const pushRemoteUrl = checkoutTarget?.isCrossRepository
         ? checkoutTarget.headRepositorySshUrl || checkoutTarget.headRepositoryUrl || undefined
         : undefined;
+    const trackOriginHead = checkoutTarget ? !checkoutTarget.isCrossRepository : false;
     return {
         kind: "checkout-github-pr",
         githubPrNumber: params.githubPrNumber,
@@ -74,6 +75,7 @@ async function resolveGitHubPrCheckoutIntent(params) {
         baseRefName,
         ...(localBranchName !== headRef ? { localBranchName } : {}),
         ...(pushRemoteUrl ? { pushRemoteUrl } : {}),
+        ...(trackOriginHead ? { trackOriginHead } : {}),
     };
 }
 async function resolveGitHubPrCheckoutTarget(params) {

package/dist/server/server/session/agent-updates/agent-updates-service.d.ts

@@ -0,0 +1,59 @@
+import type pino from "pino";
+import type { AgentSnapshotPayload, ProjectPlacementPayload, SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import type { ManagedAgent } from "../../agent/agent-manager.js";
+import type { StoredAgentRecord } from "../../agent/agent-storage.js";
+type AgentUpdatesFilter = NonNullable<Extract<SessionInboundMessage, {
+    type: "fetch_agents_request";
+}>["filter"]>;
+/**
+ * Owns the single per-client `agent_update` subscription: when a client subscribes
+ * via `fetch_agents_request`, every later agent lifecycle change (live forward,
+ * stored-record archive/detach, delete) is filtered against the subscription's
+ * filter and either emitted or — while the initial snapshot is still being built —
+ * buffered and replayed on flush. Keeping the mutable subscription state, the
+ * bootstrap buffer, the provider-visibility gate, and the filter predicate behind
+ * one interface stops the rest of session.ts from poking the subscription shape or
+ * hand-rolling `agent_update` payloads, and the (previously untested) filter/buffer/
+ * flush branches become exercisable through injected fakes.
+ *
+ * The snapshot listing path applies the SAME filter via the pure
+ * `matchesAgentUpdatesFilter` so a subscription's initial page and its live updates
+ * stay consistent.
+ */
+export interface AgentUpdatesService {
+    beginSubscription(input: {
+        subscriptionId: string;
+        filter?: AgentUpdatesFilter;
+    }): void;
+    flushBootstrapped(subscriptionId: string, options?: {
+        snapshotUpdatedAtByAgentId?: Map<string, number>;
+    }): void;
+    clearSubscription(subscriptionId: string): void;
+    hasSubscription(): boolean;
+    forwardLiveAgent(agent: ManagedAgent): Promise<void>;
+    emitStoredRecord(record: StoredAgentRecord): Promise<AgentSnapshotPayload>;
+    removeAgent(agentId: string): void;
+    dispose(): void;
+}
+export interface AgentUpdatesServiceDeps {
+    emit(message: SessionOutboundMessage): void;
+    buildAgentPayload(agent: ManagedAgent): Promise<AgentSnapshotPayload>;
+    buildStoredAgentPayload(record: StoredAgentRecord): AgentSnapshotPayload;
+    isProviderVisibleToClient(provider: string): boolean;
+    buildProjectPlacementForWorkspaceId(workspaceId: string): Promise<ProjectPlacementPayload | null>;
+    emitWorkspaceUpdateForWorkspaceId(workspaceId: string): Promise<void>;
+    logger: pino.Logger;
+}
+/**
+ * Pure predicate shared by the live subscription stream and the snapshot listing
+ * pager: does an agent (with its resolved project placement) satisfy a
+ * `fetch_agents` filter?
+ */
+export declare function matchesAgentUpdatesFilter(input: {
+    agent: AgentSnapshotPayload;
+    project: ProjectPlacementPayload;
+    filter?: AgentUpdatesFilter;
+}): boolean;
+export declare function createAgentUpdatesService(deps: AgentUpdatesServiceDeps): AgentUpdatesService;
+export {};
+//# sourceMappingURL=agent-updates-service.d.ts.map

package/dist/server/server/session/agent-updates/agent-updates-service.js

@@ -0,0 +1,220 @@
+import { resolveEffectiveThinkingOptionId } from "../../agent/agent-projections.js";
+function agentThinkingOptionMatchesFilter(agent, filter) {
+    if (filter.thinkingOptionId === undefined) {
+        return true;
+    }
+    const expectedThinkingOptionId = resolveEffectiveThinkingOptionId({
+        configuredThinkingOptionId: filter.thinkingOptionId ?? null,
+    });
+    const resolvedThinkingOptionId = agent.effectiveThinkingOptionId ??
+        resolveEffectiveThinkingOptionId({
+            runtimeInfo: agent.runtimeInfo,
+            configuredThinkingOptionId: agent.thinkingOptionId ?? null,
+        });
+    return resolvedThinkingOptionId === expectedThinkingOptionId;
+}
+function matchesAgentStructuralFilter(agent, project, filter) {
+    if (filter.statuses && filter.statuses.length > 0) {
+        const statuses = new Set(filter.statuses);
+        if (!statuses.has(agent.status)) {
+            return false;
+        }
+    }
+    if (typeof filter.requiresAttention === "boolean") {
+        const requiresAttention = agent.requiresAttention ?? false;
+        if (requiresAttention !== filter.requiresAttention) {
+            return false;
+        }
+    }
+    if (filter.projectKeys && filter.projectKeys.length > 0) {
+        const projectKeys = new Set(filter.projectKeys.filter((item) => item.trim().length > 0));
+        if (projectKeys.size > 0 && !projectKeys.has(project.projectKey)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Pure predicate shared by the live subscription stream and the snapshot listing
+ * pager: does an agent (with its resolved project placement) satisfy a
+ * `fetch_agents` filter?
+ */
+export function matchesAgentUpdatesFilter(input) {
+    const { agent, project, filter } = input;
+    if (filter?.labels) {
+        const matchesLabels = Object.entries(filter.labels).every(([key, value]) => agent.labels[key] === value);
+        if (!matchesLabels) {
+            return false;
+        }
+    }
+    const includeArchived = filter?.includeArchived ?? false;
+    if (!includeArchived && agent.archivedAt) {
+        return false;
+    }
+    if (filter && !agentThinkingOptionMatchesFilter(agent, filter)) {
+        return false;
+    }
+    if (filter && !matchesAgentStructuralFilter(agent, project, filter)) {
+        return false;
+    }
+    return true;
+}
+function agentUpdateTargetId(update) {
+    return update.kind === "remove" ? update.agentId : update.agent.id;
+}
+export function createAgentUpdatesService(deps) {
+    let subscription = null;
+    function bufferOrEmit(sub, payload) {
+        if (payload.kind === "upsert" && !deps.isProviderVisibleToClient(payload.agent.provider)) {
+            return;
+        }
+        if (sub.isBootstrapping) {
+            sub.pendingUpdatesByAgentId.set(agentUpdateTargetId(payload), payload);
+            return;
+        }
+        deps.emit({
+            type: "agent_update",
+            payload,
+        });
+    }
+    function beginSubscription(input) {
+        subscription = {
+            subscriptionId: input.subscriptionId,
+            filter: input.filter,
+            isBootstrapping: true,
+            pendingUpdatesByAgentId: new Map(),
+        };
+    }
+    function flushBootstrapped(subscriptionId, options) {
+        if (!subscription || subscription.subscriptionId !== subscriptionId) {
+            return;
+        }
+        if (!subscription.isBootstrapping) {
+            return;
+        }
+        subscription.isBootstrapping = false;
+        const pending = Array.from(subscription.pendingUpdatesByAgentId.values());
+        subscription.pendingUpdatesByAgentId.clear();
+        for (const payload of pending) {
+            if (payload.kind === "upsert") {
+                const snapshotUpdatedAt = options?.snapshotUpdatedAtByAgentId?.get(payload.agent.id);
+                if (typeof snapshotUpdatedAt === "number") {
+                    const updateUpdatedAt = Date.parse(payload.agent.updatedAt);
+                    if (!Number.isNaN(updateUpdatedAt) && updateUpdatedAt <= snapshotUpdatedAt) {
+                        continue;
+                    }
+                }
+            }
+            deps.emit({
+                type: "agent_update",
+                payload,
+            });
+        }
+    }
+    function clearSubscription(subscriptionId) {
+        if (subscription && subscription.subscriptionId === subscriptionId) {
+            subscription = null;
+        }
+    }
+    function hasSubscription() {
+        return subscription !== null;
+    }
+    function removeAgent(agentId) {
+        if (!subscription) {
+            return;
+        }
+        bufferOrEmit(subscription, { kind: "remove", agentId });
+    }
+    async function emitStoredRecord(record) {
+        const payload = deps.buildStoredAgentPayload(record);
+        const sub = subscription;
+        if (!sub) {
+            return payload;
+        }
+        const project = payload.workspaceId
+            ? await deps.buildProjectPlacementForWorkspaceId(payload.workspaceId)
+            : null;
+        if (!project) {
+            bufferOrEmit(sub, {
+                kind: "remove",
+                agentId: payload.id,
+            });
+            return payload;
+        }
+        const matches = matchesAgentUpdatesFilter({
+            agent: payload,
+            project,
+            filter: sub.filter,
+        });
+        bufferOrEmit(sub, matches
+            ? {
+                kind: "upsert",
+                agent: payload,
+                project,
+            }
+            : {
+                kind: "remove",
+                agentId: payload.id,
+            });
+        return payload;
+    }
+    async function forwardLiveAgent(agent) {
+        try {
+            const sub = subscription;
+            const payload = await deps.buildAgentPayload(agent);
+            if (sub) {
+                const project = payload.workspaceId
+                    ? await deps.buildProjectPlacementForWorkspaceId(payload.workspaceId)
+                    : null;
+                if (!project) {
+                    bufferOrEmit(sub, {
+                        kind: "remove",
+                        agentId: payload.id,
+                    });
+                }
+                else {
+                    const matches = matchesAgentUpdatesFilter({
+                        agent: payload,
+                        project,
+                        filter: sub.filter,
+                    });
+                    if (matches) {
+                        bufferOrEmit(sub, {
+                            kind: "upsert",
+                            agent: payload,
+                            project,
+                        });
+                    }
+                    else {
+                        bufferOrEmit(sub, {
+                            kind: "remove",
+                            agentId: payload.id,
+                        });
+                    }
+                }
+            }
+            // A lifecycle change updates exactly the agent's owning workspace, never
+            // every workspace sharing its cwd. Ownership is the agent's workspaceId.
+            if (payload.workspaceId) {
+                await deps.emitWorkspaceUpdateForWorkspaceId(payload.workspaceId);
+            }
+        }
+        catch (error) {
+            deps.logger.error({ err: error }, "Failed to emit agent update");
+        }
+    }
+    function dispose() {
+        subscription = null;
+    }
+    return {
+        beginSubscription,
+        flushBootstrapped,
+        clearSubscription,
+        hasSubscription,
+        forwardLiveAgent,
+        emitStoredRecord,
+        removeAgent,
+        dispose,
+    };
+}
+//# sourceMappingURL=agent-updates-service.js.map

package/dist/server/server/session/checkout/checkout-session.d.ts

@@ -2,32 +2,26 @@ import type pino from "pino";
 import type { BranchSuggestionsRequest, CheckoutRefreshRequest, CheckoutRenameBranchRequest, CheckoutStatusRequest, SessionInboundMessage, SessionOutboundMessage, SubscribeCheckoutDiffRequest, UnsubscribeCheckoutDiffRequest, ValidateBranchRequest } from "../../messages.js";
 import type { CheckoutDiffCompareInput, CheckoutDiffSnapshotPayload } from "../../checkout-diff-manager.js";
 import type { WorkspaceGitRuntimeSnapshot, WorkspaceGitService } from "../../workspace-git-service.js";
+import type { GitMutationService } from "../git-mutation/git-mutation-service.js";
 import { type GitHubService } from "../../../services/github-service.js";
-import { type CheckoutExistingBranchResult, type GitMutationRefreshReason } from "../../../utils/checkout-git.js";
+import type { GitMetadataGenerator } from "./git-metadata-generator.js";
 /**
  * The collaborators a checkout command reaches that are NOT part of the checkout
- * domain: the git-mutation refresh primitive and workspace-update emitters owned
- * by the Session shell (also used by worktree/workspace creation), the injected
- * branch operations, and the LLM-backed commit/PR text generators. CheckoutSession
- * orchestrates them but does not own them.
+ * domain and stay owned by the Session shell: client emit, workspace-update
+ * emission, the git branch-snapshot notifier, and the current-branch rename
+ * primitive. CheckoutSession orchestrates them but does not own them. The
+ * git-mutation primitives it performs (switch branch, force snapshot refresh) are
+ * injected separately as `gitMutation`, since they are shared with worktree and
+ * workspace creation.
  */
 export interface CheckoutSessionHost {
     emit(msg: SessionOutboundMessage): void;
-    notifyGitMutation(cwd: string, reason: GitMutationRefreshReason, options?: {
-        invalidateGithub?: boolean;
-    }): Promise<void>;
     emitWorkspaceUpdateForCwd(cwd: string): Promise<void>;
     handleWorkspaceGitBranchSnapshot(cwd: string, branchName: string | null): void;
     renameCurrentBranch(cwd: string, branch: string): Promise<{
         previousBranch: string | null;
         currentBranch: string | null;
     }>;
-    checkoutExistingBranch(cwd: string, branch: string): Promise<CheckoutExistingBranchResult>;
-    generateCommitMessage(cwd: string): Promise<string>;
-    generatePullRequestText(cwd: string, baseRef?: string): Promise<{
-        title: string;
-        body: string;
-    }>;
 }
 /**
  * The slice of CheckoutDiffManager that CheckoutSession needs: open a live diff
@@ -46,9 +40,11 @@ export interface CheckoutDiffSubscriber {
 }
 export interface CheckoutSessionOptions {
     host: CheckoutSessionHost;
+    gitMutation: Pick<GitMutationService, "checkoutExistingBranch" | "notifyGitMutation">;
     workspaceGitService: WorkspaceGitService;
     github: GitHubService;
     checkoutDiffManager: CheckoutDiffSubscriber;
+    gitMetadataGenerator: GitMetadataGenerator;
     paseoHome: string;
     worktreesRoot: string | undefined;
     logger: pino.Logger;
@@ -60,15 +56,17 @@ export interface CheckoutSessionOptions {
  * merge/pull/push/stash and the GitHub-PR operations).
  *
  * Command operations keep the live diff in sync by calling scheduleDiffRefresh()
- * and refresh the workspace git snapshot through host.notifyGitMutation(); the
+ * and refresh the workspace git snapshot through gitMutation.notifyGitMutation(); the
  * workspace git observer streams branch changes through emitStatusUpdate().
  */
 export declare class CheckoutSession {
     private static readonly PASEO_STASH_PREFIX;
     private readonly host;
+    private readonly gitMutation;
     private readonly workspaceGitService;
     private readonly github;
     private readonly checkoutDiffManager;
+    private readonly gitMetadataGenerator;
     private readonly paseoHome;
     private readonly worktreesRoot;
     private readonly logger;

package/dist/server/server/session/checkout/checkout-session.js

@@ -14,16 +14,18 @@ import { expandTilde } from "../../../utils/path.js";
  * merge/pull/push/stash and the GitHub-PR operations).
  *
  * Command operations keep the live diff in sync by calling scheduleDiffRefresh()
- * and refresh the workspace git snapshot through host.notifyGitMutation(); the
+ * and refresh the workspace git snapshot through gitMutation.notifyGitMutation(); the
  * workspace git observer streams branch changes through emitStatusUpdate().
  */
 export class CheckoutSession {
     constructor(options) {
         this.diffSubscriptions = new Map();
         this.host = options.host;
+        this.gitMutation = options.gitMutation;
         this.workspaceGitService = options.workspaceGitService;
         this.github = options.github;
         this.checkoutDiffManager = options.checkoutDiffManager;
+        this.gitMetadataGenerator = options.gitMetadataGenerator;
         this.paseoHome = options.paseoHome;
         this.worktreesRoot = options.worktreesRoot;
         this.logger = options.logger;
@@ -252,7 +254,7 @@ export class CheckoutSession {
     async handleCheckoutSwitchBranchRequest(msg) {
         const { cwd, branch, requestId } = msg;
         try {
-            const checkoutResult = await this.host.checkoutExistingBranch(cwd, branch);
+            const checkoutResult = await this.gitMutation.checkoutExistingBranch(cwd, branch);
             this.scheduleDiffRefresh(cwd);
             // Push a workspace_update immediately so the sidebar/header reflect
             // the new branch name without waiting for the background git watcher.
@@ -300,7 +302,7 @@ export class CheckoutSession {
         }
         try {
             const result = await this.host.renameCurrentBranch(cwd, branch);
-            await this.host.notifyGitMutation(cwd, "rename-branch", { invalidateGithub: true });
+            await this.gitMutation.notifyGitMutation(cwd, "rename-branch", { invalidateGithub: true });
             this.scheduleDiffRefresh(cwd);
             this.host.handleWorkspaceGitBranchSnapshot(cwd, result.currentBranch);
             // Branch is a git fact derived per-descriptor from each workspace's own
@@ -344,7 +346,7 @@ export class CheckoutSession {
             await execCommand("git", ["stash", "push", "--include-untracked", "-m", message], {
                 cwd,
             });
-            await this.host.notifyGitMutation(cwd, "stash-push");
+            await this.gitMutation.notifyGitMutation(cwd, "stash-push");
             this.scheduleDiffRefresh(cwd);
             this.host.emit({
                 type: "stash_save_response",
@@ -364,7 +366,7 @@ export class CheckoutSession {
             await execCommand("git", ["stash", "pop", `stash@{${stashIndex}}`], {
                 cwd,
             });
-            await this.host.notifyGitMutation(cwd, "stash-pop");
+            await this.gitMutation.notifyGitMutation(cwd, "stash-pop");
             this.scheduleDiffRefresh(cwd);
             this.host.emit({
                 type: "stash_pop_response",
@@ -400,7 +402,7 @@ export class CheckoutSession {
         try {
             let message = msg.message?.trim() ?? "";
             if (!message) {
-                message = await this.host.generateCommitMessage(cwd);
+                message = await this.gitMetadataGenerator.generateCommitMessage(cwd);
             }
             if (!message) {
                 throw new Error("Commit message is required");
@@ -409,7 +411,7 @@ export class CheckoutSession {
                 message,
                 addAll: msg.addAll ?? true,
             });
-            await this.host.notifyGitMutation(cwd, "commit-changes");
+            await this.gitMutation.notifyGitMutation(cwd, "commit-changes");
             this.scheduleDiffRefresh(cwd);
             this.host.emit({
                 type: "checkout_commit_response",
@@ -457,8 +459,8 @@ export class CheckoutSession {
                 mode: msg.strategy === "squash" ? "squash" : "merge",
             }, { paseoHome: this.paseoHome, worktreesRoot: this.worktreesRoot });
             await Promise.all([
-                this.host.notifyGitMutation(mutatedCwd, "merge-to-base", { invalidateGithub: true }),
-                ...(mutatedCwd !== cwd ? [this.host.notifyGitMutation(cwd, "merge-to-base")] : []),
+                this.gitMutation.notifyGitMutation(mutatedCwd, "merge-to-base", { invalidateGithub: true }),
+                ...(mutatedCwd !== cwd ? [this.gitMutation.notifyGitMutation(cwd, "merge-to-base")] : []),
             ]);
             this.scheduleDiffRefresh(cwd);
             this.host.emit({
@@ -496,7 +498,7 @@ export class CheckoutSession {
                 baseRef: msg.baseRef,
                 requireCleanTarget: msg.requireCleanTarget ?? true,
             });
-            await this.host.notifyGitMutation(cwd, "merge-from-base", { invalidateGithub: true });
+            await this.gitMutation.notifyGitMutation(cwd, "merge-from-base", { invalidateGithub: true });
             this.scheduleDiffRefresh(cwd);
             this.host.emit({
                 type: "checkout_merge_from_base_response",
@@ -524,7 +526,7 @@ export class CheckoutSession {
         const { cwd, requestId } = msg;
         try {
             await pullCurrentBranch(cwd);
-            await this.host.notifyGitMutation(cwd, "pull", { invalidateGithub: true });
+            await this.gitMutation.notifyGitMutation(cwd, "pull", { invalidateGithub: true });
             this.scheduleDiffRefresh(cwd);
             this.host.emit({
                 type: "checkout_pull_response",
@@ -552,7 +554,7 @@ export class CheckoutSession {
         const { cwd, requestId } = msg;
         try {
             await pushCurrentBranch(cwd);
-            await this.host.notifyGitMutation(cwd, "push", { invalidateGithub: true });
+            await this.gitMutation.notifyGitMutation(cwd, "push", { invalidateGithub: true });
             this.host.emit({
                 type: "checkout_push_response",
                 payload: {
@@ -581,7 +583,7 @@ export class CheckoutSession {
             let title = msg.title?.trim() ?? "";
             let body = msg.body?.trim() ?? "";
             if (!title || !body) {
-                const generated = await this.host.generatePullRequestText(cwd, msg.baseRef);
+                const generated = await this.gitMetadataGenerator.generatePullRequestText(cwd, msg.baseRef);
                 if (!title)
                     title = generated.title;
                 if (!body)
@@ -592,7 +594,7 @@ export class CheckoutSession {
                 body,
                 base: msg.baseRef,
             }, this.github);
-            await this.host.notifyGitMutation(cwd, "create-pr", { invalidateGithub: true });
+            await this.gitMutation.notifyGitMutation(cwd, "create-pr", { invalidateGithub: true });
             this.host.emit({
                 type: "checkout_pr_create_response",
                 payload: {
@@ -632,7 +634,7 @@ export class CheckoutSession {
                 mergeMethod: msg.mergeMethod,
                 status: pullRequest,
             });
-            await this.host.notifyGitMutation(cwd, "merge-pr", { invalidateGithub: true });
+            await this.gitMutation.notifyGitMutation(cwd, "merge-pr", { invalidateGithub: true });
             this.host.emit({
                 type: "checkout_pr_merge_response",
                 payload: {
@@ -695,7 +697,7 @@ export class CheckoutSession {
                     status: pullRequest,
                 });
             }
-            await this.host.notifyGitMutation(cwd, msg.enabled ? "enable-pr-auto-merge" : "disable-pr-auto-merge", {
+            await this.gitMutation.notifyGitMutation(cwd, msg.enabled ? "enable-pr-auto-merge" : "disable-pr-auto-merge", {
                 invalidateGithub: true,
             });
             this.host.emit({

package/dist/server/server/session/checkout/git-metadata-generator.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import type { AgentManager } from "../../agent/agent-manager.js";
+import type { ProviderSnapshotManager } from "../../agent/provider-snapshot-manager.js";
+import { type ResolveStructuredGenerationProvidersOptions, type StructuredGenerationDaemonConfig } from "../../agent/structured-generation-providers.js";
+import type { WorkspaceGitService } from "../../workspace-git-service.js";
+export interface PullRequestText {
+    title: string;
+    body: string;
+}
+/**
+ * Generates a workspace's commit message and pull-request text from its git diff
+ * via the agent LLM. The checkout subsystem is the only consumer; it owns the
+ * commit/PR commands and asks this for the wording when the user left it blank.
+ */
+export interface GitMetadataGenerator {
+    generateCommitMessage(cwd: string): Promise<string>;
+    generatePullRequestText(cwd: string, baseRef?: string): Promise<PullRequestText>;
+}
+/**
+ * The LLM boundary, injected so the generator's prompt-building and fallback
+ * behaviour is unit-testable with a fake. Production wires
+ * createAgentStructuredTextGeneration (resolve providers → run structured
+ * generation); a failed generation throws StructuredAgent*Error, which the
+ * generator catches and turns into the product fallback text.
+ */
+export interface StructuredTextGeneration {
+    generate<T>(request: StructuredTextGenerationRequest<T>): Promise<T>;
+}
+export interface StructuredTextGenerationRequest<T> {
+    cwd: string;
+    prompt: string;
+    schema: z.ZodType<T>;
+    schemaName: string;
+    agentTitle: string;
+}
+type GitMetadataDiffSource = Pick<WorkspaceGitService, "getCheckoutDiff" | "resolveRepoRoot">;
+export declare function createGitMetadataGenerator(deps: {
+    workspaceGitService: GitMetadataDiffSource;
+    generation: StructuredTextGeneration;
+}): GitMetadataGenerator;
+/**
+ * Production StructuredTextGeneration: resolve the structured-generation providers
+ * for the cwd, then run the agent with a 2-retry fallback as an internal,
+ * non-persisted session.
+ */
+export declare function createAgentStructuredTextGeneration(deps: {
+    agentManager: AgentManager;
+    providerSnapshotManager: Pick<ProviderSnapshotManager, "listProviders">;
+    readDaemonConfig: () => StructuredGenerationDaemonConfig;
+    getFocusedSelection: (cwd: string) => ResolveStructuredGenerationProvidersOptions["currentSelection"];
+}): StructuredTextGeneration;
+export {};
+//# sourceMappingURL=git-metadata-generator.d.ts.map