@oh-my-pi/pi-coding-agent 17.2.8 → 17.2.9

package/src/tools/shell-tokenize.ts

@@ -83,25 +83,47 @@ export function tokenizeShellSegments(command: string): string[][] {
 }
 
 /**
- * Returns the original text of flat shell command segments. Unlike
+ * A flat shell command segment with the context needed to decide interception.
+ *
+ * @see extractFlatShellCommandSegments
+ */
+export interface FlatShellCommandSegment {
+	/** Original segment text with quoting and escaping preserved. */
+	text: string;
+	/**
+	 * True when this segment consumes the previous stage's stdout via an
+	 * unquoted `|` or `|&`. Blank and comment-only continuation lines preserve
+	 * the pending pipe state. Such a stage reads piped stdin, so path-based
+	 * dedicated tools (read/grep/glob) cannot replace it. `||`, `;`, `&`, and
+	 * `&&` start an independent command and leave this false.
+	 */
+	pipedStdin: boolean;
+}
+
+/**
+ * Returns the flat shell command segments with the original text of each. Unlike
  * `tokenizeShellSegments`, this preserves quoting and escaping so the results
- * are safe to match against user-configured regular expressions.
+ * are safe to match against user-configured regular expressions, and flags
+ * segments that receive piped stdin.
  *
  * The extractor deliberately declines to split syntax whose execution context
  * cannot be determined with this small scanner (heredocs, command substitution,
  * backticks, grouping, and malformed quoting). Callers must still check the
  * complete input in that case.
  */
