swarmlancer 0.1.4 → 0.1.5

package/dist/agent.d.ts

@@ -1,4 +1,5 @@
 type LogFn = (line: string) => void;
 export declare function startAgent(log?: LogFn): void;
+export declare function sendToServer(msg: Record<string, unknown>): void;
 export declare function stopAgent(): void;
 export {};

package/dist/agent.js

@@ -1,22 +1,48 @@
 import WebSocket from "ws";
-import { getConfig, getAgentFilePath } from "./config.js";
+import { getConfig, getAgentFilePath, getLimits } from "./config.js";
 import { runInference } from "./inference.js";
 import { colors } from "./theme.js";
 let activeWs = null;
 let alive = false;
 let reconnectTimer = null;
+let idleTimer = null;
+// Session counters
+let activeConversations = new Set();
+let conversationMessageCounts = new Map();
+let totalConversations = 0;
+let lastConversationTime = 0;
+function resetCounters() {
+    activeConversations.clear();
+    conversationMessageCounts.clear();
+    totalConversations = 0;
+    lastConversationTime = 0;
+}
+function resetIdleTimer(limits, log) {
+    if (idleTimer)
+        clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+        log(colors.yellow(`⏱ Auto-stopping: idle for ${limits.autoStopIdleMinutes} minutes`));
+        stopAgent();
+    }, limits.autoStopIdleMinutes * 60 * 1000);
+}
 export function startAgent(log = console.log) {
     const config = getConfig();
+    const limits = getLimits();
     if (!config.token) {
         log(colors.red("Not logged in. Run: swarmlancer login"));
         return;
     }
+    resetCounters();
     const wsUrl = config.serverUrl.replace(/^http/, "ws") + "/ws";
     alive = true;
+    // Log limits
+    log(colors.gray(`Limits: ${limits.maxConcurrentConversations} concurrent, ${limits.maxMessagesPerConversation} msgs/convo, ${limits.cooldownSeconds}s cooldown, ${limits.maxConversationsPerSession} max/session, ${limits.autoStopIdleMinutes}m idle`));
     function connect() {
         log(colors.cyan(`Connecting to ${wsUrl}...`));
         const ws = new WebSocket(wsUrl);
         activeWs = ws;
+        // Start idle timer
+        resetIdleTimer(limits, log);
         ws.on("open", () => {
             ws.send(JSON.stringify({ type: "auth", token: config.token }));
         });
@@ -42,9 +68,69 @@ export function startAgent(log = console.log) {
                 }
                 case "inference_request": {
                     const { requestId, conversationId, systemPrompt, messages } = msg;
-                    log(colors.yellow(`💬 Inference request for conversation ${conversationId.slice(0, 8)}...`));
+                    // Reset idle timer on activity
+                    resetIdleTimer(limits, log);
+                    // Check concurrent conversation limit
+                    if (!activeConversations.has(conversationId) &&
+                        activeConversations.size >= limits.maxConcurrentConversations) {
+                        log(colors.yellow(`⚠ Skipping: ${limits.maxConcurrentConversations} concurrent conversations active`));
+                        ws.send(JSON.stringify({
+                            type: "inference_error",
+                            requestId,
+                            error: "Agent is at max concurrent conversations. Try again later.",
+                        }));
+                        break;
+                    }
+                    // Check session total limit
+                    if (!activeConversations.has(conversationId) &&
+                        totalConversations >= limits.maxConversationsPerSession) {
+                        log(colors.yellow(`⚠ Session limit reached (${limits.maxConversationsPerSession} conversations). Stopping.`));
+                        stopAgent();
+                        break;
+                    }
+                    // Check cooldown
+                    if (!activeConversations.has(conversationId) &&
+                        limits.cooldownSeconds > 0) {
+                        const elapsed = (Date.now() - lastConversationTime) / 1000;
+                        if (lastConversationTime > 0 && elapsed < limits.cooldownSeconds) {
+                            const wait = Math.ceil(limits.cooldownSeconds - elapsed);
+                            log(colors.yellow(`⚠ Cooldown: ${wait}s remaining`));
+                            ws.send(JSON.stringify({
+                                type: "inference_error",
+                                requestId,
+                                error: `Agent is in cooldown. Try again in ${wait} seconds.`,
+                            }));
+                            break;
+                        }
+                    }
+                    // Track conversation
+                    if (!activeConversations.has(conversationId)) {
+                        activeConversations.add(conversationId);
+                        conversationMessageCounts.set(conversationId, 0);
+                        totalConversations++;
+                        lastConversationTime = Date.now();
+                    }
+                    // Check per-conversation message limit
+                    const msgCount = (conversationMessageCounts.get(conversationId) ?? 0) + 1;
+                    conversationMessageCounts.set(conversationId, msgCount);
+                    if (msgCount > limits.maxMessagesPerConversation) {
+                        log(colors.yellow(`⚠ Conversation ${conversationId.slice(0, 8)} hit ${limits.maxMessagesPerConversation} message limit`));
+                        activeConversations.delete(conversationId);
+                        ws.send(JSON.stringify({
+                            type: "inference_response",
+                            requestId,
+                            content: "I've reached my message limit for this conversation. It was great talking! Feel free to connect on GitHub if you'd like to continue.",
+                        }));
+                        break;
+                    }
+                    log(colors.yellow(`💬 [${conversationId.slice(0, 8)}] msg ${msgCount}/${limits.maxMessagesPerConversation} (${activeConversations.size}/${limits.maxConcurrentConversations} active, ${totalConversations}/${limits.maxConversationsPerSession} total)`));
                     try {
-                        const response = await runInference(systemPrompt, messages);
+                        let response = await runInference(systemPrompt, messages);
+                        // Enforce response length limit
+                        if (response.length > limits.maxResponseLength) {
+                            response = response.slice(0, limits.maxResponseLength);
+                            log(colors.gray(`  (truncated to ${limits.maxResponseLength} chars)`));
+                        }
                         const preview = response.length > 80 ? response.slice(0, 80) + "..." : response;
                         log(colors.green(`✓ Response: ${preview}`));
                         ws.send(JSON.stringify({
@@ -67,6 +153,14 @@ export function startAgent(log = console.log) {
                 case "conversation_started": {
                     const { conversationId, withUser } = msg;
                     log(colors.brightGreen(`🤝 Conversation started with ${withUser.displayName} (@${withUser.githubUsername})`));
+                    resetIdleTimer(limits, log);
+                    break;
+                }
+                case "conversation_ended": {
+                    const endedId = msg.conversationId;
+                    activeConversations.delete(endedId);
+                    conversationMessageCounts.delete(endedId);
+                    log(colors.gray(`  Conversation ${endedId?.slice(0, 8)} ended (${activeConversations.size} active)`));
                     break;
                 }
                 case "error":
@@ -86,10 +180,18 @@ export function startAgent(log = console.log) {
     }
     connect();
 }
+export function sendToServer(msg) {
+    if (activeWs && activeWs.readyState === WebSocket.OPEN) {
+        activeWs.send(JSON.stringify(msg));
+    }
+}
 export function stopAgent() {
     alive = false;
     if (reconnectTimer)
         clearTimeout(reconnectTimer);
+    if (idleTimer)
+        clearTimeout(idleTimer);
     activeWs?.close();
     activeWs = null;
+    resetCounters();
 }

package/dist/app.js

@@ -1,9 +1,10 @@
 import { ProcessTerminal, TUI, Container } from "@mariozechner/pi-tui";
-import { getConfig, ensureAgentFile, getAgentFilePath, getAgentInstructions, saveAgentInstructions, } from "./config.js";
+import { getConfig, ensureAgentFile, getAgentFilePath, getAgentInstructions, saveAgentInstructions, getLimits, saveLimits, getDiscovery, saveDiscovery, } from "./config.js";
 import { login } from "./login.js";
 import { initInference, getAvailableModels } from "./inference.js";
 import { getProfile, isProfileComplete, saveProfile, } from "./profile.js";
-import { startAgent, stopAgent } from "./agent.js";
+import { startAgent, stopAgent, sendToServer } from "./agent.js";
+import { colors } from "./theme.js";
 import { BannerComponent } from "./screens/banner.js";
 import { SetupWizardScreen } from "./screens/setup-wizard.js";
 import { DashboardScreen } from "./screens/dashboard.js";
@@ -12,7 +13,11 @@ import { ProfileEditorScreen } from "./screens/profile-editor.js";
 import { ProfileViewScreen } from "./screens/profile-view.js";
 import { AgentEditorScreen } from "./screens/agent-editor.js";
 import { AgentRunningScreen } from "./screens/agent-running.js";
+import { SettingsScreen } from "./screens/settings.js";
+import { DiscoverySettingsScreen } from "./screens/discovery-settings.js";
+import { SessionGoalScreen } from "./screens/session-goal.js";
 import { MessageScreen } from "./screens/message.js";
+import { screenProfiles } from "./screening.js";
 let terminal;
 let tui;
 let selectedModel;
@@ -211,22 +216,167 @@ function runProfileView() {
     });
 }
 /**
- * Start the agent and show the live log screen.
+ * Agent limits settings screen.
  */
-function runAgent() {
+function runSettings() {
     return new Promise((resolve) => {
-        const config = getConfig();
-        const screen = new AgentRunningScreen(tui, selectedModel, config.serverUrl, getAgentFilePath());
+        const limits = getLimits();
+        const screen = new SettingsScreen(tui, limits);
+        screen.onSave = async (newLimits) => {
+            try {
+                saveLimits(newLimits);
+                await showMessage("Saved", ["Agent limits updated."], "success");
+            }
+            catch (err) {
+                await showMessage("Error", [err instanceof Error ? err.message : "Failed to save"], "error");
+            }
+            resolve();
+        };
+        screen.onCancel = () => resolve();
+        setScreen(screen);
+    });
+}
+/**
+ * Discovery settings screen.
+ */
+function runDiscoverySettings() {
+    return new Promise((resolve) => {
+        const discovery = getDiscovery();
+        const screen = new DiscoverySettingsScreen(tui, discovery);
+        screen.onSave = async (newSettings) => {
+            try {
+                saveDiscovery(newSettings);
+                await showMessage("Saved", ["Discovery settings updated."], "success");
+            }
+            catch (err) {
+                await showMessage("Error", [err instanceof Error ? err.message : "Failed to save"], "error");
+            }
+            resolve();
+        };
+        screen.onCancel = () => resolve();
+        setScreen(screen);
+    });
+}
+/**
+ * Ask for an optional session goal before starting.
+ */
+function askSessionGoal() {
+    return new Promise((resolve) => {
+        const screen = new SessionGoalScreen(tui);
+        screen.onSubmit = (goal) => resolve(goal.trim());
+        screen.onSkip = () => resolve("");
+        // Wire the editor's onSubmit
+        // The SessionGoalScreen's editor fires onSubmit on Enter
+        // We need to capture it from the screen level
+        setScreen(screen);
+    });
+}
+/**
+ * Fetch candidate profiles from the server's /api/discover endpoint.
+ */
+async function fetchCandidates() {
+    const config = getConfig();
+    const discovery = getDiscovery();
+    const params = new URLSearchParams();
+    if (discovery.onlineOnly)
+        params.set("onlineOnly", "true");
+    params.set("notContactedInDays", String(discovery.recontactAfterDays));
+    if (discovery.includeKeywords.length > 0) {
+        params.set("keywords", discovery.includeKeywords.join(","));
+    }
+    if (discovery.excludeKeywords.length > 0) {
+        params.set("excludeKeywords", discovery.excludeKeywords.join(","));
+    }
+    if (discovery.excludeUsers.length > 0) {
+        params.set("excludeUsers", discovery.excludeUsers.join(","));
+    }
+    params.set("limit", String(discovery.maxScreenPerSession));
+    const res = await fetch(`${config.serverUrl}/api/discover?${params}`, {
+        headers: { Authorization: `Bearer ${config.token}` },
+    });
+    if (!res.ok)
+        throw new Error(`Discover API error: ${res.status}`);
+    const data = (await res.json());
+    return data.profiles;
+}
+/**
+ * Start the agent: session goal → discover → screen → connect → run.
+ */
+async function runAgent() {
+    // 1. Ask for session goal
+    const sessionGoal = await askSessionGoal();
+    const config = getConfig();
+    const discovery = getDiscovery();
+    // 2. Show the running screen
+    const screen = new AgentRunningScreen(tui, selectedModel, config.serverUrl, getAgentFilePath(), sessionGoal);
+    const done = new Promise((resolve) => {
         screen.onStop = () => {
             stopAgent();
             resolve();
         };
-        setScreen(screen);
-        // Start the agent with the log callback
-        startAgent((line) => {
-            screen.addLog(line);
-        });
     });
+    setScreen(screen);
+    const log = (line) => screen.addLog(line);
+    // 3. Start the WebSocket agent (for incoming requests)
+    startAgent(log);
+    // 4. Discovery + screening (outbound)
+    screen.setStatus("discovering candidates...");
+    try {
+        const candidates = await fetchCandidates();
+        if (candidates.length === 0) {
+            log(colors.gray("No candidates match your discovery filters."));
+            log(colors.gray("Waiting for incoming conversations..."));
+            screen.setStatus("waiting for conversations...");
+        }
+        else {
+            log(colors.cyan(`📡 Found ${candidates.length} candidates, screening...`));
+            screen.setStatus(`screening ${candidates.length} profiles...`);
+            const results = await screenProfiles(candidates, sessionGoal, discovery.matchThreshold, discovery.maxScreenPerSession, (screened, total, result) => {
+                const icon = result.score >= discovery.matchThreshold
+                    ? colors.green("✓")
+                    : colors.gray("⊘");
+                const name = `@${result.profile.githubUsername}`;
+                const scoreStr = result.score >= discovery.matchThreshold
+                    ? colors.green(`${result.score}/10`)
+                    : colors.gray(`${result.score}/10`);
+                log(`  ${icon} ${name} ${scoreStr} — ${colors.gray(result.reason)}`);
+                screen.setStatus(`screening ${screened}/${total}...`);
+            });
+            const matches = results.filter((r) => r.score >= discovery.matchThreshold);
+            log("");
+            if (matches.length === 0) {
+                log(colors.yellow("No strong matches found. Waiting for incoming conversations..."));
+            }
+            else {
+                log(colors.green(`Found ${matches.length} match${matches.length === 1 ? "" : "es"}. Starting conversations...`));
+                log("");
+                // Initiate conversations with matches
+                for (const match of matches) {
+                    if (!match.profile.online) {
+                        log(colors.gray(`  ⊘ @${match.profile.githubUsername} is offline, skipping`));
+                        continue;
+                    }
+                    log(colors.cyan(`  🤝 Reaching out to @${match.profile.githubUsername} (${match.score}/10: ${match.reason})`));
+                    // Send start_conversation via WebSocket
+                    sendToServer({
+                        type: "start_conversation",
+                        withUserId: match.profile.id,
+                    });
+                    // Respect cooldown between outreach
+                    const limits = getLimits();
+                    if (limits.cooldownSeconds > 0) {
+                        await new Promise((r) => setTimeout(r, limits.cooldownSeconds * 1000));
+                    }
+                }
+            }
+            screen.setStatus(`${matches.length} matches • waiting for conversations...`);
+        }
+    }
+    catch (err) {
+        log(colors.red(`Discovery failed: ${err instanceof Error ? err.message : err}`));
+        screen.setStatus("waiting for conversations...");
+    }
+    return done;
 }
 /**
  * Main dashboard loop.
@@ -271,6 +421,12 @@ async function runDashboard() {
             case "profile-view":
                 await runProfileView();
                 break;
+            case "settings":
+                await runSettings();
+                break;
+            case "discovery":
+                await runDiscoverySettings();
+                break;
             case "quit":
                 shutdown();
                 return;

package/dist/config.d.ts

@@ -1,12 +1,38 @@
+export type AgentLimits = {
+    maxConcurrentConversations: number;
+    maxMessagesPerConversation: number;
+    maxResponseLength: number;
+    cooldownSeconds: number;
+    maxConversationsPerSession: number;
+    autoStopIdleMinutes: number;
+};
+export declare const DEFAULT_LIMITS: AgentLimits;
+export type DiscoverySettings = {
+    recontactAfterDays: number;
+    onlineOnly: boolean;
+    includeKeywords: string[];
+    excludeKeywords: string[];
+    excludeUsers: string[];
+    priorityUsers: string[];
+    matchThreshold: number;
+    maxScreenPerSession: number;
+};
+export declare const DEFAULT_DISCOVERY: DiscoverySettings;
 export type Config = {
     token?: string;
     serverUrl: string;
     userId?: string;
+    limits?: Partial<AgentLimits>;
+    discovery?: Partial<DiscoverySettings>;
 };
 export declare function getConfigDir(): string;
 export declare function getConfig(): Config;
 export declare function saveConfig(config: Config): void;
 export declare function getAgentInstructions(): string;
 export declare function getAgentFilePath(): string;
+export declare function getLimits(): AgentLimits;
+export declare function saveLimits(limits: AgentLimits): void;
+export declare function getDiscovery(): DiscoverySettings;
+export declare function saveDiscovery(discovery: DiscoverySettings): void;
 export declare function saveAgentInstructions(content: string): void;
 export declare function ensureAgentFile(): void;

package/dist/config.js

@@ -4,6 +4,24 @@ import { homedir } from "os";
 const CONFIG_DIR = join(homedir(), ".swarmlancer");
 const CONFIG_FILE = join(CONFIG_DIR, "config.json");
 const AGENT_FILE = join(CONFIG_DIR, "agent.md");
+export const DEFAULT_LIMITS = {
+    maxConcurrentConversations: 2,
+    maxMessagesPerConversation: 10,
+    maxResponseLength: 2000,
+    cooldownSeconds: 30,
+    maxConversationsPerSession: 50,
+    autoStopIdleMinutes: 60,
+};
+export const DEFAULT_DISCOVERY = {
+    recontactAfterDays: 30,
+    onlineOnly: true,
+    includeKeywords: [],
+    excludeKeywords: [],
+    excludeUsers: [],
+    priorityUsers: [],
+    matchThreshold: 7,
+    maxScreenPerSession: 50,
+};
 const DEFAULT_CONFIG = {
     serverUrl: "https://swarmlancer.com",
 };
@@ -35,6 +53,22 @@ export function getAgentInstructions() {
 export function getAgentFilePath() {
     return AGENT_FILE;
 }
+export function getLimits() {
+    const config = getConfig();
+    return { ...DEFAULT_LIMITS, ...config.limits };
+}
+export function saveLimits(limits) {
+    const config = getConfig();
+    saveConfig({ ...config, limits });
+}
+export function getDiscovery() {
+    const config = getConfig();
+    return { ...DEFAULT_DISCOVERY, ...config.discovery };
+}
+export function saveDiscovery(discovery) {
+    const config = getConfig();
+    saveConfig({ ...config, discovery });
+}
 export function saveAgentInstructions(content) {
     mkdirSync(CONFIG_DIR, { recursive: true });
     writeFileSync(AGENT_FILE, content);

package/dist/screening.d.ts

@@ -0,0 +1,20 @@
+export interface CandidateProfile {
+    id: string;
+    githubUsername: string;
+    displayName: string;
+    bio: string | null;
+    lookingFor: string | null;
+    skills: string | null;
+    projects: string | null;
+    online: boolean;
+}
+export interface ScreeningResult {
+    profile: CandidateProfile;
+    score: number;
+    reason: string;
+}
+/**
+ * Screen a batch of profiles using the LLM.
+ * Returns scored results sorted by score descending.
+ */
+export declare function screenProfiles(profiles: CandidateProfile[], sessionGoal: string, threshold: number, maxToScreen: number, onProgress?: (screened: number, total: number, result: ScreeningResult) => void): Promise<ScreeningResult[]>;

package/dist/screening.js

@@ -0,0 +1,101 @@
+import { runInference } from "./inference.js";
+import { getAgentInstructions } from "./config.js";
+const BATCH_SIZE = 10;
+/**
+ * Screen a batch of profiles using the LLM.
+ * Returns scored results sorted by score descending.
+ */
+export async function screenProfiles(profiles, sessionGoal, threshold, maxToScreen, onProgress) {
+    const agentMd = getAgentInstructions();
+    const toScreen = profiles.slice(0, maxToScreen);
+    const results = [];
+    // Process in batches
+    for (let i = 0; i < toScreen.length; i += BATCH_SIZE) {
+        const batch = toScreen.slice(i, i + BATCH_SIZE);
+        const batchResults = await screenBatch(batch, agentMd, sessionGoal);
+        for (const r of batchResults) {
+            results.push(r);
+            onProgress?.(results.length, toScreen.length, r);
+        }
+    }
+    // Sort by score descending
+    results.sort((a, b) => b.score - a.score);
+    return results;
+}
+async function screenBatch(profiles, agentMd, sessionGoal) {
+    const profileList = profiles
+        .map((p, i) => {
+        const parts = [`${i + 1}. ${p.displayName} (@${p.githubUsername})`];
+        if (p.bio)
+            parts.push(`   Bio: ${p.bio}`);
+        if (p.skills)
+            parts.push(`   Skills: ${p.skills}`);
+        if (p.projects)
+            parts.push(`   Projects: ${p.projects}`);
+        if (p.lookingFor)
+            parts.push(`   Looking for: ${p.lookingFor}`);
+        return parts.join("\n");
+    })
+        .join("\n\n");
+    const systemPrompt = `You are a networking assistant. Your job is to evaluate how relevant each person is to the user based on their profile and what the user is looking for.
+
+## About the user
+${agentMd}
+${sessionGoal ? `\n## What the user is looking for TODAY\n${sessionGoal}` : ""}
+
+## Instructions
+For each person below, respond with EXACTLY this format (one line per person):
+NUMBER|SCORE|REASON
+
+Where:
+- NUMBER is the person's number (1, 2, 3...)
+- SCORE is 1-10 (1=no overlap, 10=perfect match)
+- REASON is a brief explanation (one sentence)
+
+Be honest. Most people won't be a match. Only score 7+ if there's genuine relevance.`;
+    const userMessage = `Rate these ${profiles.length} profiles:\n\n${profileList}`;
+    try {
+        const response = await runInference(systemPrompt, [
+            { role: "user", content: userMessage },
+        ]);
+        return parseScreeningResponse(response, profiles);
+    }
+    catch (err) {
+        // If LLM fails, return all with score 0
+        return profiles.map((p) => ({
+            profile: p,
+            score: 0,
+            reason: "screening failed",
+        }));
+    }
+}
+function parseScreeningResponse(response, profiles) {
+    const results = [];
+    const lines = response.split("\n").filter((l) => l.includes("|"));
+    for (const line of lines) {
+        const parts = line.split("|").map((s) => s.trim());
+        if (parts.length < 3)
+            continue;
+        const num = parseInt(parts[0]) - 1;
+        const score = Math.max(1, Math.min(10, parseInt(parts[1]) || 1));
+        const reason = parts.slice(2).join("|").trim();
+        if (num >= 0 && num < profiles.length) {
+            results.push({
+                profile: profiles[num],
+                score,
+                reason,
+            });
+        }
+    }
+    // Add any missing profiles with score 0
+    for (let i = 0; i < profiles.length; i++) {
+        if (!results.find((r) => r.profile.id === profiles[i].id)) {
+            results.push({
+                profile: profiles[i],
+                score: 0,
+                reason: "not evaluated",
+            });
+        }
+    }
+    return results;
+}

package/dist/screens/agent-running.d.ts

@@ -8,8 +8,11 @@ export declare class AgentRunningScreen implements Component {
     private model;
     private serverUrl;
     private agentPath;
+    private sessionGoal;
+    private statusLine;
     onStop?: () => void;
-    constructor(tui: TUI, model: Model<Api>, serverUrl: string, agentPath: string);
+    constructor(tui: TUI, model: Model<Api>, serverUrl: string, agentPath: string, sessionGoal?: string);
+    setStatus(status: string): void;
     addLog(line: string): void;
     handleInput(data: string): void;
     render(width: number): string[];

package/dist/screens/agent-running.js

@@ -8,17 +8,20 @@ export class AgentRunningScreen {
     model;
     serverUrl;
     agentPath;
+    sessionGoal;
+    statusLine = "starting...";
     onStop;
-    constructor(tui, model, serverUrl, agentPath) {
+    constructor(tui, model, serverUrl, agentPath, sessionGoal = "") {
         this.tui = tui;
         this.model = model;
         this.serverUrl = serverUrl;
         this.agentPath = agentPath;
-        this.addLog(theme.accent("Agent starting..."));
-        this.addLog(`  Model:  ${colors.green(model.provider + "/" + model.id)}`);
-        this.addLog(`  Server: ${colors.green(serverUrl)}`);
-        this.addLog(`  Agent:  ${colors.green(agentPath)}`);
-        this.addLog("");
+        this.sessionGoal = sessionGoal;
+    }
+    setStatus(status) {
+        this.statusLine = status;
+        this.cachedRender = undefined;
+        this.tui.requestRender();
     }
     addLog(line) {
         this.logLines.push(line);
@@ -43,6 +46,9 @@ export class AgentRunningScreen {
         lines.push(theme.border("─".repeat(width)));
         const modelInfo = `${this.model.provider}/${this.model.id}`;
         lines.push(truncateToWidth(` ${theme.title("⚡ AGENT ONLINE")}  ${colors.gray("model:")} ${colors.green(modelInfo)}`, width));
+        if (this.sessionGoal) {
+            lines.push(truncateToWidth(` ${colors.gray("goal:")} ${colors.cyan(this.sessionGoal)}`, width));
+        }
         lines.push(theme.border("─".repeat(width)));
         lines.push("");
         // Log
@@ -52,7 +58,7 @@ export class AgentRunningScreen {
         // Footer
         lines.push("");
         lines.push(theme.border("─".repeat(width)));
-        lines.push(truncateToWidth(colors.gray(" esc/q stop agent • waiting for conversations..."), width));
+        lines.push(truncateToWidth(` ${colors.gray(this.statusLine)}  ${colors.gray("• esc/q stop")}`, width));
         this.cachedRender = lines;
         return lines;
     }

package/dist/screens/dashboard.d.ts

@@ -1,7 +1,7 @@
 import { type Component } from "@mariozechner/pi-tui";
 import type { TUI } from "@mariozechner/pi-tui";
 import { type StatusInfo } from "./status-panel.js";
-export type MenuAction = "start" | "profile-edit" | "agent-edit" | "model-pick" | "profile-view" | "quit";
+export type MenuAction = "start" | "profile-edit" | "agent-edit" | "settings" | "discovery" | "model-pick" | "profile-view" | "quit";
 export declare class DashboardScreen implements Component {
     private container;
     private statusPanel;

package/dist/screens/dashboard.js

@@ -3,9 +3,11 @@ import { colors, theme } from "../theme.js";
 import { StatusPanel } from "./status-panel.js";
 import { BannerComponent } from "./banner.js";
 const MENU_ITEMS = [
-    { value: "start", label: "Start agent", description: "Connect and start conversations" },
+    { value: "start", label: "Start agent", description: "Set goal → discover → screen → connect" },
     { value: "profile-edit", label: "Edit profile", description: "Update your public profile" },
     { value: "agent-edit", label: "Edit agent instructions", description: "Configure how your agent behaves" },
+    { value: "discovery", label: "Discovery settings", description: "Keywords, match threshold, filters" },
+    { value: "settings", label: "Agent limits", description: "Max conversations, cooldown, auto-stop" },
     { value: "model-pick", label: "Change model", description: "Pick a different LLM model" },
     { value: "profile-view", label: "View profile", description: "See your current public profile" },
     { value: "quit", label: "Quit", description: "Exit swarmlancer" },

package/dist/screens/discovery-settings.d.ts

@@ -0,0 +1,17 @@
+import { type Component } from "@mariozechner/pi-tui";
+import type { TUI } from "@mariozechner/pi-tui";
+import type { DiscoverySettings } from "../config.js";
+export declare class DiscoverySettingsScreen implements Component {
+    private tui;
+    private settings;
+    private selectedIndex;
+    private editingKeywords;
+    private keywordInput;
+    private cachedRender?;
+    onSave?: (settings: DiscoverySettings) => void;
+    onCancel?: () => void;
+    constructor(tui: TUI, settings: DiscoverySettings);
+    handleInput(data: string): void;
+    render(width: number): string[];
+    invalidate(): void;
+}

package/dist/screens/discovery-settings.js

@@ -0,0 +1,189 @@
+import { Input, matchesKey, Key, truncateToWidth, } from "@mariozechner/pi-tui";
+import { colors, theme } from "../theme.js";
+const FIELDS = [
+    {
+        key: "matchThreshold",
+        label: "Match threshold",
+        description: "1-10 — how picky your agent is (higher = fewer, better matches)",
+        type: "number", min: 1, max: 10, step: 1, suffix: "/10",
+    },
+    {
+        key: "maxScreenPerSession",
+        label: "Max profiles to screen",
+        description: "Don't burn tokens evaluating more than this per session",
+        type: "number", min: 5, max: 200, step: 5, suffix: "",
+    },
+    {
+        key: "recontactAfterDays",
+        label: "Re-contact after days",
+        description: "0 = only new people, 30 = re-engage after a month",
+        type: "number", min: 0, max: 365, step: 5, suffix: "d",
+    },
+    {
+        key: "onlineOnly",
+        label: "Online only",
+        description: "Only discover users with agents currently running",
+        type: "boolean",
+    },
+    {
+        key: "includeKeywords",
+        label: "Include keywords",
+        description: "Only profiles mentioning these (comma-separated, empty = all)",
+        type: "keywords",
+    },
+    {
+        key: "excludeKeywords",
+        label: "Exclude keywords",
+        description: "Skip profiles mentioning these (comma-separated)",
+        type: "keywords",
+    },
+];
+export class DiscoverySettingsScreen {
+    tui;
+    settings;
+    selectedIndex = 0;
+    editingKeywords = false;
+    keywordInput;
+    cachedRender;
+    onSave;
+    onCancel;
+    constructor(tui, settings) {
+        this.tui = tui;
+        this.settings = { ...settings };
+        this.keywordInput = new Input();
+    }
+    handleInput(data) {
+        // Keyword editing mode
+        if (this.editingKeywords) {
+            if (matchesKey(data, Key.enter)) {
+                const field = FIELDS[this.selectedIndex];
+                const val = this.keywordInput.getValue().split(",").map((s) => s.trim()).filter(Boolean);
+                this.settings[field.key] = val;
+                this.editingKeywords = false;
+                this.cachedRender = undefined;
+                this.tui.requestRender();
+                return;
+            }
+            if (matchesKey(data, Key.escape)) {
+                this.editingKeywords = false;
+                this.cachedRender = undefined;
+                this.tui.requestRender();
+                return;
+            }
+            this.keywordInput.handleInput(data);
+            this.cachedRender = undefined;
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, Key.escape)) {
+            this.onCancel?.();
+            return;
+        }
+        if (matchesKey(data, Key.ctrl("s"))) {
+            this.onSave?.({ ...this.settings });
+            return;
+        }
+        // Navigate
+        if (matchesKey(data, Key.up)) {
+            this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+            this.cachedRender = undefined;
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, Key.down)) {
+            this.selectedIndex = Math.min(FIELDS.length - 1, this.selectedIndex + 1);
+            this.cachedRender = undefined;
+            this.tui.requestRender();
+            return;
+        }
+        const field = FIELDS[this.selectedIndex];
+        // Enter to edit keywords or save
+        if (matchesKey(data, Key.enter)) {
+            if (field.type === "keywords") {
+                this.editingKeywords = true;
+                this.keywordInput.setValue(this.settings[field.key].join(", "));
+                this.cachedRender = undefined;
+                this.tui.requestRender();
+                return;
+            }
+            this.onSave?.({ ...this.settings });
+            return;
+        }
+        // Adjust values with left/right
+        if (matchesKey(data, Key.right) || matchesKey(data, Key.left)) {
+            const dir = matchesKey(data, Key.right) ? 1 : -1;
+            if (field.type === "boolean") {
+                this.settings[field.key] = !this.settings[field.key];
+            }
+            else if (field.type === "number") {
+                const step = field.step ?? 1;
+                const min = field.min ?? 0;
+                const max = field.max ?? 999;
+                const cur = this.settings[field.key];
+                this.settings[field.key] = Math.max(min, Math.min(max, cur + dir * step));
+            }
+            this.cachedRender = undefined;
+            this.tui.requestRender();
+        }
+    }
+    render(width) {
+        if (this.cachedRender)
+            return this.cachedRender;
+        const lines = [];
+        lines.push("");
+        lines.push(truncateToWidth(theme.border("─".repeat(width)), width));
+        lines.push(truncateToWidth(theme.title(" Discovery Settings"), width));
+        lines.push(truncateToWidth(colors.gray(" Control how your agent finds people to talk to."), width));
+        lines.push(truncateToWidth(theme.border("─".repeat(width)), width));
+        lines.push("");
+        for (let i = 0; i < FIELDS.length; i++) {
+            const f = FIELDS[i];
+            const isActive = i === this.selectedIndex;
+            const prefix = isActive ? theme.accent("▸ ") : "  ";
+            const label = isActive ? theme.accent(f.label) : f.label;
+            if (f.type === "number") {
+                const value = this.settings[f.key];
+                const pct = ((value - (f.min ?? 0)) / ((f.max ?? 100) - (f.min ?? 0)));
+                const barW = 16;
+                const filled = Math.round(pct * barW);
+                const bar = colors.cyan("█".repeat(filled)) + colors.gray("░".repeat(barW - filled));
+                const valStr = `${value}${f.suffix ?? ""}`;
+                lines.push(truncateToWidth(`${prefix}${label}`, width));
+                lines.push(truncateToWidth(`    ${colors.gray("◀")} ${bar} ${colors.gray("▶")}  ${isActive ? colors.brightCyan(valStr) : colors.gray(valStr)}`, width));
+            }
+            else if (f.type === "boolean") {
+                const value = this.settings[f.key];
+                const valStr = value ? colors.green("ON") : colors.red("OFF");
+                lines.push(truncateToWidth(`${prefix}${label}  ${colors.gray("◀")} ${valStr} ${colors.gray("▶")}`, width));
+            }
+            else if (f.type === "keywords") {
+                const value = this.settings[f.key];
+                const display = value.length > 0 ? value.join(", ") : colors.gray("(none)");
+                lines.push(truncateToWidth(`${prefix}${label}`, width));
+                if (this.editingKeywords && isActive) {
+                    const inputLines = this.keywordInput.render(width - 4);
+                    for (const il of inputLines) {
+                        lines.push(truncateToWidth(`    ${il}`, width));
+                    }
+                }
+                else {
+                    lines.push(truncateToWidth(`    ${display}`, width));
+                }
+            }
+            if (isActive) {
+                lines.push(truncateToWidth(`    ${colors.gray(f.description)}`, width));
+            }
+            lines.push("");
+        }
+        lines.push(truncateToWidth(theme.border("─".repeat(width)), width));
+        const help = this.editingKeywords
+            ? colors.gray(" type keywords, comma-separated • enter confirm • esc cancel")
+            : colors.gray(" ↑↓ select • ←→ adjust • enter edit/save • ctrl+s save • esc back");
+        lines.push(truncateToWidth(help, width));
+        this.cachedRender = lines;
+        return lines;
+    }
+    invalidate() {
+        this.cachedRender = undefined;
+    }
+}

package/dist/screens/session-goal.d.ts

@@ -0,0 +1,13 @@
+import { type Component } from "@mariozechner/pi-tui";
+import type { TUI } from "@mariozechner/pi-tui";
+export declare class SessionGoalScreen implements Component {
+    private tui;
+    private editor;
+    private cachedRender?;
+    onSubmit?: (goal: string) => void;
+    onSkip?: () => void;
+    constructor(tui: TUI);
+    handleInput(data: string): void;
+    render(width: number): string[];
+    invalidate(): void;
+}

package/dist/screens/session-goal.js

@@ -0,0 +1,61 @@
+import { Editor, matchesKey, Key, truncateToWidth, } from "@mariozechner/pi-tui";
+import { colors, theme } from "../theme.js";
+const EDITOR_THEME = {
+    borderColor: (s) => colors.cyan(s),
+    selectList: {
+        selectedPrefix: (t) => colors.cyan(t),
+        selectedText: (t) => colors.cyan(t),
+        description: (t) => colors.gray(t),
+        scrollInfo: (t) => colors.gray(t),
+        noMatch: (t) => colors.yellow(t),
+    },
+};
+export class SessionGoalScreen {
+    tui;
+    editor;
+    cachedRender;
+    onSubmit;
+    onSkip;
+    constructor(tui) {
+        this.tui = tui;
+        this.editor = new Editor(tui, EDITOR_THEME, { paddingX: 1 });
+        this.editor.disableSubmit = false; // Enter submits
+        this.editor.onSubmit = (text) => {
+            this.onSubmit?.(text);
+        };
+    }
+    handleInput(data) {
+        if (matchesKey(data, Key.escape)) {
+            this.onSkip?.();
+            return;
+        }
+        this.editor.handleInput(data);
+        this.cachedRender = undefined;
+        this.tui.requestRender();
+    }
+    render(width) {
+        if (this.cachedRender)
+            return this.cachedRender;
+        const lines = [];
+        lines.push("");
+        lines.push(truncateToWidth(theme.border("─".repeat(width)), width));
+        lines.push(truncateToWidth(theme.title(" What are you looking for today?"), width));
+        lines.push(truncateToWidth(colors.gray(" Optional — sharpens who your agent reaches out to. Leave empty to use defaults from agent.md."), width));
+        lines.push(truncateToWidth(theme.border("─".repeat(width)), width));
+        lines.push("");
+        lines.push(truncateToWidth(colors.gray(' Examples: "Rust developers for CLI collaboration" or "Anyone doing AI agents"'), width));
+        lines.push("");
+        for (const line of this.editor.render(width)) {
+            lines.push(line);
+        }
+        lines.push("");
+        lines.push(truncateToWidth(theme.border("─".repeat(width)), width));
+        lines.push(truncateToWidth(colors.gray(" enter submit • esc skip (use defaults)"), width));
+        this.cachedRender = lines;
+        return lines;
+    }
+    invalidate() {
+        this.cachedRender = undefined;
+        this.editor.invalidate();
+    }
+}

package/dist/screens/settings.d.ts

@@ -0,0 +1,15 @@
+import { type Component } from "@mariozechner/pi-tui";
+import type { TUI } from "@mariozechner/pi-tui";
+import type { AgentLimits } from "../config.js";
+export declare class SettingsScreen implements Component {
+    private tui;
+    private limits;
+    private selectedIndex;
+    private cachedRender?;
+    onSave?: (limits: AgentLimits) => void;
+    onCancel?: () => void;
+    constructor(tui: TUI, limits: AgentLimits);
+    handleInput(data: string): void;
+    render(width: number): string[];
+    invalidate(): void;
+}

package/dist/screens/settings.js

@@ -0,0 +1,126 @@
+import { matchesKey, Key, truncateToWidth, } from "@mariozechner/pi-tui";
+import { colors, theme } from "../theme.js";
+const SETTINGS = [
+    {
+        key: "maxConcurrentConversations",
+        label: "Max concurrent conversations",
+        description: "How many conversations at once",
+        min: 1, max: 10, step: 1, suffix: "",
+    },
+    {
+        key: "maxMessagesPerConversation",
+        label: "Max messages per conversation",
+        description: "Stop a conversation after this many messages",
+        min: 2, max: 50, step: 2, suffix: " msgs",
+    },
+    {
+        key: "maxResponseLength",
+        label: "Max response length",
+        description: "Truncate agent responses beyond this",
+        min: 200, max: 10000, step: 200, suffix: " chars",
+    },
+    {
+        key: "cooldownSeconds",
+        label: "Cooldown between conversations",
+        description: "Wait before starting the next one",
+        min: 0, max: 300, step: 10, suffix: "s",
+    },
+    {
+        key: "maxConversationsPerSession",
+        label: "Max conversations per session",
+        description: "Agent stops after this many total",
+        min: 1, max: 500, step: 10, suffix: "",
+    },
+    {
+        key: "autoStopIdleMinutes",
+        label: "Auto-stop after idle",
+        description: "Disconnect if no conversations for this long",
+        min: 5, max: 1440, step: 5, suffix: " min",
+    },
+];
+export class SettingsScreen {
+    tui;
+    limits;
+    selectedIndex = 0;
+    cachedRender;
+    onSave;
+    onCancel;
+    constructor(tui, limits) {
+        this.tui = tui;
+        this.limits = { ...limits };
+    }
+    handleInput(data) {
+        if (matchesKey(data, Key.escape)) {
+            this.onCancel?.();
+            return;
+        }
+        if (matchesKey(data, Key.ctrl("s")) || matchesKey(data, Key.enter)) {
+            this.onSave?.({ ...this.limits });
+            return;
+        }
+        // Navigate settings
+        if (matchesKey(data, Key.up)) {
+            this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+            this.cachedRender = undefined;
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, Key.down)) {
+            this.selectedIndex = Math.min(SETTINGS.length - 1, this.selectedIndex + 1);
+            this.cachedRender = undefined;
+            this.tui.requestRender();
+            return;
+        }
+        // Adjust value
+        const setting = SETTINGS[this.selectedIndex];
+        if (matchesKey(data, Key.right)) {
+            this.limits[setting.key] = Math.min(setting.max, this.limits[setting.key] + setting.step);
+            this.cachedRender = undefined;
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, Key.left)) {
+            this.limits[setting.key] = Math.max(setting.min, this.limits[setting.key] - setting.step);
+            this.cachedRender = undefined;
+            this.tui.requestRender();
+            return;
+        }
+    }
+    render(width) {
+        if (this.cachedRender)
+            return this.cachedRender;
+        const lines = [];
+        lines.push("");
+        lines.push(truncateToWidth(theme.border("─".repeat(width)), width));
+        lines.push(truncateToWidth(theme.title(" Agent Limits"), width));
+        lines.push(truncateToWidth(colors.gray(" Control how your agent behaves in conversations."), width));
+        lines.push(truncateToWidth(theme.border("─".repeat(width)), width));
+        lines.push("");
+        for (let i = 0; i < SETTINGS.length; i++) {
+            const s = SETTINGS[i];
+            const isActive = i === this.selectedIndex;
+            const value = this.limits[s.key];
+            const prefix = isActive ? theme.accent("▸ ") : "  ";
+            const label = isActive ? theme.accent(s.label) : s.label;
+            const valueStr = `${value}${s.suffix}`;
+            // Slider bar
+            const pct = (value - s.min) / (s.max - s.min);
+            const barWidth = 20;
+            const filled = Math.round(pct * barWidth);
+            const bar = colors.cyan("█".repeat(filled)) + colors.gray("░".repeat(barWidth - filled));
+            lines.push(truncateToWidth(`${prefix}${label}`, width));
+            lines.push(truncateToWidth(`    ${colors.gray("◀")} ${bar} ${colors.gray("▶")}  ${isActive ? colors.brightCyan(valueStr) : colors.gray(valueStr)}`, width));
+            if (isActive) {
+                lines.push(truncateToWidth(`    ${colors.gray(s.description)}`, width));
+            }
+            lines.push("");
+        }
+        lines.push(truncateToWidth(theme.border("─".repeat(width)), width));
+        lines.push(truncateToWidth(colors.gray(" ↑↓ select • ←→ adjust • enter save • esc cancel"), width));
+        this.cachedRender = lines;
+        return lines;
+    }
+    invalidate() {
+        this.cachedRender = undefined;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarmlancer",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Swarmlancer CLI — your agent, your rules. Connect your AI agent to a network of other agents.",
   "type": "module",
   "main": "dist/index.js",