@fickydev/pigent 0.1.0 → 0.1.2

package/.env.example

@@ -17,6 +17,6 @@ PIGENT_FAKE_AGENT=0
 # Set to 1 to use fake responses if Pi SDK execution fails.
 PIGENT_FALLBACK_FAKE_AGENT=1
 # Set to 1 to auto-create DB chat routing for new Telegram chats.
-PIGENT_AUTO_SETUP_CHATS=0
+PIGENT_AUTO_SETUP_CHATS=1
 # Agent used when auto-creating chat routing. Defaults to first loaded agent.
-PIGENT_AUTO_SETUP_DEFAULT_AGENT=coder
+PIGENT_AUTO_SETUP_DEFAULT_AGENT=assistant

package/CHANGELOG.md

@@ -12,7 +12,7 @@
 - Added project planning docs: `PLAN.md`, `TODO.md`, and `AGENTS.md`.
 - Added Bun TypeScript project skeleton with startup/shutdown flow.
 - Added config schemas and filesystem config loader.
-- Added example coder agent and software engineer profile.
+- Added example generic assistant agent and profile.
 - Added Drizzle SQLite schema, migration config, and repositories.
 - Added channel abstraction and Telegram polling adapter skeleton.
 - Added Telegram Bot API wrapper for `getUpdates` and `sendMessage`.
@@ -27,6 +27,14 @@
 - Added optional automatic Telegram chat setup via `PIGENT_AUTO_SETUP_CHATS`.
 - Set default workspace root to `~/.pigent` and added tilde expansion for agent workspaces.
 - Added npm package metadata and MIT license for publishing.
+- Added automatic user service install/start flow for `bunx @fickydev/pigent`.
+- Added `pigent update` to back up the app, refresh shipped files from the latest package, preserve user config/state, and restart the service.
+- Changed default agent to generic `Assistant` and enabled automatic chat setup by default.
+- Renamed default agent/profile files to `agents/assistant` and `profiles/assistant.yaml`.
+- Added short `pigent` command shim for `status`, `logs`, `start`, `stop`, `restart`, `update`, and `setup`.
+- Simplified published CLI flow so `bunx @fickydev/pigent` runs setup and starts Pigent without install/start/typecheck prompts.
+- Added automatic database migrations at daemon startup.
+- Kept daemon process alive after startup so CLI runs do not exit after `pigent ready`.
 
 ### Changed
 

package/README.md

@@ -71,30 +71,48 @@ src/
 
 ## Setup And Run
 
-From a published package, one command can create a project, run setup, and start the daemon:
+Install and start Pigent as a user service:
 
 ```bash
-bunx @fickydev/pigent my-pigent
+bunx @fickydev/pigent
 ```
 
-From a checked-out repo, one command handles setup when needed, then starts the daemon:
+Default app directory:
+
+```text
+~/.pigent/app
+```
+
+After install, use short commands:
 
 ```bash
-bun run run
+pigent status
+pigent logs
+pigent stop
+pigent start
+pigent restart
+pigent update
+pigent setup
+```
+
+Update to latest package:
+
+```bash
+pigent update
 ```
 
-Reconfigure anytime:
+`pigent update` backs up the app, preserves `.env`, SQLite DB, `pigent.yaml`, `agents/`, and `profiles/`, refreshes shipped files, and restarts the service.
+
+Run in foreground instead of installing a service:
 
 ```bash
-bun run run -- --setup
-# or, with bunx after publish:
-bunx @fickydev/pigent my-pigent --setup
+bunx @fickydev/pigent run
 ```
 
-Skip slow setup steps when needed:
+From a checked-out repo:
 
 ```bash
-bun run run -- --skip-install --skip-migrate --skip-typecheck
+bun run run
 ```
 
 The setup flow will:
@@ -106,9 +124,7 @@ The setup flow will:
 - optionally enable automatic Telegram chat setup
 - optionally configure Telegram chat routing in `pigent.yaml`
 - optionally configure log level and Telegram polling values in custom mode
-- optionally install dependencies
-- optionally apply database migrations
-- optionally run typecheck
+Database migrations run automatically at daemon startup. The published CLI does not ask users to run `bun install`, `bun start`, or `bun typecheck`.
 
 Manual setup:
 
