lsd-pi 1.0.0 → 1.1.1

package/dist/resources/extensions/remote-questions/telegram-live-relay.js

@@ -0,0 +1,447 @@
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { resolveRemoteConfig } from "./config.js";
+import { apiRequest } from "./http-client.js";
+import { telegramPullUpdates, telegramSyncLatestUpdateId, telegramMarkConsumerSeen } from "./telegram-update-stream.js";
+const TELEGRAM_API = "https://api.telegram.org";
+const TOOL_FLUSH_MS = 2000;
+const TELEGRAM_MESSAGE_LIMIT = 4000;
+export class TelegramLiveRelay {
+    pi;
+    state = null;
+    pollTimer = null;
+    isPolling = false;
+    shuttingDown = false;
+    botUserId = null;
+    toolBuffer = [];
+    toolFlushTimer = null;
+    consumerId;
+    recentInboundFingerprints = new Map();
+    constructor(pi) {
+        this.pi = pi;
+        this.consumerId = `telegram-live:${randomUUID()}`;
+        this.state = this.readState();
+    }
+    async connect(ctx) {
+        const config = resolveRemoteConfig();
+        if (!config || config.channel !== "telegram") {
+            ctx.ui.notify("Telegram is not configured. Run /lsd remote telegram first.", "warning");
+            return;
+        }
+        try {
+            const me = await this.telegramApi(config.token, "getMe");
+            if (!me?.ok || !me?.result?.id) {
+                ctx.ui.notify("Telegram bot validation failed. Re-run /lsd remote telegram.", "error");
+                return;
+            }
+            this.botUserId = me.result.id;
+            const baseline = await telegramSyncLatestUpdateId(config.token, ["message"]);
+            telegramMarkConsumerSeen(config.token, this.consumerId, baseline);
+            const nonce = randomUUID().slice(0, 6).toUpperCase();
+            this.state = {
+                connected: false,
+                awaitingHandshake: true,
+                nonce,
+                channel: "telegram",
+                chatId: config.channelId,
+                lastUpdateId: baseline,
+                connectedAt: Date.now(),
+                sessionKey: sessionKey(),
+            };
+            this.writeState();
+            this.startPollingLoop();
+            ctx.ui.notify(`Telegram relay handshake started for chat ${config.channelId}. Confirm in Telegram with /bind ${nonce}.`, "success");
+            await this.safeSendTelegram([
+                "🔐 LSD live relay handshake",
+                "",
+                `Reply with: /bind ${nonce}`,
+                "",
+                "Only this bound chat can control the current LSD session.",
+            ].join("\n"), true);
+            this.setStatus();
+        }
+        catch (err) {
+            ctx.ui.notify(`Telegram live relay connect failed: ${this.errorMessage(err)}`, "error");
+        }
+    }
+    async disconnect(ctx, reason) {
+        const wasConnected = !!this.state?.connected;
+        this.stopPollingLoop();
+        this.flushToolBuffer();
+        if (wasConnected) {
+            const message = reason ? `Telegram live relay disconnected: ${reason}` : "Telegram live relay disconnected.";
+            ctx?.ui.notify(message, "info");
+            if (!this.shuttingDown) {
+                await this.safeSendTelegram(`🔌 ${message}`);
+            }
+        }
+        this.state = null;
+        this.writeState();
+        this.setStatus();
+    }
+    async status(ctx) {
+        if (this.state) {
+            await this.pollOnce();
+            await this.tryDirectHandshakeCatchup();
+        }
+        if (!this.state) {
+            ctx.ui.notify("Telegram live relay: disconnected. Use /lsd telegram connect.", "info");
+            return;
+        }
+        const since = new Date(this.state.connectedAt).toLocaleString();
+        ctx.ui.notify([
+            `Telegram live relay: ${this.state.connected ? "connected" : this.state.awaitingHandshake ? "awaiting handshake" : "disconnected"}`,
+            `  chat: ${this.state.chatId}`,
+            `  connected: ${since}`,
+            `  last_update_id: ${this.state.lastUpdateId}`,
+            ...(this.state.awaitingHandshake && this.state.nonce ? [`  nonce: ${this.state.nonce}`] : []),
+        ].join("\n"), "info");
+    }
+    async handleLsdTelegram(args, ctx) {
+        const trimmed = args.trim();
+        if (!trimmed.startsWith("telegram"))
+            return false;
+        const sub = trimmed.replace(/^telegram\s*/, "").trim();
+        if (sub === "" || sub === "help") {
+            ctx.ui.notify([
+                "Telegram live relay:",
+                "  /lsd telegram connect",
+                "  /lsd telegram status",
+                "  /lsd telegram disconnect",
+            ].join("\n"), "info");
+            return true;
+        }
+        if (sub === "connect") {
+            await this.connect(ctx);
+            return true;
+        }
+        if (sub === "status") {
+            await this.status(ctx);
+            return true;
+        }
+        if (sub === "disconnect") {
+            await this.disconnect(ctx);
+            return true;
+        }
+        ctx.ui.notify(`Unknown /lsd telegram subcommand: ${sub}`, "warning");
+        return true;
+    }
+    onMessageEnd(event) {
+        if (!this.state?.connected)
+            return;
+        if (event.message?.role !== "assistant")
+            return;
+        const text = extractText(event.message.content);
+        if (!text.trim())
+            return;
+        if (this.wasRecentlyReceivedFromTelegram(text))
+            return;
+        void this.safeSendTelegramChunks(text);
+    }
+    onToolExecutionStart(event) {
+        if (!this.state?.connected)
+            return;
+        this.bufferToolEvent(`🔧 ${event.toolName} started`);
+    }
+    onToolExecutionEnd(event) {
+        if (!this.state?.connected)
+            return;
+        const status = event.isError ? "❌" : "✅";
+        this.bufferToolEvent(`${status} ${event.toolName} finished`);
+    }
+    async onSessionSwitch(_event) {
+        if (!this.state?.connected)
+            return;
+        await this.disconnect(undefined, "session switched");
+    }
+    async onSessionFork(_event) {
+        if (!this.state?.connected)
+            return;
+        await this.disconnect(undefined, "session forked");
+    }
+    async onSessionShutdown(_event) {
+        this.shuttingDown = true;
+        if (!this.state?.connected)
+            return;
+        await this.disconnect(undefined, "session shutdown");
+    }
+    onSessionBeforeCompact(_event) {
+        if (!this.state?.connected)
+            return;
+        void this.safeSendTelegram("🗜️ LSD is compacting context. Relay stays connected.");
+    }
+    setStatus() {
+        this.pi.sendMessage({
+            customType: "telegram_live_relay_status",
+            content: this.state
+                ? this.state.connected
+                    ? `Telegram live relay connected (${this.state.chatId})`
+                    : this.state.awaitingHandshake
+                        ? `Telegram live relay awaiting handshake (${this.state.chatId})`
+                        : "Telegram live relay disconnected"
+                : "Telegram live relay disconnected",
+            display: false,
+            details: this.state
+                ? {
+                    connected: this.state.connected,
+                    awaitingHandshake: !!this.state.awaitingHandshake,
+                    chatId: this.state.chatId,
+                    sessionKey: this.state.sessionKey,
+                }
+                : { connected: false },
+        });
+    }
+    startPollingLoop() {
+        this.stopPollingLoop();
+        const tick = async () => {
+            if (this.isPolling || !this.state)
+                return;
+            this.isPolling = true;
+            try {
+                await this.pollOnce();
+            }
+            finally {
+                this.isPolling = false;
+                if (this.state)
+                    this.pollTimer = setTimeout(tick, 1500);
+            }
+        };
+        this.pollTimer = setTimeout(tick, 250);
+    }
+    stopPollingLoop() {
+        if (this.pollTimer)
+            clearTimeout(this.pollTimer);
+        this.pollTimer = null;
+    }
+    async pollOnce() {
+        const config = resolveRemoteConfig();
+        if (!config || config.channel !== "telegram" || !this.state)
+            return;
+        try {
+            const updates = await telegramPullUpdates(config.token, this.consumerId, ["message"]);
+            for (const update of updates) {
+                if (typeof update.update_id === "number" && update.update_id > this.state.lastUpdateId) {
+                    this.state.lastUpdateId = update.update_id;
+                }
+                await this.handleUpdate(update);
+            }
+            this.writeState();
+        }
+        catch {
+            // keep trying on next tick
+        }
+    }
+    async handleUpdate(update) {
+        if (!this.state || !update.message?.text)
+            return;
+        const msg = update.message;
+        if (String(msg.chat?.id ?? "") !== this.state.chatId)
+            return;
+        if (msg.from?.is_bot)
+            return;
+        const textRaw = msg.text ?? "";
+        const text = textRaw.trim();
+        if (!text)
+            return;
+        if (this.state.awaitingHandshake && this.state.nonce) {
+            if (text === `/bind ${this.state.nonce}`) {
+                this.state.connected = true;
+                this.state.awaitingHandshake = false;
+                delete this.state.nonce;
+                this.writeState();
+                this.setStatus();
+                await this.safeSendTelegram("🔗 LSD live relay connected. Send messages here to continue this session.", true);
+            }
+            else {
+                await this.safeSendTelegram(`🔐 Handshake pending. Reply with /bind ${this.state.nonce}`, true);
+            }
+            return;
+        }
+        if (!this.state.connected)
+            return;
+        if (text === "/disconnect") {
+            await this.safeSendTelegram("🔌 Disconnecting live relay.", true);
+            await this.disconnect(undefined, "requested from Telegram");
+            return;
+        }
+        if (text === "/status") {
+            await this.safeSendTelegram(`✅ Live relay connected. Chat ${this.state.chatId}.`, true);
+            return;
+        }
+        if (text === "/help") {
+            await this.safeSendTelegram("Commands: /status, /disconnect. Any other text is forwarded to LSD.", true);
+            return;
+        }
+        this.rememberInboundText(text);
+        await this.safeSendTelegram("📨 Message queued for LSD.", true);
+        this.pi.sendUserMessage(text, { deliverAs: "followUp" });
+    }
+    bufferToolEvent(line) {
+        this.toolBuffer.push(line);
+        if (this.toolFlushTimer)
+            return;
+        this.toolFlushTimer = setTimeout(() => this.flushToolBuffer(), TOOL_FLUSH_MS);
+    }
+    flushToolBuffer() {
+        if (this.toolFlushTimer)
+            clearTimeout(this.toolFlushTimer);
+        this.toolFlushTimer = null;
+        if (this.toolBuffer.length === 0)
+            return;
+        const lines = [...this.toolBuffer];
+        this.toolBuffer = [];
+        void this.safeSendTelegram(lines.slice(0, 12).join("\n"));
+    }
+    async tryDirectHandshakeCatchup() {
+        if (!this.state?.awaitingHandshake || !this.state.nonce)
+            return;
+        const config = resolveRemoteConfig();
+        if (!config || config.channel !== "telegram")
+            return;
+        try {
+            const res = await this.telegramApi(config.token, "getUpdates", {
+                timeout: 0,
+                allowed_updates: ["message"],
+            });
+            if (!res?.ok || !Array.isArray(res.result))
+                return;
+            const match = res.result.find((update) => {
+                const text = update.message?.text?.trim();
+                const chatId = String(update.message?.chat?.id ?? "");
+                return chatId === this.state?.chatId && text === `/bind ${this.state?.nonce}`;
+            });
+            if (!match)
+                return;
+            this.state.connected = true;
+            this.state.awaitingHandshake = false;
+            if (typeof match.update_id === "number" && match.update_id > this.state.lastUpdateId) {
+                this.state.lastUpdateId = match.update_id;
+            }
+            telegramMarkConsumerSeen(config.token, this.consumerId, this.state.lastUpdateId);
+            delete this.state.nonce;
+            this.writeState();
+            this.setStatus();
+            await this.safeSendTelegram("🔗 LSD live relay connected. Send messages here to continue this session.", true);
+        }
+        catch {
+            // best effort
+        }
+    }
+    async safeSendTelegram(text, allowDuringHandshake = false) {
+        const config = resolveRemoteConfig();
+        if (!config || config.channel !== "telegram" || !this.state)
+            return;
+        if (!allowDuringHandshake && !this.state.connected)
+            return;
+        try {
+            await this.telegramApi(config.token, "sendMessage", {
+                chat_id: this.state.chatId,
+                text,
+            });
+        }
+        catch {
+            // best effort
+        }
+    }
+    async safeSendTelegramChunks(text) {
+        const chunks = chunkText(text, TELEGRAM_MESSAGE_LIMIT);
+        for (let i = 0; i < chunks.length; i++) {
+            const prefix = chunks.length > 1 ? `(${i + 1}/${chunks.length})\n` : "";
+            await this.safeSendTelegram(prefix + chunks[i]);
+        }
+    }
+    rememberInboundText(text) {
+        const now = Date.now();
+        this.recentInboundFingerprints.set(fingerprint(text), now);
+        for (const [key, ts] of this.recentInboundFingerprints) {
+            if (now - ts > 2 * 60 * 1000)
+                this.recentInboundFingerprints.delete(key);
+        }
+    }
+    wasRecentlyReceivedFromTelegram(text) {
+        const key = fingerprint(text);
+        const ts = this.recentInboundFingerprints.get(key);
+        if (!ts)
+            return false;
+        if (Date.now() - ts > 2 * 60 * 1000) {
+            this.recentInboundFingerprints.delete(key);
+            return false;
+        }
+        return true;
+    }
+    async telegramApi(token, method, params) {
+        return apiRequest(`${TELEGRAM_API}/bot${token}/${method}`, "POST", params, { errorLabel: "Telegram API" });
+    }
+    readState() {
+        const path = relayStatePath();
+        if (!existsSync(path))
+            return null;
+        try {
+            return JSON.parse(readFileSync(path, "utf-8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    writeState() {
+        const path = relayStatePath();
+        mkdirSync(dirname(path), { recursive: true });
+        if (!this.state) {
+            try {
+                writeFileSync(path, "null\n", "utf-8");
+            }
+            catch { /* ignore */ }
+            return;
+        }
+        try {
+            writeFileSync(path, JSON.stringify(this.state, null, 2) + "\n", "utf-8");
+        }
+        catch {
+            // ignore
+        }
+    }
+    errorMessage(err) {
+        return err instanceof Error ? err.message : String(err);
+    }
+}
+function relayStatePath() {
+    return join(process.env.LSD_HOME || join(homedir(), ".lsd"), "runtime", "relay", sessionKey(), "telegram-live.json");
+}
+function sessionKey() {
+    return createHash("sha256").update(process.cwd()).digest("hex").slice(0, 12);
+}
+function fingerprint(text) {
+    return createHash("sha256").update(text.trim()).digest("hex").slice(0, 16);
+}
+function extractText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((part) => typeof part === "object" && part !== null && "type" in part)
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text ?? "")
+        .join("");
+}
+function chunkText(text, limit) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return [];
+    const chunks = [];
+    let remaining = trimmed;
+    while (remaining.length > limit) {
+        let splitAt = remaining.lastIndexOf("\n\n", limit);
+        if (splitAt < Math.floor(limit * 0.5))
+            splitAt = remaining.lastIndexOf("\n", limit);
+        if (splitAt < Math.floor(limit * 0.5))
+            splitAt = limit;
+        chunks.push(remaining.slice(0, splitAt).trim());
+        remaining = remaining.slice(splitAt).trim();
+    }
+    if (remaining)
+        chunks.push(remaining);
+    return chunks.filter(Boolean);
+}

