@deepseek-ai/dsh-experimental-forge-session 0.0.0-stage → 0.2.2-alpha.2

package/lib/index.js

@@ -0,0 +1,844 @@
+import { Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+import { changeRequestKey } from "@deepseek-ai/dsh-experimental-forge";
+import { SessionSeq, appendPluginRecord, pluginRecordOf } from "@deepseek-ai/dsh-session";
+import { MAX_TIMER_DELAY_MS, deadline } from "@deepseek-ai/dsh-timeout";
+import parse from "shell-quote/parse.js";
+import quote from "shell-quote/quote.js";
+import { z as z$1 } from "zod";
+import { assertNever } from "@deepseek-ai/dsh-util-values";
+//#region lib/types/references.js
+/** Literal GitHub CLI references, with shell quoting and command separators preserved. */
+const VALUE_OPTIONS = new Set([
+	"--json",
+	"--jq",
+	"-q",
+	"--template",
+	"-t",
+	"--title",
+	"--body",
+	"-b",
+	"--body-file",
+	"-F",
+	"--base",
+	"-B",
+	"--add-assignee",
+	"--add-label",
+	"--add-project",
+	"--add-reviewer",
+	"--milestone",
+	"-m",
+	"--remove-assignee",
+	"--remove-label",
+	"--remove-project",
+	"--remove-reviewer",
+	"--branch"
+]);
+const BOOLEAN_OPTIONS = new Set([
+	"--comments",
+	"-c",
+	"--web",
+	"-w",
+	"--detach",
+	"-d",
+	"--force",
+	"-f",
+	"--recurse-submodules",
+	"--remove-milestone"
+]);
+const SEPARATORS = new Set([
+	"&&",
+	"||",
+	";",
+	"|",
+	"|&",
+	"&"
+]);
+const REPOSITORY = /^(?:([a-z\d.-]+(?::\d+)?)\/)?([a-z\d_-]+)\/([a-z\d_.-]+)$/i;
+/**
+* Read explicit URL selectors or numeric selectors with `--repo`/`-R`.
+* Shell expansion, multiline scripts, substitutions, and unsupported options
+* are excluded. Unqualified repositories can be resolved only for a single
+* simple command, optionally piped to an output filter; compound commands
+* may change the CLI environment. PowerShell callers may use only `url`.
+* @param command - logged shell command text.
+* @returns references in command order; no process or environment is read.
+*/
+function ghReferences(command) {
+	if (/[\r\n`]|\$\(/.test(command) || !/^(?:[^'"\\]|\\.|'(?:[^']*)'|"(?:[^"\\]|\\.)*")*$/.test(command)) return [];
+	let tokens;
+	try {
+		tokens = parse(command, () => {
+			throw new Error("dynamic shell word");
+		});
+	} catch (error) {
+		return [];
+	}
+	const references = [];
+	const compound = tokens.some((token, index) => {
+		const next = tokens[index + 1];
+		return typeof token !== "string" && "op" in token && ([
+			"&&",
+			"||",
+			";",
+			"&"
+		].includes(token.op) || ["|", "|&"].includes(token.op) && (typeof next !== "string" || ![
+			"head",
+			"tail",
+			"cat"
+		].includes(next)));
+	});
+	let words = [];
+	let first = true;
+	let unsupported = false;
+	const flush = () => {
+		const reference = unsupported ? void 0 : referenceOf(words, first && !compound);
+		if (reference !== void 0) references.push(reference);
+		words = [];
+		first = false;
+		unsupported = false;
+	};
+	for (let index = 0; index < tokens.length; index++) {
+		const token = tokens[index];
+		if (typeof token === "string") words.push(token);
+		else if (token !== void 0 && "op" in token && SEPARATORS.has(token.op)) flush();
+		else if (token !== void 0 && "op" in token && token.op === ">&" && words.at(-1) === "2" && tokens[index + 1] === "1") {
+			words.pop();
+			index++;
+		} else unsupported = true;
+	}
+	flush();
+	return references;
+}
+function referenceOf(words, allowLookup) {
+	const environment = [];
+	let executable = words[0] === "env" ? 1 : 0;
+	for (const word of words.slice(executable)) {
+		if (!/^[A-Za-z_][A-Za-z\d_]*=/.test(word)) break;
+		environment.push(word);
+		executable++;
+	}
+	if (words[executable] !== "gh") return void 0;
+	let repository;
+	let take = null;
+	const positional = [];
+	for (const arg of words.slice(executable + 1)) {
+		if (take !== null) {
+			if (take === "repo") repository = arg;
+			take = null;
+			continue;
+		}
+		if (arg === "--repo" || arg === "-R") take = "repo";
+		else if (arg.startsWith("--repo=")) repository = arg.slice(7);
+		else if (arg.startsWith("-R") && arg.length > 2) repository = arg.slice(2);
+		else {
+			const option = arg.replace(/=.*/, "");
+			if (VALUE_OPTIONS.has(option)) {
+				if (!arg.includes("=")) take = "value";
+			} else if (!BOOLEAN_OPTIONS.has(option)) {
+				if (arg.startsWith("-")) return void 0;
+				positional.push(arg);
+			}
+		}
+	}
+	if (take !== null) return void 0;
+	const [resource, operation, selector] = positional;
+	if (resource !== "pr" || ![
+		"view",
+		"edit",
+		"checkout"
+	].includes(operation ?? "") || selector === void 0 || positional.length !== 3) return void 0;
+	const url = /^(https?:\/\/[^\s/]+\/[^\s/]+\/[^\s/]+\/pull\/[1-9]\d*)(?:[/?#].*)?$/.exec(selector)?.[1];
+	if (url !== void 0) return {
+		url,
+		lookup: null
+	};
+	if (!/^[1-9]\d*$/.test(selector) || !Number.isSafeInteger(Number(selector)) || repository === void 0) return void 0;
+	const match = REPOSITORY.exec(repository.replace(/^https?:\/\//, "").replace(/\.git$/, ""));
+	if (match === null || match[3] === "." || match[3] === "..") return void 0;
+	const [, repoHost, owner, name] = match;
+	const host = repoHost ?? environment.findLast((entry) => entry.startsWith("GH_HOST="))?.slice(8);
+	if (host !== void 0 && /^[a-z\d.-]+(?::\d+)?$/i.test(host)) return {
+		url: `https://${host}/${owner}/${name}/pull/${selector}`,
+		lookup: null
+	};
+	return {
+		url: null,
+		lookup: allowLookup ? quote([
+			"env",
+			...environment,
+			"gh",
+			"pr",
+			"view",
+			selector,
+			"--repo",
+			repository,
+			"--json",
+			"url"
+		]) : null
+	};
+}
+//#endregion
+//#region lib/types/commands.js
+/** Recognition of shell commands and output that bind change requests to a Session. */
+const CREATE_COMMAND = /\bgh\s+pr\s+(?:create|new)\b/;
+const REFERENCE_COMMAND = /\bgh\s+pr\s+(?:view|edit|checkout)\b/;
+const OWN_URL_LINE = /^(?:url:\s+)?(https?:\/\/[^\s"'<>]+?\/pull\/\d+)\/?$/;
+const OWN_URL_MEMBER = /"url"\s*:\s*"(https?:\/\/[^\s"'<>]+?\/pull\/\d+)\/?"/g;
+const PUSH_COMMAND = /\bgit(?:\s+(?:-[Cc]\s+\S+|--[\w-]+(?:=\S+)?))*\s+push\b/;
+const CHANGE_REQUEST_URL = /\bhttps?:\/\/[^\s"'<>]+?\/pull\/\d+(?![\w-])/g;
+const PUSH_TARGET_LINE = /^To (\S+)$/;
+const PUSH_REF_LINE = /^ [ +*=] (\[[^\]]+\]|\S+) +\S+ -> (\S+)(?: \(.*\))?$/;
+/**
+* Read the command string of a `bash` or `pwsh` tool call.
+* @param argumentsJson - raw tool-call arguments as the model produced them.
+* @returns the command, or undefined when the arguments are not JSON or carry no string `command`.
+*/
+function commandOf(argumentsJson) {
+	let parsed;
+	try {
+		parsed = JSON.parse(argumentsJson);
+	} catch (error) {
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null) return void 0;
+	const command = parsed.command;
+	return typeof command === "string" ? command : void 0;
+}
+/**
+* Classify the binding evidence a command and its output can carry.
+* `gh pr create` (or its alias `gh pr new`) prints the change request URL;
+* `gh pr view`, `gh pr edit`, and `gh pr checkout` act on one change request,
+* which a URL or a number with an explicit repository and host can name;
+* their output can also print its URL. `git push`,
+* with or without leading `-C`, `-c`, and long options, prints the updated
+* refs. When a command does both, the URLs a result prints bind as created.
+* The match is textual, so quoted mentions also classify; the result parsers
+* then find no evidence in their output.
+* @param command - shell command text.
+* @returns the evidence, or undefined when the command has none of these forms.
+*/
+function commandEvidence(command) {
+	const create = CREATE_COMMAND.test(command);
+	const references = ghReferences(command);
+	const reference = REFERENCE_COMMAND.test(command) || references.length > 0;
+	const pushes = PUSH_COMMAND.test(command);
+	if (!create && !reference && !pushes) return void 0;
+	const named = [...new Set(references.flatMap((reference) => reference.url === null ? [] : [reference.url]))];
+	return {
+		urls: create ? "created" : reference ? "referenced" : null,
+		pushes,
+		named
+	};
+}
+/**
+* Find GitHub pull request URLs in command output.
+* @param text - rendered shell result.
+* @returns distinct URLs in order of first appearance.
+*/
+function changeRequestUrls(text) {
+	return [...new Set(text.match(CHANGE_REQUEST_URL))];
+}
+/**
+* Find the URLs that `gh pr view`, `gh pr edit`, or `gh pr checkout` output
+* prints for the change request it acts on: gh's `url:` field or a URL alone
+* on a line before the `--` line that starts a description, and JSON `url`
+* members. Links in a description or in other fields name other pages.
+* @param text - rendered shell result.
+* @returns distinct URLs in order of first appearance.
+*/
+function ownChangeRequestUrls(text) {
+	const urls = [];
+	for (const line of text.split(/\r?\n/)) {
+		if (line === "--") break;
+		const [, own] = OWN_URL_LINE.exec(line.trim()) ?? [];
+		if (own !== void 0) urls.push(own);
+	}
+	for (const [, member = ""] of text.matchAll(OWN_URL_MEMBER)) urls.push(member);
+	return [...new Set(urls)];
+}
+/**
+* Find branches that `git push` output reports as created, updated, forced,
+* or already up to date. Each ref line belongs to the nearest preceding
+* `To <remote>` line. Rejected and deleted refs, new tags, and explicit refs
+* outside `refs/heads/` are excluded. Unqualified tag updates cannot be
+* distinguished from branch updates and are included.
+* @param text - rendered shell result, stdout and stderr.
+* @returns distinct pushed branches in order of first appearance.
+*/
+function pushedBranches(text) {
+	const pushed = [];
+	let remote;
+	for (const line of text.split(/\r?\n/)) {
+		const target = PUSH_TARGET_LINE.exec(line);
+		if (target !== null) {
+			[, remote = ""] = target;
+			continue;
+		}
+		const ref = PUSH_REF_LINE.exec(line);
+		if (remote === void 0 || ref === null) continue;
+		const [, summary = "", destination = ""] = ref;
+		if (summary === "[new tag]") continue;
+		const branch = destination.startsWith("refs/heads/") ? destination.slice(11) : destination;
+		if (branch.startsWith("refs/")) continue;
+		if (!pushed.some((entry) => entry.remote === remote && entry.branch === branch)) pushed.push({
+			remote,
+			branch
+		});
+	}
+	return pushed;
+}
+/**
+* Compare two change request URLs ignoring scheme, letter case, query,
+* fragment, and trailing slashes.
+* @param left - one URL.
+* @param right - the other URL.
+* @returns whether both name the same web page.
+*/
+function sameChangeRequestUrl(left, right) {
+	return urlIdentity(left) === urlIdentity(right);
+}
+function urlIdentity(url) {
+	return url.replace(/^https?:\/\//i, "").replace(/[?#].*$/s, "").replace(/\/+$/, "").toLowerCase();
+}
+//#endregion
+//#region lib/types/projection.js
+/** Projection that folds shell results and binding records into one Session's change request bindings, and shows clients the bindings. */
+/** Plugin record type of binding actions. */
+const BINDING_RECORD = "plugin:forge-session/binding";
+/** Tools whose calls run shell commands with a string `command` argument. */
+const SHELL_TOOLS = new Set(["bash", "pwsh"]);
+const EMPTY = Object.freeze({
+	pending: Object.freeze([]),
+	bindings: Object.freeze([]),
+	pushes: Object.freeze([])
+});
+const bindingRecordSchema = z$1.object({
+	action: z$1.enum([
+		"track",
+		"dismiss",
+		"discover",
+		"reference"
+	]),
+	url: z$1.string().regex(/^https?:\/\/\S+$/)
+});
+const bindingsSchema = z$1.array(z$1.object({
+	url: z$1.string(),
+	origin: z$1.enum([
+		"created",
+		"referenced",
+		"discovered",
+		"tracked"
+	]),
+	dismissed: z$1.boolean()
+}).strict());
+/**
+* The `forgeChangeRequests` unit. A `bash` or `pwsh` call whose command is
+* `gh pr create`, `gh pr view`, `gh pr edit`, `gh pr checkout`, or
+* `git push` stays pending until its first result. A successful result binds
+* every pull request URL a `gh pr create` result prints; for the other `gh pr`
+* commands it binds the URL the command names and the URL the output prints
+* for its own change request; and it records the branches it reports as
+* pushed. Failed tool executions bind nothing; a nonzero exit status does not
+* matter, because the URL or ref line is the evidence. `turn/end` drops calls
+* that never received a result. Binding records bind, restore, and hide URLs.
+* Clients, including the Session summary, see the bindings; the array keeps
+* its reference while only pending calls and pushes change.
+*/
+const forgeChangeRequestsProjection = {
+	key: "forgeChangeRequests",
+	stateVersion: 3,
+	stateSchema: z$1.object({
+		pending: z$1.array(z$1.object({
+			callId: z$1.string(),
+			urls: z$1.enum(["created", "referenced"]).nullable(),
+			pushes: z$1.boolean(),
+			named: z$1.array(z$1.string())
+		}).strict()),
+		bindings: bindingsSchema,
+		pushes: z$1.array(z$1.object({
+			remote: z$1.string(),
+			branch: z$1.string(),
+			seq: z$1.number().int().nonnegative().transform((value) => SessionSeq(value))
+		}).strict())
+	}).strict(),
+	init: () => EMPTY,
+	apply,
+	wire: {
+		viewSchema: bindingsSchema,
+		view: (state) => state.bindings
+	}
+};
+function apply(state, event) {
+	switch (event.type) {
+		case "tool/call": return applyCall(state, event.data);
+		case "tool/result": return applyResult(state, event.data, event.seq);
+		case "turn/end": return state.pending.length === 0 ? state : {
+			...state,
+			pending: EMPTY.pending
+		};
+		default: return applyRecord(state, event);
+	}
+}
+function applyCall(state, call) {
+	if (!SHELL_TOOLS.has(call.name)) return state;
+	const command = commandOf(call.arguments);
+	const evidence = command === void 0 ? void 0 : commandEvidence(command);
+	if (evidence === void 0) return state;
+	return {
+		...state,
+		pending: [...state.pending, {
+			callId: call.callId,
+			...evidence
+		}]
+	};
+}
+function applyResult(state, result, seq) {
+	const callId = result.message.toolCallId;
+	const pending = state.pending.find((entry) => entry.callId === callId);
+	if (pending === void 0) return state;
+	const rest = state.pending.filter((entry) => entry !== pending);
+	if (result.message.isError === true) return {
+		...state,
+		pending: rest
+	};
+	const text = result.message.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n");
+	const printed = pending.urls === "created" ? changeRequestUrls(text) : ownChangeRequestUrls(text);
+	return {
+		pending: rest,
+		bindings: pending.urls === null ? state.bindings : bind(state.bindings, [...pending.named, ...printed], pending.urls),
+		pushes: pending.pushes ? recordPushes(state.pushes, pushedBranches(text), seq) : state.pushes
+	};
+}
+function applyRecord(state, event) {
+	const record = pluginRecordOf(event);
+	if (record?.type !== "plugin:forge-session/binding") return state;
+	const parsed = bindingRecordSchema.safeParse(record.data);
+	if (!parsed.success) return state;
+	const { action, url } = parsed.data;
+	const index = state.bindings.findIndex((binding) => sameChangeRequestUrl(binding.url, url));
+	const existing = state.bindings[index];
+	switch (action) {
+		case "reference": return existing === void 0 ? {
+			...state,
+			bindings: bind(state.bindings, [url], "referenced")
+		} : state;
+		case "discover": return existing === void 0 ? {
+			...state,
+			bindings: bind(state.bindings, [url], "discovered")
+		} : state;
+		case "track":
+			if (existing === void 0) return {
+				...state,
+				bindings: bind(state.bindings, [url], "tracked")
+			};
+			return existing.dismissed ? {
+				...state,
+				bindings: state.bindings.with(index, {
+					...existing,
+					dismissed: false
+				})
+			} : state;
+		case "dismiss": return existing !== void 0 && !existing.dismissed ? {
+			...state,
+			bindings: state.bindings.with(index, {
+				...existing,
+				dismissed: true
+			})
+		} : state;
+		/* v8 ignore next -- closed BindingRecord action union exhaustiveness guard */
+		default: return assertNever(action, "BindingRecord.action");
+	}
+}
+/** Append each URL not already bound; returns the input array when nothing is new. */
+function bind(bindings, urls, origin) {
+	let next = bindings;
+	for (const url of urls) if (!next.some((binding) => sameChangeRequestUrl(binding.url, url))) next = [...next, {
+		url,
+		origin,
+		dismissed: false
+	}];
+	return next;
+}
+/** Move each reported branch to the end with the reporting event's sequence number. */
+function recordPushes(pushes, pushed, seq) {
+	if (pushed.length === 0) return pushes;
+	return [...pushes.filter((entry) => !pushed.some((ref) => ref.remote === entry.remote && ref.branch === entry.branch)), ...pushed.map((ref) => ({
+		remote: ref.remote,
+		branch: ref.branch,
+		seq
+	}))];
+}
+//#endregion
+//#region lib/types/reference-lookup.js
+/** Resolve unqualified CLI references in the shell execution world and persist only confirmed URLs. */
+const completedShell = z$1.object({
+	kind: z$1.literal("foreground"),
+	cwd: z$1.string(),
+	exitCode: z$1.literal(0),
+	signal: z$1.null(),
+	timedOut: z$1.literal(false),
+	aborted: z$1.literal(false)
+});
+const shellArguments = z$1.object({ command: z$1.string() });
+const resolvedReference = z$1.object({ url: z$1.string().regex(/^https?:\/\/[^\s/]+\/[^\s/]+\/[^\s/]+\/pull\/[1-9]\d*\/?$/) });
+/**
+* Observe completed foreground Bash calls while tools and shell services exist.
+* Queries use the same shell service, cwd, managed environment, and standing
+* sandbox policy. Failed lookups leave bindings unchanged and log a warning.
+* Cancellation leaves bindings unchanged; disposal aborts and awaits all queries.
+* Replay performs no lookup.
+* @param ctx - owning plugin context.
+* @param timeoutMs - shell deadline for one read-only lookup.
+* @param record - persists a confirmed URL without restoring dismissed bindings.
+*/
+function observeReferences(ctx, timeoutMs, record) {
+	ctx.inject([
+		"tools",
+		"shell",
+		"shellEnv"
+	], (scope) => {
+		const lifetime = new AbortController();
+		const tasks = /* @__PURE__ */ new Set();
+		scope.effect(() => async () => {
+			lifetime.abort();
+			await Promise.allSettled(tasks);
+		}, "forge-session: stop reference lookups");
+		scope.on("tools/result", (exec, result) => {
+			const task = resolve(exec, result).catch((error) => {
+				if (lifetime.signal.aborted || exec.signal.aborted) return;
+				scope.logger.warn(`forge-session: PR reference lookup failed; use a full PR URL to bind it: ${error instanceof Error ? error.message : String(error)}`);
+			});
+			tasks.add(task);
+			task.then(() => tasks.delete(task));
+		});
+		async function resolve(exec, result) {
+			if (exec.name !== "bash" || exec.agent === void 0 || exec.parent !== void 0 || result.isError) return;
+			const argumentsResult = shellArguments.safeParse(exec.arguments);
+			const shell = completedShell.safeParse(result.value);
+			if (!argumentsResult.success || !shell.success) return;
+			if (ownChangeRequestUrls(result.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n")).length > 0) return;
+			const lookups = ghReferences(argumentsResult.data.command).flatMap((reference) => reference.lookup === null ? [] : [reference.lookup]);
+			const agent = exec.agent;
+			const signal = AbortSignal.any([lifetime.signal, exec.signal]);
+			for (const command of lookups) {
+				signal.throwIfAborted();
+				const spec = scope.shell.resolve({
+					command,
+					workdir: shell.data.cwd,
+					timeoutMs,
+					signal,
+					dshEnv: scope.shellEnv.collect(exec),
+					sandboxPolicy: scope.get("sandboxPolicy")?.resolve({ session: agent.session })
+				});
+				const output = await (await scope.shell.execute(spec)).result();
+				signal.throwIfAborted();
+				if (output.exitCode !== 0 || output.signal !== null || output.timedOut || output.aborted || output.stdout.truncated) throw new Error("gh did not return a complete successful reference lookup");
+				const parsed = resolvedReference.parse(JSON.parse(output.stdout.text));
+				record(agent.session, parsed.url);
+			}
+		}
+	});
+}
+//#endregion
+//#region lib/types/index.js
+/** Binds change requests to the Session that created, pushed, or tracked them, and watches the bound ones. */
+var __addDisposableResource = function(env, value, async) {
+	if (value !== null && value !== void 0) {
+		if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+		var dispose, inner;
+		if (async) {
+			if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+			dispose = value[Symbol.asyncDispose];
+		}
+		if (dispose === void 0) {
+			if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+			dispose = value[Symbol.dispose];
+			if (async) inner = dispose;
+		}
+		if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+		if (inner) dispose = function() {
+			try {
+				inner.call(this);
+			} catch (e) {
+				return Promise.reject(e);
+			}
+		};
+		env.stack.push({
+			value,
+			dispose,
+			async
+		});
+	} else if (async) env.stack.push({ async: true });
+	return value;
+};
+var __disposeResources = (function(SuppressedError) {
+	return function(env) {
+		function fail(e) {
+			env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+			env.hasError = true;
+		}
+		var r, s = 0;
+		function next() {
+			while (r = env.stack.pop()) try {
+				if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+				if (r.dispose) {
+					var result = r.dispose.call(r.value);
+					if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+						fail(e);
+						return next();
+					});
+				} else s |= 1;
+			} catch (e) {
+				fail(e);
+			}
+			if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+			if (env.hasError) throw env.error;
+		}
+		return next();
+	};
+})(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+	var e = new Error(message);
+	return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+/**
+* Session-scoped change request bindings. The `forgeChangeRequests`
+* projection derives them from `gh pr create`, `gh pr view`, `gh pr edit`,
+* `gh pr checkout`, and `git push` results and from
+* `plugin:forge-session/binding` records. After each push result, and when a
+* caller reports the branch a Session works on, the service looks up open
+* change requests whose head is that branch and records the unbound ones as
+* discovered. Watching a Session polls its visible change requests through
+* `ctx.forge`.
+*/
+var ForgeSessionService = class extends Service {
+	static inject = [
+		"forge",
+		"sessions",
+		"sessionProjections"
+	];
+	static Config = z.object({ discoveryTimeoutMs: z.number().default(3e4) });
+	home;
+	discoveryTimeoutMs;
+	watches = /* @__PURE__ */ new Map();
+	discoveries = /* @__PURE__ */ new Set();
+	sessionLifetimes = /* @__PURE__ */ new WeakMap();
+	lifetime = new AbortController();
+	projection;
+	constructor(ctx, config) {
+		super(ctx, "forgeSession");
+		const { discoveryTimeoutMs } = config;
+		if (!Number.isSafeInteger(discoveryTimeoutMs) || discoveryTimeoutMs <= 0 || discoveryTimeoutMs > MAX_TIMER_DELAY_MS) throw new Error(`forge-session: discoveryTimeoutMs must be a positive integer no greater than ${MAX_TIMER_DELAY_MS}`);
+		this.home = ctx;
+		this.discoveryTimeoutMs = discoveryTimeoutMs;
+		ctx.effect(() => async () => {
+			this.lifetime.abort(/* @__PURE__ */ new Error("forge-session service disposed"));
+			await Promise.allSettled(this.discoveries);
+		}, "forge-session: stop discovery");
+	}
+	/**
+	* List the change requests bound to a Session and not dismissed.
+	* @param session - Session whose bindings are read.
+	* @returns visible bindings in first-recorded order, each with its latest polling result.
+	*/
+	changeRequests(session) {
+		return this.entries(this.state(session).bindings);
+	}
+	/**
+	* Bind a change request to a Session by URL, or restore a dismissed binding.
+	* Appends a `track` record with the provider's canonical URL unless the
+	* change request is already visible.
+	* @param session - Session that receives the binding.
+	* @param url - web URL of the change request.
+	* @throws when no registered provider recognizes the URL.
+	*/
+	track(session, url) {
+		const ref = this.home.forge.changeRequestFromUrl(url);
+		if (ref === void 0) throw new Error(`forge-session: no forge provider recognizes ${JSON.stringify(url)}`);
+		const canonical = this.home.forge.changeRequestUrl(ref);
+		const existing = this.state(session).bindings.find((binding) => sameChangeRequestUrl(binding.url, canonical));
+		if (existing === void 0 || existing.dismissed) appendPluginRecord(session, BINDING_RECORD, {
+			action: "track",
+			url: canonical
+		});
+	}
+	/**
+	* Look up open change requests whose head is a branch the Session works on,
+	* and record the unbound ones as discovered, as after a push of that branch.
+	* A remote that no provider recognizes changes nothing; a failed lookup is
+	* logged and changes nothing.
+	* @param session - Session that receives the bindings.
+	* @param remote - URL of the remote that holds the branch.
+	* @param branch - branch name on that remote.
+	* @returns resolves once the lookup has recorded its bindings or failed.
+	*/
+	discoverBranch(session, remote, branch) {
+		return this.discover(session, remote, branch);
+	}
+	/**
+	* Hide a visible binding. Appends a `dismiss` record; a URL that is not
+	* visibly bound leaves the log unchanged. Discovery never restores a
+	* dismissed binding; `track` does.
+	* @param session - Session that owns the binding.
+	* @param url - web URL of the change request.
+	*/
+	dismiss(session, url) {
+		const existing = this.state(session).bindings.find((binding) => !binding.dismissed && sameChangeRequestUrl(binding.url, url));
+		if (existing !== void 0) appendPluginRecord(session, BINDING_RECORD, {
+			action: "dismiss",
+			url: existing.url
+		});
+	}
+	/**
+	* Watch a Session's visible change requests as an effect on the calling
+	* fiber. Every visible change request that a provider recognizes is polled
+	* through `ctx.forge` while the Session has a watcher. Listeners receive the
+	* complete list after each later binding or provider change, or polling result; read the
+	* current list with {@link changeRequests}. Listeners must not throw; a
+	* thrown error is logged and skipped.
+	* @param session - Session to watch.
+	* @param listener - receives the complete visible list.
+	* @returns the disposer that stops this watch.
+	*/
+	watch(session, listener) {
+		const dispose = this.ctx.effect(() => {
+			let watch = this.watches.get(session);
+			if (watch === void 0) {
+				watch = {
+					listeners: /* @__PURE__ */ new Set(),
+					bindings: this.state(session).bindings,
+					forgeWatches: /* @__PURE__ */ new Map()
+				};
+				this.watches.set(session, watch);
+				this.sync(watch);
+			}
+			const owned = watch;
+			owned.listeners.add(listener);
+			return () => {
+				owned.listeners.delete(listener);
+				if (owned.listeners.size > 0) return;
+				this.watches.delete(session);
+				for (const unwatch of owned.forgeWatches.values()) unwatch();
+				owned.forgeWatches.clear();
+			};
+		}, "forgeSession.watch()");
+		return () => void dispose();
+	}
+	async [Service.init]() {
+		this.projection = await this.home.sessionProjections.register(forgeChangeRequestsProjection);
+		this.home.on("session/event", (session, event) => {
+			this.react(session, event);
+		});
+		observeReferences(this.home, this.discoveryTimeoutMs, (session, url) => {
+			if (!this.state(session).bindings.some((binding) => sameChangeRequestUrl(binding.url, url))) appendPluginRecord(session, BINDING_RECORD, {
+				action: "reference",
+				url
+			});
+		});
+		this.home.on("session/disposed", (session) => {
+			this.sessionLifetimes.get(session)?.abort(/* @__PURE__ */ new Error("forge-session: Session was disposed"));
+			this.sessionLifetimes.delete(session);
+		});
+		this.home.on("forge/providers-changed", () => {
+			for (const [session, watch] of [...this.watches]) {
+				if (this.watches.get(session) !== watch) continue;
+				this.sync(watch);
+				this.notify(watch);
+			}
+		});
+	}
+	state(session) {
+		return this.projection.stateOf(session);
+	}
+	entries(bindings) {
+		const entries = [];
+		for (const binding of bindings) {
+			if (binding.dismissed) continue;
+			const ref = this.home.forge.changeRequestFromUrl(binding.url) ?? null;
+			const update = ref === null ? null : this.home.forge.latest(ref) ?? null;
+			entries.push({
+				url: binding.url,
+				origin: binding.origin,
+				ref,
+				update
+			});
+		}
+		return entries;
+	}
+	/** Discover change requests for this result's pushes and refresh watchers after binding changes. */
+	react(session, event) {
+		if (event.type !== "tool/result" && pluginRecordOf(event)?.type !== "plugin:forge-session/binding") return;
+		const state = this.state(session);
+		for (const push of state.pushes) if (push.seq === event.seq) this.discover(session, push.remote, push.branch);
+		const watch = this.watches.get(session);
+		if (watch === void 0 || watch.bindings === state.bindings) return;
+		watch.bindings = state.bindings;
+		this.sync(watch);
+		this.notify(watch);
+	}
+	/** Poll exactly the visible change requests that a provider recognizes. */
+	sync(watch) {
+		const wanted = /* @__PURE__ */ new Map();
+		for (const entry of this.entries(watch.bindings)) if (entry.ref !== null) wanted.set(changeRequestKey(entry.ref), entry.ref);
+		for (const [key, unwatch] of watch.forgeWatches) {
+			if (wanted.has(key)) continue;
+			unwatch();
+			watch.forgeWatches.delete(key);
+		}
+		for (const [key, ref] of wanted) if (!watch.forgeWatches.has(key)) watch.forgeWatches.set(key, this.home.forge.watch(ref, () => {
+			this.notify(watch);
+		}));
+	}
+	notify(watch) {
+		const changeRequests = this.entries(watch.bindings);
+		for (const listener of [...watch.listeners]) try {
+			listener(changeRequests);
+		} catch (error) {
+			this.home.logger.warn(`forge-session: change request listener failed: ${String(error)}`);
+		}
+	}
+	discover(session, remote, branch) {
+		const repository = this.home.forge.repositoryFromRemote(remote);
+		if (repository === void 0) return Promise.resolve();
+		let lifetime = this.sessionLifetimes.get(session);
+		if (lifetime === void 0) {
+			lifetime = new AbortController();
+			this.sessionLifetimes.set(session, lifetime);
+		}
+		const signal = AbortSignal.any([this.lifetime.signal, lifetime.signal]);
+		const task = this.lookup(session, repository, branch, signal).catch((error) => {
+			if (signal.aborted) return;
+			this.home.logger.warn(`forge-session: change request lookup for ${branch} failed: ${error instanceof Error ? error.message : String(error)}`);
+		});
+		this.discoveries.add(task);
+		task.then(() => this.discoveries.delete(task));
+		return task;
+	}
+	async lookup(session, repository, branch, signal) {
+		const env_1 = {
+			stack: [],
+			error: void 0,
+			hasError: false
+		};
+		try {
+			const timeout = __addDisposableResource(env_1, deadline(signal, this.discoveryTimeoutMs, "FORGE_DISCOVERY_TIMEOUT"), false);
+			const refs = await this.home.forge.findByHead(repository, branch, timeout.signal);
+			for (const ref of refs) {
+				if (signal.aborted || this.home.sessions.get(session.id) !== session) return;
+				const url = this.home.forge.changeRequestUrl(ref);
+				if (this.state(session).bindings.some((binding) => sameChangeRequestUrl(binding.url, url))) continue;
+				appendPluginRecord(session, BINDING_RECORD, {
+					action: "discover",
+					url
+				});
+			}
+		} catch (e_1) {
+			env_1.error = e_1;
+			env_1.hasError = true;
+		} finally {
+			__disposeResources(env_1);
+		}
+	}
+};
+//#endregion
+export { ForgeSessionService, ForgeSessionService as default };