wheems 0.0.1 → 0.0.2

package/CHANGELOG.md

@@ -3,6 +3,52 @@
 Wheems follows [semantic versioning](https://semver.org). While it's 0.0.x, any release may
 change anything, including commands and config formats, without a migration path.
 
+## 0.0.2
+
+Fixes from the first preview, a welcome screen, and checks that catch common set-up problems.
+Still an early preview: not ready for real use.
+
+**Added**
+
+- `wheems` on its own shows a welcome screen: the cloud from the brand kit, in blue, beside the
+  name and "Your crew, ready for work.", then how the install is doing (workspaces and agents,
+  the service, search, and anything waiting for review). `wheems setup` opens with the cloud too.
+- `wheems init` creates the install when there isn't one, so setup can be scripted from a fresh
+  machine (connecting Slack still needs `wheems setup`).
+- `wheems doctor` checks that Claude Code is signed in (`claude auth status`), and that the app is
+  a member of each workspace's chat channel: Slack lists public channels the app isn't in, and
+  sends no messages from them. The service warns about such a channel when it starts.
+
+**Fixed**
+
+- Search needs SQLite full-text search (FTS5), which Node only bundles from 22.16 in the 22
+  line and from 24; no Node 23 release has it. `engines` is now `^22.16.0 || >=24`, the CLI and
+  `wheems service install` refuse other versions with a plain message, `wheems doctor` checks
+  that this Node's SQLite has full-text search, and search says so instead of failing with
+  "no such module: fts5".
+- `npm run build` now marks `dist/cli/main.js` executable, so a `wheems` linked with `npm link`
+  runs instead of failing with "Permission denied".
+- Slack messages with a file attached were silently ignored. Now a file with no words gets a reply
+  asking for the text, and with words the agent gets them and a note that files can't be passed
+  on yet.
+- After a quick reply from an agent, Wheems could add a false "The agent finished without
+  replying here": it recorded when a message was sent only after typing it in.
+- After connecting Slack, setup says to restart the service (which reads tokens only when it
+  starts) and how to let someone else talk to the agents.
+- On Linux, `wheems doctor` warns that the service needs macOS for now instead of passing.
+- Docs: where to install Herdr core ([herdr.dev/core](https://herdr.dev/core/)), npm as the way
+  to install, inviting the app to a channel, session names, which commands take `--home`, a
+  broken table in config.md, and milestone numbers in code comments.
+
+**Known issues**
+
+- Only one Slack connection, named `slack`, can be set up from `wheems setup` and `wheems init`;
+  a second Slack app has to be added by hand.
+- The Slack app's manifest asks for interactivity, which nothing uses until approvals with
+  buttons (milestone 3).
+- The launchd label is fixed, so only one install per Mac user can run as a service.
+- `wheems kb search --json` reports inbox notes as `kind: note`; the path tells them apart.
+
 ## 0.0.1
 
 The first preview: milestones 0 to 2 of the [roadmap](docs/roadmap.md). Not ready for real use.

package/README.md

@@ -78,9 +78,11 @@ Wheems was formerly called Opinr.
 
 You need:
 
-- macOS (the service runs under launchd; Linux comes later)
-- Node.js 22.13 or later
-- Herdr core 0.1.20 or later (`hc`)
+- macOS (the service runs under launchd; Linux, with systemd, comes with the always-on
+  milestone)
+- Node.js 22.16 or later in the 22 line, or 24 or later (not 23: its SQLite has no full-text
+  search, which Wheems needs)
+- Herdr core 0.1.20 or later (`hc`): see [herdr.dev/core](https://herdr.dev/core/) to install it
 - A Slack workspace where you can add apps
 
 Install the `wheems` command from npm:
@@ -102,9 +104,10 @@ npm link            # puts the wheems command on your PATH
 Clone it anywhere except `~/wheems`. That folder is your install: your private config, notes
 and knowledge base, kept in a git folder of its own that is never pushed anywhere.
 
-If your default `node` is older than 22.13, use a newer one, such as Homebrew's
+If your default `node` isn't one of those (Homebrew's `node` may be 23), use one that is, such as Homebrew's
 (`brew install node@22`), and run `/opt/homebrew/opt/node@22/bin/node dist/cli/main.js` in place
-of `wheems`. `wheems doctor` says which Node.js it runs on and fails when it's too old.
+of `wheems`. `wheems doctor` says which Node.js it runs on, and fails when it's unsupported or its SQLite has no
+full-text search.
 
 ## Set up
 
@@ -141,6 +144,14 @@ One Slack app serves every workspace, so you do this once.
 5. Give your Slack member ID (your profile, **⋯**, **Copy member ID**). Only people on this list
    can talk to your agents. Messages from anyone else are ignored.
 
+### Inviting the app to a channel
+
+A workspace that chats in a channel needs the app in that channel: in the channel, type
+`/invite` and choose the app. Slack lists public channels the app isn't in, so a channel name
+that's spelt right can still hear nothing; the service warns at start-up and `wheems doctor`
+checks it. The service looks channels up when it starts, so after creating a channel or renaming
+one, run `wheems service restart`.
+
 ### Trusting the workspace folder
 
 Claude Code and Codex ask once whether to trust a new folder, and nobody can answer that from
@@ -149,7 +160,9 @@ folder, then press Ctrl+C twice to come back. `wheems doctor` checks the trust.
 
 ### Without the menu
 
-Each part has a command of its own, for scripts:
+Each part has a command of its own, for scripts. `wheems init` creates the install too when
+there isn't one, so a fresh machine can start there; connecting Slack still needs `wheems setup`,
+because you type its tokens in yourself:
 
 ```bash
 wheems init personal                                   # a workspace on Claude Code
@@ -226,8 +239,9 @@ can be given skills, but nothing starts them yet: teams of agents come in later
 Message the Slack app (or the workspace's channel). Each message you send starts a
 **conversation**, and replies in its thread carry it on.
 
-- Each conversation is its own engine session in Herdr, named after the workspace and agent.
-  Watch it or take over with `hc attach <session>`.
+- Each conversation is its own engine session in Herdr, named after the workspace with a short
+  id for the thread, such as `personal-3f9a2c1b`. Watch it or take over with
+  `hc attach <session>`.
 - A 👀 reaction means your message has reached the agent. It goes when the agent answers.
 - The agent's last message of each turn is posted to the thread as its answer. The answer is
   read from the engine's own record of the conversation, never from the screen.
@@ -506,13 +520,15 @@ from its workspace's skills. Pinned skill versions must exist in the library.
 
 ## Command reference
 
-Every command takes `--home <dir>` for the install folder (default: `$WHEEMS_HOME`, then
-`~/wheems`).
+Commands that use the install take `--home <dir>` for the install folder (default:
+`$WHEEMS_HOME`, then `~/wheems`). `wheems service restart`, `service uninstall` and
+`slack manifest` don't need it.
 
 **For you**
 
 | Command                                                                        | What it does                                                                                              |
 | ------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------- |
+| `wheems`                                                                       | The welcome screen: the cloud, and how the install is doing (workspaces, the service, search, review)     |
 | `wheems setup`                                                                 | The setup menu: engines, Slack, workspaces, knowledge, the service, doctor                                |
 | `wheems init <workspace> [--name] [--channel] [--engine] [--model]`            | Creates a workspace with its chief of staff. `--engine` is `claude-code` (default), `codex` or `opencode` |
 | `wheems doctor [--quick] [--json]`                                             | Checks the machine, Herdr core and the install                                                            |

package/dist/cli/commands/service.js

@@ -1,12 +1,11 @@
 import { realpathSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
-import { NODE_MINIMUM_VERSION } from '../../doctor/doctor.js';
+import { nodeVersionProblem } from '../../util/node-support.js';
 import { defaultHome, paths } from '../../home.js';
 import { request } from '../../service/control.js';
 import { installService, plistPath, restartService, serviceStatus, uninstallService, } from '../../service/launchd.js';
 import { runService } from '../../service/service.js';
-import { isAtLeast } from '../../util/version.js';
 import { packageVersion } from '../version.js';
 /** The script that is running this CLI, resolved through npm links. */
 export function cliPath() {
@@ -14,9 +13,9 @@ export function cliPath() {
 }
 /** Installs the service under launchd with this Node.js and build, and waits for it to answer. */
 export async function installAndWait(where) {
-    if (!isAtLeast(process.versions.node, NODE_MINIMUM_VERSION)) {
-        throw new Error(`The service needs Node.js ${NODE_MINIMUM_VERSION} or later, and this is ${process.versions.node}.`);
-    }
+    const problem = nodeVersionProblem(process.versions.node);
+    if (problem !== null)
+        throw new Error(problem);
     const cli = cliPath();
     if (!cli.endsWith('.js')) {
         throw new Error('Install the service from a build of Wheems (npm run build), not from source.');

package/dist/cli/commands/setup.js

@@ -156,6 +156,10 @@ async function channels(options, where) {
     doc.setIn(['connections', connection, 'allowed_users'], doc.createNode(result.allowedUsers, { flow: true }));
     await writeFile(where.install, doc.toString());
     ui.success(`${entry.label} is connected. Its tokens are saved privately in ${where.secrets}`);
+    ui.info([
+        'The service reads tokens when it starts: restart it (Service) for these to take effect.',
+        `To let someone else talk to your agents, add their member ID to allowed_users under connections.${connection} in install.yaml, then restart the service.`,
+    ].join('\n'));
     return true;
 }
 /**

package/dist/cli/main.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-// Check the Node.js version before loading anything that needs a newer one, so an old
-// Node.js gets a plain message rather than a stack trace from a dependency.
-const [major = 0, minor = 0] = process.versions.node.split('.').map(Number);
-if (major < 22 || (major === 22 && minor < 13)) {
-    process.stderr.write(`Wheems needs Node.js 22.13 or later, and this is ${process.versions.node} (${process.execPath}).\n`);
+// Check the Node.js version before loading anything that needs a newer one, so an
+// unsupported Node.js gets a plain message rather than a stack trace from a dependency.
+import { nodeVersionProblem } from '../util/node-support.js';
+const problem = nodeVersionProblem(process.versions.node);
+if (problem !== null) {
+    process.stderr.write(`${problem}\nThis is ${process.execPath}.\n`);
     process.exit(1);
 }
 const { defaultIo, run } = await import('./program.js');
@@ -15,5 +16,4 @@ process.exitCode = await run(process.argv.slice(2), {
     color,
     ...defaultIo(),
 });
-export {};
 //# sourceMappingURL=main.js.map

package/dist/cli/program.d.ts

@@ -15,6 +15,6 @@ export interface Io {
 export declare function defaultIo(): Pick<Io, 'registry' | 'stdin'>;
 /** Builds the `wheems` command. */
 export declare function createProgram(io: Io): Command;
-/** Runs the CLI and returns the exit code. */
+/** Runs the CLI and returns the exit code. With no command, it shows the welcome screen. */
 export declare function run(argv: string[], io: Io): Promise<number>;
 export declare function formatReport(report: DoctorReport, color: boolean): string;

package/dist/cli/program.js

@@ -15,8 +15,9 @@ import { registerSkill } from './commands/skill.js';
 import { registerNote } from './commands/note.js';
 import { registerReply } from './commands/reply.js';
 import { registerService } from './commands/service.js';
-import { setup } from './commands/setup.js';
+import { ensureInstall, setup } from './commands/setup.js';
 import { clackUi } from './clack-ui.js';
+import { renderWelcome, welcomeStatus } from './welcome.js';
 import { installAndWait, serviceAnswers } from './commands/service.js';
 import { runCommand, runInteractive } from '../util/process.js';
 import { SetupCancelled } from '../contracts/setup.js';
@@ -88,7 +89,7 @@ export function createProgram(io) {
     });
     program
         .command('setup')
-        .description('Set up Wheems: connect channels, create workspaces, run the service')
+        .description('Set up Wheems: engines, chat channels, workspaces, search and the service')
         .option('--home <dir>', 'the install folder (default: $WHEEMS_HOME or ~/wheems)')
         .action(async (options) => {
         if (!process.stdin.isTTY || !process.stdout.isTTY) {
@@ -98,6 +99,7 @@ export function createProgram(io) {
         const where = paths(home, io.env);
         const registry = io.registry();
         const ui = clackUi();
+        io.out(renderWelcome({ version: packageVersion(), status: [], color: io.color, hints: false }));
         ui.intro(' Wheems setup ');
         try {
             await setup({
@@ -133,7 +135,7 @@ export function createProgram(io) {
     });
     program
         .command('init')
-        .description('Create a workspace with its chief of staff')
+        .description('Create a workspace with its chief of staff (and the install, if there is none)')
         .argument('<workspace>', 'the workspace id, such as personal')
         .option('--name <name>', 'its display name (default: from the id)')
         .option('--channel <channel>', "chat in this channel instead of the bot's direct messages")
@@ -154,8 +156,13 @@ export function createProgram(io) {
             throw new Error(`No engine "${options.engine}". Choose one of: ${known}`);
         }
         const setup = entry.engine;
+        const home = resolve(options.home ?? defaultHome(io.env));
+        // On a fresh machine, init makes the install too, so setup can be scripted.
+        const createdInstall = await ensureInstall(paths(home, io.env));
+        if (createdInstall)
+            io.out(`Created the install at ${home} (a git folder)\n`);
         const dir = await initWorkspace({
-            home: resolve(options.home ?? defaultHome(io.env)),
+            home,
             id,
             env: io.env,
             engine: {
@@ -206,8 +213,20 @@ export function createProgram(io) {
 function shellPath(path) {
     return /^[\w./-]+$/.test(path) ? path : `'${path.replaceAll("'", `'\\''`)}'`;
 }
-/** Runs the CLI and returns the exit code. */
+/** Runs the CLI and returns the exit code. With no command, it shows the welcome screen. */
 export async function run(argv, io) {
+    if (argv.length === 0) {
+        const home = resolve(defaultHome(io.env));
+        // The welcome never fails: a problem reading the install becomes one of its lines.
+        const status = await welcomeStatus(home, io.env).catch((error) => [
+            {
+                mark: '!',
+                text: `Couldn't read the install at ${home}: ${error instanceof Error ? error.message : String(error)}. Run wheems doctor.`,
+            },
+        ]);
+        io.out(renderWelcome({ version: packageVersion(), status, color: io.color }));
+        return 0;
+    }
     const program = createProgram(io);
     try {
         await program.parseAsync(argv, { from: 'user' });

package/dist/cli/welcome.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The cloud, from the brand kit's terminal mark (Unicode half blocks, drawn from the mascot's
+ * silhouette). Its eye and smile are the gaps the half blocks leave.
+ */
+export declare const CLOUD: string[];
+/** The brand line under the name. */
+export declare const TAGLINE = "Your crew, ready for work.";
+export interface WelcomeStatus {
+    mark: '✓' | '!' | '-';
+    text: string;
+}
+/** The welcome screen: the cloud with the name and tagline beside it, then the install's status. */
+export declare function renderWelcome(options: {
+    version: string;
+    status: WelcomeStatus[];
+    color: boolean;
+    /** Ends with the commands to try next. On by default. */
+    hints?: boolean;
+}): string;
+/**
+ * What the welcome screen says about this install: its workspaces and agents, the service,
+ * search, and anything waiting for review. Quick: it reads files and pings the service, and
+ * never starts a session.
+ */
+export declare function welcomeStatus(home: string, env: NodeJS.ProcessEnv, ping?: (socket: string) => Promise<boolean>): Promise<WelcomeStatus[]>;

package/dist/cli/welcome.js

@@ -0,0 +1,105 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { loadInstall } from '../config/load.js';
+import { paths } from '../home.js';
+import { listAboutYou } from '../review/review.js';
+import { request } from '../service/control.js';
+import { listProposals } from '../skills/proposals.js';
+/**
+ * The cloud, from the brand kit's terminal mark (Unicode half blocks, drawn from the mascot's
+ * silhouette). Its eye and smile are the gaps the half blocks leave.
+ */
+// Every character is one UTF-16 unit, so .length is the width in columns.
+export const CLOUD = [
+    '            ▄▄██▄▄▄',
+    '          ██████████',
+    '     ▄██▄████████████',
+    '    █████████████████',
+    '   ▄█████████████████',
+    ' ▄████▀█████████████▄▄',
+    '▄██████████████████████',
+    '▀████▄▀▄████████████████',
+    ' ██████████████████████',
+    '  ▀▀▀███████████████▀▀',
+];
+/** The brand line under the name. */
+export const TAGLINE = 'Your crew, ready for work.';
+/**
+ * A blue between the brand's cobalt (light backgrounds) and its dark-mode blue, from the
+ * 256-colour palette, so the cloud reads on light and dark terminals alike.
+ */
+const CLOUD_COLOUR = '\x1b[38;5;69m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const RESET = '\x1b[0m';
+/** The welcome screen: the cloud with the name and tagline beside it, then the install's status. */
+export function renderWelcome(options) {
+    const paint = (code, text) => (options.color ? `${code}${text}${RESET}` : text);
+    const width = Math.max(...CLOUD.map((line) => line.length));
+    const beside = {
+        4: paint(BOLD, 'wheems') + ' ' + paint(DIM, options.version),
+        5: TAGLINE,
+    };
+    const lines = CLOUD.map((line, row) => {
+        const text = beside[row];
+        const padded = line + ' '.repeat(width - line.length);
+        return text === undefined
+            ? paint(CLOUD_COLOUR, line)
+            : `${paint(CLOUD_COLOUR, padded)}   ${text}`;
+    });
+    const marks = { '✓': '\x1b[32m', '!': '\x1b[33m', '-': DIM };
+    return [
+        '',
+        ...lines,
+        '',
+        ...options.status.map((s) => `${paint(marks[s.mark], s.mark)} ${s.text}`),
+        ...(options.status.length > 0 ? [''] : []),
+        ...(options.hints === false
+            ? []
+            : [paint(DIM, 'wheems setup · wheems doctor · wheems --help'), '']),
+    ].join('\n');
+}
+/**
+ * What the welcome screen says about this install: its workspaces and agents, the service,
+ * search, and anything waiting for review. Quick: it reads files and pings the service, and
+ * never starts a session.
+ */
+export async function welcomeStatus(home, env, ping = (socket) => request(socket, { op: 'ping' }, 1000).then((answer) => answer.ok, () => false)) {
+    const where = paths(home, env);
+    const hasInstall = await readFile(join(home, 'install.yaml')).then(() => true, () => false);
+    if (!hasInstall) {
+        return [{ mark: '!', text: `No install at ${tilde(home, env)} yet: run wheems setup` }];
+    }
+    const install = await loadInstall(home);
+    const workspaces = install.workspaces.filter((w) => w.config);
+    const agents = workspaces.reduce((n, w) => n + w.agents.length, 0);
+    const status = [];
+    status.push(workspaces.length > 0
+        ? {
+            mark: '✓',
+            text: `${count(workspaces.length, 'workspace')}, ${count(agents, 'agent')} in ${tilde(home, env)}`,
+        }
+        : { mark: '!', text: 'No workspaces yet: run wheems setup' });
+    status.push((await ping(where.socket))
+        ? { mark: '✓', text: 'The service is running' }
+        : { mark: '!', text: "The service isn't running: wheems service install" });
+    const embeddings = install.config?.knowledge.embeddings;
+    status.push(embeddings
+        ? { mark: '✓', text: `Search by meaning with ${embeddings.model ?? embeddings.driver}` }
+        : { mark: '-', text: 'Search by keyword only (wheems setup → Knowledge for meaning)' });
+    const waiting = (await listProposals(where.state)).length + (await listAboutYou(where.state)).length;
+    if (waiting > 0) {
+        status.push({ mark: '!', text: `${count(waiting, 'thing')} waiting for you: wheems review` });
+    }
+    return status;
+}
+function count(n, noun) {
+    return `${String(n)} ${noun}${n === 1 ? '' : 's'}`;
+}
+function tilde(path, env) {
+    const home = env.HOME;
+    return home !== undefined && home !== '' && path.startsWith(`${home}/`)
+        ? `~${path.slice(home.length)}`
+        : path;
+}
+//# sourceMappingURL=welcome.js.map

package/dist/contracts/channel.d.ts

@@ -1,7 +1,7 @@
 import type { Driver, HealthCheck } from './driver.js';
 /**
  * The channel contract: sends and receives messages, buttons and threads.
- * Version one ships Slack (milestone 1) and Telegram and email (milestone 9).
+ * Version one ships Slack (milestone 1) and Telegram and email (milestone 10).
  *
  * A channel driver holds one connection, such as one Slack app. Channels inside
  * it are addressed by the driver's own channel id.
@@ -27,6 +27,16 @@ export interface ChannelDriver extends Driver<'channel'> {
     react(message: MessageRef, reaction: string, on: boolean): Promise<void>;
     /** Disconnects. No handler calls happen after it resolves. Safe to call twice. */
     stop(): Promise<void>;
+    /**
+     * Optional: a channel's id from its name (or its id), or null when the app can't see it.
+     * Drivers without it take channel names as ids.
+     */
+    resolveChannel?(nameOrId: string): Promise<string | null>;
+    /**
+     * Optional: whether the app is a member of a channel, so messages there reach it. Null when it
+     * can't tell. Seeing a channel isn't enough: Slack lists public channels the app isn't in.
+     */
+    isMember?(channelId: string): Promise<boolean | null>;
 }
 export interface MessageRef {
     channel: string;
@@ -56,6 +66,10 @@ export interface InboundMessage {
     /** True for a direct message between the person and the bot. */
     direct: boolean;
     receivedAt: Date;
+    /** Files attached to it, by name. Wheems can't pass their contents on yet. */
+    files?: {
+        name: string;
+    }[];
 }
 export interface ButtonPress {
     type: 'button';

package/dist/doctor/doctor.d.ts

@@ -2,7 +2,6 @@ export { trustedIn } from '../util/trust.js';
 import type { HealthCheck } from '../contracts/driver.js';
 import type { DriverRegistry } from '../contracts/registry.js';
 export { defaultHome } from '../home.js';
-export declare const NODE_MINIMUM_VERSION = "22.13.0";
 export interface DoctorOptions {
     /** The install folder. */
     home: string;
@@ -15,6 +14,8 @@ export interface DoctorOptions {
     platform?: NodeJS.Platform;
     /** Whether an engine trusts a folder: true, false, or null when it can't tell. */
     trust?: (engine: string, dir: string) => Promise<boolean | null>;
+    /** Why SQLite can't do full-text search, or null when it can. */
+    fullTextSearch?: () => Promise<string | null>;
     /** Whether the service is installed and answering. */
     service?: (home: string) => Promise<{
         installed: boolean;

package/dist/doctor/doctor.js

@@ -13,13 +13,14 @@ import { HERDR_MINIMUM_VERSION } from '../drivers/runtime/herdr/herdr-runtime.js
 import { KnowledgeSearch } from '../knowledge/search.js';
 import { listAboutYou } from '../review/review.js';
 import { listProposals } from '../skills/proposals.js';
-import { compareVersions, isAtLeast } from '../util/version.js';
+import { compareVersions } from '../util/version.js';
+import { NODE_SUPPORTED, nodeVersionProblem } from '../util/node-support.js';
+import { fullTextSearchProblem } from '../util/sqlite.js';
 export { defaultHome } from '../home.js';
-export const NODE_MINIMUM_VERSION = '22.13.0';
 /** Runs every health check: the system, the runtime, and the install's config. */
 export async function runDoctor(options) {
     const sections = [];
-    sections.push({ title: 'System', checks: systemChecks(options) });
+    sections.push({ title: 'System', checks: await systemChecks(options) });
     const installFile = join(options.home, 'install.yaml');
     const hasInstall = await exists(installFile);
     const install = hasInstall ? await loadInstall(options.home) : null;
@@ -164,7 +165,11 @@ async function channelChecks(install, options) {
         }
         try {
             const driver = options.registry.create('channel', settings.driver, { ...secret });
-            checks.push(...(await driver.check()).map((c) => ({ ...c, name: `${connection}: ${c.name}` })));
+            const health = await driver.check();
+            checks.push(...health.map((c) => ({ ...c, name: `${connection}: ${c.name}` })));
+            if (health.every((c) => c.status !== 'fail')) {
+                checks.push(...(await channelMembership(install, connection, driver)));
+            }
         }
         catch (error) {
             checks.push({
@@ -177,6 +182,46 @@ async function channelChecks(install, options) {
     }
     return checks;
 }
+/**
+ * For each workspace that chats in a channel on this connection: can the app see the channel,
+ * and is it a member? Slack lists public channels the app isn't in, and sends no messages from
+ * them, so a workspace can look bound and never hear anything.
+ */
+async function channelMembership(install, connection, driver) {
+    const checks = [];
+    for (const workspace of install.workspaces) {
+        const chat = workspace.config?.channels.chat;
+        if (!chat || chat.connection !== connection || !('channel' in chat))
+            continue;
+        const name = `${workspace.id} chat channel`;
+        const id = driver.resolveChannel ? await driver.resolveChannel(chat.channel) : chat.channel;
+        if (id === null) {
+            checks.push({
+                name,
+                status: 'fail',
+                message: `The app can't see ${chat.channel}`,
+                hint: 'Check the name in workspace.yaml, invite the app to the channel, then run wheems service restart.',
+            });
+            continue;
+        }
+        const member = driver.isMember ? await driver.isMember(id) : null;
+        checks.push(member === true
+            ? { name, status: 'pass', message: `The app is in ${chat.channel}` }
+            : member === false
+                ? {
+                    name,
+                    status: 'warn',
+                    message: `The app isn't in ${chat.channel}, so messages there never reach the chief of staff`,
+                    hint: `In ${chat.channel}, type /invite and choose the app.`,
+                }
+                : {
+                    name,
+                    status: 'skip',
+                    message: `Couldn't tell whether the app is in ${chat.channel}`,
+                });
+    }
+    return checks;
+}
 /** What waits for the person in `wheems review`. Never a failure: it's for their attention. */
 async function reviewCheck(options) {
     const state = paths(options.home, options.env).state;
@@ -313,29 +358,36 @@ async function probeService(home) {
     const answering = await request(paths(home).socket, { op: 'ping' }, 2000).then((answer) => answer.ok, () => false);
     return { installed: status.loaded, answering };
 }
-function systemChecks(options) {
+async function systemChecks(options) {
     const nodeVersion = options.nodeVersion ?? process.versions.node;
     const platform = options.platform ?? process.platform;
     const checks = [];
-    checks.push(isAtLeast(nodeVersion, NODE_MINIMUM_VERSION)
-        ? {
-            name: 'Node.js',
-            status: 'pass',
-            message: `${nodeVersion} meets the minimum ${NODE_MINIMUM_VERSION}`,
-        }
+    const problem = nodeVersionProblem(nodeVersion);
+    checks.push(problem === null
+        ? { name: 'Node.js', status: 'pass', message: `${nodeVersion} is supported` }
+        : { name: 'Node.js', status: 'fail', message: problem, hint: `Install ${NODE_SUPPORTED}.` });
+    const search = await (options.fullTextSearch ?? (() => fullTextSearchProblem()))();
+    checks.push(search === null
+        ? { name: 'SQLite search', status: 'pass', message: "Node's SQLite has full-text search" }
         : {
-            name: 'Node.js',
+            name: 'SQLite search',
             status: 'fail',
-            message: `${nodeVersion} is older than the minimum ${NODE_MINIMUM_VERSION}`,
-            hint: `Install Node.js ${NODE_MINIMUM_VERSION} or later.`,
-        });
-    checks.push(platform === 'darwin' || platform === 'linux'
-        ? { name: 'platform', status: 'pass', message: platform === 'darwin' ? 'macOS' : 'Linux' }
-        : {
-            name: 'platform',
-            status: 'warn',
-            message: `${platform} is not supported yet; Wheems runs on macOS and Linux`,
+            message: search,
+            hint: `Install ${NODE_SUPPORTED}.`,
         });
+    checks.push(platform === 'darwin'
+        ? { name: 'platform', status: 'pass', message: 'macOS' }
+        : platform === 'linux'
+            ? {
+                name: 'platform',
+                status: 'warn',
+                message: 'Linux: the commands work, but the service runs under launchd on macOS only; systemd comes with the always-on milestone',
+            }
+            : {
+                name: 'platform',
+                status: 'warn',
+                message: `${platform} is not supported yet; Wheems runs on macOS (and Linux, apart from the service)`,
+            });
     return checks;
 }
 /** Starts a tiny session, sends it a line, waits, reads it back and removes it. */

package/dist/drivers/channel/slack/slack-channel.d.ts

@@ -24,6 +24,7 @@ export declare class SlackChannel implements ChannelDriver {
      * Returns null when the bot cannot see a channel by that name.
      */
     resolveChannel(nameOrId: string): Promise<string | null>;
+    isMember(channelId: string): Promise<boolean | null>;
     stop(): Promise<void>;
     private onEvent;
     private toDriverError;

package/dist/drivers/channel/slack/slack-channel.js

@@ -139,6 +139,16 @@ export class SlackChannel {
         } while (cursor !== undefined && !this.channelIds.has(name));
         return this.channelIds.get(name) ?? null;
     }
+    async isMember(channelId) {
+        try {
+            const info = await this.transport.call('conversations.info', { channel: channelId });
+            const member = info.channel?.is_member;
+            return typeof member === 'boolean' ? member : null;
+        }
+        catch {
+            return null;
+        }
+    }
     async stop() {
         this.handler = undefined;
         if (!this.started)
@@ -150,8 +160,9 @@ export class SlackChannel {
         const handler = this.handler;
         if (!handler || event.type !== 'message')
             return;
-        // Edits, deletions, joins and bot posts arrive as subtypes; only plain messages count.
-        if (typeof event.subtype === 'string')
+        // Edits, deletions, joins and bot posts arrive as subtypes; only plain messages, and
+        // messages with files attached, count.
+        if (typeof event.subtype === 'string' && event.subtype !== 'file_share')
             return;
         if (typeof event.bot_id === 'string' || event.user === this.botUserId)
             return;
@@ -170,6 +181,8 @@ export class SlackChannel {
             text: typeof event.text === 'string' ? event.text : '',
             direct: event.channel_type === 'im',
             receivedAt: new Date(Number.parseFloat(event.ts) * 1000),
+            ...(Array.isArray(event.files) &&
+                event.files.length > 0 && { files: fileNames(event.files) }),
         });
     }
     toDriverError(error, what) {
@@ -209,4 +222,12 @@ function chunks(text, size) {
         parts.push(rest);
     return parts;
 }
+/** The names of the files on a Slack message. */
+function fileNames(files) {
+    return files.map((file) => {
+        const f = (file ?? {});
+        const name = typeof f.name === 'string' ? f.name : typeof f.title === 'string' ? f.title : 'a file';
+        return { name };
+    });
+}
 //# sourceMappingURL=slack-channel.js.map

package/dist/drivers/engine/claude-code.d.ts

@@ -28,6 +28,8 @@ export declare class ClaudeCodeEngine implements EngineDriver {
     }, after: string | null): Promise<FinalMessage[]>;
     private transcript;
     check(): Promise<HealthCheck[]>;
+    /** Whether Claude Code is signed in, from `claude auth status`. Never shows the account. */
+    private signInCheck;
     prepare(agent: AgentDefinition, context: EngineContext): Promise<LaunchPlan>;
 }
 /**

package/dist/drivers/engine/claude-code.js

@@ -82,7 +82,49 @@ export class ClaudeCodeEngine {
             ];
         }
         const version = extractVersion(result.stdout) ?? result.stdout.trim();
-        return [{ name: 'Claude Code', status: 'pass', message: `claude ${version}` }];
+        return [
+            { name: 'Claude Code', status: 'pass', message: `claude ${version}` },
+            await this.signInCheck(),
+        ];
+    }
+    /** Whether Claude Code is signed in, from `claude auth status`. Never shows the account. */
+    async signInCheck() {
+        const status = await runCommand(this.binary, ['auth', 'status', '--json'], {
+            timeoutMs: 15_000,
+        });
+        let loggedIn = null;
+        let method = null;
+        try {
+            const parsed = JSON.parse(status.stdout);
+            if (typeof parsed.loggedIn === 'boolean')
+                loggedIn = parsed.loggedIn;
+            if (typeof parsed.authMethod === 'string')
+                method = parsed.authMethod;
+        }
+        catch {
+            // An older Claude Code without `auth status`, or output it doesn't recognise.
+        }
+        if (loggedIn === true) {
+            return {
+                name: 'Claude Code sign-in',
+                status: 'pass',
+                message: method !== null ? `Signed in (${method})` : 'Signed in',
+            };
+        }
+        if (loggedIn === false) {
+            return {
+                name: 'Claude Code sign-in',
+                status: 'fail',
+                message: 'Claude Code is not signed in, so agents on it cannot answer',
+                hint: 'Run claude auth login, or wheems setup and choose Engines.',
+            };
+        }
+        return {
+            name: 'Claude Code sign-in',
+            status: 'warn',
+            message: "Couldn't tell whether Claude Code is signed in (claude auth status didn't say)",
+            hint: 'Update Claude Code, or check by running claude yourself.',
+        };
     }
     prepare(agent, context) {
         const { session } = context;

package/dist/drivers/runtime/herdr/hc.js

@@ -205,7 +205,7 @@ export class Hc {
 }
 function toHcError(error, stderr, binary) {
     if (error.code === 'ENOENT') {
-        return new HcError('missing', `Herdr core's hc command was not found (${binary})`, 'Install Herdr core, or make sure hc is on PATH.', null, { cause: error });
+        return new HcError('missing', `Herdr core's hc command was not found (${binary})`, 'Install Herdr core (https://herdr.dev/core/), or make sure hc is on PATH.', null, { cause: error });
     }
     const exitCode = typeof error.code === 'number' ? error.code : null;
     if (error.killed === true) {

package/dist/drivers/runtime/herdr/herdr-runtime.js

@@ -33,7 +33,7 @@ export class HerdrRuntime {
                 name: 'hc installed',
                 status: 'fail',
                 message: describe(error),
-                hint: 'Install Herdr core and make sure hc is on PATH.',
+                hint: 'Install Herdr core (https://herdr.dev/core/) and make sure hc is on PATH.',
             });
             return checks;
         }

package/dist/drivers/vector-store/sqlite.js

@@ -2,6 +2,7 @@ import { mkdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { DriverError } from '../../contracts/driver.js';
 import { COLLECTION_NAME, } from '../../contracts/vector-store.js';
+import { NODE_SUPPORTED } from '../../util/node-support.js';
 import { openDatabase, sqlite } from '../../util/sqlite.js';
 /**
  * Vectors in SQLite files, one per collection, compared in code. Every search reads every
@@ -37,7 +38,7 @@ export class SqliteVectorStore {
                     name: 'vector store',
                     status: 'fail',
                     message: `Node's SQLite isn't available: ${error instanceof Error ? error.message : String(error)}`,
-                    hint: 'Use Node.js 22.13 or later.',
+                    hint: `Use ${NODE_SUPPORTED}.`,
                 },
             ];
         }

package/dist/knowledge/search.d.ts

@@ -73,6 +73,11 @@ export interface SearchIndexOptions {
     /** Where vectors go; needed only with embeddings. */
     vectors: VectorStoreDriver | null;
     log?: (message: string) => void;
+    /**
+     * Throws when SQLite can't do full-text search, which the index needs. Defaults to checking
+     * this Node's `node:sqlite`; tests pass their own.
+     */
+    requireFullTextSearch?: () => Promise<void>;
 }
 /** One workspace's search index. Writes run one at a time; searches can run alongside. */
 export declare class SearchIndex {

package/dist/knowledge/search.js

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { lstat, mkdir, readdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { basename, join, relative, sep } from 'node:path';
 import { parseDocument } from 'yaml';
-import { openDatabase } from '../util/sqlite.js';
+import { openDatabase, requireFullTextSearch } from '../util/sqlite.js';
 import { knowledgePaths, looksLikeSecret, noteTitle } from './notes.js';
 /**
  * Searching a workspace's knowledge base: its pages and notes, by keyword with SQLite's
@@ -328,6 +328,7 @@ export class SearchIndex {
         if (!(await exists(this.dbFile(current.generation)))) {
             throw new Error(`The ${this.workspace} workspace's search index is missing. The service rebuilds it, or run: wheems kb reindex`);
         }
+        await (this.options.requireFullTextSearch ?? requireFullTextSearch)();
         const db = await openDatabase(this.dbFile(current.generation));
         createSchema(db);
         const collection = current.embeddings !== null && this.options.vectors
@@ -351,6 +352,7 @@ export class SearchIndex {
         const vectors = embeddings !== null ? this.options.vectors : null;
         if (vectors)
             await vectors.drop(this.collectionName(generation));
+        await (this.options.requireFullTextSearch ?? requireFullTextSearch)();
         const db = await openDatabase(file);
         createSchema(db);
         const connection = {

package/dist/secrets.d.ts

@@ -1,7 +1,7 @@
 /**
  * Credentials, by name: `secrets.slack.bot_token`. They live in a private file on
  * this machine (mode 600), outside the install folder, and never pass through an
- * agent. The encrypted secret store comes in milestone 8.
+ * agent. The vault (the Keychain, or an encrypted file on servers) comes in milestone 9.
  */
 export type Secrets = Record<string, Record<string, string>>;
 export declare function readSecrets(file: string): Promise<Secrets>;

package/dist/service/conversations.js

@@ -58,7 +58,21 @@ export class ConversationManager {
         if (!binding)
             return Promise.resolve();
         const key = conversationKey(binding.workspace.id, connection, event.channel, replyThread(event));
-        return this.enqueue(key, () => this.deliver(key, binding, event).catch((error) => {
+        let message = event;
+        // Files can't reach the agent yet. Say so, rather than leave them unanswered.
+        if (event.files !== undefined && event.files.length > 0) {
+            const names = event.files.map((f) => f.name).join(', ');
+            if (event.text.trim() === '') {
+                return this.enqueue(key, () => this.notice(key, binding, replyThread(event), `I can't open files yet (${names}). Paste the text, or say in words what you need.`).catch((error) => {
+                    this.options.log(`Conversation ${key}: ${describe(error)}`);
+                }));
+            }
+            message = {
+                ...event,
+                text: `${event.text}\n\n(The person attached ${event.files.length === 1 ? 'a file' : `${String(event.files.length)} files`}: ${names}. Wheems can't pass files to you yet, so if you need what's in them, ask the person to paste it.)`,
+            };
+        }
+        return this.enqueue(key, () => this.deliver(key, binding, message).catch((error) => {
             this.options.log(`Conversation ${key}: ${describe(error)}`);
             return this.notice(key, binding, replyThread(event), `Something went wrong: ${describe(error)}`);
         }));
@@ -230,10 +244,12 @@ export class ConversationManager {
                     if (wait > 0)
                         await sleep(wait);
                 }
+                // Taken before sending: a quick agent can reply before the turn is being followed.
+                const sentAt = Date.now();
                 const sent = await this.options.runtime.send(session.id, event.text);
                 await this.options.store.touch(key, now);
                 await this.options.store.addPending(key);
-                this.watchTurn(key, binding, sessionName, sent.turn, seen, this.conversationFor(key, binding));
+                this.watchTurn(key, binding, sessionName, sent.turn, seen, this.conversationFor(key, binding), false, sentAt);
             }
             catch (error) {
                 if (!isDriverError(error, 'blocked'))
@@ -277,7 +293,8 @@ export class ConversationManager {
             pending: 1,
         });
         // A new session's turns count from 0; its first turn is the message it was started with.
-        this.watchTurn(key, binding, sessionName, 0, seen, this.conversationFor(key, binding));
+        // `now` was taken before the session started, so a reply to its first message counts.
+        this.watchTurn(key, binding, sessionName, 0, seen, this.conversationFor(key, binding), false, now.getTime());
         this.options.log(`Started ${started.id} (${sessionName}) for ${key}`);
         this.trimLater(binding.workspace.id, sessionName);
     }
@@ -379,7 +396,9 @@ export class ConversationManager {
         }
     }
     /** Follows the turn a message started, and tells the person if it ends badly or silently. */
-    watchTurn(key, binding, sessionName, fromTurn, seen, target, recovered = false) {
+    watchTurn(key, binding, sessionName, fromTurn, seen, target, recovered = false, 
+    /** When the message was handed to the agent; replies from then on count as its answer. */
+    sentAt = Date.now()) {
         const active = this.watches.get(key);
         if (active && active.sessionName === sessionName && !active.closed) {
             // A turn is already being followed. The agent takes this message during that turn or
@@ -391,7 +410,7 @@ export class ConversationManager {
         const watch = {
             sessionName,
             fromTurn,
-            sentAt: Date.now(),
+            sentAt,
             seen: seen ? [seen] : [],
             queued: [],
             closed: false,

package/dist/service/launchd.js

@@ -1,6 +1,6 @@
 /**
  * Runs the service under launchd on macOS, as a user agent that starts at login
- * and restarts if it stops. Linux (systemd) arrives with milestone 9.
+ * and restarts if it stops. Linux (systemd) arrives with the always-on milestone (10).
  */
 import { mkdir, rm, writeFile } from 'node:fs/promises';
 import { homedir, userInfo } from 'node:os';
@@ -99,7 +99,7 @@ export function parseLaunchctlPrint(text) {
 }
 function ensureMac() {
     if (process.platform !== 'darwin') {
-        throw new Error('The service runs under launchd on macOS for now; systemd on Linux comes in milestone 9.');
+        throw new Error('The service runs under launchd on macOS for now; systemd on Linux comes with the always-on milestone (10).');
     }
 }
 function xml(value) {

package/dist/service/service.js

@@ -65,12 +65,17 @@ export async function runService(options) {
         const channel = channelFor(chat.connection);
         let channelId = null;
         if ('channel' in chat) {
-            const resolver = channel.resolveChannel;
-            channelId = resolver ? await resolver.call(channel, chat.channel) : chat.channel;
+            channelId = channel.resolveChannel
+                ? await channel.resolveChannel(chat.channel)
+                : chat.channel;
             if (channelId === null) {
-                log(`Workspace ${workspace.id}: the bot cannot see channel ${chat.channel}; invite it to the channel`);
+                log(`Workspace ${workspace.id}: the app can't see channel ${chat.channel}; check the name, invite the app to it, then run wheems service restart`);
                 continue;
             }
+            // Slack lists public channels the app isn't in, and sends no messages from them.
+            if ((await channel.isMember?.(channelId)) === false) {
+                log(`Workspace ${workspace.id}: the app isn't in channel ${chat.channel}, so messages there won't reach the chief of staff. Invite it: in that channel, /invite @ the app's name`);
+            }
         }
         bindings.push({ workspace, connection: chat.connection, channel: channelId });
         log(`Workspace ${workspace.id}: chat on ${chat.connection} ${channelId === null ? '(direct messages)' : channelId}`);

package/dist/testing/memory-channel.d.ts

@@ -29,6 +29,9 @@ export declare class MemoryChannel implements ChannelDriver {
         threadId?: string;
         userId?: string;
         direct?: boolean;
+        files?: {
+            name: string;
+        }[];
     }): Promise<string>;
     /** Delivers a press of a button on a message the driver sent. */
     press(press: {

package/dist/testing/memory-channel.js

@@ -77,6 +77,7 @@ export class MemoryChannel {
             text: message.text,
             direct: message.direct ?? false,
             receivedAt: new Date(),
+            ...(message.files !== undefined && { files: message.files }),
         });
         return messageId;
     }

package/dist/util/node-support.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Which Node.js versions Wheems runs on. Search needs SQLite's full-text search (FTS5) in
+ * Node's built-in `node:sqlite`. Node bundles SQLite with FTS5 from 22.16.0 and 24.0.0 (nodejs
+ * PR 57621); no Node 23 release has it, and below 22.13 `node:sqlite` needs a flag. Builds that
+ * use the system's SQLite can still lack it, so doctor and search also check at run time.
+ *
+ * Kept free of imports: the CLI checks this before loading anything else.
+ */
+export declare const NODE_SUPPORTED = "Node.js 22.16 or later in the 22 line, or 24 or later";
+/** Why this Node.js version can't run Wheems, or null when it can. */
+export declare function nodeVersionProblem(version: string): string | null;

package/dist/util/node-support.js

@@ -0,0 +1,21 @@
+/**
+ * Which Node.js versions Wheems runs on. Search needs SQLite's full-text search (FTS5) in
+ * Node's built-in `node:sqlite`. Node bundles SQLite with FTS5 from 22.16.0 and 24.0.0 (nodejs
+ * PR 57621); no Node 23 release has it, and below 22.13 `node:sqlite` needs a flag. Builds that
+ * use the system's SQLite can still lack it, so doctor and search also check at run time.
+ *
+ * Kept free of imports: the CLI checks this before loading anything else.
+ */
+export const NODE_SUPPORTED = 'Node.js 22.16 or later in the 22 line, or 24 or later';
+/** Why this Node.js version can't run Wheems, or null when it can. */
+export function nodeVersionProblem(version) {
+    const [major = 0, minor = 0] = version.replace(/^v/, '').split('.').map(Number);
+    if (major === 23) {
+        return `Node.js ${version} can't run Wheems: no Node 23 release has SQLite full-text search, which Wheems's search needs. Use ${NODE_SUPPORTED}.`;
+    }
+    if (major < 22 || (major === 22 && minor < 16)) {
+        return `Node.js ${version} is too old for Wheems. Use ${NODE_SUPPORTED}.`;
+    }
+    return null;
+}
+//# sourceMappingURL=node-support.js.map

package/dist/util/sqlite.d.ts

@@ -10,4 +10,16 @@ export declare function sqlite(): Promise<Sqlite>;
 export declare function openDatabase(file: string, options?: {
     readOnly?: boolean;
 }): Promise<DatabaseSync>;
+/** Something that runs SQL, as `DatabaseSync` does; tests pass a stand-in. */
+export interface SqlRunner {
+    exec(sql: string): void;
+    close(): void;
+}
+/**
+ * Why this SQLite can't do full-text search (FTS5), which search needs, or null when it can.
+ * `open` makes a scratch database; by default an in-memory one from `node:sqlite`.
+ */
+export declare function fullTextSearchProblem(open?: () => Promise<SqlRunner>): Promise<string | null>;
+/** Throws a plain explanation when this Node's SQLite has no full-text search. Checks once. */
+export declare function requireFullTextSearch(): Promise<void>;
 export {};

package/dist/util/sqlite.js

@@ -1,3 +1,4 @@
+import { NODE_SUPPORTED } from './node-support.js';
 let loaded;
 /**
  * Node's built-in SQLite, loaded without its "experimental" warning, which would otherwise
@@ -39,4 +40,38 @@ export async function openDatabase(file, options = {}) {
         db.exec('PRAGMA journal_mode = WAL');
     return db;
 }
+/**
+ * Why this SQLite can't do full-text search (FTS5), which search needs, or null when it can.
+ * `open` makes a scratch database; by default an in-memory one from `node:sqlite`.
+ */
+export async function fullTextSearchProblem(open) {
+    let db;
+    try {
+        db = open ? await open() : new (await sqlite()).DatabaseSync(':memory:');
+    }
+    catch (error) {
+        return `Node's SQLite isn't available: ${describe(error)}. Use ${NODE_SUPPORTED}.`;
+    }
+    try {
+        db.exec('CREATE VIRTUAL TABLE probe USING fts5(text)');
+        return null;
+    }
+    catch (error) {
+        return `This Node.js (${process.versions.node}, ${process.execPath}) has SQLite without full-text search (FTS5), which Wheems's search needs (${describe(error)}). Use ${NODE_SUPPORTED}, from nodejs.org or a package that bundles Node's own SQLite.`;
+    }
+    finally {
+        db.close();
+    }
+}
+let checked;
+/** Throws a plain explanation when this Node's SQLite has no full-text search. Checks once. */
+export async function requireFullTextSearch() {
+    checked ??= fullTextSearchProblem();
+    const problem = await checked;
+    if (problem !== null)
+        throw new Error(problem);
+}
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 //# sourceMappingURL=sqlite.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wheems",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "An opinionated framework for running teams of AI agents, on Herdr core",
   "license": "Apache-2.0",
   "homepage": "https://wheems.dev",
@@ -24,7 +24,7 @@
   ],
   "type": "module",
   "engines": {
-    "node": ">=22.13.0"
+    "node": "^22.16.0 || >=24"
   },
   "bin": {
     "wheems": "dist/cli/main.js"
@@ -48,7 +48,7 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json && tsx scripts/make-executable.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "lint": "eslint . && prettier --check .",
     "format": "prettier --write .",