flint-agent 1.14.0 → 1.14.2

package/.env.example

@@ -72,7 +72,7 @@ INTENT_MODEL=openai/gpt-5.4-mini
 
 # Timeouts
 # AGENT_IDLE_TIMEOUT=0             # Auto-exit after N seconds idle (0=disabled)
-# AGENT_CHILD_IDLE_TIMEOUT=300     # Child agent idle timeout (seconds)
+# AGENT_CHILD_IDLE_TIMEOUT=0       # Child agent idle timeout (seconds, 0 = lives as long as the parent)
 # AGENT_CHILD_CLEANUP_DELAY=5000   # Delay before cleaning up dead children (ms)
 
 # Context management

package/CHANGELOG.md

@@ -7,6 +7,39 @@ All notable changes to Flint are written here. The format follows
 Each version is a `## [x.y.z] - YYYY-MM-DD` heading: `/update` reads these
 headings to show what changed between your version and the newest one.
 
+## [1.14.2] - 2026-10-02
+
+### Fixed
+- Child agents opened in their own window (`spawn_agent` with `visible`)
+  stay reachable. The process that opens the window exits at once, and Flint
+  took that for the agent's exit: it reported "exited", forgot the agent,
+  and `ask_agent` answered "has stopped", so every question started a new
+  agent. Whether such an agent is alive is now decided by its heartbeat, and
+  Esc stops the agent itself rather than the long-gone window launcher.
+- The API key is no longer written in plain text to a temporary `.bat` file
+  when a visible child agent starts on Windows; it is passed in the
+  environment.
+- A piece of the "loading..." splash no longer stays on the top line of the
+  console now and then: Flint waits until the splash has stopped before it
+  clears the screen.
+
+### Changed
+- A child agent lives as long as its parent instead of stopping after 60
+  seconds idle, so you can talk to it across several questions. It still
+  stops about a minute after its parent is gone. `AGENT_CHILD_IDLE_TIMEOUT`
+  turns an idle limit back on.
+
+## [1.14.1] - 2026-10-02
+
+### Fixed
+- Free mode no longer crashes the console. After `/model free` or
+  `/model free auto` chose a model, Flint stopped with React error #185, and
+  then on every start, because the chosen models are remembered. The status
+  line built its free-request counter as a new object on each check, so the
+  screen redrew without end.
+- `bin` in package.json written the way npm expects, so publishing no longer
+  warns that it was corrected.
+
 ## [1.14.0] - 2026-10-02
 
 ### Added

package/FEATURES.md

@@ -43,7 +43,7 @@
 ### 5. Multi-Agent
 - Spawn child agents with different models and profiles (`spawn_agent`)
 - `ask_agent` waits for the child's answer; `wait_tasks` waits for delegated work
-- Each child runs on its own port with its own data folder, and stops itself after an idle timeout
+- Each child runs on its own port with its own data folder, and lives as long as its parent (an idle timeout can be turned on)
 - Child agents can push datasets back to the parent
 
 ### 6. Memory & Knowledge

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flint-agent",
-  "version": "1.14.0",
+  "version": "1.14.2",
   "description": "A lightweight AI agent for the terminal that works with any LLM, free tiers included: files, commands, web, MCP",
   "type": "module",
   "main": "src/index.js",