@@ -127,8 +143,8 @@ TELEGRAM_BOT_TOKEN=
 PIGENT_WORKSPACE_ROOT=~/.pigent
 PIGENT_FAKE_AGENT=0
 PIGENT_FALLBACK_FAKE_AGENT=1
-PIGENT_AUTO_SETUP_CHATS=0
-PIGENT_AUTO_SETUP_DEFAULT_AGENT=coder
+PIGENT_AUTO_SETUP_CHATS=1
+PIGENT_AUTO_SETUP_DEFAULT_AGENT=assistant
 ```
 
 Start daemon directly after setup:
@@ -195,9 +211,9 @@ Edit `pigent.yaml`:
 telegramChats:
   - chatId: "123456"
     title: Ficky Private Chat
-    defaultAgent: coder
+    defaultAgent: assistant
     allowedAgents:
-      - coder
+      - assistant
     instructions: |
       Be concise.
 ```
@@ -221,17 +237,17 @@ hello
 ```
 
 ```text
-@coder review this
+@assistant review this
 ```
 
 ```text
-/agent coder write a test
+/agent assistant write a test
 ```
 
 With `PIGENT_FAKE_AGENT=1`, expected fake runner response:
 
 ```text
-[Code Agent] fake runner received: hello
+[Assistant] fake runner received: hello
 ```
 
 With `PIGENT_FAKE_AGENT=0`, Pigent calls the Pi SDK and returns the Pi assistant response.
@@ -241,23 +257,23 @@ With `PIGENT_FAKE_AGENT=0`, Pigent calls the Pi SDK and returns the Pi assistant
 Example agent lives at:
 
 ```text
-agents/coder/agent.yaml
-agents/coder/SYSTEM.md
+agents/assistant/agent.yaml
+agents/assistant/SYSTEM.md
 ```
 
 Example profile:
 
 ```text
-profiles/software-engineer.yaml
+profiles/assistant.yaml
 ```
 
 Agent config shape:
 
 ```yaml
-id: coder
-name: Code Agent
-profile: software-engineer
-workspace: ~/.pigent/workspaces/coder
+id: assistant
+name: Assistant
+profile: generic-assistant
+workspace: ~/.pigent/workspaces/assistant
 systemPromptFile: ./SYSTEM.md
 skills: []
 extensions: []
@@ -284,13 +300,13 @@ Enable in `.env`:
 
 ```env
 PIGENT_AUTO_SETUP_CHATS=1
-PIGENT_AUTO_SETUP_DEFAULT_AGENT=coder
+PIGENT_AUTO_SETUP_DEFAULT_AGENT=assistant
 ```
 
 When a new Telegram chat sends any message Pigent receives, the daemon inserts a chat config into SQLite with:
 
-- `defaultAgent: coder`
-- `allowedAgents: [coder]`
+- `defaultAgent: assistant`
+- `allowedAgents: [assistant]`
 - `enabled: true`
 
 This does not write to `pigent.yaml`; it creates runtime DB config only. Keep it off for stricter production setups.

package/TODO.md

@@ -2,6 +2,11 @@
 
 ## Now
 
+- [x] Add `pigent update` command
+- [x] Add user service install/start/status/logs CLI
+- [x] Add `pigent` command shim
+- [x] Remove install/migrate/typecheck prompts from published run flow
+- [x] Add automatic startup migrations
 - [x] Add `bunx @fickydev/pigent <dir>` scaffold/setup/run command
 - [x] Add one-command setup-and-run CLI
 - [x] Add interactive setup CLI
@@ -15,6 +20,7 @@
 - [x] Add `.env.example`
 - [x] Add `.gitignore`
 - [x] Add basic `src/main.ts`
+- [x] Keep daemon alive after startup
 - [x] Add graceful shutdown handling
 
 ## Dependencies
@@ -41,9 +47,10 @@
 - [x] Implement config loader
 - [x] Load configs from `agents/*/agent.yaml`
 - [x] Load profiles from `profiles/*.yaml`
