@seele00/seele 0.1.63 → 0.1.64

package/server/dist/codex-runtime/run-streamed-turn.js

@@ -1,587 +0,0 @@
-import { CodexAppServer, } from "@seele-codex/codex";
-import { appendFileSync } from "node:fs";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { buildRuntimeAdditionalContext, buildRuntimeThreadBootstrapInstructions, } from "../contracts/index.js";
-import { sendSse } from "../realtime/sse.js";
-const DEVELOPER_INSTRUCTIONS_DEBUG_LOG_PATH = "/tmp/seele-developer-instructions.log";
-const execFileAsync = promisify(execFile);
-export async function runStreamedTurn(config, request, response, callbacks = {}) {
-    const cwd = request.cwd ?? config.defaultCwd ?? process.cwd();
-    const globalEnvironment = describeGlobalEnvironment(config);
-    const threadBootstrapInstructions = buildRuntimeThreadBootstrapInstructions();
-    const runtimeContractContext = {
-        workspaceId: request.workspaceId,
-        workspaceTitle: request.workspaceTitle,
-        workspacePath: cwd,
-        workspaceTranscriptApiBase: request.workspaceTranscriptApiBase,
-        workspaceResponsibility: request.workspaceResponsibility,
-        workspaceKnowledge: request.workspaceKnowledge,
-        workspaceKnowledgeApiBase: request.workspaceKnowledgeApiBase,
-        globalMemory: request.globalMemory,
-        workspaceMemory: request.workspaceMemory,
-        globalMemoryItems: request.globalMemoryItems,
-        workspaceMemoryItems: request.workspaceMemoryItems,
-        globalEnvironment,
-    };
-    const runtimeAdditionalContext = buildRuntimeAdditionalContext(runtimeContractContext);
-    const appServer = new CodexAppServer({
-        codexBin: config.codexBin,
-        codexArgs: [
-            "-c",
-            "project_root_markers=[]",
-            "-c",
-            "allow_login_shell=false",
-            ...runtimeConfigurationArgs(config),
-            ...shellEnvironmentPolicyArgs(config),
-        ],
-        cwd,
-        env: codexProcessEnv(config),
-        clientInfo: {
-            name: "seele_codex",
-            title: "Seele Codex",
-            version: "0.1.0",
-        },
-    });
-    let threadId = request.threadId ?? null;
-    const assistantTextCollector = createAssistantTextCollector();
-    let activeControl = null;
-    let hardStopped = false;
-    let activeTurnId = null;
-    const pendingApprovals = new Map();
-    const emit = (event, data) => {
-        callbacks.onEvent?.(event, data);
-        if (response) {
-            sendSse(response, event, data);
-        }
-    };
-    appServer.rpc.on("stderr", (line) => emit("codex.stderr", line));
-    appServer.rpc.onRequest((serverRequest) => {
-        if (serverRequest.method === "item/commandExecution/requestApproval") {
-            void handleCommandApprovalRequest(serverRequest);
-            return;
-        }
-        appServer.rpc.respondError(serverRequest.id, -32601, `Unsupported server request: ${serverRequest.method}`);
-    });
-    appServer.rpc.onNotification((notification) => {
-        if (notification.method === "turn/started") {
-            const turn = readObject(readObject(notification.params).turn);
-            if (typeof turn.id === "string") {
-                activeTurnId = turn.id;
-            }
-        }
-        assistantTextCollector.record(notification);
-        emit("codex.notification", notification);
-    });
-    try {
-        await appServer.start();
-        emit("server.status", { status: "initialized" });
-        const approvalPolicy = request.approvalPolicy ?? approvalPolicyForSandbox(request.sandbox ?? config.defaultSandbox);
-        const threadOptions = {
-            model: request.model ?? config.defaultModel,
-            cwd,
-            approvalPolicy,
-            sandbox: request.sandbox ?? config.defaultSandbox,
-            developerInstructions: threadBootstrapInstructions,
-        };
-        let thread;
-        if (threadId) {
-            try {
-                logDeveloperInstructions("thread/resume", {
-                    threadId,
-                    workspaceId: request.workspaceId,
-                    workspaceTitle: request.workspaceTitle,
-                    cwd,
-                    developerInstructions: threadBootstrapInstructions,
-                });
-                thread = await appServer.resumeThread({
-                    threadId,
-                    ...threadOptions,
-                });
-            }
-            catch (error) {
-                if (!isArchivedSessionError(error)) {
-                    throw error;
-                }
-                emit("server.status", {
-                    status: "archived_thread_replaced",
-                    archivedThreadId: threadId,
-                });
-                threadId = null;
-                logDeveloperInstructions("thread/start", {
-                    threadId,
-                    workspaceId: request.workspaceId,
-                    workspaceTitle: request.workspaceTitle,
-                    cwd,
-                    developerInstructions: threadBootstrapInstructions,
-                });
-                thread = await appServer.startThread(threadOptions);
-            }
-        }
-        else {
-            logDeveloperInstructions("thread/start", {
-                threadId,
-                workspaceId: request.workspaceId,
-                workspaceTitle: request.workspaceTitle,
-                cwd,
-                developerInstructions: threadBootstrapInstructions,
-            });
-            thread = await appServer.startThread(threadOptions);
-        }
-        threadId = thread.id;
-        const activeThreadId = thread.id;
-        emit("server.thread", thread);
-        activeControl = {
-            steer: async (message) => {
-                if (!activeTurnId) {
-                    throw new Error("Cannot steer before the active turn id is known");
-                }
-                await appServer.steerTurn({
-                    threadId: activeThreadId,
-                    expectedTurnId: activeTurnId,
-                    input: [{ type: "text", text: message }],
-                });
-            },
-            interrupt: async () => {
-                await appServer.interruptTurn({ threadId: activeThreadId });
-            },
-            stop: async () => {
-                hardStopped = true;
-                void appServer
-                    .interruptTurn({ threadId: activeThreadId })
-                    .catch(() => undefined);
-                appServer.stop();
-            },
-            respondApproval: (requestId, decision) => {
-                const pending = pendingApprovals.get(String(requestId));
-                if (!pending) {
-                    throw new Error(`approval request not found: ${requestId}`);
-                }
-                pending.resolve(decision);
-            },
-        };
-        callbacks.onActiveTurn?.(activeControl);
-        await appServer.startTurn({
-            threadId,
-            input: [{ type: "text", text: request.message }],
-            cwd,
-            approvalPolicy,
-            model: request.model ?? config.defaultModel,
-            sandbox: request.sandbox ?? config.defaultSandbox,
-            additionalContext: mapRuntimeAdditionalContext(runtimeAdditionalContext),
-        });
-        emit("server.status", { status: "turn_started" });
-        await waitForTurnCompletion(appServer);
-        return { threadId, assistantText: assistantTextCollector.text() };
-    }
-    catch (error) {
-        if (hardStopped && threadId) {
-            emit("server.stopped", { threadId });
-            return { threadId, assistantText: assistantTextCollector.text() };
-        }
-        emit("server.error", {
-            message: error instanceof Error ? error.message : String(error),
-        });
-        return null;
-    }
-    finally {
-        for (const pending of pendingApprovals.values()) {
-            pending.reject(new Error("Codex turn ended before approval was resolved"));
-        }
-        pendingApprovals.clear();
-        if (activeControl) {
-            callbacks.onInactiveTurn?.(activeControl);
-        }
-        appServer.stop();
-    }
-    async function handleCommandApprovalRequest(serverRequest) {
-        emit("codex.server_request", {
-            requestId: serverRequest.id,
-            method: serverRequest.method,
-            params: serverRequest.params ?? null,
-        });
-        try {
-            const decision = await new Promise((resolve, reject) => {
-                pendingApprovals.set(String(serverRequest.id), {
-                    resolve,
-                    reject,
-                });
-            });
-            pendingApprovals.delete(String(serverRequest.id));
-            appServer.rpc.respond(serverRequest.id, { decision });
-            emit("server.approval.resolved", {
-                requestId: serverRequest.id,
-                decision,
-            });
-        }
-        catch (error) {
-            pendingApprovals.delete(String(serverRequest.id));
-            appServer.rpc.respond(serverRequest.id, { decision: "cancel" });
-            emit("server.approval.error", {
-                requestId: serverRequest.id,
-                message: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-}
-function logDeveloperInstructions(method, input) {
-    const entry = [
-        "===== SEELE DEBUG developerInstructions BEGIN =====",
-        `time=${new Date().toISOString()}`,
-        `method=${method}`,
-        `threadId=${input.threadId ?? "new"}`,
-        `workspaceId=${input.workspaceId ?? ""}`,
-        `workspaceTitle=${input.workspaceTitle ?? ""}`,
-        `cwd=${input.cwd}`,
-        input.developerInstructions,
-        "===== SEELE DEBUG developerInstructions END =====",
-        "",
-    ].join("\n");
-    console.log(entry);
-    appendFileSync(DEVELOPER_INSTRUCTIONS_DEBUG_LOG_PATH, entry, "utf8");
-}
-function mapRuntimeAdditionalContext(fragments) {
-    return Object.fromEntries(Object.entries(fragments).map(([key, value]) => [
-        key,
-        {
-            kind: "application",
-            value,
-        },
-    ]));
-}
-export async function rebuildRuntimeThread(config, request, injectedItems) {
-    const cwd = request.cwd ?? config.defaultCwd ?? process.cwd();
-    const threadBootstrapInstructions = buildRuntimeThreadBootstrapInstructions();
-    const appServer = new CodexAppServer({
-        codexBin: config.codexBin,
-        codexArgs: [
-            "-c",
-            "project_root_markers=[]",
-            "-c",
-            "allow_login_shell=false",
-            ...runtimeConfigurationArgs(config),
-            ...shellEnvironmentPolicyArgs(config),
-        ],
-        cwd,
-        env: codexProcessEnv(config),
-        clientInfo: {
-            name: "seele_codex",
-            title: "Seele Codex",
-            version: "0.1.0",
-        },
-    });
-    try {
-        await appServer.start();
-        const sandbox = request.sandbox ?? config.defaultSandbox;
-        const thread = await appServer.startThread({
-            model: request.model ?? config.defaultModel,
-            cwd,
-            approvalPolicy: request.approvalPolicy ?? approvalPolicyForSandbox(sandbox),
-            sandbox,
-            developerInstructions: threadBootstrapInstructions,
-        });
-        if (injectedItems.length > 0) {
-            await appServer.injectThreadItems({
-                threadId: thread.id,
-                items: injectedItems,
-            });
-        }
-        return {
-            threadId: thread.id,
-            injectedItemCount: injectedItems.length,
-        };
-    }
-    finally {
-        appServer.stop();
-    }
-}
-export async function readRuntimeThread(config, request) {
-    const cwd = request.cwd ?? config.defaultCwd ?? process.cwd();
-    const appServer = new CodexAppServer({
-        codexBin: config.codexBin,
-        codexArgs: [
-            "-c",
-            "project_root_markers=[]",
-            "-c",
-            "allow_login_shell=false",
-            ...runtimeConfigurationArgs(config),
-            ...shellEnvironmentPolicyArgs(config),
-        ],
-        cwd,
-        env: codexProcessEnv(config),
-        clientInfo: {
-            name: "seele_codex",
-            title: "Seele Codex",
-            version: "0.1.0",
-        },
-    });
-    try {
-        await appServer.start();
-        return await appServer.readThread({
-            threadId: request.threadId,
-            includeTurns: true,
-        });
-    }
-    finally {
-        appServer.stop();
-    }
-}
-export async function listRuntimeModels(config) {
-    const cwd = config.defaultCwd ?? process.cwd();
-    const codexVersion = await readCodexCliVersion(config, cwd);
-    const appServer = new CodexAppServer({
-        codexBin: config.codexBin,
-        codexArgs: [
-            "-c",
-            "project_root_markers=[]",
-            "-c",
-            "allow_login_shell=false",
-            ...shellEnvironmentPolicyArgs(config),
-        ],
-        cwd,
-        env: codexProcessEnv(config),
-        clientInfo: {
-            name: "seele_codex",
-            title: "Seele Codex",
-            version: "0.1.0",
-        },
-    });
-    try {
-        await appServer.start();
-        const models = [];
-        let cursor = null;
-        do {
-            const page = await appServer.listModels({
-                cursor,
-                limit: 100,
-                includeHidden: false,
-            });
-            models.push(...page.data);
-            cursor = page.nextCursor;
-        } while (cursor);
-        return { models, codexVersion };
-    }
-    finally {
-        appServer.stop();
-    }
-}
-export async function readRuntimeRateLimits(config) {
-    const cwd = config.defaultCwd ?? process.cwd();
-    const appServer = new CodexAppServer({
-        codexBin: config.codexBin,
-        codexArgs: [
-            "-c",
-            "project_root_markers=[]",
-            "-c",
-            "allow_login_shell=false",
-            ...shellEnvironmentPolicyArgs(config),
-        ],
-        cwd,
-        env: codexProcessEnv(config),
-        clientInfo: {
-            name: "seele_codex",
-            title: "Seele Codex",
-            version: "0.1.0",
-        },
-    });
-    try {
-        await appServer.start();
-        return await appServer.readRateLimits();
-    }
-    finally {
-        appServer.stop();
-    }
-}
-async function readCodexCliVersion(config, cwd) {
-    const { stdout, stderr } = await execFileAsync(config.codexBin ?? "codex", ["--version"], {
-        cwd,
-        env: codexProcessEnv(config),
-    });
-    return stdout.trim() || stderr.trim() || "unknown";
-}
-const SHELL_ENVIRONMENT_EXCLUDES = [
-    "*_PROXY",
-    "GIT_PROXY_COMMAND",
-];
-function approvalPolicyForSandbox(sandbox) {
-    return sandbox === "danger-full-access" ? "never" : "on-request";
-}
-function waitForTurnCompletion(appServer) {
-    return new Promise((resolve, reject) => {
-        const removeNotificationHandler = appServer.rpc.onNotification((notification) => {
-            if (notification.method === "turn/completed") {
-                cleanup();
-                resolve();
-            }
-        });
-        const onError = (error) => {
-            cleanup();
-            reject(error);
-        };
-        const onExit = (event) => {
-            cleanup();
-            reject(new Error(`codex app-server exited before turn completion: code=${event.code} signal=${event.signal}${event.stderr ? `\n${event.stderr}` : ""}`));
-        };
-        const cleanup = () => {
-            removeNotificationHandler();
-            appServer.rpc.off("error", onError);
-            appServer.rpc.off("exit", onExit);
-        };
-        appServer.rpc.on("error", onError);
-        appServer.rpc.on("exit", onExit);
-    });
-}
-function readObject(value) {
-    return value && typeof value === "object" ? value : {};
-}
-function createAssistantTextCollector() {
-    const phases = new Map();
-    const texts = new Map();
-    let anonymousFinalText = "";
-    let anonymousAssistantText = "";
-    let lastAssistantItemId = null;
-    return {
-        record(notification) {
-            const params = readObject(notification.params);
-            if (notification.method === "item/started") {
-                const item = readObject(params.item);
-                if (item.type === "agentMessage" && typeof item.id === "string") {
-                    phases.set(item.id, readAgentMessagePhase(item.phase));
-                    texts.set(item.id, "");
-                    lastAssistantItemId = item.id;
-                }
-                return;
-            }
-            if (notification.method === "item/agentMessage/delta") {
-                const delta = params.delta;
-                if (typeof delta !== "string" || !delta) {
-                    return;
-                }
-                const itemId = typeof params.itemId === "string" ? params.itemId : lastAssistantItemId;
-                if (itemId) {
-                    texts.set(itemId, `${texts.get(itemId) ?? ""}${delta}`);
-                    return;
-                }
-                if (readAgentMessagePhase(params.phase) === "final_answer") {
-                    anonymousFinalText += delta;
-                }
-                else {
-                    anonymousAssistantText += delta;
-                }
-                return;
-            }
-            if (notification.method === "item/completed") {
-                const item = readObject(params.item);
-                if (item.type !== "agentMessage" || typeof item.id !== "string") {
-                    return;
-                }
-                phases.set(item.id, readAgentMessagePhase(item.phase));
-                if (typeof item.text === "string") {
-                    texts.set(item.id, item.text);
-                }
-            }
-        },
-        text() {
-            const finalTexts = [...texts.entries()]
-                .filter(([itemId]) => phases.get(itemId) === "final_answer")
-                .map(([, value]) => value)
-                .join("")
-                .trim();
-            if (finalTexts) {
-                return finalTexts;
-            }
-            const latestNonCommentary = [...texts.entries()]
-                .filter(([itemId]) => phases.get(itemId) !== "commentary")
-                .map(([, value]) => value.trim())
-                .filter(Boolean)
-                .at(-1);
-            if (latestNonCommentary) {
-                return latestNonCommentary;
-            }
-            return (anonymousFinalText || anonymousAssistantText).trim();
-        },
-    };
-}
-function readAgentMessagePhase(value) {
-    return value === "commentary" || value === "final_answer" ? value : "unknown";
-}
-function runtimeConfigurationArgs(config) {
-    const args = [];
-    if (config.defaultReasoningEffort) {
-        args.push("-c", `model_reasoning_effort="${config.defaultReasoningEffort}"`);
-    }
-    if (config.defaultFastMode) {
-        args.push("-c", 'service_tier="fast"', "-c", "features.fast_mode=true");
-    }
-    return args;
-}
-function shellEnvironmentPolicyArgs(config) {
-    const globalKeys = Object.keys(config.globalEnvironment ?? {}).sort();
-    if (globalKeys.length === 0) {
-        return [
-            "-c",
-            'shell_environment_policy.inherit="core"',
-            "-c",
-            `shell_environment_policy.exclude=${JSON.stringify(SHELL_ENVIRONMENT_EXCLUDES)}`,
-        ];
-    }
-    return [
-        "-c",
-        'shell_environment_policy.inherit="all"',
-        "-c",
-        "shell_environment_policy.ignore_default_excludes=true",
-        "-c",
-        `shell_environment_policy.include_only=${JSON.stringify([
-            ...DEFAULT_SHELL_ENVIRONMENT_INCLUDE,
-            ...globalKeys,
-        ])}`,
-        "-c",
-        `shell_environment_policy.exclude=${JSON.stringify(SHELL_ENVIRONMENT_EXCLUDES)}`,
-    ];
-}
-function describeGlobalEnvironment(config) {
-    const descriptions = config.globalEnvironmentDescriptions ?? {};
-    return Object.keys(config.globalEnvironment ?? {}).map((key) => ({
-        key,
-        description: descriptions[key] ?? "",
-    }));
-}
-function codexProcessEnv(config) {
-    const env = {
-        ...(config.globalEnvironment ?? {}),
-        ...codexProxyEnv(config),
-    };
-    return Object.keys(env).length > 0 ? env : undefined;
-}
-function codexProxyEnv(config) {
-    if (!config.proxy) {
-        return {};
-    }
-    return {
-        ALL_PROXY: config.proxy,
-        HTTP_PROXY: config.proxy,
-        HTTPS_PROXY: config.proxy,
-        all_proxy: config.proxy,
-        http_proxy: config.proxy,
-        https_proxy: config.proxy,
-    };
-}
-const DEFAULT_SHELL_ENVIRONMENT_INCLUDE = [
-    "HOME",
-    "LANG",
-    "LC_ALL",
-    "LC_CTYPE",
-    "LOGNAME",
-    "PATH",
-    "PWD",
-    "SHELL",
-    "TEMP",
-    "TERM",
-    "TMP",
-    "TMPDIR",
-    "USER",
-];
-function isArchivedSessionError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return /session .* is archived/i.test(message);
-}

package/server/dist/config/config.js

@@ -1,71 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-export function loadConfig(env = process.env) {
-    const defaultCwd = env.SEELE_CODEX_DEFAULT_CWD ?? inferDefaultCwd();
-    const seeleRoot = env.SEELE_ROOT ?? path.join(os.homedir(), "seele");
-    const runtimeDir = env.SEELE_RUNTIME_DIR ?? path.join(seeleRoot, ".runtime");
-    const centerDbPath = env.SEELE_DB_PATH ?? path.join(seeleRoot, "seele.db");
-    const workspaceRoot = env.SEELE_CODEX_WORKSPACE_ROOT ?? path.join(seeleRoot, "workspaces");
-    const host = env.SEELE_CODEX_HOST ?? "127.0.0.1";
-    const authPassword = env.SEELE_AUTH_PASSWORD;
-    return {
-        host,
-        port: Number.parseInt(env.SEELE_CODEX_PORT ?? "3000", 10),
-        codexBin: path.join(runtimeDir, "bin", "codex"),
-        defaultCwd,
-        seeleRoot,
-        centerDbPath,
-        workspaceRoot,
-        webDistPath: env.SEELE_CODEX_WEB_DIST ?? path.join(defaultCwd, "web", "dist"),
-        publicBasePath: normalizePublicBasePath(env.SEELE_PUBLIC_BASE_PATH),
-        proxy: env.SEELE_PROXY,
-        defaultModel: env.SEELE_CODEX_DEFAULT_MODEL,
-        defaultReasoningEffort: normalizeReasoningEffort(env.SEELE_CODEX_DEFAULT_REASONING_EFFORT),
-        defaultFastMode: normalizeBoolean(env.SEELE_CODEX_FAST_MODE),
-        defaultSandbox: env.SEELE_CODEX_DEFAULT_SANDBOX ??
-            "workspace-write",
-        authUsername: env.SEELE_AUTH_USERNAME?.trim() || "admin",
-        authPassword,
-        authSessionTtlSeconds: normalizePositiveInteger(env.SEELE_AUTH_SESSION_TTL_SECONDS, 30 * 24 * 60 * 60),
-    };
-}
-export function normalizePublicBasePath(value) {
-    const trimmed = value?.trim() || "/";
-    if (!trimmed.startsWith("/") ||
-        trimmed.includes("?") ||
-        trimmed.includes("#") ||
-        trimmed.includes("\\")) {
-        throw new Error("SEELE_PUBLIC_BASE_PATH must be an absolute URL path without a query or fragment");
-    }
-    const segments = trimmed.split("/").filter(Boolean);
-    if (segments.some((segment) => segment === "." || segment === "..")) {
-        throw new Error("SEELE_PUBLIC_BASE_PATH cannot contain dot segments");
-    }
-    return segments.length === 0 ? "/" : `/${segments.join("/")}/`;
-}
-function normalizePositiveInteger(value, fallback) {
-    const parsed = Number.parseInt(value ?? "", 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-}
-function normalizeReasoningEffort(value) {
-    if (value === "minimal" ||
-        value === "low" ||
-        value === "medium" ||
-        value === "high" ||
-        value === "xhigh") {
-        return value;
-    }
-    return "medium";
-}
-function normalizeBoolean(value) {
-    if (!value) {
-        return undefined;
-    }
-    return value === "1" || value === "true" || value === "yes";
-}
-function inferDefaultCwd() {
-    if (path.basename(process.cwd()) === "server") {
-        return path.dirname(process.cwd());
-    }
-    return process.cwd();
-}

package/server/dist/contracts/artifact-rendering.js

@@ -1,14 +0,0 @@
-export function artifactRenderingContract() {
-    return {
-        id: "artifact-rendering",
-        title: "Artifact rendering",
-        body: [
-            "CAPABILITY: Seele Web can render generated image artifacts inline when you reference them in the final answer.",
-            "REQUIRED FORMAT: Supported inline image artifact extensions are .svg, .png, .jpg, .jpeg, .webp, and .gif.",
-            "REQUIRED FORMAT: Save a visual artifact as a file in the current workspace and mention it once using Markdown link syntax with a workspace-relative path, for example [usage-colors.svg](usage-colors.svg).",
-            "REQUIRED BOUNDARY: Do not expose host absolute paths such as /Users/... or /home/... in final answers unless the user explicitly asks for an absolute path.",
-            "REQUIRED BOUNDARY: Do not paste full SVG, image, or generated artifact source into the final answer unless the user explicitly asks for the source.",
-            "GUIDANCE: Use this for generated visual outputs that should appear directly in the Seele chat UI. Prefer a concise link over verbose path explanation.",
-        ],
-    };
-}

package/server/dist/contracts/global-environment.js

@@ -1,23 +0,0 @@
-export function globalEnvironmentContract(context) {
-    const variables = context.globalEnvironment
-        .slice()
-        .sort((left, right) => left.key.localeCompare(right.key));
-    return {
-        id: "global-environment",
-        title: "Global environment",
-        body: variables.length > 0
-            ? [
-                "CAPABILITY: The following Seele global environment variables are available to shell commands in this workspace:",
-                ...variables.map((item) => item.description
-                    ? `STATE ENV: ${item.key}: ${item.description}`
-                    : `STATE ENV: ${item.key}: no description provided`),
-                "REQUIRED BOUNDARY: The variable values are intentionally not shown in the prompt. Read them only from the shell environment when running commands or scripts.",
-                "REQUIRED BOUNDARY: Do not print, persist, or reveal secret values.",
-                "GUIDANCE: Use these variables when they match the task's needed credential, token, endpoint, or configuration. Do not ask the user to provide a secret again when a relevant variable is already listed here.",
-                "GUIDANCE: If the variable name is ambiguous or none of the listed variables matches the missing requirement, ask the user for clarification instead of guessing.",
-            ]
-            : [
-                "STATE: No Seele global environment variables are configured for this workspace run.",
-            ],
-    };
-}