@@ -36,7 +36,7 @@
     "vitest": "^4.0.18"
   },
   "bin": {
-    "flint": "./bin/flint.js"
+    "flint": "bin/flint.js"
   },
   "engines": {
     "node": ">=22.12.0"

package/src/api/server.js

@@ -311,6 +311,10 @@ export function startServer(port, store, processMessage, opts = {}) {
           model: s.model,
           messages: s.messages.length,
           alive: true,
+          // A parent that opened this agent in its own window only knows the
+          // pid of the window launcher, which exits at once; it learns the
+          // real one here so it can stop the agent (tools/agent-tools.js).
+          pid: process.pid,
           // A bench harness cannot sum the per-turn figures and get the truth:
           // a turn it abandoned on a timeout still spent money it never saw.
           // The session total is the only honest number, so serve it, and the

package/src/components/App.js

@@ -112,7 +112,11 @@ export function App({ store, onSubmit, onAbort, onQuit, onClipboard, onRecallQue
     careLevel: s._careLevel || null,
     spendLevel: s._spendLevel || getSpendLevel(),
     // Free mode: requests made today with a free model, of the daily limit.
-    freeQuota: config.freeChain ? { used: freeUsedToday(), limit: s._freeLimit || savedFreeLimit() } : null,
+    // Two plain numbers, not an object: the selector runs on every store
+    // check, and a fresh object each time never compares equal, so React
+    // re-rendered forever (error #185) as soon as free mode was on.
+    freeUsed: config.freeChain ? freeUsedToday() : null,
+    freeLimit: config.freeChain ? s._freeLimit || savedFreeLimit() : null,
   }));
   const { inputHistory } = ui;
 

package/src/components/LiveZone.js

@@ -221,7 +221,7 @@ export function statusText(state) {
   }
   parts.push(formatStatusLevel());
   if (state.spendLevel) parts.push(`spend: ${state.spendLevel}`);
-  if (state.freeQuota) parts.push(`free ${state.freeQuota.used}/${state.freeQuota.limit}`);
+  if (state.freeLimit != null) parts.push(`free ${state.freeUsed}/${state.freeLimit}`);
   parts.push("/help");
   return ` ${parts.join("  |  ")}`;
 }

package/src/config.js