-- [x] Add example `agents/coder/agent.yaml`
-- [x] Add example `agents/coder/SYSTEM.md`
-- [x] Add example `profiles/software-engineer.yaml`
+- [x] Rename default agent/profile files to assistant
+- [x] Add example generic assistant agent config
+- [x] Add example generic assistant system prompt
+- [x] Add example generic assistant profile
 
 ## Database
 

package/agents/assistant/SYSTEM.md

@@ -0,0 +1,3 @@
+You are Assistant, a helpful general-purpose agent.
+
+Be concise, practical, and friendly. Help with questions, planning, writing, debugging, and everyday tasks. Ask before risky or destructive actions.

package/agents/{coder → assistant}/agent.yaml

@@ -1,7 +1,7 @@
-id: coder
-name: Code Agent
-profile: software-engineer
-workspace: ~/.pigent/workspaces/coder
+id: assistant
+name: Assistant
+profile: generic-assistant
+workspace: ~/.pigent/workspaces/assistant
 systemPromptFile: ./SYSTEM.md
 skills: []
 extensions: []

package/package.json

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

package/pigent.yaml

@@ -5,8 +5,8 @@ telegramChats: []
 # telegramChats:
 #   - chatId: "123456"
 #     title: Example Private Chat
-#     defaultAgent: coder
+#     defaultAgent: assistant
 #     allowedAgents:
-#       - coder
+#       - assistant
 #     instructions: |
 #       Be concise.

package/profiles/assistant.yaml

@@ -0,0 +1,11 @@
+id: generic-assistant
+name: Generic Assistant
+model: null
+instructions: |
+  You are a helpful general-purpose assistant.
+  Prefer concise, useful answers. Ask clarifying questions only when needed.
+defaultSkills: []
+defaultExtensions: []
+permissions:
+  canRunShell: false
+  canEditFiles: false

package/src/cli/run.ts

@@ -1,39 +1,153 @@
 #!/usr/bin/env bun
 import { $ } from "bun";
 import { existsSync } from "node:fs";
