@timurproko/a1 0.2.7-dev.1252 → 0.2.7-dev.1264

package/dist/integrations/pi/engine/adapter.js

@@ -11,11 +11,10 @@ import { PiEngineRuntime } from "./session-runtime.js";
 import { detachedEngineHostPorts } from "./host-ports.js";
 import { PiEngineSettings } from "./settings-port.js";
 import { PiSessionEvents } from "./session-events.js";
-import { readUsageView } from "./usage-view.js";
 import { PiWorkflowContexts } from "./workflow-contexts.js";
 import { PiWorkflowRunner } from "./workflow-runner.js";
 import { defaultWorkflowHost } from "./workflow-support.js";
-import { EngineViewState } from "./view-state.js";
+import { EngineViewState, projectSessionView } from "./view-state.js";
 import { createEnginePorts } from "./ports.js";
 /** Explicit flush failure when required delivery was interrupted rather than completed. */
 export class EngineDeliveryError extends Error {
@@ -198,14 +197,13 @@ export class PiEngineAdapter {
     get settings() { return this.#ports.settings; }
     get catalog() { return this.#ports.catalog; }
     get extensions() { return this.#ports.extensions; }
+    /** Pinned Pi's changelog since the profile's last seen version and extension package updates; the host announces each once per process. */
+    get announcements() { return this.#ports.announcements; }
     /** The Pi objects behind pinned selectors and renderers, for the session presenters owner only. */
     presentationSource() { return this.#ports.presentation; }
     setWorkflowInteractionHost(interaction) {
         this.#workflowInteraction = interaction;
     }
-    #resolveTranscriptImage(assetId) {
-        return this.#projection.assets.resolve(assetId);
-    }
     // Rationale: the startup check's newer release becomes pinned Pi's `Update Available` notice; it arrives
     // whenever the check resolves, so a late result is appended like Pi's own fire-and-forget version check.
     #announceReleaseUpdate(release) {
@@ -240,14 +238,6 @@ export class PiEngineAdapter {
         this.#emitView();
         return this.view();
     }
-    /** Announce pinned Pi's changelog since the profile's last seen version; the host calls this once per process. */
-    announceStartupChangelog() {
-        return this.#engine.announceChangelog();
-    }
-    /** Probe extension packages for updates and announce them; the host calls this once per process. */
-    announcePackageUpdates() {
-        return this.#engine.announcePackageUpdates();
-    }
     onEvent(listener) {
         return this.#delivery.subscribe(listener, this.#delivery.stamp({ type: "session-view", view: this.view() }));
     }
@@ -263,9 +253,6 @@ export class PiEngineAdapter {
             throw new EngineDeliveryError();
         }
     }
-    abortBashWorkflow() {
-        this.#workflows.abortBashWorkflow();
-    }
     async executeWorkflow(request) {
         const result = await this.#workflows.executeWorkflow(request);
         if (request.command === "tree" && result.outcome === "completed" && request.selection !== undefined) {
@@ -273,20 +260,10 @@ export class PiEngineAdapter {
         }
         return result;
     }
-    /**
-     * The theme the engine is configured with, in the engine's own grammar: a
-     * theme's name, or a `light/dark` pair meaning "follow the terminal".
-     */
-    configuredTheme() {
-        return this.#settings.configuredTheme();
-    }
     /** Settings port for the live runtime, or null before the runtime is available. */
     settingsPort() {
         return this.#settings.settingsPort();
     }
-    pinnedSettingsSnapshot() {
-        return this.#settings.pinnedSettingsSnapshot();
-    }
     clearQueuedWorkflows() {
         const session = this.#requireWorkflowSession();
         const result = session.clearQueue?.();
@@ -296,42 +273,13 @@ export class PiEngineAdapter {
         return [...readStringArray(result.steering), ...readStringArray(result.followUp)];
     }
     view() {
-        const routed = this.#engine.session?.routedModel;
-        const routedModel = routed === undefined ? null : readModel(routed.model);
-        return {
-            contractVersion: 1,
+        return projectSessionView({
             sessionId: this.#sessionId,
-            revision: this.#state.revision,
-            lifecycle: this.#state.lifecycle,
+            state: this.#state,
+            engine: this.#engine,
             transcript: this.#projection.snapshot(),
-            editor: { ...this.#state.editor, queuedSubmissions: [...this.#state.editor.queuedSubmissions] },
-            status: {
-                ...this.#state.status,
-                diagnostics: [...this.#state.status.diagnostics],
-                badges: [...this.#state.status.badges],
-                usage: this.#state.usage(() => readUsageView(this.#engine.session, this.#engine.runtime, this.#state.activeModel)),
-                footer: {
-                    branch: this.#engine.gitBranch,
-                    repositoryPath: this.#engine.repositoryCwd,
-                    pullRequest: this.#engine.pullRequest,
-                    sessionName: this.#engine.session?.sessionManager?.getSessionName() ?? null,
-                    availableProviderCount: new Set(this.#engine.runtime?.services.modelRuntime.getAvailableSnapshot?.().map(model => model.provider).filter(provider => provider !== undefined) ?? []).size,
-                    extensionStatuses: [],
-                },
-            },
-            terminal: { ...this.#state.terminal },
-            activeModel: this.#state.activeModel === null ? null : { ...this.#state.activeModel },
-            routedModel: routedModel === null ? null : {
-                model: routedModel,
-                ...(routed?.thinkingLevel === undefined ? {} : { thinkingLevel: readThinkingLevel(routed.thinkingLevel) }),
-            },
-            thinkingLevel: this.#state.thinkingLevel,
-            activeCommandIds: [...this.#commands.activeCommandIds],
-            dialog: null,
-            overlay: null,
-            customizations: [],
-            diagnostics: this.#state.diagnostics.map(diagnostic => ({ ...diagnostic })),
-        };
+            activeCommandIds: this.#commands.activeCommandIds,
+        });
     }
     snapshot() {
         const snapshot = {
@@ -395,7 +343,7 @@ export class PiEngineAdapter {
             clearQueuedWorkflows: () => this.clearQueuedWorkflows(),
             setWorkflowInteractionHost: interaction => { this.setWorkflowInteractionHost(interaction); },
             announceReleaseUpdate: release => { this.#announceReleaseUpdate(release); },
-            resolveTranscriptImage: assetId => this.#resolveTranscriptImage(assetId),
+            resolveTranscriptImage: assetId => this.#projection.assets.resolve(assetId),
             extensionRunner: () => this.#requireWorkflowSession().extensionRunner,
         });
     }

package/dist/integrations/pi/engine/changelog.d.ts

@@ -1,2 +1,2 @@
-export declare function readPinnedCommandChangelog(sinceVersion?: string): Promise<string>;
-export declare function formatPinnedCommandChangelog(content: string, sinceVersion?: string): string;
+/** Pinned Pi's changelog since `sinceVersion` (all of it when absent), read from the owned data resource. */
+export declare function readPinnedCommandChangelog(sinceVersion?: string, path?: URL): Promise<string>;

package/dist/integrations/pi/engine/changelog.js

@@ -2,8 +2,8 @@ import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { posix } from "node:path";
 const REPOSITORY = "https://github.com/earendil-works/pi";
-export async function readPinnedCommandChangelog(sinceVersion) {
-    const path = new URL("./resources/changelog.json", import.meta.url);
+/** Pinned Pi's changelog since `sinceVersion` (all of it when absent), read from the owned data resource. */
+export async function readPinnedCommandChangelog(sinceVersion, path = new URL("./resources/changelog.json", import.meta.url)) {
     if (!existsSync(path))
         return sinceVersion === undefined ? "No changelog entries found." : "";
     try {
@@ -19,7 +19,7 @@ export async function readPinnedCommandChangelog(sinceVersion) {
         return sinceVersion === undefined ? "No changelog entries found." : "";
     }
 }
-export function formatPinnedCommandChangelog(content, sinceVersion) {
+function formatPinnedCommandChangelog(content, sinceVersion) {
     // Provenance: behavior follows Pi 0.84.2 utils/changelog.ts at 914cf1472e715297caa30db4b9535d534a9eb718.
     // Runtime reads only the owned data resource; maintenance tooling verifies its pinned provenance.
     let releases = content.split(/(?=^## )/m).flatMap((section) => {

package/dist/integrations/pi/engine/compaction-progress.d.ts

@@ -1,7 +1,5 @@
-/** Expected summary size for a first compaction, when no previous summary on the branch can serve as the estimate. */
-export declare const DEFAULT_EXPECTED_COMPACTION_SUMMARY_CHARS = 4000;
 /** The public session surface compaction progress reads: the agent's stream function and the branch entries. */
-export interface CompactionProgressSession {
+interface CompactionProgressSession {
     readonly agent?: {
         streamFunction?: unknown;
     } | undefined;
@@ -22,3 +20,4 @@ export interface CompactionProgressObserver {
  * when the session exposes no callable public stream function.
  */
 export declare function observeCompactionProgress(session: CompactionProgressSession, onProgress: (percent: number) => void): CompactionProgressObserver | null;
+export {};

package/dist/integrations/pi/engine/compaction-progress.js

@@ -1,5 +1,5 @@
 /** Expected summary size for a first compaction, when no previous summary on the branch can serve as the estimate. */
-export const DEFAULT_EXPECTED_COMPACTION_SUMMARY_CHARS = 4000;
+const DEFAULT_EXPECTED_COMPACTION_SUMMARY_CHARS = 4000;
 /** Character-based estimates stay below terminal stream completion. */
 const MAX_STREAMING_PERCENT = 99;
 const COMPLETE_PERCENT = 100;

package/dist/integrations/pi/engine/conformance.d.ts

@@ -20,7 +20,7 @@ export declare class PiCapabilityCompatibilityError extends Error {
     readonly operation: string;
     constructor(packageVersion: string, capability: string, operation: string, detail: string);
 }
-export interface PiUpgradeConformanceReport {
+interface PiUpgradeConformanceReport {
     readonly schema: "pi-engine-conformance-v1";
     readonly packageName: "@earendil-works/pi-coding-agent";
     readonly packageVersion: string;
@@ -37,3 +37,4 @@ export declare class PiUpgradeConformanceError extends Error {
 }
 export declare function runPiUpgradeConformance(): Promise<PiUpgradeConformanceReport>;
 export declare function validatePiCapabilityResults(packageVersion: string, results: readonly PiCapabilityConformanceResult[]): void;
+export {};

package/dist/integrations/pi/engine/default-model-setting.d.ts

@@ -5,8 +5,6 @@ interface DefaultModelChoice {
     readonly label: string;
     readonly name: string;
 }
-export declare const DEFAULT_MODEL_SETTING_KEY = "defaultModel";
-export declare const SUPPLEMENTAL_SETTING_KEYS: readonly ["defaultModel"];
 export declare function defaultModelDescriptor(settings: SettingsManager, models: readonly DefaultModelChoice[]): AgentSettingDescriptor;
 export declare function writeDefaultModel(settings: SettingsManager, models: readonly DefaultModelChoice[], value: unknown): Promise<AgentSettingChangeOutcome>;
 export {};

package/dist/integrations/pi/engine/default-model-setting.js

@@ -1,5 +1,4 @@
-export const DEFAULT_MODEL_SETTING_KEY = "defaultModel";
-export const SUPPLEMENTAL_SETTING_KEYS = [DEFAULT_MODEL_SETTING_KEY];
+const DEFAULT_MODEL_SETTING_KEY = "defaultModel";
 const UNSET = "not set";
 function read(settings) {
     const provider = settings.getDefaultProvider();

package/dist/integrations/pi/engine/event-delivery.d.ts

@@ -24,7 +24,7 @@ export type PiEmittedEvent = Omit<Extract<OwnedUiEvent, {
     type: "diagnostic";
 }>, "sessionId" | "sequence">;
 /** A command outcome held back during an overload so its command can still settle after recovery. */
-export interface ReservedCommandOutcome {
+interface ReservedCommandOutcome {
     readonly outcome: Extract<OwnedUiEvent, {
         type: "command-outcome";
     }>["outcome"];
@@ -98,3 +98,4 @@ export declare class PiEventDelivery {
     /** Resolves once every queued event has been delivered or invalidated. */
     settle(): Promise<void>;
 }
+export {};

package/dist/integrations/pi/engine/extension-ui-binding.d.ts

@@ -1,7 +1,7 @@
 import type { AgentSession } from "../startup-public.js";
 import { type OwnedUiDiagnostics, type OwnedUiVisualExtensionSupport } from "../../../contracts/owned-ui/index.js";
 export type OwnedPiVisualExtensionSupport = OwnedUiVisualExtensionSupport;
-export interface PiExtensionUiBindingPorts {
+interface PiExtensionUiBindingPorts {
     session(): AgentSession | undefined;
     diagnostic(severity: OwnedUiDiagnostics["severity"], code: string, message: string, recoverable: boolean): void;
     emitView(): void;
@@ -24,3 +24,4 @@ export declare class PiExtensionUiBinding {
     /** Bind the attached bridge to the current session, reporting failures as diagnostics. */
     rebind(): Promise<void>;
 }
+export {};

package/dist/integrations/pi/engine/host.js

@@ -134,14 +134,14 @@ class ProcessPiEngineHost {
         const theme = this.#options.theme;
         theme.apply.packageBorderProjection(theme.packageBorderProjection);
         theme.apply.accentColor(this.#accentColor);
-        theme.apply.base(theme.base === "dark" ? "dark" : adapter.configuredTheme());
+        theme.apply.base(theme.base === "dark" ? "dark" : adapter.settings.configuredTheme());
     }
     async #announceOnce(adapter) {
         if (this.#announced)
             return;
         this.#announced = true;
         if (this.#options.announceStartupChangelog !== false)
-            await adapter.announceStartupChangelog();
-        void adapter.announcePackageUpdates();
+            await adapter.announcements.startupChangelog();
+        void adapter.announcements.packageUpdates();
     }
 }

package/dist/integrations/pi/engine/message-values.d.ts

@@ -10,7 +10,6 @@ export declare function retainCompletedArguments(current: OwnedUiTranscriptBlock
  * need re-renders it for nothing.
  */
 export declare function sameBlockContent(left: OwnedUiTranscriptBlock, right: OwnedUiTranscriptBlock): boolean;
-export declare function sameValue(left: unknown, right: unknown): boolean;
 export declare function textFromContent(content: unknown): string;
 export declare function assistantContent(content: readonly unknown[]): readonly Record<string, unknown>[];
 export declare function contentImageCount(content: unknown): number;

package/dist/integrations/pi/engine/message-values.js

@@ -35,7 +35,7 @@ export function sameBlockContent(left, right) {
         && sameValue(left.payload, right.payload)
         && sameValue(left.imageReferences ?? [], right.imageReferences ?? []);
 }
-export function sameValue(left, right) {
+function sameValue(left, right) {
     if (left === right)
         return true;
     if (typeof left !== typeof right || left === null || right === null)

package/dist/integrations/pi/engine/pending-delivery.d.ts

@@ -1,8 +1,4 @@
 import type { OwnedUiEvent } from "../../../contracts/owned-ui/index.js";
-export declare const MAX_PENDING_EVENTS = 1024;
-export declare const MAX_PENDING_EVENT_BYTES: number;
-/** Actual shell semantics: only live complete block state has no independent side effect. */
-export declare function replaceableEventKey(event: OwnedUiEvent): string | null;
 /** Intrusive FIFO + segment index: replacement unlinks in O(1), never changes source ordering. */
 export declare class PendingEngineDelivery {
     #private;

package/dist/integrations/pi/engine/pending-delivery.js

@@ -1,7 +1,7 @@
-export const MAX_PENDING_EVENTS = 1024;
-export const MAX_PENDING_EVENT_BYTES = 8 * 1024 * 1024;
+const MAX_PENDING_EVENTS = 1024;
+const MAX_PENDING_EVENT_BYTES = 8 * 1024 * 1024;
 /** Actual shell semantics: only live complete block state has no independent side effect. */
-export function replaceableEventKey(event) {
+function replaceableEventKey(event) {
     switch (event.type) {
         case "transcript-block": return event.block.status === "live" && !(typeof event.block.payload === "object" && event.block.payload !== null && "isError" in event.block.payload && event.block.payload.isError === true) ? event.block.id : null;
         case "session-view": // Invariant: may clear compaction work, replace editor/session state, or preempt presentation.

package/dist/integrations/pi/engine/ports.d.ts

@@ -24,6 +24,11 @@ export interface PiSessionPresentationSource {
     pinnedSettingsModels(): Pick<PiPinnedSettingsSnapshot, "currentModel" | "availableDefaultModels">;
     applyPinnedSettingValue(callback: PiPinnedSettingsCallback, value: unknown): Promise<PiWorkflowResult>;
 }
+/** Startup announcements the host makes once per process: pinned Pi's changelog and extension package updates. */
+export interface PiEngineAnnouncements {
+    startupChangelog(): Promise<void>;
+    packageUpdates(): Promise<void>;
+}
 export interface PiEngineAdapterPorts {
     readonly identity: OwnedUiSessionIdentityPort;
     readonly session: OwnedUiSessionPort;
@@ -32,12 +37,13 @@ export interface PiEngineAdapterPorts {
     readonly catalog: OwnedUiSessionCatalogPort;
     readonly extensions: OwnedUiExtensionPort;
     readonly presentation: PiSessionPresentationSource;
+    readonly announcements: PiEngineAnnouncements;
 }
 /** The adapter's collaborators and its own session operations, which every port member reaches at call time. */
 export interface EnginePortParts {
     readonly sessionId: string;
     readonly agentDir: string;
-    readonly engine: Pick<PiEngineRuntime, "cwd" | "generation" | "bindingGeneration" | "currentSessionResumeMetadata" | "currentSessionFile" | "session">;
+    readonly engine: Pick<PiEngineRuntime, "cwd" | "generation" | "bindingGeneration" | "currentSessionResumeMetadata" | "currentSessionFile" | "session" | "announceChangelog" | "announcePackageUpdates">;
     readonly contexts: PiWorkflowContexts;
     readonly workflows: PiWorkflowRunner;
     readonly settings: PiEngineSettings;

package/dist/integrations/pi/engine/ports.js

@@ -65,6 +65,10 @@ export function createEnginePorts(parts) {
             bindClipboardWriter: writer => workflows.bindClipboardWriter(writer),
             announceReleaseUpdate: release => { parts.announceReleaseUpdate(release); },
         },
+        announcements: {
+            startupChangelog: () => engine.announceChangelog(),
+            packageUpdates: () => engine.announcePackageUpdates(),
+        },
         presentation: {
             pinnedModelSelectorContext: () => contexts.pinnedModelSelectorContext(),
             pinnedSessionSelectorContext: () => contexts.pinnedSessionSelectorContext(),

package/dist/integrations/pi/engine/project-trust-preflight.d.ts

@@ -1,4 +1,4 @@
-export type PiProjectTrustChoiceId = "trust" | "trust-parent" | "trust-session" | "deny" | "deny-session";
+type PiProjectTrustChoiceId = "trust" | "trust-parent" | "trust-session" | "deny" | "deny-session";
 export interface PiProjectTrustPreflightRequest {
     readonly cwd: string;
     readonly defaultDecision: "ask" | "always" | "never";
@@ -24,3 +24,4 @@ export interface ResolvePiProjectTrustPreflightOptions {
  * result exists.
  */
 export declare function resolvePiProjectTrustPreflight(options: ResolvePiProjectTrustPreflightOptions): Promise<PiProjectTrustPreflightResult>;
+export {};

package/dist/integrations/pi/engine/prompt-suggestions.d.ts

@@ -1,13 +1,13 @@
 import type { AgentSession, AgentSessionRuntime } from "../startup-public.js";
 import { type OwnedUiModelInfo, type OwnedUiPromptSuggestionGeneratorPort, type OwnedUiPromptSuggestionReasoning, type OwnedUiPromptSuggestionRequest, type OwnedUiPromptSuggestionResult } from "../../../contracts/owned-ui/index.js";
 /** The run position a suggestion request must still match to be answered. */
-export interface PiPromptSuggestionIdentity {
+interface PiPromptSuggestionIdentity {
     readonly sessionId: string;
     readonly sessionGeneration: number;
     readonly runSequence: number;
     readonly responseSequence: number;
 }
-export interface PiPromptSuggestionPorts {
+interface PiPromptSuggestionPorts {
     session(): AgentSession | undefined;
     runtime(): AgentSessionRuntime | undefined;
     activeModel(): OwnedUiModelInfo | null;
@@ -28,3 +28,4 @@ export declare class PiPromptSuggestions implements OwnedUiPromptSuggestionGener
     reasoningPolicy(): OwnedUiPromptSuggestionReasoning;
     generate(request: OwnedUiPromptSuggestionRequest): Promise<OwnedUiPromptSuggestionResult>;
 }
+export {};

package/dist/integrations/pi/engine/provider-authentication.d.ts

@@ -4,7 +4,7 @@ import type { OwnedUiModelInfo } from "../../../contracts/owned-ui/index.js";
 import type { PiWorkflowInteractionHost, PiWorkflowRequest, PiWorkflowResult } from "./workflows.js";
 type PiSessionApi = AgentSession;
 type PiRuntimeApi = AgentSessionRuntime;
-export interface PiProviderAuthenticationPorts {
+interface PiProviderAuthenticationPorts {
     runtime(): PiRuntimeApi | undefined;
     requireSession(): PiSessionApi;
     disposed(): boolean;

package/dist/integrations/pi/engine/public-main-entry.d.ts

@@ -1,5 +1 @@
-export interface PublicMainEntryDependencies {
-    readonly main?: (arguments_: string[]) => Promise<void>;
-    readonly stderr?: (message: string) => void;
-}
-export declare function runPublicMainEntry(arguments_: readonly string[], dependencies?: PublicMainEntryDependencies): Promise<number>;
+export {};

package/dist/integrations/pi/engine/public-main-entry.js

@@ -2,7 +2,7 @@ import { realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { main as runPublicMain } from "@earendil-works/pi-coding-agent";
-export async function runPublicMainEntry(arguments_, dependencies = {}) {
+async function runPublicMainEntry(arguments_, dependencies = {}) {
     try {
         await (dependencies.main ?? runPublicMain)([...arguments_]);
         return 0;

package/dist/integrations/pi/engine/repository-metadata.d.ts

@@ -0,0 +1,49 @@
+import { type PiPullRequestIdentity, type PiPullRequestProbe } from "./repository-pr.js";
+interface PiRepositoryContextSelection {
+    readonly cwd: string;
+    readonly branch: string;
+}
+export type PiRepositoryContextReader = (sessionId: string, sessionFile: string, signal: AbortSignal) => Promise<PiRepositoryContextSelection | null>;
+type PiGitBranchReader = (cwd: string, signal: AbortSignal) => Promise<string | null>;
+export interface RepositoryMetadataOptions {
+    readonly pullRequestProbe?: PiPullRequestProbe;
+    readonly pullRequestRefreshMs?: number;
+    readonly repositoryContextPollMs?: number;
+    readonly repositoryContextReader?: PiRepositoryContextReader;
+    readonly gitBranchReader?: PiGitBranchReader;
+}
+export interface RepositoryMetadataPorts {
+    /** The session binding generation; a probe started under an older one is dropped. */
+    bindingGeneration(): number;
+    /** The bound session's id and file, when its session manager exposes them. */
+    sessionIdentity(): {
+        readonly sessionId: unknown;
+        readonly sessionFile: unknown;
+    };
+    /** The engine cwd, used when no associated repository context is known. */
+    fallbackCwd(): string;
+    disposed(): boolean;
+    /** The branch, pull request or repository path changed. */
+    changed(): void;
+}
+/**
+ * The branch and pull request shown for the bound session: a poll loop with one probe in flight,
+ * a pending flag for a refresh requested meanwhile, a slower pull-request clock, and a guard that
+ * drops results from an aborted probe, an older binding or a disposed engine.
+ */
+export declare class RepositoryMetadataPoller {
+    #private;
+    constructor(options: RepositoryMetadataOptions, ports: RepositoryMetadataPorts);
+    get cwd(): string;
+    get branch(): string | null;
+    get pullRequest(): PiPullRequestIdentity | null;
+    /** Enable polling and probe now. */
+    start(): void;
+    /** Probe now while polling is enabled; a request made during a probe runs once it settles. */
+    refresh(): void;
+    /** Abort the running probe and forget the previous binding's metadata. */
+    reset(): void;
+    /** Stop polling; resolves once the running probe has settled. */
+    dispose(): Promise<void>;
+}
+export {};

package/dist/integrations/pi/engine/repository-metadata.js

@@ -0,0 +1,189 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { promisify } from "node:util";
+import { readPullRequest } from "./repository-pr.js";
+const execFileAsync = promisify(execFile);
+const PULL_REQUEST_REFRESH_MS = 60_000;
+const REPOSITORY_CONTEXT_POLL_MS = 5_000;
+const GIT_BRANCH_TIMEOUT_MS = 5_000;
+const GIT_BRANCH_MAX_BUFFER_BYTES = 4 * 1024;
+/**
+ * The branch and pull request shown for the bound session: a poll loop with one probe in flight,
+ * a pending flag for a refresh requested meanwhile, a slower pull-request clock, and a guard that
+ * drops results from an aborted probe, an older binding or a disposed engine.
+ */
+export class RepositoryMetadataPoller {
+    #ports;
+    #pullRequestProbe;
+    #pullRequestRefreshMs;
+    #pollMs;
+    #contextReader;
+    #branchReader;
+    #cwd;
+    #branch = null;
+    #pullRequest = null;
+    #timer;
+    #abort;
+    #task;
+    #pending = false;
+    #lastPullRequestProbeAt = null;
+    #enabled = false;
+    constructor(options, ports) {
+        this.#ports = ports;
+        this.#cwd = ports.fallbackCwd();
+        this.#pullRequestProbe = options.pullRequestProbe ?? readPullRequest;
+        this.#pullRequestRefreshMs = options.pullRequestRefreshMs ?? PULL_REQUEST_REFRESH_MS;
+        this.#pollMs = options.repositoryContextPollMs ?? REPOSITORY_CONTEXT_POLL_MS;
+        this.#contextReader = options.repositoryContextReader ?? (async () => null);
+        this.#branchReader = options.gitBranchReader ?? readGitBranch;
+    }
+    get cwd() {
+        return this.#cwd;
+    }
+    get branch() {
+        return this.#branch;
+    }
+    get pullRequest() {
+        return this.#pullRequest;
+    }
+    /** Enable polling and probe now. */
+    start() {
+        this.#enabled = true;
+        this.refresh();
+    }
+    /** Probe now while polling is enabled; a request made during a probe runs once it settles. */
+    refresh() {
+        if (!this.#enabled || this.#ports.disposed())
+            return;
+        if (this.#task !== undefined) {
+            this.#pending = true;
+            return;
+        }
+        const task = this.#probe();
+        this.#task = task;
+        const settled = () => {
+            if (this.#task === task)
+                this.#task = undefined;
+            if (!this.#pending)
+                return;
+            this.#pending = false;
+            this.refresh();
+        };
+        void task.then(settled, settled);
+    }
+    /** Abort the running probe and forget the previous binding's metadata. */
+    reset() {
+        if (this.#timer !== undefined)
+            clearTimeout(this.#timer);
+        this.#timer = undefined;
+        this.#abort?.abort();
+        this.#cwd = this.#ports.fallbackCwd();
+        this.#branch = null;
+        this.#pullRequest = null;
+        this.#lastPullRequestProbeAt = null;
+    }
+    /** Stop polling; resolves once the running probe has settled. */
+    async dispose() {
+        this.#enabled = false;
+        if (this.#timer !== undefined)
+            clearTimeout(this.#timer);
+        this.#timer = undefined;
+        this.#pending = false;
+        this.#abort?.abort();
+        await this.#task;
+    }
+    #current(controller, generation) {
+        return !controller.signal.aborted && generation === this.#ports.bindingGeneration() && this.#enabled && !this.#ports.disposed();
+    }
+    async #probe() {
+        if (this.#abort !== undefined || this.#ports.disposed())
+            return;
+        const controller = new AbortController();
+        const generation = this.#ports.bindingGeneration();
+        this.#abort = controller;
+        let associatedContext = null;
+        const { sessionId, sessionFile } = this.#ports.sessionIdentity();
+        try {
+            if (typeof sessionId === "string" && sessionId.length > 0 && typeof sessionFile === "string" && sessionFile.length > 0) {
+                try {
+                    associatedContext = await this.#contextReader(sessionId, sessionFile, controller.signal);
+                }
+                catch {
+                    associatedContext = null;
+                }
+            }
+            const nextCwd = associatedContext?.cwd ?? this.#ports.fallbackCwd();
+            let nextBranch = associatedContext?.branch ?? null;
+            if (associatedContext === null) {
+                try {
+                    nextBranch = await this.#branchReader(nextCwd, controller.signal);
+                }
+                catch {
+                    nextBranch = null;
+                }
+            }
+            const metadataChanged = nextCwd !== this.#cwd || nextBranch !== this.#branch;
+            const remoteDue = metadataChanged || this.#lastPullRequestProbeAt === null
+                || Date.now() - this.#lastPullRequestProbeAt >= this.#pullRequestRefreshMs;
+            if (remoteDue) {
+                let nextPullRequest = null;
+                try {
+                    nextPullRequest = nextBranch === null
+                        ? null
+                        : await this.#pullRequestProbe(nextCwd, nextBranch, controller.signal);
+                }
+                catch {
+                    nextPullRequest = null;
+                }
+                if (!this.#current(controller, generation))
+                    return;
+                this.#apply(nextCwd, nextBranch, nextPullRequest);
+            }
+        }
+        catch {
+            if (this.#current(controller, generation))
+                this.#apply(this.#ports.fallbackCwd(), null, null);
+        }
+        finally {
+            if (this.#abort === controller)
+                this.#abort = undefined;
+        }
+        if (!this.#current(controller, generation))
+            return;
+        this.#timer = setTimeout(() => {
+            this.#timer = undefined;
+            this.refresh();
+        }, this.#pollMs);
+        this.#timer.unref?.();
+    }
+    #apply(cwd, branch, pullRequest) {
+        const changed = cwd !== this.#cwd || branch !== this.#branch || !samePullRequest(this.#pullRequest, pullRequest);
+        this.#cwd = cwd;
+        this.#branch = branch;
+        this.#pullRequest = pullRequest;
+        this.#lastPullRequestProbeAt = Date.now();
+        if (changed)
+            this.#ports.changed();
+    }
+}
+function samePullRequest(left, right) {
+    return left?.number === right?.number && left?.url === right?.url;
+}
+async function readGitBranch(cwd, signal) {
+    if (!existsSync(cwd))
+        return null;
+    try {
+        const { stdout } = await execFileAsync("git", ["branch", "--show-current"], {
+            cwd,
+            windowsHide: true,
+            timeout: GIT_BRANCH_TIMEOUT_MS,
+            maxBuffer: GIT_BRANCH_MAX_BUFFER_BYTES,
+            signal,
+            encoding: "utf8",
+        });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}