@@ -195,7 +195,7 @@ export const config = {
     .filter(Boolean)
     .map((p) => path.resolve(p)),
   maxChildAgents: parseInt(process.env.AGENT_MAX_CHILDREN || "5", 10),
-  childIdleTimeout: parseInt(process.env.AGENT_CHILD_IDLE_TIMEOUT || "60", 10), // seconds
+  childIdleTimeout: parseInt(process.env.AGENT_CHILD_IDLE_TIMEOUT || "0", 10), // seconds, 0 = live as long as the parent
   childCleanupDelay: parseInt(process.env.AGENT_CHILD_CLEANUP_DELAY || "30000", 10), // ms before removing stopped agent from registry
   shell: process.env.AGENT_SHELL || (() => {
     if (process.platform !== "win32") return "/bin/bash";

package/src/index.js

@@ -235,6 +235,36 @@ function handleAbort() {
 // Populate header lines BEFORE Ink render so first frame is complete
 printHeader();
 
+// Longest wait for the launcher to confirm its spinner stopped. It answers in
+// a few ms; the cap only matters for a launcher that never answers.
+const LAUNCHER_RELEASE_WAIT_MS = 500;
+
+// Stop the launcher's splash spinner BEFORE clearing the screen, and wait
+// until it says it has stopped.
+//
+// The launcher spawns us with the three standard streams inherited, so it
+// cannot see our output: there is no pipe to watch. Its spinner repaints with
+// a bare \r every 120 ms. "flint:ready" used to be sent after Ink's first
+// render, so a tick landing between the clear below and that message wrote
+// "loading..." onto the top line of the cleared screen, where Ink then drew
+// its border on the same row (owner, 2026-10-02, intermittent). The launcher
+// stops the interval first and answers "flint:released" after, so once the
+// answer is here no tick can follow. The wait is capped: an older launcher
+// never answers, and a missing answer must not hold the start.
+//
+// Sent only when there is a channel: run directly (`node src/index.js`,
+// tests) there is no parent IPC and process.send is undefined, which is a
+// normal way to start Flint and must not throw.
+if (process.send) {
+  await new Promise((resolve) => {
+    const done = () => { clearTimeout(timer); process.off("message", onMessage); resolve(); };
+    const onMessage = (msg) => { if (msg && msg.type === "flint:released") done(); };
+    const timer = setTimeout(done, LAUNCHER_RELEASE_WAIT_MS);
+    process.on("message", onMessage);
+    process.send({ type: "flint:ready" });
+  });
+}
+
 // Clear entire screen (remove launcher splash) before Ink takes over
 if (cli.action !== "headless") {
   process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
@@ -245,23 +275,6 @@ if (inkInstance) {
   store.setState({ _inkClear: () => inkInstance.clear() });
 }
 
-// Tell the launcher we are drawing now, so it stops repainting its splash
-// spinner over this frame.
-//
-// The launcher spawns us with the three standard streams inherited, so it
-// cannot see our output: there is no pipe to watch. Its spinner repaints with
-// a bare \r, which the terminal reads as "back to column 0 of whatever line is
-// current now" — and once this frame exists, that is this line. The result was
-// the startup banner and the first few commands printed several times over.
-//
-// The message is sent only when there is a channel to send it on: run directly
-// (`node src/index.js`, tests, headless) there is no parent IPC and
-// process.send is undefined, which is a normal way to start Flint and must not
-// throw.
-if (process.send) {
-  process.send({ type: "flint:ready" });
-}
-
 // -- Graceful shutdown --
 
 function gracefulShutdown(signal) {

package/src/launcher.js

@@ -76,8 +76,9 @@ const _spinner = setInterval(() => {
  * streams stay inherited on purpose — piping them would cost Ink the TTY, and
  * raw-mode key handling with it.
  *
- * So the child says when it has drawn, over an IPC channel that costs nothing
- * and is invisible to the terminal. The interval is kept as a ceiling rather
+ * So the child says when it is about to draw, over an IPC channel that costs
+ * nothing and is invisible to the terminal, and waits for "flint:released"
+ * before it clears the screen. The interval is kept as a ceiling rather
  * than removed: a child that dies without saying anything must not hold the
  * event loop open, and `_released` makes the remaining ticks no-ops.
  */
@@ -100,8 +101,13 @@ function start(extraArgs = []) {
   });
   if (stdioMode) releaseTerminal();
 
+  // On "flint:ready": stop first, answer after. Once the child has the answer
+  // no tick can follow, so it can clear the screen safely (src/index.js).
   child.on("message", (msg) => {
-    if (msg && msg.type === "flint:ready") releaseTerminal();
+    if (msg && msg.type === "flint:ready") {
+      releaseTerminal();
+      try { child.send({ type: "flint:released" }); } catch {}
+    }
     if (msg && msg.type === "flint:restart" && typeof msg.sessionId === "string") resumeSessionId = msg.sessionId;
   });
 

package/src/tools/agent-tools.js

@@ -20,6 +20,16 @@ const HEARTBEAT_INTERVAL = 15000; // 15s
 const MAX_MISSED_PINGS = 3;
 let _heartbeatTimer = null;
 
+// Keep the pid a child reports in /status: for an agent in its own window it
+// is the only handle on the real process (the launcher's pid is dead).
+async function notePid(agent, res) {
+  if (!agent.visible || agent.agentPid || typeof res.json !== "function") return;
+  try {
+    const data = await res.json();
+    if (Number.isInteger(data?.pid)) agent.agentPid = data.pid;
+  } catch {}
+}
+
 // Start heartbeat monitoring for child agents
 function startChildHeartbeat(store) {
   if (_heartbeatTimer) return;
@@ -31,6 +41,7 @@ function startChildHeartbeat(store) {
           signal: AbortSignal.timeout(3000),
         });
         if (res.ok) {
+          await notePid(agent, res);
           if (agent.missedPings > 0) {
             // Recovered
             const label = agent.profile !== "generic" ? agent.profile : null;
@@ -49,6 +60,12 @@ function startChildHeartbeat(store) {
         printChildEvent(port, `connection lost (${MAX_MISSED_PINGS} missed pings)`, label);
         store.getState().finishProcess(agent.procId, null, "lost");
         activeChildren.delete(agent.procId);
+        // A visible agent has no "close" of its own to clean up after it
+        // (spawn_agent), so the heartbeat does it.
+        if (agent.visible) {
+          if (agent.taskRegId) store.getState().unregisterTask(agent.taskRegId);
+          setTimeout(() => _childAgents.delete(port), config.childCleanupDelay);
+        }
       } else {
         log.debug(`Agent@${port} no response (${agent.missedPings}/${MAX_MISSED_PINGS})`);
         printChildEvent(port, `no response (${agent.missedPings}/${MAX_MISSED_PINGS})`, label);
@@ -179,8 +196,12 @@ export function createAgentHandlers(store) {
       childEnv.AGENT_PAIRING_SECRET = pairingSecret;
       // Parent port for orphan protection heartbeat
       childEnv.AGENT_PARENT_PORT = String(config.port);
-      // Auto-exit after idle period (zombie fix)
-      childEnv.AGENT_IDLE_TIMEOUT = String(config.childIdleTimeout || 60);
+      // Idle exit, off by default (0): a child lives as long as its parent,
+      // and the parent heartbeat in index.js stops it when the parent is
+      // gone, which is what the idle exit was first added for. A 60 s default
+      // stopped children between two questions, so a conversation with one
+      // was impossible (owner, 2026-10-02). AGENT_CHILD_IDLE_TIMEOUT turns it on.
+      childEnv.AGENT_IDLE_TIMEOUT = String(config.childIdleTimeout || 0);
       // Track agent depth for child-policy enforcement
       const currentDepth = parseInt(process.env.AGENT_DEPTH || "0", 10);
       childEnv.AGENT_DEPTH = String(currentDepth + 1);
@@ -201,35 +222,25 @@ export function createAgentHandlers(store) {
 
       let child;
       if (visible && isWin) {
-        // Write a temp .bat launcher, then open it in a new window via Start-Process
-        // This ensures complete process isolation — no shared console with parent
+        // A temp .bat opened in a new window with `start`, so the child has a
+        // console of its own. The environment (API key, pairing secret) goes
+        // to cmd.exe, and `start` hands it to the new window. It used to be
+        // written into the .bat as `set` lines, which left the API key in
+        // plain text in %TEMP% for good, while Flint stores keys encrypted
+        // everywhere else (found 2026-10-02).
         const os = await import("node:os");
         const fs = await import("node:fs");
         const batPath = path.join(os.tmpdir(), `flint-agent-${assignedPort}.bat`);
         const batLines = [
           "@echo off",
           `title Flint@${assignedPort}`,
-          `set "AGENT_PORT=${assignedPort}"`,
-          `set "AGENT_PAIRING_SECRET=${pairingSecret}"`,
-          `set "AGENT_PARENT_PORT=${config.port}"`,
-          `set "AGENT_DEPTH=${childEnv.AGENT_DEPTH}"`,
-          `set "FLINT_PROVIDER=${config.provider}"`,
-          `set "FLINT_DATA_DIR=${childEnv.FLINT_DATA_DIR}"`,
+          `cd /d "${config.projectRoot}"`,
+          cmd,
         ];
-        // Pass the correct API key env var in bat file
-        if (config.apiKey) {
-          if (config.provider === "openrouter") batLines.push(`set "OPENROUTER_API_KEY=${config.apiKey}"`);
-          else if (config.provider === "openai") batLines.push(`set "OPENAI_API_KEY=${config.apiKey}"`);
-          else if (config.provider === "anthropic") batLines.push(`set "ANTHROPIC_API_KEY=${config.apiKey}"`);
-          else batLines.push(`set "OPENROUTER_API_KEY=${config.apiKey}"`);
-        }
-        if (childEnv.AGENT_DENIED_PATHS) batLines.push(`set "AGENT_DENIED_PATHS=${childEnv.AGENT_DENIED_PATHS}"`);
-        if (task_id) batLines.push(`set "AGENT_TASK_ID=${task_id}"`);
-        batLines.push(`cd /d "${config.projectRoot}"`);
-        batLines.push(cmd);
         fs.writeFileSync(batPath, batLines.join("\r\n") + "\r\n");
 
         child = spawn("cmd.exe", ["/c", "start", `"Flint@${assignedPort}"`, batPath], {
+          env: childEnv,
           stdio: "ignore",
           detached: true,
           windowsHide: true,
@@ -297,7 +308,13 @@ export function createAgentHandlers(store) {
         port: assignedPort,
         kill: () => {
           try {
-            if (process.platform === "win32" && child.pid) {
+            // A visible agent's own pid comes from its /status; child.pid is
+            // the window launcher, long gone.
+            const agentPid = _childAgents.get(assignedPort)?.agentPid;
+            if (visible && agentPid) {
+              if (process.platform === "win32") spawn("taskkill", ["/PID", String(agentPid), "/T", "/F"], { stdio: "ignore" });
+              else process.kill(agentPid, "SIGTERM");
+            } else if (process.platform === "win32" && child.pid) {
               spawn("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" });
             } else {
               child.kill("SIGTERM");
@@ -305,6 +322,7 @@ export function createAgentHandlers(store) {
           } catch {}
         },
       });
+      _childAgents.get(assignedPort).taskRegId = taskRegId;
 
       // Start heartbeat monitoring
       startChildHeartbeat(store);
@@ -325,6 +343,14 @@ export function createAgentHandlers(store) {
       }
 
       child.on("close", (code) => {
+        // A visible agent runs in a window that `start` (Windows), tmux,
+        // screen or a terminal emulator opened; the process spawned here only
+        // opens it and exits at once with 0. Taking that for the agent's exit
+        // marked a live agent stopped and forgot it 5 s later, so ask_agent
+        // answered "has stopped" and the model spawned a new agent for every
+        // question (owner, 2026-10-02). The heartbeat decides when a visible
+        // agent is gone; only a launcher that failed counts here.
+        if (visible && code === 0) return;
         activeChildren.delete(procId);
         store.getState().unregisterTask(taskRegId);
         store.getState().finishProcess(procId, code);
@@ -354,7 +380,10 @@ export function createAgentHandlers(store) {
             });
             if (res.ok) {
               const agent = _childAgents.get(assignedPort);
-              if (agent) agent.status = "running";
+              if (agent) {
+                agent.status = "running";
+                await notePid(agent, res);
+              }
               // Send the task (authenticated with pairing secret)
               const taskRes = await fetch(apiUrl(assignedPort, "/message"), {
                 method: "POST",
@@ -385,7 +414,7 @@ export function createAgentHandlers(store) {
     async ask_agent({ port, message }) {
       const agent = _childAgents.get(port);
       if (!agent) return `No agent on port ${port}. Use list_agents() to see available agents.`;
-      if (agent.status === "stopped") return `Agent@${port} has stopped. Spawn a new one.`;
+      if (agent.status === "stopped" || agent.status === "lost") return `Agent@${port} has stopped. Spawn a new one.`;
 
       // Wait for agent to be ready if it's still starting
       if (agent.status === "starting") {
@@ -393,7 +422,7 @@ export function createAgentHandlers(store) {
           await new Promise((r) => setTimeout(r, 1000));
           try {
             const check = await fetch(apiUrl(port, "/status"), { signal: AbortSignal.timeout(2000) });
-            if (check.ok) { agent.status = "running"; break; }
+            if (check.ok) { agent.status = "running"; await notePid(agent, check); break; }
           } catch {}
         }
         if (agent.status !== "running") return `Agent@${port} failed to start within 30s.`;