-import { cp, mkdir } from "node:fs/promises";
+import { chmod, cp, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
+const packageName = "@fickydev/pigent";
+const serviceName = "pigent";
+const defaultRoot = join(homedir(), ".pigent");
+const defaultAppDir = join(defaultRoot, "app");
+const defaultLogPath = join(defaultRoot, "pigent.log");
 const args = process.argv.slice(2);
-const flags = new Set(args.filter((arg) => arg.startsWith("--")));
-const targetDirArg = args.find((arg) => !arg.startsWith("--"));
-const forceSetup = flags.has("--setup") || flags.has("--reconfigure");
-const skipInstall = flags.has("--skip-install");
-const skipMigrate = flags.has("--skip-migrate");
-const skipTypecheck = flags.has("--skip-typecheck");
+const commands = new Set([
+  "install",
+  "setup",
+  "start",
+  "stop",
+  "restart",
+  "status",
+  "logs",
+  "run",
+  "foreground",
+  "update",
+  "help",
+]);
+const command = commands.has(args[0] ?? "") ? args[0] : null;
+const targetDirArg = args.find((arg, index) => !arg.startsWith("--") && !(index === 0 && command));
+const appDir = targetDirArg ? resolve(process.cwd(), targetDirArg) : defaultAppDir;
 
 async function main(): Promise<void> {
-  if (targetDirArg) {
-    const targetDir = resolve(process.cwd(), targetDirArg);
-    await ensureProject(targetDir);
-    process.chdir(targetDir);
+  switch (command) {
+    case "help":
+      printHelp();
+      return;
+    case "setup":
+      await ensureConfiguredApp(appDir, true);
+      return;
+    case "install":
+      await installAndStartService(appDir);
+      return;
+    case "start":
+      await startService(appDir);
+      return;
+    case "stop":
+      await systemctl("stop");
+      return;
+    case "restart":
+      await systemctl("restart");
+      return;
+    case "status":
+      await systemctl("status", false);
+      return;
+    case "logs":
+      await showLogs();
+      return;
+    case "update":
+      await updateApp(appDir);
+      return;
+    case "run":
+    case "foreground":
+      await runForeground(resolveForegroundDir());
+      return;
+    default:
+      await installAndStartService(appDir);
   }
+}
+
+async function installAndStartService(targetDir: string): Promise<void> {
+  await ensureConfiguredApp(targetDir, true);
+
+  if (!(await hasSystemctl())) {
+    console.log("[pigent] systemd user service unavailable; running in foreground");
+    await runForeground(targetDir);
+    return;
+  }
+
+  await installCommandShim();
+  await writeServiceFile(targetDir);
+  await systemctl("daemon-reload");
+  await systemctl("enable", true, `${serviceName}.service`);
+  await systemctl("restart");
+
+  console.log("\nPigent installed and running.");
+  console.log("Commands:");
+  console.log("  pigent status");
+  console.log("  pigent logs");
+  console.log("  pigent stop");
+  console.log("  pigent restart");
+  console.log("  pigent update");
+}
+
+async function startService(targetDir: string): Promise<void> {
+  if (!existsSync(servicePath())) {
+    await installAndStartService(targetDir);
+    return;
+  }
+
+  await systemctl("start");
+}
+
+async function updateApp(targetDir: string): Promise<void> {
+  console.log("[pigent] updating app");
+
+  if (await hasSystemctl()) {
+    await systemctl("stop", true);
+  }
+
+  await mkdir(defaultRoot, { recursive: true });
+  await installCommandShim();
+  await refreshProject(targetDir);
+
+  if (await hasSystemctl()) {
+    await writeServiceFile(targetDir);
+    await systemctl("daemon-reload");
+    await systemctl("enable", true, `${serviceName}.service`);
+    await systemctl("restart");
+    console.log("[pigent] updated and restarted service");
+  } else {
+    console.log("[pigent] updated. Run `pigent run` to start foreground daemon.");
+  }
+}
 
-  const { runSetup } = await import("./setup");
+async function ensureConfiguredApp(targetDir: string, interactive: boolean): Promise<void> {
+  await ensureProject(targetDir);
+  process.chdir(targetDir);
 
-  if (forceSetup || needsSetup(process.cwd())) {
-    await runSetup({ skipInstall, skipMigrate, skipTypecheck });
+  if (interactive || needsSetup(targetDir)) {
+    const { runSetup } = await import("./setup");
+    await runSetup();
   }
+}
 
-  await $`bun run src/main.ts`;
+async function runForeground(targetDir: string): Promise<void> {
+  await ensureProject(targetDir);
+  process.chdir(targetDir);
+
+  if (needsSetup(targetDir)) {
+    const { runSetup } = await import("./setup");
+    await runSetup();
+  }
+
+  await import("../main");
 }
 
 async function ensureProject(targetDir: string): Promise<void> {
   await mkdir(targetDir, { recursive: true });
 
   if (existsSync(join(targetDir, "package.json"))) {
-    console.log(`[pigent] using existing project ${targetDir}`);
     return;
   }
 
@@ -47,6 +161,105 @@ async function ensureProject(targetDir: string): Promise<void> {
   });
 }
 
+async function refreshProject(targetDir: string): Promise<void> {
+  const sourceRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+  const backupDir = join(defaultRoot, "backups", `app-${timestamp()}`);
+
+  if (existsSync(targetDir)) {
+    await mkdir(dirname(backupDir), { recursive: true });
+    await cp(targetDir, backupDir, { recursive: true, force: false });
+    console.log(`[pigent] backup created ${backupDir}`);
+  }
+
+  await mkdir(targetDir, { recursive: true });
+
+  const preserved = [".env", "pigent.db", "pigent.db-shm", "pigent.db-wal", "pigent.yaml", "agents", "profiles"];
+  const tempPreserveDir = join(defaultRoot, ".update-preserve");
+  await rm(tempPreserveDir, { recursive: true, force: true });
+  await mkdir(tempPreserveDir, { recursive: true });
+
+  for (const entry of preserved) {
+    const source = join(targetDir, entry);
+    if (existsSync(source)) {
+      await rename(source, join(tempPreserveDir, entry));
+    }
+  }
+
+  await cp(sourceRoot, targetDir, {
+    recursive: true,
+    force: true,
+    filter: (source) => shouldCopy(sourceRoot, source),
+  });
+
+  for (const entry of preserved) {
+    const source = join(tempPreserveDir, entry);
+    if (existsSync(source)) {
+      await rm(join(targetDir, entry), { recursive: true, force: true });
+      await rename(source, join(targetDir, entry));
+    }
+  }
+
+  await rm(tempPreserveDir, { recursive: true, force: true });
+}
+
+async function installCommandShim(): Promise<void> {
+  const binDir = join(homedir(), ".local", "bin");
+  const shimPath = join(binDir, "pigent");
+  await mkdir(binDir, { recursive: true });
+  await writeFile(shimPath, `#!/usr/bin/env sh\nexec bunx ${packageName}@latest "$@"\n`);
+  await chmod(shimPath, 0o755);
+
+  const pathParts = (process.env.PATH ?? "").split(":");
+  if (!pathParts.includes(binDir)) {
+    console.log(`[pigent] add ${binDir} to PATH to use the pigent command from new shells`);
+  }
+}
+
+async function writeServiceFile(targetDir: string): Promise<void> {
+  const pathValue = process.env.PATH ?? "";
+  const bunPath = process.execPath;
+  await mkdir(dirname(servicePath()), { recursive: true });
+  await writeFile(
+    servicePath(),
+    `[Unit]\nDescription=Pigent autonomous agent daemon\nAfter=network-online.target\nWants=network-online.target\n\n[Service]\nType=simple\nWorkingDirectory=${targetDir}\nExecStart=${bunPath} run src/main.ts\nRestart=always\nRestartSec=5\nEnvironment=NODE_ENV=production\nEnvironment=PATH=${pathValue}\n\n[Install]\nWantedBy=default.target\n`,
+  );
+}
+
+async function showLogs(): Promise<void> {
+  if (await hasSystemctl()) {
+    await $`systemctl --user status ${serviceName}.service`.nothrow().quiet();
+    await $`journalctl --user -u ${serviceName}.service -f`;
+    return;
+  }
+
+  if (existsSync(defaultLogPath)) {
+    console.log(await readFile(defaultLogPath, "utf8"));
+    return;
+  }
+
+  console.log("No logs found.");
+}
+
+async function systemctl(action: string, nothrow = false, extra?: string): Promise<void> {
+  const commandArgs = extra ? [action, extra] : [action, `${serviceName}.service`];
+  const proc = $`systemctl --user ${commandArgs}`;
+  if (nothrow) {
+    await proc.nothrow();
+  } else {
+    await proc;
+  }
+}
+
+async function hasSystemctl(): Promise<boolean> {
+  if (!existsSync("/bin/systemctl") && !existsSync("/usr/bin/systemctl")) return false;
+  const result = await $`systemctl --user show-environment`.nothrow().quiet();
+  return result.exitCode === 0;
+}
+
+function servicePath(): string {
+  return join(homedir(), ".config", "systemd", "user", `${serviceName}.service`);
+}
+
 function shouldCopy(sourceRoot: string, source: string): boolean {
   const relative = source.slice(sourceRoot.length).replace(/^\/+/, "");
   if (!relative) return true;
@@ -66,9 +279,25 @@ function shouldCopy(sourceRoot: string, source: string): boolean {
 }
 
 function needsSetup(rootDir: string): boolean {
-  if (!existsSync(join(rootDir, ".env"))) return true;
-  if (!existsSync(join(rootDir, "pigent.db"))) return true;
-  return false;
+  return !existsSync(join(rootDir, ".env"));
+}
+
+function resolveForegroundDir(): string {
+  if (targetDirArg) return appDir;
+  if (looksLikePigentProject(process.cwd())) return process.cwd();
+  return defaultAppDir;
+}
+
+function looksLikePigentProject(rootDir: string): boolean {
+  return existsSync(join(rootDir, "pigent.yaml")) && existsSync(join(rootDir, "agents"));
+}
+
+function timestamp(): string {
+  return new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+
+function printHelp(): void {
+  console.log(`Pigent\n\nUsage:\n  pigent                 Install/start user service in ~/.pigent/app\n  pigent install         Install/start user service\n  pigent setup           Reconfigure app\n  pigent start           Start service\n  pigent stop            Stop service\n  pigent restart         Restart service\n  pigent status          Show service status\n  pigent logs            Follow service logs\n  pigent update          Update app from latest package and restart\n  pigent run             Run foreground daemon\n\nWith bunx:\n  bunx ${packageName}\n  bunx ${packageName} status\n`);
 }
 
 main().catch((error) => {

package/src/cli/setup.ts

@@ -1,7 +1,6 @@
 import { existsSync } from "node:fs";
 import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { $ } from "bun";
 import YAML from "yaml";
 
 const rootDir = process.cwd();
@@ -15,11 +14,7 @@ export type SetupOptions = {
   skipTypecheck?: boolean;
 };
 
-export async function runSetup(options: SetupOptions = {}): Promise<void> {
-  const skipInstall = options.skipInstall ?? false;
-  const skipMigrate = options.skipMigrate ?? false;
-  const skipTypecheck = options.skipTypecheck ?? false;
-
+export async function runSetup(_options: SetupOptions = {}): Promise<void> {
   banner();
 
   const mode = select("Setup mode", ["quick", "custom"], "quick");
@@ -29,30 +24,12 @@ export async function runSetup(options: SetupOptions = {}): Promise<void> {
   await configureEnvironment(isCustom);
   await configureTelegramChat(isCustom);
 
-  if (!skipInstall && confirm("Install dependencies?", true)) {
-    await runStep("Install dependencies", async () => {
-      await $`bun install`;
-    });
-  }
-
-  if (!skipMigrate && confirm("Apply database migrations?", true)) {
-    await runStep("Apply database migrations", async () => {
-      await $`bun run db:migrate`;
-    });
-  }
-
-  if (!skipTypecheck && confirm("Run typecheck?", true)) {
-    await runStep("Typecheck", async () => {
-      await $`bun run typecheck`;
-    });
-  }
-
   summary();
 }
 
 function banner(): void {
-  console.log("\nPigent interactive setup");
-  console.log("------------------------");
+  console.log("\nPigent setup");
+  console.log("------------");
 }
 
 async function ensureEnvFile(): Promise<void> {
@@ -89,16 +66,8 @@ async function configureEnvironment(isCustom: boolean): Promise<void> {
     }
   }
 
-  if (confirm("Auto-configure new Telegram chats?", getEnvValue(env, "PIGENT_AUTO_SETUP_CHATS") === "1")) {
-    env = setEnvValue(env, "PIGENT_AUTO_SETUP_CHATS", "1");
-    env = setEnvValue(
-      env,
-      "PIGENT_AUTO_SETUP_DEFAULT_AGENT",
-      input("Auto-setup default agent", getEnvValue(env, "PIGENT_AUTO_SETUP_DEFAULT_AGENT") ?? "coder"),
-    );
-  } else {
-    env = setEnvValue(env, "PIGENT_AUTO_SETUP_CHATS", "0");
-  }
+  env = setEnvValue(env, "PIGENT_AUTO_SETUP_CHATS", "1");
+  env = setEnvValue(env, "PIGENT_AUTO_SETUP_DEFAULT_AGENT", getEnvValue(env, "PIGENT_AUTO_SETUP_DEFAULT_AGENT") ?? "assistant");
 
   if (isCustom) {
     env = setEnvValue(env, "LOG_LEVEL", select("Log level", ["debug", "info", "warn", "error"], getEnvValue(env, "LOG_LEVEL") ?? "info"));
@@ -135,8 +104,8 @@ async function configureTelegramChat(isCustom: boolean): Promise<void> {
     return;
   }
 
-  const title = input("Chat title", "");
-  const defaultAgent = input("Default agent", "coder") || "coder";
+  const title = input("Chat title", "Home");
+  const defaultAgent = input("Default agent", "assistant") || "assistant";
   const allowedAgentsInput = input("Allowed agents, comma-separated", defaultAgent);
   const instructions = isCustom ? inputMultiline("Chat instructions", "") : "";
   const allowedAgents = allowedAgentsInput
@@ -172,11 +141,6 @@ async function configureTelegramChat(isCustom: boolean): Promise<void> {
   log(`Configured Telegram chat ${chatId}`);
 }
 
-async function runStep(name: string, step: () => Promise<void>): Promise<void> {
-  log(name);
-  await step();
-}
-
 function input(label: string, defaultValue: string): string {
   const suffix = defaultValue ? ` [${defaultValue}]` : "";
   const value = prompt(`${label}${suffix}:`)?.trim();
@@ -236,11 +200,7 @@ function setEnvValue(content: string, key: string, value: string): string {
 }
 
 function summary(): void {
-  console.log("\nSetup complete");
-  console.log("--------------");
-  console.log("Start daemon: bun run start");
-  console.log("Dev mode:     bun run dev");
-  console.log("Typecheck:    bun run typecheck");
+  console.log("\nSetup complete. Starting Pigent...\n");
 }
 
 function log(message: string): void {
@@ -248,13 +208,7 @@ function log(message: string): void {
 }
 
 if (import.meta.main) {
-  const flags = new Set(process.argv.slice(2));
-
-  runSetup({
-    skipInstall: flags.has("--skip-install"),
-    skipMigrate: flags.has("--skip-migrate"),
-    skipTypecheck: flags.has("--skip-typecheck"),
-  }).catch((error) => {
+  runSetup().catch((error) => {
     console.error("[setup] failed", error instanceof Error ? error.message : error);
     process.exit(1);
   });

package/src/db/client.ts

@@ -2,6 +2,7 @@ import { mkdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { Database } from "bun:sqlite";
 import { drizzle } from "drizzle-orm/bun-sqlite";
+import { migrate } from "drizzle-orm/bun-sqlite/migrator";
 import * as schema from "./schema";
 
 function databasePathFromEnv(): string {
@@ -16,6 +17,8 @@ mkdirSync(dirname(databasePath), { recursive: true });
 export const sqlite = new Database(databasePath);
 export const db = drizzle(sqlite, { schema });
 
+migrate(db, { migrationsFolder: "./drizzle/migrations" });
+
 export type DbClient = typeof db;
 
 export function getDatabasePath(): string {

package/src/db/repositories/TelegramRepository.ts

@@ -63,8 +63,8 @@ export class TelegramRepository {
 
     const raw = message.raw as { chat?: { title?: string; username?: string; first_name?: string; last_name?: string } } | null;
     const title = raw?.chat
-      ? raw.chat.title ?? [raw.chat.first_name, raw.chat.last_name].filter(Boolean).join(" ") ?? raw.chat.username
-      : undefined;
+      ? raw.chat.title ?? [raw.chat.first_name, raw.chat.last_name].filter(Boolean).join(" ") ?? raw.chat.username ?? "Home"
+      : "Home";
 
     await this.upsertConfiguredChat({
       chatId: message.chatId,

package/src/main.ts

@@ -25,10 +25,19 @@ async function shutdown(signal: string): Promise<void> {
 process.on("SIGINT", () => void shutdown("SIGINT"));
 process.on("SIGTERM", () => void shutdown("SIGTERM"));
 
+function keepAlive(): Promise<never> {
+  return new Promise(() => {
+    setInterval(() => {
+      // Keep daemon process alive even when no adapter currently has an active handle.
+    }, 60_000);
+  });
+}
+
 try {
   logger.info("pigent starting");
   await daemon.start();
   logger.info("pigent ready");
+  await keepAlive();
 } catch (error) {
   logger.error("pigent failed to start", {
     error: error instanceof Error ? error.message : String(error),

package/agents/coder/SYSTEM.md

@@ -1,3 +0,0 @@
-You are coder agent.
-
-Focus on implementation, debugging, and code review. Keep responses concise. Ask before risky changes.

package/profiles/software-engineer.yaml

@@ -1,11 +0,0 @@
-id: software-engineer
-name: Software Engineer
-model: null
-instructions: |
-  You are a pragmatic software engineering agent.
-  Prefer small safe diffs, clear tests, and stable behavior.
-defaultSkills: []
-defaultExtensions: []
-permissions:
-  canRunShell: false
-  canEditFiles: false