@fickydev/pigent 0.1.13 → 0.1.15

package/AGENTS.md

@@ -26,6 +26,7 @@ Add Hono later only for webhooks, Slack, WhatsApp, admin API, health endpoints,
 - Always update `CHANGELOG.md` after working.
 - Always update `TODO.md` after working.
 - Whenever user says `remember this`, update `AGENTS.md` accordingly.
+- When user says `release package`, commit current changes, push, and publish a patch release.
 - Do not add Hono until explicitly requested.
 - Do not let channel adapters call Pi directly.
 - Do not let Pi runtime know channel secrets.

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+## 0.1.15 - 2026-05-18
+
+### Fixed
+
+- Added startup schema self-heal for shipped `agent_sessions` columns when a migration journal is ahead of the actual SQLite table.
+
+## 0.1.14 - 2026-05-18
+
 ### Added
 
 - Added `task_runs` table and `TaskRepository` for scheduled task persistence.
@@ -61,6 +69,8 @@
 - Added `/task` to Telegram bot command list (shows subcommands in help text).
 - Added `/new` Telegram command to start a fresh active chat session.
 - Added `/status` Telegram command with session/model/workspace/task info and estimated context usage.
+- Added persistent Pi session files per Pigent session so chat memory survives across messages and daemon restarts.
+- Added Pi session metadata to `/status`, with real Pi context usage when available.
 - Changed `/model` picker to use Pi's currently available models automatically when explicit `modelChoices` are not configured.
 - Kept daemon process alive after startup so CLI runs do not exit after `pigent ready`.
 

package/README.md

@@ -380,6 +380,7 @@ Planned commands:
 - Keep Telegram-specific logic inside `src/channels/telegram` or routing config.
 - Channel adapters must not call Pi directly.
 - Pi runner must not know channel secrets.
+- Pi sessions are persisted under `~/.pigent/pi-sessions` by default (`PIGENT_PI_SESSION_DIR` overrides this).
 - Use repositories for database access.
 - Keep SQLite/PostgreSQL portability in mind.
 - Never inject secrets or raw `.env` values into model prompts.

package/TODO.md

@@ -139,7 +139,10 @@
 - [x] Apply session model override
 - [x] Apply thinking level selection
 - [x] Confirm SDK APIs needed for session creation
-- [ ] Confirm persistent session manager approach
+- [x] Confirm persistent session manager approach
+- [x] Persist Pi session file path per active Pigent session
+- [x] Reuse Pi session files across messages
+- [x] Self-heal missing runtime `agent_sessions` columns after partial/mismatched migration state
 - [ ] Confirm per-agent system prompt injection
 - [ ] Confirm per-agent skills loading
 - [ ] Confirm per-agent extensions loading

package/drizzle/migrations/0005_pi_session_path.sql

@@ -0,0 +1 @@
+ALTER TABLE `agent_sessions` ADD `pi_session_path` text;

package/drizzle/migrations/meta/_journal.json

@@ -36,6 +36,13 @@
       "when": 1779099600000,
       "tag": "0004_active_agent_sessions",
       "breakpoints": true