-export function extractFlatShellCommandSegments(command: string): string[] {
-	const segments: string[] = [];
+export function extractFlatShellCommandSegments(command: string): FlatShellCommandSegment[] {
+	const segments: FlatShellCommandSegment[] = [];
 	let segmentStart = 0;
 	let inSingle = false;
 	let inDouble = false;
 	let atWordStart = true;
+	let currentPiped = false;
 
-	const pushSegment = (end: number) => {
+	const pushSegment = (end: number): boolean => {
 		const segment = command.slice(segmentStart, end).trim();
-		if (segment.length > 0) segments.push(segment);
+		if (segment.length === 0) return false;
+		segments.push({ text: segment, pipedStdin: currentPiped });
+		return true;
 	};
 
 	for (let i = 0; i < command.length; i++) {
@@ -154,12 +176,14 @@ export function extractFlatShellCommandSegments(command: string): string[] {
 			return [];
 		}
 		if (ch === "#" && atWordStart) {
-			pushSegment(i);
+			const pushed = pushSegment(i);
 			const newline = command.indexOf("\n", i + 1);
 			if (newline === -1) return segments;
 			i = newline;
 			segmentStart = newline + 1;
 			atWordStart = true;
+			// Preserve a pending pipe through a comment-only continuation.
+			if (pushed) currentPiped = false;
 			continue;
 		}
 		const isRedirectionOperatorCharacter =
@@ -169,8 +193,13 @@ export function extractFlatShellCommandSegments(command: string): string[] {
 					? command[i - 1] === ">" || command[i - 1] === "<" || command[i + 1] === ">"
 					: false;
 		if ((ch === "\n" || ch === ";" || ch === "|" || ch === "&") && !isRedirectionOperatorCharacter) {
-			pushSegment(i);
-			if ((ch === "|" || ch === "&") && command[i + 1] === ch) i++;
+			const pushed = pushSegment(i);
+			const doubled = (ch === "|" || ch === "&") && command[i + 1] === ch;
+			const pipeStderr = ch === "|" && command[i + 1] === "&";
+			if (doubled || pipeStderr) i++;
+			// `|` and `|&` pipe into the next segment. Blank continuation
+			// lines preserve that pending state; all other operators reset it.
+			if (pushed || ch !== "\n") currentPiped = ch === "|" && !doubled;
 			segmentStart = i + 1;
 			atWordStart = true;
 			continue;

package/src/utils/changelog.ts

@@ -198,9 +198,10 @@ function parseChangelogContent(content: string): ChangelogEntry[] {
 }
 
 /**
- * Compare versions. Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
+ * Compare changelog entries by their parsed version parts.
+ * Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
  */
-export function compareVersions(v1: ChangelogEntry, v2: ChangelogEntry): number {
+export function compareChangelogEntries(v1: ChangelogEntry, v2: ChangelogEntry): number {
 	if (v1.major !== v2.major) return v1.major - v2.major;
 	if (v1.minor !== v2.minor) return v1.minor - v2.minor;
 	return v1.patch - v2.patch;
@@ -232,7 +233,7 @@ export function getNewEntries(entries: ChangelogEntry[], lastVersion: string): C
 		return [];
 	}
 
-	return entries.filter(entry => compareVersions(entry, parsedLastVersion) > 0);
+	return entries.filter(entry => compareChangelogEntries(entry, parsedLastVersion) > 0);
 }
 
 /**
@@ -328,7 +329,7 @@ export async function resolveStartupChangelogForDisplay(options: {
 	}
 	if (options.mode === "hidden") {
 		const currentVersion = parseChangelogVersion(options.currentVersion);
-		if (currentVersion && compareVersions(currentVersion, parsedLastVersion) > 0) {
+		if (currentVersion && compareChangelogEntries(currentVersion, parsedLastVersion) > 0) {
 			await writeLastChangelogVersion(options.currentVersion, options.agentDir);
 		}
 		return undefined;

package/src/utils/late-cleanup.ts

@@ -0,0 +1,17 @@
+import { logger } from "@oh-my-pi/pi-utils";
+
+const pendingCleanups = new Set<Promise<void>>();
+
+/** Keep timed-out cleanup reachable until its resources really settle. */
+export function trackLateCleanup(work: Promise<void>, context: Record<string, unknown>): void {
+	let tracked: Promise<void>;
+	tracked = work
+		.catch(error => {
+			logger.warn("Deferred cleanup failed", {
+				...context,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		})
+		.finally(() => pendingCleanups.delete(tracked));
+	pendingCleanups.add(tracked);
+}

package/src/vibe/runtime.ts

@@ -70,8 +70,8 @@ const TRACE_LINE_MAX = 120;
 const DEFAULT_WAIT_TIMEOUT_MS = 30_000;
 /** Response text cap inside a delivered turn result; full output stays at agent://<id>. */
 const RESPONSE_PREVIEW_MAX = 6000;
-/** Grace period for abort-aware turns before teardown detaches a stuck provider/tool call. */
-const CANCELLED_TURN_SETTLE_GRACE_MS = 250;
+/** Grace period for Vibe cancellation/release cleanup before teardown detaches (ms). */
+const VIBE_TEARDOWN_GRACE_MS = 5_000;
 
 const VIBE_LIFECYCLE_CUSTOM_TYPE = "vibe-session-lifecycle";
 const VIBE_LIFECYCLE_VERSION = 1;
@@ -252,6 +252,48 @@ export interface VibeWaitOutcome {
 	timedOut: boolean;
 }
 
+type VibeTeardownStatus = "pending" | "settled" | "failed";
+
+interface TrackedVibeTeardown {
+	promise: Promise<void>;
+	status: () => VibeTeardownStatus;
+}
+
+/** Observe cleanup without propagating a detached late rejection. */
+function trackVibeTeardown(promise: Promise<unknown>, onError: (error: unknown) => void): TrackedVibeTeardown {
+	let status: VibeTeardownStatus = "pending";
+	return {
+		promise: promise.then(
+			() => {
+				status = "settled";
+			},
+			error => {
+				status = "failed";
+				onError(error);
+			},
+		),
+		status: () => status,
+	};
+}
+
+/** Wait for cleanup only until the caller's shared absolute deadline. */
+async function waitForVibeTeardown(tasks: readonly TrackedVibeTeardown[], deadline: number): Promise<boolean> {
+	if (tasks.length === 0 || tasks.every(task => task.status() !== "pending")) return true;
+	const remainingMs = deadline - Date.now();
+	if (remainingMs <= 0) return false;
+	const timeout = Promise.withResolvers<void>();
+	const timer = setTimeout(timeout.resolve, remainingMs);
+	timer.unref?.();
+	try {
+		return await Promise.race([
+			Promise.allSettled(tasks.map(task => task.promise)).then(() => true),
+			timeout.promise.then(() => false),
+		]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
 /** Normalize a text fragment to one bounded roster/trace line. */
 function firstLine(text: string, max = 100): string {
 	return oneLineLabel(text, max);
@@ -354,24 +396,6 @@ function mergeTrace(turn: VibeTurn, progress: AgentProgress): void {
 /** Thrown from a turn job body so the job manager marks the job failed while carrying the formatted result. */
 export class VibeTurnError extends Error {}
 
-async function awaitCancelledTurnJobs(jobs: ReadonlySet<AsyncJob>): Promise<void> {
-	if (jobs.size === 0) return;
-	const settled = Promise.allSettled([...jobs].map(job => job.promise)).then(() => true);
-	const timeout = Promise.withResolvers<false>();
-	const timer = setTimeout(() => timeout.resolve(false), CANCELLED_TURN_SETTLE_GRACE_MS);
-	timer.unref();
-	try {
-		if (!(await Promise.race([settled, timeout.promise]))) {
-			logger.warn("vibe: detached cancelled turn that did not settle within teardown grace period", {
-				jobCount: jobs.size,
-				graceMs: CANCELLED_TURN_SETTLE_GRACE_MS,
-			});
-		}
-	} finally {
-		clearTimeout(timer);
-	}
-}
-
 /**
  * Process-global registry of vibe worker sessions, scoped by both owner agent
  * id and stable parent session id. Persisted lifecycle events rebuild idle
@@ -419,6 +443,12 @@ export class VibeSessionRegistry {
 	readonly #records = new Map<string, VibeRecord>();
 	readonly #terminationTails = new Map<string, Promise<void>>();
 	readonly #terminatedScopes = new Set<string>();
+	#teardownGraceMs = VIBE_TEARDOWN_GRACE_MS;
+
+	/** Override the teardown grace period for deterministic lifecycle tests. */
+	setTeardownGraceForTesting(timeoutMs: number): void {
+		this.#teardownGraceMs = Math.max(1, timeoutMs);
+	}
 
 	ownerScope(session: VibeParentSession): VibeOwnerScope {
 		const parentSessionId = session.getSessionId?.();
@@ -709,11 +739,50 @@ export class VibeSessionRegistry {
 		}
 	}
 
+	#trackAgentRelease(id: string, ref: AgentRef, action: "detach" | "release"): TrackedVibeTeardown {
+		return trackVibeTeardown(AgentLifecycleManager.global().release(id, ref), error => {
+			logger.warn(`vibe: failed to ${action} worker session`, {
+				id,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		});
+	}
+
+	#finishAgentRelease(id: string, ref: AgentRef, task: TrackedVibeTeardown, action: "detach" | "release"): void {
+		if (task.status() === "settled") return;
+		if (task.status() === "pending") {
+			logger.warn(`vibe: timed out waiting to ${action} worker session; detaching registry ref`, { id });
+		}
+		AgentRegistry.global().unregister(id, ref);
+	}
+
+	async #releaseRefWithinDeadline(
+		id: string,
+		ref: AgentRef,
+		deadline: number,
+		action: "detach" | "release",
+	): Promise<void> {
+		const task = this.#trackAgentRelease(id, ref, action);
+		await waitForVibeTeardown([task], deadline);
+		this.#finishAgentRelease(id, ref, task, action);
+	}
+
+	#trackJobSettlement(record: VibeRecord, job: AsyncJob): TrackedVibeTeardown {
+		return trackVibeTeardown(job.promise, error => {
+			logger.warn("vibe: cancelled worker turn cleanup failed", {
+				id: record.id,
+				jobId: job.id,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		});
+	}
+
 	async #markTerminalRef(
 		id: string,
 		ownerId: string,
 		childSessionFile: string,
 		expected?: AgentRef | null,
+		teardownDeadline?: number,
 	): Promise<void> {
 		const registry = AgentRegistry.global();
 		const existing = registry.get(id);
@@ -726,7 +795,9 @@ export class VibeSessionRegistry {
 		}
 		if (existing?.status === "aborted" && !existing.session) return;
 		if (existing && !registry.setStatus(id, "aborted", existing)) return;
-		if (existing && AgentLifecycleManager.global().has(id, existing)) {
+		if (existing && teardownDeadline !== undefined) {
+			await this.#releaseRefWithinDeadline(id, existing, teardownDeadline, "release");
+		} else if (existing && AgentLifecycleManager.global().has(id, existing)) {
 			await AgentLifecycleManager.global().release(id, existing);
 		} else if (existing?.session) {
 			await existing.session.dispose();
@@ -1086,21 +1157,50 @@ export class VibeSessionRegistry {
 			this.#records.delete(scopeKey(scope, record.id));
 			if (record.turn && manager) manager.cancel(record.turn.jobId, { ownerId: record.ownerId });
 		}
-		for (const { record, ref } of teardown) {
-			if (!ref) continue;
-			try {
-				await AgentLifecycleManager.global().release(record.id, ref);
-			} catch (error) {
-				logger.warn("vibe: failed to detach worker session", {
+		const deadline = Date.now() + this.#teardownGraceMs;
+		const cleanup = teardown.map(entry => ({
+			...entry,
+			releaseTask: entry.ref ? this.#trackAgentRelease(entry.record.id, entry.ref, "detach") : undefined,
+			jobTask: entry.job ? this.#trackJobSettlement(entry.record, entry.job) : undefined,
+		}));
+		await waitForVibeTeardown(
+			cleanup.flatMap(entry => [entry.releaseTask, entry.jobTask].filter(task => task !== undefined)),
+			deadline,
+		);
+		for (const { record, ref, releaseTask, job, jobTask } of cleanup) {
+			if (ref && releaseTask) this.#finishAgentRelease(record.id, ref, releaseTask, "detach");
+			if (job && jobTask?.status() === "pending") {
+				logger.warn("vibe: timed out waiting for cancelled worker turn; cleanup continues in the background", {
 					id: record.id,
-					error: error instanceof Error ? error.message : String(error),
+					jobId: job.id,
 				});
+				this.#continueSuspendedCleanup(scope, record, jobTask);
+			}
+			if (this.#records.has(scopeKey(scope, record.id))) continue;
+			const lateRef = this.#registeredAgent(record);
+			if (lateRef && lateRef !== ref) {
+				await this.#releaseRefWithinDeadline(record.id, lateRef, deadline, "detach");
 			}
 		}
-		await awaitCancelledTurnJobs(new Set(teardown.flatMap(entry => (entry.job ? [entry.job] : []))));
 		return records.length;
 	}
 
+	#continueSuspendedCleanup(scope: VibeOwnerScope, record: VibeRecord, jobTask: TrackedVibeTeardown): void {
+		void jobTask.promise
+			.then(async () => {
+				if (this.#records.has(scopeKey(scope, record.id))) return;
+				const lateRef = this.#registeredAgent(record);
+				if (!lateRef) return;
+				await this.#releaseRefWithinDeadline(record.id, lateRef, Date.now() + this.#teardownGraceMs, "detach");
+			})
+			.catch(error => {
+				logger.warn("vibe: failed to finish suspended worker cleanup", {
+					id: record.id,
+					error: error instanceof Error ? error.message : String(error),
+				});
+			});
+	}
+
 	/** Terminate one worker; a tombstone failure still tears it down before reconciliation and error delivery. */
 	async kill(session: ToolSession, id: string): Promise<VibeKillOutcome> {
 		const scope = this.ownerScope(session);
@@ -1144,15 +1244,21 @@ export class VibeSessionRegistry {
 			await this.#persistModeExit(session, scope, records);
 		} catch (error) {
 			if (error instanceof SessionPersistenceIndeterminateError) {
-				for (const record of records) {
-					await this.#killRecord(record, session.asyncJobManager, session, "mode-exit", false);
-				}
+				const teardownDeadline = Date.now() + this.#teardownGraceMs;
+				await Promise.all(
+					records.map(record =>
+						this.#killRecord(record, session.asyncJobManager, session, "mode-exit", false, teardownDeadline),
+					),
+				);
 			}
 			throw error;
 		}
-		for (const record of records) {
-			await this.#killRecord(record, session.asyncJobManager, session, "mode-exit");
-		}
+		const teardownDeadline = Date.now() + this.#teardownGraceMs;
+		await Promise.all(
+			records.map(record =>
+				this.#killRecord(record, session.asyncJobManager, session, "mode-exit", true, teardownDeadline),
+			),
+		);
 		return records.length;
 	}
 
@@ -1162,6 +1268,7 @@ export class VibeSessionRegistry {
 		session: VibeParentSession,
 		reason: VibeTombstoneReason,
 		persistTerminal = true,
+		teardownDeadline?: number,
 	): Promise<VibeKillOutcome> {
 		const registered = this.#registeredAgent(record);
 		const settlingJobs = new Set<AsyncJob>();
@@ -1198,26 +1305,29 @@ export class VibeSessionRegistry {
 		record.state = "dead";
 		record.lastActivityAt = Date.now();
 		record.lastActivity = "killed";
-		if (registered) {
-			try {
-				await AgentLifecycleManager.global().release(record.id, registered);
-			} catch (error) {
-				logger.warn("vibe: failed to release worker session", {
-					id: record.id,
-					error: error instanceof Error ? error.message : String(error),
-				});
-			}
+		const deadline = teardownDeadline ?? Date.now() + this.#teardownGraceMs;
+		const releaseTask = registered ? this.#trackAgentRelease(record.id, registered, "release") : undefined;
+		const jobCleanup = [...settlingJobs].map(job => ({ job, task: this.#trackJobSettlement(record, job) }));
+		await waitForVibeTeardown(
+			[releaseTask, ...jobCleanup.map(entry => entry.task)].filter(task => task !== undefined),
+			deadline,
+		);
+		if (registered && releaseTask) this.#finishAgentRelease(record.id, registered, releaseTask, "release");
+		const pendingJobs = jobCleanup.filter(entry => entry.task.status() === "pending");
+		for (const { job } of pendingJobs) {
+			logger.warn("vibe: timed out waiting for cancelled worker turn; cleanup continues in the background", {
+				id: record.id,
+				jobId: job.id,
+			});
 		}
-		await awaitCancelledTurnJobs(settlingJobs);
 		const terminalRef = registered ?? this.#registeredAgent(record) ?? null;
-		if (record.childSessionFile) {
-			try {
-				const persisted = await SessionManager.peekSessionInit(record.childSessionFile);
-				if (persisted?.init)
-					await this.#markTerminalRef(record.id, record.ownerId, record.childSessionFile, terminalRef);
-			} catch {
-				// A turn killed before session initialization has no readable history to retain.
-			}
+		await this.#markTerminalRecord(record, terminalRef, deadline);
+		if (pendingJobs.length > 0) {
+			this.#continueKilledCleanup(
+				record,
+				pendingJobs.map(entry => entry.task),
+				registered,
+			);
 		}
 		if (persistenceError) {
 			let finalPersistenceError = persistenceError;
@@ -1246,6 +1356,40 @@ export class VibeSessionRegistry {
 		return { id: record.id, cancelledTurn };
 	}
 
+	async #markTerminalRecord(
+		record: VibeRecord,
+		expected: AgentRef | null | undefined,
+		teardownDeadline: number,
+	): Promise<void> {
+		if (!record.childSessionFile) return;
+		try {
+			const persisted = await SessionManager.peekSessionInit(record.childSessionFile);
+			if (persisted?.init) {
+				await this.#markTerminalRef(record.id, record.ownerId, record.childSessionFile, expected, teardownDeadline);
+			}
+		} catch (error) {
+			logger.warn("vibe: failed to retain terminal worker transcript", {
+				id: record.id,
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+	}
+
+	#continueKilledCleanup(
+		record: VibeRecord,
+		jobTasks: readonly TrackedVibeTeardown[],
+		expected: AgentRef | undefined,
+	): void {
+		void Promise.allSettled(jobTasks.map(task => task.promise))
+			.then(() => this.#markTerminalRecord(record, expected, Date.now() + this.#teardownGraceMs))
+			.catch(error => {
+				logger.warn("vibe: failed to finish killed worker cleanup", {
+					id: record.id,
+					error: error instanceof Error ? error.message : String(error),
+				});
+			});
+	}
+
 	/** Build the ExecutorOptions for a first spawn, mirroring the `task`/eval-bridge plumbing. */
 	async #buildSpawnOptions(
 		session: ToolSession,

package/src/web/scrapers/hackage.ts

@@ -1,4 +1,4 @@
-import { tryParseJson } from "@oh-my-pi/pi-utils";
+import { compareVersions, tryParseJson } from "@oh-my-pi/pi-utils";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, loadPage } from "./types";
 
@@ -20,17 +20,6 @@ interface ParsedCabal {
 	stability?: string;
 }
 
-function compareVersions(a: string, b: string): number {
-	const aParts = a.split(".").map(part => Number.parseInt(part, 10) || 0);
-	const bParts = b.split(".").map(part => Number.parseInt(part, 10) || 0);
-	const max = Math.max(aParts.length, bParts.length);
-	for (let i = 0; i < max; i++) {
-		const delta = (aParts[i] || 0) - (bParts[i] || 0);
-		if (delta !== 0) return delta;
-	}
-	return 0;
-}
-
 function extractCabalField(content: string, fieldName: string): string | undefined {
 	const pattern = new RegExp(`^${fieldName}:\\s*(.*)$`, "im");
 	const match = content.match(pattern);

package/src/web/search/providers/duckduckgo.ts

@@ -372,7 +372,7 @@ export class DuckDuckGoProvider extends SearchProvider {
 		return true;
 	}
 
-	isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
+	override isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
 		return true;
 	}
 

package/src/web/search/providers/ecosia.ts

@@ -173,7 +173,7 @@ export class EcosiaProvider extends SearchProvider {
 		return true;
 	}
 
-	isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
+	override isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
 		return true;
 	}
 

package/src/web/search/providers/exa.ts

@@ -458,7 +458,7 @@ export class ExaProvider extends SearchProvider {
 	 * still uses {@link isAvailable} so an unrelated configured provider
 	 * keeps priority over the public fallback.
 	 */
-	isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
+	override isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
 		return this.#settingsAllowSearch();
 	}
 

package/src/web/search/providers/firecrawl.ts

@@ -203,7 +203,7 @@ export class FirecrawlProvider extends SearchProvider {
 	 * Firecrawl supports keyless mode, so an explicit user selection
 	 * (`webSearch: firecrawl`) works without any credential configured.
 	 */
-	isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
+	override isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
 		return true;
 	}
 

package/src/web/search/providers/mojeek.ts

@@ -210,7 +210,7 @@ export class MojeekProvider extends SearchProvider {
 		return true;
 	}
 
-	isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
+	override isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
 		return true;
 	}
 

package/src/web/search/providers/perplexity.ts

@@ -973,7 +973,7 @@ export class PerplexityProvider extends SearchProvider {
 	 * configured provider keeps priority over the anonymous/OpenRouter
 	 * fallbacks.
 	 */
-	isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
+	override isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
 		return true;
 	}
 

package/src/web/search/providers/public.ts

@@ -189,7 +189,7 @@ export class PublicWebProvider extends SearchProvider {
 		return false;
 	}
 
-	isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
+	override isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
 		return true;
 	}
 

package/src/web/search/providers/startpage.ts

@@ -215,7 +215,7 @@ export class StartpageProvider extends SearchProvider {
 		return true;
 	}
 
-	isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
+	override isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
 		return true;
 	}