niahere 0.2.60 → 0.2.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.60",
+  "version": "0.2.61",
   "description": "A personal AI assistant daemon — chat, scheduled jobs, persona system, extensible via skills.",
   "type": "module",
   "scripts": {

package/src/channels/slack.ts

@@ -12,6 +12,7 @@ import { log } from "../utils/log";
 import { getMcpServers } from "../mcp";
 import { getNiaHome, getPaths } from "../utils/paths";
 import { classifyMime, validateAttachment, prepareImage } from "../utils/attachment";
+import { resolveWatchBehavior } from "../utils/watches";
 
 /** Strip markdown backticks so sentinel tokens like [NO_REPLY] match even when the LLM wraps them. */
 function cleanSentinel(text: string): string {
@@ -133,22 +134,36 @@ class SlackChannel implements Channel {
 
     let botUserId: string | undefined;
 
-    // Watch channels: mtime-based hot-reload from config.yaml
-    // Keys are always channel_id#channel_name format
+    // Watch channels: mtime-based hot-reload from config.yaml AND any watch
+    // behavior files referenced by that config. Keys are channel_id#channel_name.
     let watchCache: Map<string, { name: string; behavior: string }> = new Map();
-    let watchConfigMtime = 0;
+    let watchFilePaths: string[] = [];
+    let lastReloadMtime = 0;
+
+    function maxMtime(paths: string[]): number {
+      let max = 0;
+      for (const p of paths) {
+        try {
+          const m = statSync(p).mtimeMs;
+          if (m > max) max = m;
+        } catch {
+          // ignore missing files
+        }
+      }
+      return max;
+    }
 
     function reloadWatchChannels(): Map<string, { name: string; behavior: string }> {
       const configPath = getPaths().config;
-      let mtime = 0;
-      try { mtime = statSync(configPath).mtimeMs; } catch { return watchCache; }
-      if (mtime === watchConfigMtime) return watchCache;
+      const mtime = maxMtime([configPath, ...watchFilePaths]);
+      if (mtime === 0) return watchCache;
+      if (mtime === lastReloadMtime) return watchCache;
 
-      watchConfigMtime = mtime;
       resetConfig(); // clear cached config so getConfig() re-reads from disk
       const cfg = getConfig();
       const watch = cfg.channels.slack.watch;
       const fresh = new Map<string, { name: string; behavior: string }>();
+      const freshFiles: string[] = [];
       if (watch) {
         for (const [key, entry] of Object.entries(watch)) {
           if (!entry.enabled) continue;
@@ -159,13 +174,17 @@ class SlackChannel implements Channel {
           }
           const id = key.slice(0, hashIdx);
           const name = key.slice(hashIdx + 1);
-          fresh.set(id, { name, behavior: entry.behavior });
+          const resolved = resolveWatchBehavior(entry.behavior, name);
+          if (resolved.filePath) freshFiles.push(resolved.filePath);
+          fresh.set(id, { name, behavior: resolved.behavior });
         }
       }
       if (fresh.size !== watchCache.size) {
         log.info({ count: fresh.size }, "slack: watch channels reloaded");
       }
       watchCache = fresh;
+      watchFilePaths = freshFiles;
+      lastReloadMtime = maxMtime([configPath, ...freshFiles]);
       return watchCache;
     }
 
@@ -209,7 +228,10 @@ class SlackChannel implements Channel {
       const isDm = command.channel_name === "directmessage";
       const key = isDm ? `dm-${command.user_id}` : await resolveChannelName(app, command.channel_id);
       const state = await restartChat(key);
-      log.info({ channel: command.channel_id, key, room: roomName(key, state.roomIndex) }, "new slack session via /nia-new");
+      log.info(
+        { channel: command.channel_id, key, room: roomName(key, state.roomIndex) },
+        "new slack session via /nia-new",
+      );
       await respond("New conversation started.");
     });
 
@@ -264,7 +286,12 @@ class SlackChannel implements Channel {
         if (existsSync(diskPath) && existsSync(metaPath)) {
           try {
             const meta = JSON.parse(readFileSync(metaPath, "utf8"));
-            const entry: CachedFile = { path: diskPath, type: meta.type || attType, mimeType: meta.mimeType || mime, filename: meta.filename || file.name };
+            const entry: CachedFile = {
+              path: diskPath,
+              type: meta.type || attType,
+              mimeType: meta.mimeType || mime,
+              filename: meta.filename || file.name,
+            };
             fileIndex.set(file.url_private_download, entry);
             attachments.push(loadCached(entry));
             continue;
@@ -354,7 +381,10 @@ class SlackChannel implements Channel {
             const parentMsg = parent.messages?.[0];
             if (parentMsg && (parentMsg.user === botUserId || parentMsg.bot_id)) {
               isActiveThread = true;
-              log.debug({ channel: msg.channel, thread_ts: msg.thread_ts }, "thread parent is bot-authored, activating");
+              log.debug(
+                { channel: msg.channel, thread_ts: msg.thread_ts },
+                "thread parent is bot-authored, activating",
+              );
             }
           } catch (err) {
             log.warn({ err, channel: msg.channel, thread_ts: msg.thread_ts }, "failed to check thread parent");
@@ -368,16 +398,19 @@ class SlackChannel implements Channel {
       const isWatched = !!watchConfig;
 
       if (!isDm && !isMention && !isActiveThread && !isWatched) {
-        log.debug({
-          channel: msg.channel,
-          text: (msg.text || "").slice(0, 80),
-          thread_ts: msg.thread_ts,
-          isDm,
-          isMention: !!isMention,
-          isActiveThread,
-          activeChats: [...chats.keys()],
-          reason: !msg.thread_ts ? "no mention in channel" : "no active session for thread",
-        }, "slack message ignored");
+        log.debug(
+          {
+            channel: msg.channel,
+            text: (msg.text || "").slice(0, 80),
+            thread_ts: msg.thread_ts,
+            isDm,
+            isMention: !!isMention,
+            isActiveThread,
+            activeChats: [...chats.keys()],
+            reason: !msg.thread_ts ? "no mention in channel" : "no active session for thread",
+          },
+          "slack message ignored",
+        );
         return;
       }
 
@@ -424,7 +457,7 @@ class SlackChannel implements Channel {
       }
 
       if (!text && (!attachments || attachments.length === 0)) return;
-      if (!text) text = attachments?.some(a => a.type === "image") ? "What's in this image?" : "Here's a file.";
+      if (!text) text = attachments?.some((a) => a.type === "image") ? "What's in this image?" : "Here's a file.";
 
       // When replying in a thread, fetch thread context so Nia can see the full conversation
       if (msg.thread_ts) {
@@ -434,12 +467,11 @@ class SlackChannel implements Channel {
             ts: msg.thread_ts,
             limit: 50,
           });
-          const priorMessages = (replies.messages || [])
-            .filter((m: any) => m.ts !== msg.ts); // exclude the triggering message
+          const priorMessages = (replies.messages || []).filter((m: any) => m.ts !== msg.ts); // exclude the triggering message
 
           const now = new Date();
           const threadMessages = priorMessages.map((m: any) => {
-            const sender = m.bot_id ? "bot" : (m.user || "unknown");
+            const sender = m.bot_id ? "bot" : m.user || "unknown";
             const fileHint = m.files?.length ? ` [${m.files.length} file(s) attached]` : "";
             const age = m.ts ? ` (${relativeTime(new Date(parseFloat(m.ts) * 1000), now)})` : "";
             return `[${sender}]${age}: ${m.text || "(no text)"}${fileHint}`;
@@ -474,10 +506,21 @@ class SlackChannel implements Channel {
 
       // Prepend watch behavior context for watched channels
       if (watchConfig) {
-        text = `[Watch mode — #${watchConfig.name}]\nBehavior: ${watchConfig.behavior}\nRespond with [NO_REPLY] if no action needed.\n\n${text}`;
+        const behaviorLine = watchConfig.behavior ? `Behavior: ${watchConfig.behavior}\n` : "";
+        text = `[Watch mode — #${watchConfig.name}]\n${behaviorLine}Respond with [NO_REPLY] if no action needed.\n\n${text}`;
       }
 
-      log.info({ channel: msg.channel, key, text: text.slice(0, 100), isDm, watched: isWatched, attachments: attachments?.length || 0 }, "slack message received");
+      log.info(
+        {
+          channel: msg.channel,
+          key,
+          text: text.slice(0, 100),
+          isDm,
+          watched: isWatched,
+          attachments: attachments?.length || 0,
+        },
+        "slack message received",
+      );
 
       let state: ChatState;
       try {
@@ -489,15 +532,20 @@ class SlackChannel implements Channel {
 
       withLock(key, async () => {
         // Add thinking reaction inside the lock so cleanup is guaranteed
-        await client.reactions.add({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" })
+        await client.reactions
+          .add({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" })
           .catch((err) => log.debug({ err, channel: msg.channel }, "slack: failed to add thinking reaction"));
 
         try {
-          const { result, messageId } = await state.engine.send(text, {
-            onActivity(status) {
-              log.debug({ status }, "slack engine activity");
+          const { result, messageId } = await state.engine.send(
+            text,
+            {
+              onActivity(status) {
+                log.debug({ status }, "slack engine activity");
+              },
             },
-          }, attachments);
+            attachments,
+          );
 
           const reply = result.trim();
 
@@ -529,16 +577,19 @@ class SlackChannel implements Channel {
           log.error({ err, channel: msg.channel }, "slack message processing failed");
 
           if (replyThreadTs) {
-            await client.chat.postMessage({
-              channel: msg.channel,
-              text: `[error] ${errText}`,
-              thread_ts: replyThreadTs,
-            }).catch(() => {});
+            await client.chat
+              .postMessage({
+                channel: msg.channel,
+                text: `[error] ${errText}`,
+                thread_ts: replyThreadTs,
+              })
+              .catch(() => {});
           } else {
             await say(`[error] ${errText}`).catch(() => {});
           }
         } finally {
-          await client.reactions.remove({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" })
+          await client.reactions
+            .remove({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" })
             .catch((err) => log.debug({ err, channel: msg.channel }, "slack: failed to remove thinking reaction"));
         }
       });

package/src/chat/engine.ts

@@ -18,8 +18,7 @@ import type {
   EngineOptions,
 } from "../types";
 import { truncate, formatToolUse } from "../utils/format-activity";
-import { consolidateSession } from "../core/consolidator";
-import { summarizeSession } from "../core/summarizer";
+import { finalizeSession, cancelPending } from "../core/finalizer";
 import { log } from "../utils/log";
 
 const IDLE_TIMEOUT = 10 * 60 * 1000; // 10 minutes
@@ -33,10 +32,7 @@ interface SDKUserMessage {
 }
 
 /** Convert provider-agnostic attachments to Anthropic content blocks. */
-export function buildContentBlocks(
-  text: string,
-  attachments?: Attachment[],
-): MessageParam["content"] {
+export function buildContentBlocks(text: string, attachments?: Attachment[]): MessageParam["content"] {
   if (!attachments?.length) return text;
 
   const blocks: Array<
@@ -124,19 +120,11 @@ interface PendingResult {
 function sessionFileExists(sessionId: string, cwd: string): boolean {
   // SDK stores sessions at ~/.claude/projects/<encoded-cwd>/<session-id>.jsonl
   const encoded = cwd.replace(/\//g, "-");
-  const sessionFile = join(
-    homedir(),
-    ".claude",
-    "projects",
-    encoded,
-    `${sessionId}.jsonl`,
-  );
+  const sessionFile = join(homedir(), ".claude", "projects", encoded, `${sessionId}.jsonl`);
   return existsSync(sessionFile);
 }
 
-export async function createChatEngine(
-  opts: EngineOptions,
-): Promise<ChatEngine> {
+export async function createChatEngine(opts: EngineOptions): Promise<ChatEngine> {
   const { room, channel, resume, mcpServers } = opts;
   let systemPrompt = buildSystemPrompt("chat", channel);
 
@@ -181,22 +169,13 @@ export async function createChatEngine(
     idleTimer = setTimeout(async () => {
       if (pending) {
         // Don't tear down while a request is in flight
-        log.warn(
-          { room },
-          "idle timer fired while request pending, skipping teardown",
-        );
+        log.warn({ room }, "idle timer fired while request pending, skipping teardown");
         return;
       }
-      // Memory consolidation + session summary before "sleep"
+      // Enqueue finalization before "sleep"
       if (sessionId && messageCount > 0) {
-        consolidateSession(sessionId, room).catch((err) => {
-          log.error({ err, room }, "consolidation failed during idle teardown");
-        });
-        summarizeSession(sessionId, room).catch((err) => {
-          log.error(
-            { err, room },
-            "session summary failed during idle teardown",
-          );
+        finalizeSession(sessionId, room).catch((err) => {
+          log.error({ err, room }, "finalization enqueue failed during idle teardown");
         });
       }
       teardown();
@@ -216,10 +195,7 @@ export async function createChatEngine(
     longRunningTimer = setTimeout(() => {
       if (pending) {
         longRunningWarned = true;
-        log.warn(
-          { room, elapsed: LONG_RUNNING_WARN / 1000 },
-          "engine request running for 30+ minutes",
-        );
+        log.warn({ room, elapsed: LONG_RUNNING_WARN / 1000 }, "engine request running for 30+ minutes");
       }
     }, LONG_RUNNING_WARN);
   }
@@ -314,10 +290,7 @@ export async function createChatEngine(
                 if (lines.length > 1) {
                   // Show the last complete line (not the partial one being typed)
                   const completeLine = lines[lines.length - 2]?.trim();
-                  if (
-                    completeLine &&
-                    completeLine !== pending.lastThinkingLine
-                  ) {
+                  if (completeLine && completeLine !== pending.lastThinkingLine) {
                     pending.lastThinkingLine = completeLine;
                     pending.onActivity?.(truncate(completeLine, 70));
                   }
@@ -445,11 +418,7 @@ export async function createChatEngine(
             "query stream ended without result, rejecting pending request",
           );
           await ActiveEngine.unregister(room).catch(() => {});
-          pending.reject(
-            new Error(
-              `stream ended without result (${partial.length} chars accumulated)`,
-            ),
-          );
+          pending.reject(new Error(`stream ended without result (${partial.length} chars accumulated)`));
           pending = null;
         }
       } catch (err) {
@@ -476,15 +445,16 @@ export async function createChatEngine(
       return room;
     },
 
-    async send(
-      userMessage: string,
-      callbacks?: SendCallbacks,
-      attachments?: Attachment[],
-    ) {
+    async send(userMessage: string, callbacks?: SendCallbacks, attachments?: Attachment[]) {
       // Clear idle timer — engine is not idle while processing a request
       clearIdleTimer();
       startLongRunningTimer();
 
+      // Cancel any pending finalization — session is active again
+      if (sessionId) {
+        cancelPending(sessionId).catch(() => {});
+      }
+
       await ActiveEngine.register(room, channel);
 
       if (!alive || !stream) {
@@ -524,13 +494,10 @@ export async function createChatEngine(
     },
 
     close() {
-      // Memory consolidation + session summary on explicit close
+      // Enqueue finalization — processed by daemon or inline if we are the daemon
       if (sessionId && messageCount > 0 && !pending) {
-        consolidateSession(sessionId, room).catch((err) => {
-          log.error({ err, room }, "consolidation failed during close");
-        });
-        summarizeSession(sessionId, room).catch((err) => {
-          log.error({ err, room }, "session summary failed during close");
+        finalizeSession(sessionId, room).catch((err) => {
+          log.error({ err, room }, "finalization enqueue failed during close");
         });
       }
       teardown();

package/src/chat/repl.ts

@@ -222,11 +222,12 @@ export async function startRepl(mode: ChatMode = "continue", simulateChannel?: s
     rl.prompt();
   });
 
-  rl.on("close", async () => {
+  rl.on("close", () => {
     console.log(`\n${DIM}bye${RESET}`);
     engine.close();
-    await closeDb();
-    process.exit(0);
+    closeDb()
+      .catch(() => {})
+      .finally(() => process.exit(0));
   });
 
   process.on("SIGINT", () => {

package/src/cli/watch.ts

@@ -5,11 +5,15 @@ import { fail, ICON_PASS, ICON_FAIL } from "../utils/cli";
 const HELP = `Usage: nia watch <command>
 
 Commands:
-  list                              List watch channels (default)
-  add <channel_id#name> <behavior>  Add a watch channel
-  remove <channel_id#name>          Remove a watch channel
-  enable <channel_id#name>          Enable a watch channel
-  disable <channel_id#name>         Disable a watch channel`;
+  list                                 List watch channels (default)
+  add <channel_id#name> [behavior]     Add a watch channel. If [behavior] is
+                                       omitted, loads watches/<name>/behavior.md
+                                       at runtime. If [behavior] is a single
+                                       word, it names a different file to load.
+                                       Otherwise it is treated as inline prose.
+  remove <channel_id#name>             Remove a watch channel
+  enable <channel_id#name>             Enable a watch channel
+  disable <channel_id#name>            Disable a watch channel`;
 
 export function watchCommand(): void {
   const sub = process.argv[3];
@@ -36,17 +40,18 @@ export function watchCommand(): void {
         const cfg = val as Record<string, unknown>;
         const enabled = cfg.enabled !== false;
         const icon = enabled ? ICON_PASS : ICON_FAIL;
-        const behavior = typeof cfg.behavior === "string" ? cfg.behavior.slice(0, 80).replace(/\n/g, " ") : "";
-        console.log(`  ${icon} ${key}  ${behavior}${behavior.length >= 80 ? "..." : ""}`);
+        const rawBehavior = typeof cfg.behavior === "string" ? cfg.behavior : "";
+        const behavior = rawBehavior ? rawBehavior.slice(0, 80).replace(/\n/g, " ") : "(default — loads from file)";
+        console.log(`  ${icon} ${key}  ${behavior}${rawBehavior.length > 80 ? "..." : ""}`);
       }
       break;
     }
 
     case "add": {
       const name = process.argv[4];
-      const behavior = process.argv.slice(5).join(" ");
-      if (!name || !behavior) {
-        fail('Usage: nia watch add <channel_id#name> <behavior>');
+      const behavior = process.argv.slice(5).join(" ") || undefined;
+      if (!name) {
+        fail("Usage: nia watch add <channel_id#name> [behavior]");
       }
       console.log(addWatchChannel(name, behavior));
       break;

package/src/commands/init.ts

@@ -50,7 +50,11 @@ async function offerBeadsShellExport(rl: readline.Interface, beadsDir: string):
     }
   }
 
-  const answer = await ask(rl, `\nAdd BEADS_DIR to ${rcFile.replace(homedir(), "~")} so 'bd' works globally? (y/n)`, "y");
+  const answer = await ask(
+    rl,
+    `\nAdd BEADS_DIR to ${rcFile.replace(homedir(), "~")} so 'bd' works globally? (y/n)`,
+    "y",
+  );
   if (answer.toLowerCase() !== "y") return;
 
   appendFileSync(rcFile, `\n# Beads global task DB\n${exportLine}\n`);
@@ -198,7 +202,9 @@ export async function runInit(): Promise<void> {
         Bun.spawn([openCmd, createUrl], { stdio: ["ignore", "ignore", "ignore"] });
         console.log("  1. Click 'Create' to create the app");
         console.log("  2. Go to 'OAuth & Permissions' → Install to workspace → copy Bot Token (xoxb-...)");
-        console.log("  3. Go to 'Basic Information' → 'App-Level Tokens' → create one with connections:write → copy (xapp-...)\n");
+        console.log(
+          "  3. Go to 'Basic Information' → 'App-Level Tokens' → create one with connections:write → copy (xapp-...)\n",
+        );
 
         slackBotToken = await ask(rl, "Bot token (xoxb-...)", "");
         slackAppToken = await ask(rl, "App token (xapp-...)", "");
@@ -217,7 +223,7 @@ export async function runInit(): Promise<void> {
       const masked = `...${existingGemini.slice(-6)}`;
       const reconfigure = await ask(rl, `\nGemini API: configured (${masked}). Reconfigure? (y/n)`, "n");
       if (reconfigure.toLowerCase() === "y") {
-        geminiApiKey = await ask(rl, "Gemini API key", "") || existingGemini;
+        geminiApiKey = (await ask(rl, "Gemini API key", "")) || existingGemini;
       } else {
         geminiApiKey = existingGemini;
       }
@@ -229,7 +235,7 @@ export async function runInit(): Promise<void> {
     }
 
     // Beads task manager
-    const bdInstalled = await Bun.spawn(["which", "bd"], { stdout: "pipe", stderr: "pipe" }).exited === 0;
+    const bdInstalled = (await Bun.spawn(["which", "bd"], { stdout: "pipe", stderr: "pipe" }).exited) === 0;
     const beadsInitialized = existsSync(`${paths.beadsDir}/.beads`);
 
     if (bdInstalled && beadsInitialized) {
@@ -266,7 +272,7 @@ export async function runInit(): Promise<void> {
           console.log("  \u2713 beads installed");
           mkdirSync(paths.beadsDir, { recursive: true });
           const initProc = Bun.spawn(["bd", "init"], { cwd: paths.beadsDir, stdout: "pipe", stderr: "pipe" });
-          if (await initProc.exited === 0) {
+          if ((await initProc.exited) === 0) {
             console.log(`  \u2713 initialized beads at ${paths.beadsDir}`);
             await offerBeadsShellExport(rl, paths.beadsDir);
           }
@@ -325,28 +331,45 @@ export async function runInit(): Promise<void> {
           // User provided a description — generate from scratch
           console.log("  Generating reference image from description...");
           const prompt = `Ultra photorealistic portrait: ${visualChoice}. Natural skin texture, DSLR quality, 8k, hyper-detailed.`;
-          const proc = Bun.spawn([
-            "python3", GENERATE_SCRIPT,
-            "--no-reference",
-            "--api-key", geminiApiKey,
-            "--aspect-ratio", "9:16",
-            "--prompt", prompt,
-            "--output", `${imagesDir}/reference.webp`,
-          ], { stdout: "pipe", stderr: "pipe" });
+          const proc = Bun.spawn(
+            [
+              "python3",
+              GENERATE_SCRIPT,
+              "--no-reference",
+              "--api-key",
+              geminiApiKey,
+              "--aspect-ratio",
+              "9:16",
+              "--prompt",
+              prompt,
+              "--output",
+              `${imagesDir}/reference.webp`,
+            ],
+            { stdout: "pipe", stderr: "pipe" },
+          );
           const exitCode = await proc.exited;
           if (exitCode === 0) {
             console.log(`  \u2713 generated reference image at ${imagesDir}/reference.webp`);
             // Also generate a profile picture
             console.log("  Generating profile picture...");
-            const profileProc = Bun.spawn([
-              "python3", GENERATE_SCRIPT,
-              "--reference", `${imagesDir}/reference.webp`,
-              "--api-key", geminiApiKey,
-              "--aspect-ratio", "1:1",
-              "--prompt", `Photorealistic close-up portrait of the same person from the reference. Warm slight smile, direct eye contact, soft ambient side lighting, creamy bokeh background, 85mm f/1.8, shallow depth of field. Same face, same style, natural skin texture, DSLR quality, hyper-detailed.`,
-              "--output", `${imagesDir}/profile.webp`,
-            ], { stdout: "pipe", stderr: "pipe" });
-            if (await profileProc.exited === 0) {
+            const profileProc = Bun.spawn(
+              [
+                "python3",
+                GENERATE_SCRIPT,
+                "--reference",
+                `${imagesDir}/reference.webp`,
+                "--api-key",
+                geminiApiKey,
+                "--aspect-ratio",
+                "1:1",
+                "--prompt",
+                `Photorealistic close-up portrait of the same person from the reference. Warm slight smile, direct eye contact, soft ambient side lighting, creamy bokeh background, 85mm f/1.8, shallow depth of field. Same face, same style, natural skin texture, DSLR quality, hyper-detailed.`,
+                "--output",
+                `${imagesDir}/profile.webp`,
+              ],
+              { stdout: "pipe", stderr: "pipe" },
+            );
+            if ((await profileProc.exited) === 0) {
               console.log(`  \u2713 generated profile picture at ${imagesDir}/profile.webp`);
             }
           } else {
@@ -373,6 +396,7 @@ export async function runInit(): Promise<void> {
     // Create directories
     mkdirSync(home, { recursive: true });
     mkdirSync(paths.selfDir, { recursive: true });
+    mkdirSync(paths.watchesDir, { recursive: true });
     mkdirSync(`${home}/tmp`, { recursive: true });
 
     // Write config.yaml
@@ -423,7 +447,10 @@ export async function runInit(): Promise<void> {
 
     if (ownerName) {
       let ownerContent = loadTemplate("owner.md", vars);
-      ownerContent = ownerContent.split("\n").filter((l) => !l.match(/\*\*\w+\*\*:\s*$/)).join("\n");
+      ownerContent = ownerContent
+        .split("\n")
+        .filter((l) => !l.match(/\*\*\w+\*\*:\s*$/))
+        .join("\n");
       writeFileSync(selfFile("owner.md"), ownerContent);
       console.log(`  \u2713 wrote ${selfFile("owner.md")}`);
     }