package/dist/resources/extensions/remote-questions/telegram-update-stream.js

@@ -0,0 +1,67 @@
+import { apiRequest } from "./http-client.js";
+const TELEGRAM_API = "https://api.telegram.org";
+const MAX_BUFFERED_UPDATES = 200;
+const streams = new Map();
+function getState(token) {
+    let state = streams.get(token);
+    if (!state) {
+        state = {
+            latestUpdateId: 0,
+            fetching: null,
+            history: [],
+            consumerOffsets: new Map(),
+        };
+        streams.set(token, state);
+    }
+    return state;
+}
+export async function telegramPullUpdates(token, consumerId, allowedUpdates = ["message", "callback_query"]) {
+    const state = getState(token);
+    await syncTelegramUpdates(token, allowedUpdates);
+    const lastSeen = state.consumerOffsets.get(consumerId) ?? 0;
+    const unseen = state.history.filter((u) => u.update_id > lastSeen);
+    if (unseen.length > 0) {
+        state.consumerOffsets.set(consumerId, unseen[unseen.length - 1].update_id);
+    }
+    return unseen;
+}
+export async function telegramSyncLatestUpdateId(token, allowedUpdates = ["message", "callback_query"]) {
+    await syncTelegramUpdates(token, allowedUpdates);
+    return getState(token).latestUpdateId;
+}
+export function telegramMarkConsumerSeen(token, consumerId, updateId) {
+    const state = getState(token);
+    state.consumerOffsets.set(consumerId, updateId);
+}
+async function syncTelegramUpdates(token, allowedUpdates) {
+    const state = getState(token);
+    if (state.fetching) {
+        await state.fetching;
+        return;
+    }
+    state.fetching = (async () => {
+        const res = await apiRequest(`${TELEGRAM_API}/bot${token}/getUpdates`, "POST", {
+            offset: state.latestUpdateId + 1,
+            timeout: 0,
+            allowed_updates: allowedUpdates,
+        }, { errorLabel: "Telegram API" });
+        if (!res?.ok || !Array.isArray(res.result))
+            return;
+        for (const update of res.result) {
+            if (typeof update.update_id !== "number")
+                continue;
+            if (update.update_id > state.latestUpdateId)
+                state.latestUpdateId = update.update_id;
+            state.history.push(update);
+        }
+        if (state.history.length > MAX_BUFFERED_UPDATES) {
+            state.history.splice(0, state.history.length - MAX_BUFFERED_UPDATES);
+        }
+    })();
+    try {
+        await state.fetching;
+    }
+    finally {
+        state.fetching = null;
+    }
+}