+    },
+    {
+      "idx": 5,
+      "version": "6",
+      "when": 1779099900000,
+      "tag": "0005_pi_session_path",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fickydev/pigent",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "private": false,
   "type": "module",
   "description": "Autonomous multi-agent daemon using Pi as core execution engine.",

package/src/agents/AgentRunner.ts

@@ -104,14 +104,21 @@ export class AgentRunner {
     if (!agent) return { text: `Unknown agent: ${input.agentId}` };
 
     try {
-      const text = await this.piRunner.run({
+      const result = await this.piRunner.run({
         agent,
         profile: this.registry.getProfile(agent.profile),
         session,
         prompt: this.composePrompt(input, chatInstructions),
       });
 
-      return { text };
+      if (session.piSessionId !== result.piSessionId || session.piSessionPath !== result.piSessionPath) {
+        await this.repositories.sessions.updatePiSession(session.id, {
+          piSessionId: result.piSessionId,
+          piSessionPath: result.piSessionPath,
+        });
+      }
+
+      return { text: result.text };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
 

package/src/agents/BotCommandHandler.ts

@@ -1,7 +1,9 @@
 import { AuthStorage, ModelRegistry } from "@earendil-works/pi-coding-agent";
 import type { InboundMessage, InlineKeyboardButton } from "../channels/types";
-import type { ModelChoiceConfig } from "../config/schemas";
+import type { LoadedAgentConfig, ModelChoiceConfig, ProfileConfig } from "../config/schemas";
+import type { AgentSessionRow } from "../db/schema";
 import type { Repositories } from "../db/repositories";
+import { PiAgentRunner, type PiContextUsage } from "../pi/PiAgentRunner";
 import { getAvailableModelChoices } from "../pi/PiAvailableModels";
 import { isValidModelRef, resolveModelSelection } from "../pi/PiModelResolver";
 import type { AgentRegistry } from "./AgentRegistry";
@@ -21,6 +23,8 @@ const THINKING_LEVELS = ["off", "low", "medium", "high"] as const;
 type ThinkingLevel = (typeof THINKING_LEVELS)[number];
 
 export class BotCommandHandler {
+  private readonly piRunner = new PiAgentRunner();
+
   constructor(
     private readonly registry: AgentRegistry,
     private readonly repositories: Repositories,
@@ -134,7 +138,11 @@ export class BotCommandHandler {
     const profile = this.registry.getProfile(agent.profile);
     const messageStats = await this.repositories.messages.statsBySession(sessionResult.session.id);
     const modelInfo = this.resolveStatusModel(sessionResult.session, agent, profile);
-    const contextText = formatContext(messageStats.estimatedTokens, modelInfo.contextWindow);
+    const piStatus = await this.loadPiStatus(sessionResult.session, agent, profile);
+    const contextText = piStatus?.contextUsage
+      ? formatPiContext(piStatus.contextUsage)
+      : formatEstimatedContext(messageStats.estimatedTokens, modelInfo.contextWindow);
+    const contextSource = piStatus?.contextUsage ? "Pi session" : "Pigent DB estimate";
     const taskCount = this.scheduler
       ? this.scheduler.getTasks().filter((task) => task.chatId === message.chatId || !task.chatId).length
       : null;
@@ -151,6 +159,8 @@ export class BotCommandHandler {
       "Model: " + modelInfo.model,
       "Thinking: " + (sessionResult.session.thinkingLevel ?? agent.thinkingLevel ?? profile?.thinkingLevel ?? "default"),
       "Context: " + contextText,
+      "Context source: " + contextSource,
+      "Pi session: " + (piStatus?.piSessionId ?? sessionResult.session.piSessionId ?? "not created"),
       "Workspace: " + formatPath(agent.workspace),
       "Chat: " + message.chatId,
       "Thread: " + (message.threadId ?? "none"),
@@ -159,6 +169,14 @@ export class BotCommandHandler {
     ].join("\n");
   }
 
+  private async loadPiStatus(session: AgentSessionRow, agent: LoadedAgentConfig, profile: ProfileConfig | null) {
+    try {
+      return await this.piRunner.status({ agent, profile, session });
+    } catch {
+      return null;
+    }
+  }
+
   private resolveStatusModel(session: { model: string | null }, agent: { model?: string | null }, profile: { model?: string | null } | null) {
     const configuredModel = session.model ?? agent.model ?? profile?.model ?? null;
     if (!configuredModel) return { model: "default", contextWindow: null as number | null };
@@ -455,7 +473,15 @@ function chunk<T>(items: T[], size: number): T[][] {
   return rows;
 }
 
-function formatContext(tokens: number, contextWindow: number | null): string {
+function formatPiContext(contextUsage: PiContextUsage): string {
+  if (contextUsage.percent === null || contextUsage.tokens === null) {
+    return "? / " + formatTokens(contextUsage.contextWindow);
+  }
+
+  return contextUsage.percent.toFixed(1) + "% / " + formatTokens(contextUsage.contextWindow);
+}
+
+function formatEstimatedContext(tokens: number, contextWindow: number | null): string {
   if (!contextWindow || contextWindow <= 0) {
     return "~" + formatTokens(tokens) + " tokens estimated / unknown limit";
   }

package/src/db/client.ts

@@ -18,9 +18,23 @@ export const sqlite = new Database(databasePath);
 export const db = drizzle(sqlite, { schema });
 
 migrate(db, { migrationsFolder: "./drizzle/migrations" });
+ensureRuntimeSchema();
 
 export type DbClient = typeof db;
 
 export function getDatabasePath(): string {
   return databasePath;
 }
+
+function ensureRuntimeSchema(): void {
+  ensureColumn("agent_sessions", "active", "ALTER TABLE `agent_sessions` ADD `active` integer DEFAULT true NOT NULL");
+  ensureColumn("agent_sessions", "ended_at", "ALTER TABLE `agent_sessions` ADD `ended_at` integer");
+  ensureColumn("agent_sessions", "pi_session_path", "ALTER TABLE `agent_sessions` ADD `pi_session_path` text");
+}
+
+function ensureColumn(table: string, column: string, statement: string): void {
+  const columns = sqlite.query<{ name: string }, []>(`PRAGMA table_info(${table})`).all();
+  if (!columns.some((item) => item.name === column)) {
+    sqlite.exec(statement);
+  }
+}

package/src/db/repositories/SessionRepository.ts

@@ -62,6 +62,19 @@ export class SessionRepository {
     return this.requireById(id);
   }
 
+  async updatePiSession(id: string, input: { piSessionId: string; piSessionPath: string }): Promise<AgentSessionRow> {
+    await this.db
+      .update(agentSessions)
+      .set({
+        piSessionId: input.piSessionId,
+        piSessionPath: input.piSessionPath,
+        updatedAt: Date.now(),
+      })
+      .where(eq(agentSessions.id, id));
+
+    return this.requireById(id);
+  }
+
   async findById(id: string): Promise<AgentSessionRow | null> {
     const row = await this.db.query.agentSessions.findFirst({
       where: eq(agentSessions.id, id),

package/src/db/schema.ts

@@ -47,6 +47,7 @@ export const agentSessions = sqliteTable(
     threadId: text("thread_id"),
     userId: text("user_id"),
     piSessionId: text("pi_session_id"),
+    piSessionPath: text("pi_session_path"),
     instructionsHash: text("instructions_hash"),
     model: text("model"),
     thinkingLevel: text("thinking_level", { enum: ["off", "low", "medium", "high"] }),

package/src/pi/PiAgentRunner.ts

@@ -4,7 +4,6 @@ import {
   DefaultResourceLoader,
   ModelRegistry,
   getAgentDir,
-  SessionManager,
   SettingsManager,
 } from "@earendil-works/pi-coding-agent";
 import { mkdir } from "node:fs/promises";
@@ -12,6 +11,7 @@ import { resolve } from "node:path";
 import type { LoadedAgentConfig, ProfileConfig } from "../config/schemas";
 import type { AgentSessionRow } from "../db/schema";
 import { resolveModelSelection } from "./PiModelResolver";
+import { loadOrCreatePiSession } from "./PiSessionFactory";
 
 export type PiAgentRunInput = {
   agent: LoadedAgentConfig;
@@ -20,8 +20,58 @@ export type PiAgentRunInput = {
   prompt: string;
 };
 
+export type PiContextUsage = {
+  tokens: number | null;
+  contextWindow: number;
+  percent: number | null;
+};
+
+export type PiAgentRunResult = {
+  text: string;
+  piSessionId: string;
+  piSessionPath: string;
+  contextUsage?: PiContextUsage;
+};
+
+export type PiSessionStatus = {
+  piSessionId: string;
+  piSessionPath: string;
+  contextUsage?: PiContextUsage;
+};
+
 export class PiAgentRunner {
-  async run(input: PiAgentRunInput): Promise<string> {
+  async run(input: PiAgentRunInput): Promise<PiAgentRunResult> {
+    const prepared = await this.prepare(input);
+
+    let response = "";
+    prepared.session.subscribe((event) => {
+      if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+        response += event.assistantMessageEvent.delta;
+      }
+    });
+
+    await prepared.session.prompt(input.prompt);
+
+    return {
+      text: response.trim() || "(no response)",
+      piSessionId: prepared.piSession.sessionId,
+      piSessionPath: prepared.piSession.sessionPath,
+      contextUsage: prepared.session.getContextUsage(),
+    };
+  }
+
+  async status(input: Omit<PiAgentRunInput, "prompt">): Promise<PiSessionStatus | null> {
+    if (!input.session.piSessionPath) return null;
+
+    const prepared = await this.prepare({ ...input, prompt: "" });
+    return {
+      piSessionId: prepared.piSession.sessionId,
+      piSessionPath: prepared.piSession.sessionPath,
+      contextUsage: prepared.session.getContextUsage(),
+    };
+  }
+
+  private async prepare(input: PiAgentRunInput) {
     const workspace = resolve(input.agent.workspace);
     await mkdir(workspace, { recursive: true });
 
@@ -41,6 +91,7 @@ export class PiAgentRunner {
     const authStorage = AuthStorage.create();
     const modelRegistry = ModelRegistry.create(authStorage);
     const modelSelection = resolveModelSelection(modelRegistry, [input.session, input.agent, input.profile ?? {}]);
+    const piSession = await loadOrCreatePiSession(workspace, input.session);
     const { session } = await createAgentSession({
       cwd: workspace,
       authStorage,
@@ -48,22 +99,13 @@ export class PiAgentRunner {
       model: modelSelection.model,
       thinkingLevel: modelSelection.thinkingLevel,
       resourceLoader,
-      sessionManager: SessionManager.create(workspace),
+      sessionManager: piSession.manager,
       settingsManager,
       agentDir,
       tools: [],
     });
 
-    let response = "";
-    session.subscribe((event) => {
-      if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
-        response += event.assistantMessageEvent.delta;
-      }
-    });
-
-    await session.prompt(input.prompt);
-
-    return response.trim() || "(no response)";
+    return { session, piSession };
   }
 }
 

package/src/pi/PiSessionFactory.ts

@@ -0,0 +1,49 @@
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import type { AgentSessionRow } from "../db/schema";
+
+export type PiSessionHandle = {
+  manager: SessionManager;
+  sessionId: string;
+  sessionPath: string;
+  created: boolean;
+};
+
+export async function loadOrCreatePiSession(workspace: string, session: AgentSessionRow): Promise<PiSessionHandle> {
+  const sessionDir = piSessionDir();
+  await mkdir(sessionDir, { recursive: true });
+
+  if (session.piSessionPath && existsSync(session.piSessionPath)) {
+    const manager = SessionManager.open(session.piSessionPath, sessionDir, workspace);
+    return {
+      manager,
+      sessionId: manager.getSessionId(),
+      sessionPath: manager.getSessionFile() ?? session.piSessionPath,
+      created: false,
+    };
+  }
+
+  const manager = SessionManager.create(workspace, sessionDir);
+  manager.newSession({ id: session.piSessionId ?? session.id });
+
+  const sessionPath = manager.getSessionFile();
+  if (!sessionPath) {
+    throw new Error("failed to create persisted Pi session file");
+  }
+
+  await mkdir(dirname(sessionPath), { recursive: true });
+
+  return {
+    manager,
+    sessionId: manager.getSessionId(),
+    sessionPath,
+    created: true,
+  };
+}
+
+export function piSessionDir(): string {
+  return resolve(process.env.PIGENT_PI_SESSION_DIR ?? join(process.env.PIGENT_HOME ?? join(homedir(), ".pigent"), "pi-sessions"));
+}