@getpaseo/server 0.1.95 → 0.1.97-beta.1

package/dist/server/terminal/worker-terminal-manager.js

@@ -1,8 +1,22 @@
-import { fork } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { randomUUID } from "node:crypto";
-import { TerminalInputModeTracker } from "@getpaseo/protocol/terminal-input-mode";
+import { fork } from "node:child_process";
+import { randomBytes, randomUUID } from "node:crypto";
+import { assertAbsolutePath, isSameOrDescendantPath } from "../server/path-utils.js";
+import { deriveTerminalActivityStatusBucket } from "@getpaseo/protocol/terminal-activity";
 const REQUEST_TIMEOUT_MS = 10000;
+function requiredWorkspaceId(workspaceId) {
+    if (workspaceId === undefined) {
+        throw new Error("workspaceId is required");
+    }
+    return workspaceId;
+}
+function asRequiredWorkerTerminalInfo(info) {
+    requiredWorkspaceId(info.workspaceId);
+    return info;
+}
+function createActivityToken() {
+    return randomBytes(32).toString("base64url");
+}
 function resolveWorkerUrl() {
     const currentUrl = import.meta.url;
     if (currentUrl.endsWith(".ts")) {
@@ -34,7 +48,9 @@ function cloneTerminalInfo(info) {
         id: info.id,
         name: info.name,
         cwd: info.cwd,
+        workspaceId: info.workspaceId,
         ...(info.title ? { title: info.title } : {}),
+        activity: info.activity,
     };
 }
 function forkTerminalWorker() {
@@ -50,7 +66,10 @@ export function createWorkerTerminalManager(managerOptions = {}) {
     const pendingRequests = new Map();
     const recordsById = new Map();
     const terminalIdsByCwd = new Map();
+    const terminalActivityTokenById = new Map();
     const terminalsChangedListeners = new Set();
+    const terminalActivityListeners = new Set();
+    const terminalWorkspaceContributionChangedListeners = new Set();
     let workerExited = false;
     let workerShutdownTimer = null;
     function emitTerminalsChanged(event) {
@@ -63,6 +82,26 @@ export function createWorkerTerminalManager(managerOptions = {}) {
             }
         }
     }
+    function emitTerminalWorkspaceContributionChanged(event) {
+        for (const listener of Array.from(terminalWorkspaceContributionChangedListeners)) {
+            try {
+                listener(event);
+            }
+            catch {
+                // no-op
+            }
+        }
+    }
+    function emitTerminalActivityTransition(event) {
+        for (const listener of Array.from(terminalActivityListeners)) {
+            try {
+                listener(event);
+            }
+            catch {
+                // no-op
+            }
+        }
+    }
     function listTerminalItemsForCwd(cwd) {
         const terminalIds = terminalIdsByCwd.get(cwd);
         if (!terminalIds) {
@@ -78,7 +117,9 @@ export function createWorkerTerminalManager(managerOptions = {}) {
                 id: record.info.id,
                 name: record.info.name,
                 cwd: record.info.cwd,
+                workspaceId: record.info.workspaceId,
                 ...(record.info.title ? { title: record.info.title } : {}),
+                activity: record.activity,
             });
         }
         return terminals;
@@ -93,12 +134,14 @@ export function createWorkerTerminalManager(managerOptions = {}) {
         const record = {
             info: cloneTerminalInfo(input.info),
             state: input.state,
-            inputModeTracker: new TerminalInputModeTracker(),
+            activity: input.info.activity,
+            replayPreamble: "",
             exitInfo: null,
             messageListeners: new Set(),
             exitListeners: new Set(),
             commandFinishedListeners: new Set(),
             titleChangeListeners: new Set(),
+            activityChangeListeners: new Set(),
             session: undefined,
         };
         const session = {
@@ -111,6 +154,9 @@ export function createWorkerTerminalManager(managerOptions = {}) {
             get cwd() {
                 return record.info.cwd;
             },
+            get workspaceId() {
+                return record.info.workspaceId;
+            },
             send(message) {
                 if (message.type === "resize") {
                     record.state = {
@@ -163,6 +209,27 @@ export function createWorkerTerminalManager(managerOptions = {}) {
                     record.titleChangeListeners.delete(listener);
                 };
             },
+            onActivityChange(listener) {
+                record.activityChangeListeners.add(listener);
+                return () => {
+                    record.activityChangeListeners.delete(listener);
+                };
+            },
+            getActivity() {
+                return record.activity;
+            },
+            setActivity(state) {
+                record.activity = { state, changedAt: Date.now() };
+                sendBestEffortRequest({ type: "setActivity", terminalId: record.info.id, state });
+            },
+            clearActivityAttention() {
+                if (record.activity?.attentionReason == null) {
+                    return false;
+                }
+                record.activity = { state: record.activity.state, changedAt: Date.now() };
+                sendBestEffortRequest({ type: "clearAttention", terminalId: record.info.id });
+                return true;
+            },
             getSize() {
                 return {
                     rows: record.state.rows,
@@ -183,7 +250,12 @@ export function createWorkerTerminalManager(managerOptions = {}) {
                 };
             },
             getReplayPreamble() {
-                return record.inputModeTracker.getPreamble();
+                // Refreshed from every getTerminalState response, which the controller fetches
+                // before every snapshot replay (legacy + visible-snapshot restore). The one
+                // gap is restore.mode === "live", which replays without fetching state — there
+                // this can be stale/empty. No client sends "live" today; revisit (ship the
+                // preamble on the worker's snapshotReady) if one ever does.
+                return record.replayPreamble;
             },
             getTitle() {
                 return record.info.title;
@@ -225,6 +297,7 @@ export function createWorkerTerminalManager(managerOptions = {}) {
             return undefined;
         }
         recordsById.delete(terminalId);
+        terminalActivityTokenById.delete(terminalId);
         const terminalIds = terminalIdsByCwd.get(record.info.cwd);
         if (terminalIds) {
             terminalIds.delete(terminalId);
@@ -242,8 +315,8 @@ export function createWorkerTerminalManager(managerOptions = {}) {
         if (message.message.type === "snapshot") {
             record.state = message.message.state;
         }
-        if (message.message.type === "output") {
-            record.inputModeTracker.feed(message.message.data);
+        if (message.message.type === "snapshotReady" && message.message.replayPreamble !== undefined) {
+            record.replayPreamble = message.message.replayPreamble;
         }
         for (const listener of Array.from(record.messageListeners)) {
             listener(message.message);
@@ -259,7 +332,15 @@ export function createWorkerTerminalManager(managerOptions = {}) {
             listener(message.info);
         }
         record.exitListeners.clear();
-        removeRecord(message.terminalId);
+        const previousBucket = deriveTerminalActivityStatusBucket(record.activity);
+        const removedRecord = removeRecord(message.terminalId);
+        if (previousBucket !== null && removedRecord) {
+            emitTerminalWorkspaceContributionChanged({
+                terminalId: removedRecord.info.id,
+                cwd: removedRecord.info.cwd,
+                workspaceId: removedRecord.info.workspaceId,
+            });
+        }
         emitTerminalsChanged({
             cwd: record.info.cwd,
             terminals: listTerminalItemsForCwd(record.info.cwd),
@@ -299,28 +380,52 @@ export function createWorkerTerminalManager(managerOptions = {}) {
             listener(message.info);
         }
     }
-    function handleTerminalsChangedEvent(message) {
+    function handleTerminalActivityChangeEvent(message) {
+        const record = recordsById.get(message.terminalId);
+        if (!record) {
+            return;
+        }
+        const previousActivity = record.activity;
+        record.activity = message.activity;
+        const transition = {
+            activity: message.activity,
+            previous: message.previous,
+        };
+        for (const listener of Array.from(record.activityChangeListeners)) {
+            listener(transition);
+        }
+        emitTerminalActivityTransition({
+            terminalId: record.info.id,
+            name: record.info.name,
+            cwd: record.info.cwd,
+            workspaceId: record.info.workspaceId,
+            activity: message.activity,
+            previous: message.previous,
+        });
+        const previousBucket = deriveTerminalActivityStatusBucket(previousActivity);
+        const nextBucket = deriveTerminalActivityStatusBucket(message.activity);
+        if (previousBucket !== nextBucket) {
+            emitTerminalWorkspaceContributionChanged({
+                terminalId: record.info.id,
+                cwd: record.info.cwd,
+                workspaceId: record.info.workspaceId,
+            });
+        }
         emitTerminalsChanged({
-            cwd: message.cwd,
-            terminals: message.terminals.map((terminal) => ({
-                id: terminal.id,
-                name: terminal.name,
-                cwd: terminal.cwd,
-                ...(terminal.title ? { title: terminal.title } : {}),
-            })),
+            cwd: record.info.cwd,
+            terminals: listTerminalItemsForCwd(record.info.cwd),
         });
     }
     function handleWorkerEvent(message) {
         switch (message.type) {
             case "terminalCreated": {
-                registerRecord({ info: message.terminal, state: message.state });
-                return;
-            }
-            case "terminalRemoved": {
-                removeRecord(message.terminalId);
+                registerRecord({
+                    info: asRequiredWorkerTerminalInfo(message.terminal),
+                    state: message.state,
+                });
                 emitTerminalsChanged({
-                    cwd: message.cwd,
-                    terminals: listTerminalItemsForCwd(message.cwd),
+                    cwd: message.terminal.cwd,
+                    terminals: listTerminalItemsForCwd(message.terminal.cwd),
                 });
                 return;
             }
@@ -340,8 +445,8 @@ export function createWorkerTerminalManager(managerOptions = {}) {
                 handleTerminalCommandFinishedEvent(message);
                 return;
             }
-            case "terminalsChanged": {
-                handleTerminalsChangedEvent(message);
+            case "terminalActivityChange": {
+                handleTerminalActivityChangeEvent(message);
                 return;
             }
         }
@@ -408,19 +513,56 @@ export function createWorkerTerminalManager(managerOptions = {}) {
             // lifecycle state; do not let fire-and-forget sends crash the daemon.
         });
     }
-    function toSessions(terminals) {
-        return terminals
-            .map((terminal) => recordsById.get(terminal.id)?.session)
-            .filter((session) => Boolean(session));
-    }
     return {
-        async getTerminals(cwd) {
-            const result = (await sendRequest({ type: "getTerminals", cwd }));
-            return toSessions(result);
+        async getTerminals(cwd, options) {
+            assertAbsolutePath(cwd);
+            // Served from the local mirror, exactly like every other parent read.
+            // Terminals are bucketed by exact cwd, but an agent can open a terminal in
+            // a subdirectory of the workspace. A query for the workspace root must
+            // surface those too, so aggregate every bucket at or below `cwd`.
+            const sessions = [];
+            for (const [bucketCwd, terminalIds] of terminalIdsByCwd) {
+                if (!isSameOrDescendantPath(cwd, bucketCwd)) {
+                    continue;
+                }
+                for (const terminalId of terminalIds) {
+                    const session = recordsById.get(terminalId)?.session;
+                    if (session) {
+                        sessions.push(session);
+                    }
+                }
+            }
+            // When the query carries a workspaceId, two workspaces sharing a cwd must
+            // not see each other's terminals. A missing owner is not workspace
+            // membership; unscoped callers can still list those legacy terminals.
+            if (options?.workspaceId !== undefined) {
+                return sessions.filter((session) => session.workspaceId === options.workspaceId);
+            }
+            return sessions;
         },
         async createTerminal(options) {
-            const result = (await sendRequest({ type: "createTerminal", options }));
-            return registerRecord({ info: result.terminal, state: result.state });
+            const terminalId = options.id ?? randomUUID();
+            const activityToken = createActivityToken();
+            const terminalActivityUrl = managerOptions.getTerminalActivityUrl?.() ?? null;
+            terminalActivityTokenById.set(terminalId, activityToken);
+            let result;
+            try {
+                result = (await sendRequest({
+                    type: "createTerminal",
+                    options: {
+                        ...options,
+                        id: terminalId,
+                        activityToken,
+                        activityUrl: terminalActivityUrl,
+                    },
+                }));
+            }
+            catch (error) {
+                terminalActivityTokenById.delete(terminalId);
+                throw error;
+            }
+            const session = registerRecord({ info: result.terminal, state: result.state });
+            return session;
         },
         registerCwdEnv(options) {
             sendBestEffortRequest({
@@ -429,15 +571,29 @@ export function createWorkerTerminalManager(managerOptions = {}) {
                 env: options.env,
             });
         },
+        validateTerminalActivityToken(terminalId, token) {
+            const expected = terminalActivityTokenById.get(terminalId);
+            if (!expected) {
+                return "unknown";
+            }
+            return expected === token ? "valid" : "invalid";
+        },
         getTerminal(id) {
             return recordsById.get(id)?.session;
         },
         async getTerminalState(id, options) {
-            return (await sendRequest({
+            const snapshot = (await sendRequest({
                 type: "getTerminalState",
                 terminalId: id,
                 ...(options ? { options } : {}),
             }));
+            if (snapshot && snapshot.replayPreamble !== undefined) {
+                const record = recordsById.get(id);
+                if (record) {
+                    record.replayPreamble = snapshot.replayPreamble;
+                }
+            }
+            return snapshot;
         },
         setTerminalTitle(id, title) {
             const session = recordsById.get(id)?.session;
@@ -447,6 +603,22 @@ export function createWorkerTerminalManager(managerOptions = {}) {
             session.setTitle(title);
             return true;
         },
+        async setTerminalActivity(id, state) {
+            const record = recordsById.get(id);
+            if (!record) {
+                return false;
+            }
+            await sendRequest({ type: "setActivity", terminalId: id, state });
+            return true;
+        },
+        async clearTerminalAttention(id) {
+            const record = recordsById.get(id);
+            if (!record || record.activity?.attentionReason == null) {
+                return false;
+            }
+            await sendRequest({ type: "clearAttention", terminalId: id });
+            return true;
+        },
         killTerminal(id) {
             void sendRequest({ type: "killTerminal", terminalId: id }).catch(() => {
                 // no-op; kill is intentionally best-effort and synchronous in the public interface.
@@ -496,6 +668,18 @@ export function createWorkerTerminalManager(managerOptions = {}) {
                 terminalsChangedListeners.delete(listener);
             };
         },
+        subscribeTerminalActivity(listener) {
+            terminalActivityListeners.add(listener);
+            return () => {
+                terminalActivityListeners.delete(listener);
+            };
+        },
+        subscribeTerminalWorkspaceContributionChanged(listener) {
+            terminalWorkspaceContributionChangedListeners.add(listener);
+            return () => {
+                terminalWorkspaceContributionChangedListeners.delete(listener);
+            };
+        },
     };
 }
 export function terminateWorkerTerminalManager(manager) {

package/dist/server/utils/build-metadata-prompt.d.ts

@@ -1,4 +1,4 @@
-export type MetadataConfigKey = "agentTitle" | "branchName" | "commitMessage" | "pullRequest";
+export type MetadataConfigKey = "branchName" | "commitMessage" | "pullRequest";
 export interface RepoRootResolver {
     resolveRepoRoot: (cwd: string) => Promise<string>;
 }

package/dist/server/utils/github-remote.js

@@ -1,5 +1,5 @@
 import { isGitHubHost, normalizeHost, parseGitHubRemoteIdentity, parseGitRemoteLocation, } from "@getpaseo/protocol/git-remote";
-import { findExecutable } from "./executable.js";
+import { findExecutable } from "../executable-resolution/executable-resolution.js";
 import { execCommand } from "./spawn.js";
 let sshExecutableLookup = null;
 const sshHostnameResolutionCache = new Map();

package/dist/server/utils/tree-kill.d.ts

@@ -5,7 +5,7 @@ export interface TreeKillTarget {
     kill(signal?: NodeJS.Signals | number): boolean;
     once?(event: "exit", listener: () => void): unknown;
 }
-interface TerminateWithTreeKillOptions {
+export interface TerminateWithTreeKillOptions {
     gracefulSignal?: NodeJS.Signals;
     forceSignal?: NodeJS.Signals;
     gracefulTimeoutMs: number;
@@ -13,6 +13,6 @@ interface TerminateWithTreeKillOptions {
     onForceSignal?: () => void;
 }
 export type TerminateWithTreeKillResult = "already-exited" | "terminated" | "killed" | "kill-timeout";
+export type ProcessTerminator = (child: TreeKillTarget, options: TerminateWithTreeKillOptions) => Promise<TerminateWithTreeKillResult>;
 export declare function terminateWithTreeKill(child: TreeKillTarget, options: TerminateWithTreeKillOptions): Promise<TerminateWithTreeKillResult>;
-export {};
 //# sourceMappingURL=tree-kill.d.ts.map

package/dist/src/{utils/executable.js → executable-resolution/executable-resolution.js}

@@ -1,9 +1,9 @@
 import { createRequire } from "node:module";
 import { existsSync } from "node:fs";
-import { extname } from "node:path";
-import { execCommand } from "./spawn.js";
-import { isWindowsCommandScript } from "./windows-command.js";
-export { quoteWindowsArgument, quoteWindowsCommand } from "./windows-command.js";
+import { execCommand } from "../utils/spawn.js";
+import { isWindowsCommandScript } from "../utils/windows-command.js";
+import { windowsExecutableResolution } from "./windows.js";
+export { quoteWindowsArgument, quoteWindowsCommand } from "../utils/windows-command.js";
 const require = createRequire(import.meta.url);
 const which = require("which");
 const PROBE_TIMEOUT_MS = 2000;
@@ -83,22 +83,24 @@ function classifyProbeError(error) {
  * Check a literal executable path. PATH search is handled by findExecutable().
  */
 export function executableExists(executablePath, exists = existsSync) {
-    if (exists(executablePath))
-        return executablePath;
-    if (process.platform === "win32" && !extname(executablePath)) {
-        for (const ext of [".exe", ".cmd"]) {
-            const candidate = executablePath + ext;
-            if (exists(candidate))
-                return candidate;
-        }
+    if (process.platform === "win32") {
+        return windowsExecutableResolution.exists(executablePath, { exists });
     }
-    return null;
+    return exists(executablePath) ? executablePath : null;
 }
 export async function findExecutable(name, probeTimeoutMs = PROBE_TIMEOUT_MS) {
     const trimmed = name.trim();
     if (!trimmed) {
         return null;
     }
+    if (process.platform === "win32") {
+        return windowsExecutableResolution.find(trimmed, {
+            enumeratePathCandidates: enumerateCandidates,
+            probeExecutable,
+            exists: existsSync,
+            probeTimeoutMs,
+        });
+    }
     if (hasPathSeparator(trimmed)) {
         return (await probeExecutable(trimmed, probeTimeoutMs)) ? trimmed : null;
     }
@@ -113,4 +115,4 @@ export async function findExecutable(name, probeTimeoutMs = PROBE_TIMEOUT_MS) {
 export async function isCommandAvailable(command) {
     return (await findExecutable(command)) !== null;
 }
-//# sourceMappingURL=executable.js.map
+//# sourceMappingURL=executable-resolution.js.map

package/dist/src/executable-resolution/windows.js

@@ -0,0 +1,62 @@
+import { readdirSync } from "node:fs";
+import { extname, join } from "node:path";
+function hasPathSeparator(value) {
+    return value.includes("/") || value.includes("\\");
+}
+function enumerateLiteralPathCandidates(executablePath) {
+    if (extname(executablePath)) {
+        return [executablePath];
+    }
+    return [executablePath, `${executablePath}.exe`, `${executablePath}.cmd`];
+}
+function enumerateWingetPackageCandidates(name, localAppData) {
+    if (!localAppData) {
+        return [];
+    }
+    const wingetPackages = join(localAppData, "Microsoft", "WinGet", "Packages");
+    let packageDirs;
+    try {
+        packageDirs = readdirSync(wingetPackages, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+    const exeName = `${name}.exe`;
+    return packageDirs.map((packageDir) => join(wingetPackages, packageDir, exeName));
+}
+async function find(input, options) {
+    if (hasPathSeparator(input)) {
+        return findFirstProbeable(enumerateLiteralPathCandidates(input), options);
+    }
+    const pathCandidates = await options.enumeratePathCandidates(input);
+    const wingetCandidates = enumerateWingetPackageCandidates(input, options.localAppData ?? process.env.LOCALAPPDATA).filter(options.exists);
+    return findFirstProbeable([...pathCandidates, ...wingetCandidates], options);
+}
+async function findFirstProbeable(candidates, options) {
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (seen.has(candidate)) {
+            continue;
+        }
+        seen.add(candidate);
+        if (await options.probeExecutable(candidate, options.probeTimeoutMs)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function exists(executablePath, options) {
+    for (const candidate of enumerateLiteralPathCandidates(executablePath)) {
+        if (options.exists(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export const windowsExecutableResolution = {
+    exists,
+    find,
+};
+//# sourceMappingURL=windows.js.map

package/dist/src/server/agent/provider-launch-config.js

@@ -1,5 +1,5 @@
 import { isAbsolute } from "node:path";
-import { executableExists, findExecutable } from "../../utils/executable.js";
+import { executableExists, findExecutable, } from "../../executable-resolution/executable-resolution.js";
 import { createExternalProcessEnv } from "../paseo-env.js";
 export { AgentProviderRuntimeSettingsMapSchema, ProviderCommandSchema, ProviderOverrideSchema, ProviderOverridesSchema, ProviderProfileModelSchema, ProviderRuntimeSettingsSchema, } from "@getpaseo/protocol/provider-config";
 import { ProviderOverrideSchema, ProviderOverridesSchema, ProviderRuntimeSettingsSchema, } from "@getpaseo/protocol/provider-config";

package/dist/src/server/persisted-config.js

@@ -187,6 +187,7 @@ export const PersistedConfigSchema = z
             .passthrough()
             .optional(),
         autoArchiveAfterMerge: z.boolean().optional(),
+        enableTerminalAgentHooks: z.boolean().optional(),
         appendSystemPrompt: z.string().optional(),
         terminalProfiles: z.array(TerminalProfileSchema).optional(),
         cors: z

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/server",
-  "version": "0.1.95",
+  "version": "0.1.97-beta.1",
   "description": "Paseo backend server",
   "files": [
     "dist/server",
@@ -22,6 +22,11 @@
       "types": "./dist/server/utils/tool-call-parsers.d.ts",
       "source": "./src/utils/tool-call-parsers.ts",
       "default": "./dist/server/utils/tool-call-parsers.js"
+    },
+    "./agent-hooks": {
+      "types": "./dist/server/terminal/agent-hooks/provider-registry.d.ts",
+      "source": "./src/terminal/agent-hooks/provider-registry.ts",
+      "default": "./dist/server/terminal/agent-hooks/provider-registry.js"
     }
   },
   "publishConfig": {
@@ -59,10 +64,10 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.17.1",
     "@anthropic-ai/claude-agent-sdk": "^0.2.133",
-    "@getpaseo/client": "0.1.95",
-    "@getpaseo/highlight": "0.1.95",
-    "@getpaseo/protocol": "0.1.95",
-    "@getpaseo/relay": "0.1.95",
+    "@getpaseo/client": "0.1.97-beta.1",
+    "@getpaseo/highlight": "0.1.97-beta.1",
+    "@getpaseo/protocol": "0.1.97-beta.1",
+    "@getpaseo/relay": "0.1.97-beta.1",
     "@isaacs/ttlcache": "^2.1.4",
     "@modelcontextprotocol/sdk": "^1.20.1",
     "@opencode-ai/sdk": "1.14.46",

package/dist/server/server/agent/agent-metadata-generator.d.ts

@@ -1,36 +0,0 @@
-import type { Logger } from "pino";
-import type { AgentManager } from "./agent-manager.js";
-import { generateStructuredAgentResponseWithFallback } from "./agent-response-loop.js";
-import { type StructuredGenerationDaemonConfig } from "./structured-generation-providers.js";
-import type { WorkspaceGitService } from "../workspace-git-service.js";
-import type { ProviderSnapshotManager } from "./provider-snapshot-manager.js";
-export interface AgentMetadataGeneratorDeps {
-    generateStructuredAgentResponseWithFallback?: typeof generateStructuredAgentResponseWithFallback;
-}
-export interface AgentMetadataGenerationOptions {
-    agentManager: AgentManager;
-    agentId: string;
-    cwd: string;
-    workspaceGitService?: Pick<WorkspaceGitService, "resolveRepoRoot">;
-    providerSnapshotManager?: Pick<ProviderSnapshotManager, "listProviders">;
-    daemonConfig?: StructuredGenerationDaemonConfig | null;
-    currentSelection?: {
-        provider?: string | null;
-        model?: string | null;
-        thinkingOptionId?: string | null;
-    };
-    initialPrompt?: string | null;
-    explicitTitle?: string | null;
-    paseoHome?: string;
-    logger: Logger;
-    deps?: AgentMetadataGeneratorDeps;
-}
-interface AgentMetadataNeeds {
-    prompt: string | null;
-    needsTitle: boolean;
-}
-export declare function determineAgentMetadataNeeds(options: Pick<AgentMetadataGenerationOptions, "initialPrompt" | "explicitTitle" | "cwd" | "paseoHome" | "deps">): Promise<AgentMetadataNeeds>;
-export declare function generateAndApplyAgentMetadata(options: AgentMetadataGenerationOptions): Promise<void>;
-export declare function scheduleAgentMetadataGeneration(options: AgentMetadataGenerationOptions): void;
-export {};
-//# sourceMappingURL=agent-metadata-generator.d.ts.map