package/dist/resources/extensions/search-the-web/native-search.js

@@ -4,7 +4,7 @@
  * Extracted from index.ts so it can be unit-tested without importing
  * the heavy tool-registration modules.
  */
-import { resolveSearchProviderFromPreferences } from "../gsd/preferences.js";
+import { resolveSearchProviderFromPreferences } from "../shared/preferences.js";
 /** Tool names for the Brave-backed custom search tools */
 export const BRAVE_TOOL_NAMES = ["search-the-web", "search_and_read"];
 /** All custom search tool names that should be disabled when native search is active */

package/dist/resources/extensions/search-the-web/provider.js

@@ -11,7 +11,6 @@
 import { AuthStorage } from '@gsd/pi-coding-agent';
 import { homedir } from 'os';
 import { join } from 'path';
-import { resolveSearchProviderFromPreferences } from '../gsd/preferences.js';
 // Compute authFilePath locally instead of importing from app-paths.ts,
 // because extensions are copied to ~/.gsd/agent/extensions/ at runtime
 // where the relative import '../../../app-paths.ts' doesn't resolve.
@@ -90,18 +89,11 @@ export function resolveSearchProvider(overridePreference) {
     if (overridePreference && VALID_PREFERENCES.has(overridePreference)) {
         pref = overridePreference;
     }
+    else if (overridePreference !== undefined && !VALID_PREFERENCES.has(overridePreference)) {
+        pref = 'auto';
+    }
     else {
-        // PREFERENCES.md takes priority over auth.json
-        const mdPref = resolveSearchProviderFromPreferences();
-        if (mdPref && mdPref !== 'auto' && mdPref !== 'native') {
-            pref = mdPref;
-        }
-        else if (overridePreference !== undefined && !VALID_PREFERENCES.has(overridePreference)) {
-            pref = 'auto';
-        }
-        else {
-            pref = getSearchProviderPreference();
-        }
+        pref = getSearchProviderPreference();
     }
     // Resolve based on preference
     if (pref === 'auto') {

package/dist/resources/extensions/shared/debug-logger.js

@@ -0,0 +1,103 @@
+import { appendFileSync, mkdirSync, readdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveProjectStateRoot } from './paths.js';
+let _enabled = false;
+let _logPath = null;
+let _startTime = 0;
+const _counters = {
+    deriveStateCalls: 0,
+    deriveStateTotalMs: 0,
+    ttsrChecks: 0,
+    ttsrTotalMs: 0,
+    ttsrPeakBuffer: 0,
+    parseRoadmapCalls: 0,
+    parseRoadmapTotalMs: 0,
+    parsePlanCalls: 0,
+    parsePlanTotalMs: 0,
+    dispatches: 0,
+    renders: 0,
+};
+const MAX_DEBUG_LOGS = 5;
+export function enableDebug(basePath) {
+    const debugDir = join(resolveProjectStateRoot(basePath), 'debug');
+    mkdirSync(debugDir, { recursive: true });
+    try {
+        const files = readdirSync(debugDir)
+            .filter(f => f.startsWith('debug-') && f.endsWith('.log'))
+            .sort();
+        while (files.length >= MAX_DEBUG_LOGS) {
+            const oldest = files.shift();
+            try {
+                unlinkSync(join(debugDir, oldest));
+            }
+            catch { }
+        }
+    }
+    catch { }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    _logPath = join(debugDir, `debug-${timestamp}.log`);
+    _startTime = Date.now();
+    _enabled = true;
+    for (const key of Object.keys(_counters)) {
+        _counters[key] = 0;
+    }
+}
+export function disableDebug() {
+    const path = _logPath;
+    _enabled = false;
+    _logPath = null;
+    _startTime = 0;
+    return path;
+}
+export function isDebugEnabled() { return _enabled; }
+export function getDebugLogPath() { return _logPath; }
+export function debugLog(event, data) {
+    if (!_enabled || !_logPath)
+        return;
+    try {
+        appendFileSync(_logPath, JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + '\n');
+    }
+    catch { }
+}
+export function debugTime(event) {
+    if (!_enabled)
+        return _noop;
+    const start = performance.now();
+    return (data) => {
+        const elapsed_ms = Math.round((performance.now() - start) * 100) / 100;
+        debugLog(event, { elapsed_ms, ...data });
+    };
+}
+export function debugCount(counter, value = 1) {
+    if (!_enabled)
+        return;
+    _counters[counter] += value;
+}
+export function debugPeak(counter, value) {
+    if (!_enabled)
+        return;
+    if (value > _counters[counter])
+        _counters[counter] = value;
+}
+export function writeDebugSummary() {
+    if (!_enabled || !_logPath)
+        return null;
+    const totalElapsed_ms = Date.now() - _startTime;
+    const avgDeriveState_ms = _counters.deriveStateCalls > 0 ? Math.round((_counters.deriveStateTotalMs / _counters.deriveStateCalls) * 100) / 100 : 0;
+    const avgTtsrCheck_ms = _counters.ttsrChecks > 0 ? Math.round((_counters.ttsrTotalMs / _counters.ttsrChecks) * 100) / 100 : 0;
+    debugLog('debug-summary', {
+        totalElapsed_ms,
+        dispatches: _counters.dispatches,
+        deriveStateCalls: _counters.deriveStateCalls,
+        avgDeriveState_ms,
+        parseRoadmapCalls: _counters.parseRoadmapCalls,
+        avgParseRoadmap_ms: _counters.parseRoadmapCalls > 0 ? Math.round((_counters.parseRoadmapTotalMs / _counters.parseRoadmapCalls) * 100) / 100 : 0,
+        parsePlanCalls: _counters.parsePlanCalls,
+        ttsrChecks: _counters.ttsrChecks,
+        avgTtsrCheck_ms,
+        ttsrPeakBuffer: _counters.ttsrPeakBuffer,
+        renders: _counters.renders,
+    });
+    return disableDebug();
+}
+function _noop(_data) { }

package/dist/resources/extensions/shared/env-utils.js

@@ -0,0 +1,17 @@
+import { readFile } from 'node:fs/promises';
+export async function checkExistingEnvKeys(keys, envFilePath) {
+    let fileContent = '';
+    try {
+        fileContent = await readFile(envFilePath, 'utf8');
+    }
+    catch { }
+    const existing = [];
+    for (const key of keys) {
+        const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(`^${escaped}\\s*=`, 'm');
+        if (regex.test(fileContent) || key in process.env) {
+            existing.push(key);
+        }
+    }
+    return existing;
+}

package/dist/resources/extensions/shared/paths.js

@@ -0,0 +1,17 @@
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+export function resolveProjectStateRoot(basePath) {
+    let current = resolve(basePath);
+    while (true) {
+        const lsdDir = join(current, '.lsd');
+        if (existsSync(lsdDir))
+            return lsdDir;
+        const legacyDir = join(current, '.gsd');
+        if (existsSync(legacyDir))
+            return legacyDir;
+        const parent = dirname(current);
+        if (parent === current)
+            return join(resolve(basePath), '.lsd');
+        current = parent;
+    }
+}