hotsheet 0.19.0 → 0.20.0-beta.10

package/README.md

@@ -10,7 +10,7 @@
 
 <br>
 
-**Hot Sheet** is a local-first project management tool wired into your AI coding workflow. Create tickets with a bullet-list interface, drag them into priority order, and your AI tools automatically get a structured worklist they can act on. A real PTY-backed terminal lives in the footer drawer — switch to the dashboard view to see every terminal across every project as a tile grid — so you can keep an eye on dev servers, tests, and the AI's own Claude Code session from the same window.
+**Hot Sheet** is a local-first project management tool wired into your AI coding workflow. Create tickets with a bullet-list interface, drag them into priority order, and your AI tools automatically get a structured worklist they can act on. A real PTY-backed terminal lives in the footer drawer — switch to the dashboard view to see every terminal across every project as a tile grid — so you can keep an eye on dev servers, tests, and the AI's own Claude Code session from the same window. Step away, and the **Announcer** narrates what the AI got done while you were gone.
 
 No cloud. No logins. No JIRA. Just tickets, terminals, and a tight feedback loop.
 
@@ -183,6 +183,68 @@ Read .hotsheet/worklist.md for current work items.
 
 Hot Sheet automatically generates skill files for Claude Code (as well as Cursor, GitHub Copilot, and Windsurf) so your AI tool can create tickets directly. Run `/hotsheet` in Claude Code to process the worklist.
 
+### Recommended project instructions
+
+Hot Sheet works best when your AI assistant follows a few conventions: drive work through Hot Sheet tickets, keep double test coverage, and keep requirements docs in sync. Add these sections to your project's `CLAUDE.md` (Claude Code) — Hot Sheet can do it for you, or copy them by hand.
+
+- **Automatic:** when Hot Sheet detects Claude Code in a project, it offers (once per project) to add these sections to your `CLAUDE.md`. Your existing file is preserved — the sections are wrapped in markers so Hot Sheet can keep them up to date without touching anything else, and the test/docs *specifics* are filled in by your assistant for that project.
+- **Manual:** click **Update CLAUDE.md** in **Settings → General** at any time, or copy the blocks below.
+
+<details>
+<summary><strong>Ticket-Driven Work</strong></summary>
+
+```markdown
+## Ticket-Driven Work
+
+When the user gives you work directly (not via the Hot Sheet channel or events), create Hot Sheet tickets before starting implementation — especially for substantial or multi-step work.
+
+- **Do create tickets** for: features, bug fixes, refactoring, multi-step tasks, anything changing code. **Don't** for: simple questions, git commits, quick lookups, trivial one-liners. **When in doubt, create them.**
+- Create via the Hot Sheet API (prefer the `hotsheet_*` MCP tools), mark Up Next, then work through them: set status `started` → implement → set `completed` with notes.
+- **Always create follow-up tickets** for incomplete work (unfinished steps, open design questions, known gaps, designed-but-unbuilt features). If it's not in a ticket, it's forgotten.
+- **Incomplete-work checklist** — before marking a ticket `completed`, file follow-ups for any: (1) UI placeholder text ("coming soon"), (2) TODO/FIXME comments, (3) documented-but-unimplemented requirements, (4) empty/stub functions returning mock data.
+- **Use FEEDBACK NEEDED before deferring or asking about follow-ups.** When about to (a) defer a ticket needing more work, (b) ask whether to file follow-ups, or (c) close with a question buried in notes — DON'T. Leave the ticket `started`, add a `FEEDBACK NEEDED:` note (per `.hotsheet/worklist.md`), signal channel done, and wait. It's the only reliable way to surface a question.
+```
+
+</details>
+
+<details>
+<summary><strong>Testing Philosophy</strong></summary>
+
+```markdown
+## Testing Philosophy
+
+- **Double coverage**: every feature covered by both unit tests AND E2E tests. Unit = logic in isolation; E2E = real user flows through the running app with minimal mocking.
+- **Unit tests**: Mock external deps (filesystem, network), test real logic.
+- **E2E tests**: As much as possible, use test automation tools to run realistic, user-facing flows. Minimize mocks.
+- **Coverage**: Merge all test coverage (e.g. unit, E2E server, E2E browser) into one report. Low-coverage files should get more of both test types. Aim for 100% coverage of code lines, 100% coverage of branches, and 100% of features described in the requirements documentation.
+- **Manual test plan**: keep a manual test plan doc (e.g. `docs/manual-test-plan.md`) for features that can't be reliably automated. **Keep it up to date** — add such features there; when you add automated coverage for a previously-manual item, remove it and note it in an "Automated Coverage Summary".
+- **Always fix lint and type errors before finishing**: Fix as you go, don't batch.
+```
+
+When Hot Sheet adds this section it also scaffolds a self-healing **"this project's test setup"** block: a short prompt that asks your assistant to detect and record the project's actual test runner, file locations, and commands the first time it does test work — so the generic principles get project-specific teeth for any language.
+
+</details>
+
+<details>
+<summary><strong>Requirements Documentation</strong></summary>
+
+```markdown
+## Requirements Documentation
+
+Keep human-readable requirements documents as the source of truth for what the project does, and **keep them up to date in the same change as the code** (add/remove/modify a requirement → update its doc). Create new docs for major new functional areas. Cross-reference related docs with relative links.
+
+### AI Summaries
+
+Maintain two synthesis docs an AI assistant reads at the start of a fresh session — keep them in sync with reality (source doc/code wins on conflict), and prefer small targeted edits over rewrites:
+
+- A **codebase map** — directory tree, entry points, data schema, build, tests, settings, and a "where do I look for X" index. Update it in the same change when you add a file or directory, add a route/endpoint, change the schema, add a client module, or add a setting key.
+- A **requirements summary** — a synthesized view of every requirements doc with status markers (e.g. Shipped / Partial / Design only / Deferred). Update it in the same change when you add a requirements doc, ship a design-only feature, or defer/regress a shipped one.
+```
+
+</details>
+
+See [docs/86-ai-assistant-setup.md](docs/86-ai-assistant-setup.md) for how the auto-install / auto-update mechanism works.
+
 ### Claude Channel Integration (Experimental)
 
 Hot Sheet can push events directly to a running Claude Code session via MCP channels. Enable it in Settings:
@@ -191,10 +253,10 @@ Hot Sheet can push events directly to a running Claude Code session via MCP chan
 - **Auto mode** — double-click the play button to enable automatic mode. Claude is triggered immediately, then continues monitoring for new Up Next items with debounce. Exponential backoff prevents runaway retries.
 - **Auto-prioritize** — when no tickets are flagged as Up Next, Claude automatically evaluates open tickets and picks the most important ones to work on.
 - **Feedback loop** — Claude can request user input by adding notes prefixed with `FEEDBACK NEEDED:` or `IMMEDIATE FEEDBACK NEEDED:`. A rich dialog appears in the UI with inline-response slots between every prompt block, a catch-all field, and file attachment support. Save Draft to come back later (text + attachments survive); Submit re-triggers Claude with your response. Blue dots on project tabs indicate pending feedback.
-- **Custom commands** — create named buttons that send custom prompts to Claude **or run shell commands** directly. Organize into collapsible groups. Toggle between "Claude Code" and "Shell" targets per command. Shell commands execute server-side with stdout/stderr streamed to the commands log in real time.
+- **Custom commands** — create named buttons that send custom prompts to Claude **or run shell commands** directly. Organize into collapsible groups. Toggle between "Claude Code" and "Shell" targets per command. Shell commands execute server-side with stdout/stderr streamed to the commands log in real time. **Long-press** a button for a secondary action (a shell command runs in a fresh terminal; a Claude command files a task ticket), and **hover** any button to see when it last ran.
 - **Permission relay** — when Claude needs tool approval (Bash, Edit, etc.), a full-screen overlay shows the tool name and command preview with Allow/Deny/Dismiss buttons — no need to switch to the terminal. Per-project **allow-rules** can auto-approve specific tool+pattern pairs (e.g. always allow `Bash:npm test`) so trusted commands skip the overlay entirely.
 - **Commands log + embedded terminal** — the footer drawer hosts both a resizable commands log (every trigger, completion, permission request, shell output) AND tabs for any number of project-scoped terminals. Hop between an `npm run dev` terminal, the Claude session, and the audit log without leaving Hot Sheet.
-- **MCP tools** — Claude Code sees Hot Sheet as a connected MCP server with schema-validated tools: `hotsheet_create_ticket`, `hotsheet_update_ticket`, `hotsheet_query_tickets`, `hotsheet_batch`, `hotsheet_signal_done`, `hotsheet_request_feedback`, and 8 more. Tickets, notes, and attachments all round-trip without the AI hand-crafting curl commands.
+- **MCP tools** — Claude Code sees Hot Sheet as a connected MCP server with schema-validated tools: `hotsheet_create_ticket`, `hotsheet_update_ticket`, `hotsheet_query_tickets`, `hotsheet_batch`, `hotsheet_signal_done`, `hotsheet_request_feedback`, `hotsheet_announce`, and 8 more. Tickets, notes, and attachments all round-trip without the AI hand-crafting curl commands.
 - **Status indicator** — shows "Claude working" / "Shell running" / idle in the footer.
 
 Requires Claude Code v2.1.80+ with channel support. See [docs/12-claude-channel.md](docs/12-claude-channel.md) for setup details.
@@ -203,6 +265,23 @@ Requires Claude Code v2.1.80+ with channel support. See [docs/12-claude-channel.
   <img src="docs/demo-9.png" alt="Claude Channel integration with play button, custom command buttons, and AI-driven workflow" width="900">
 </p>
 
+### Announcer — narrated playback of project work (Beta)
+
+Step away while Claude works, and the **Announcer** catches you up. It turns completion notes, the command log, and Claude Code's own telemetry stream into a short spoken-and-visual digest — a draggable, resizable picture-in-picture transcript that reads each update aloud, emphasizes the key phrases, and shows the actual before/after code diff for the change it's describing.
+
+- **After-the-fact digest** — click **Listen** to hear everything that happened since you last checked in, narrated in order. The PIP shows the running transcript with playback controls (play/pause, previous, next, speed) and tier-1 emphasis on the phrases that matter.
+- **Live mode** — narrates work as it happens, coalescing bursts of activity into coherent entries and learning from the ones you skip. It's **off unless you're listening** — a client-renewed lease gates generation so it never spends your key in the background, with a per-project call budget on top.
+- **Cross-project** — an "All Projects" context interleaves every enabled project's reel chronologically, each entry tagged with a project chip and prefixed with its project name when spoken.
+- **Spoken permission checks** — hear "Permission needed in *Project*: …" read aloud when Claude needs tool approval, even with no PIP open and no API key required.
+- **Bring your own model — or none** — summarize with your Anthropic key, **on-device with Apple Foundation Models** (macOS 26, free and fully private, no key), or a local **Ollama / OpenAI-compatible** endpoint. Playback uses the built-in OS/browser voice by default.
+- **Code-diff visuals** — the working agent can hand the Announcer the exact before/after through the `hotsheet_announce` MCP tool, rendered inline in the PIP next to the narration.
+
+API keys are managed once in **Settings → API Keys** — a machine-global registry of named keys stored in the OS keychain, selected by name per project so you never paste a secret twice. Enable narration in **Settings → Announcer**.
+
+<p align="center">
+  <img src="docs/demo-14.png" alt="Announcer transcript picture-in-picture narrating recent work over the ticket board, with emphasized phrases and an inline before/after code diff" width="900">
+</p>
+
 ### Telemetry & Cost Tracking
 
 **On by default** (HS-8684 — opt out per project via Settings → Telemetry). Hot Sheet stamps Claude Code's spawn env so its OpenTelemetry exporter posts cost / token / latency events back to a localhost-bound endpoint. The data drives several surfaces:
@@ -213,7 +292,7 @@ Requires Claude Code v2.1.80+ with channel support. See [docs/12-claude-channel.
 - **Per-ticket Claude usage** — when you trigger Claude via the channel with an active ticket selected, Hot Sheet prepends an invisible `<!-- hotsheet:ticket=HS-NNNN -->` marker to the prompt so the cost / tokens / wall-clock from that work attribute back to the ticket and appear as a "Claude usage on this ticket" block in the detail panel.
 - **Beta enhanced tracing** — separate toggle wires `CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1` so each prompt's drilldown switches from a flat event timeline to a parent-child span tree with an inline waterfall chart. New `claude` sessions started after the toggle begin capturing spans.
 
-Security model: localhost-bound OTLP receiver + `hotsheet_project` resource-attribute filter — foreign OTLP traffic from other tools on the same machine can't pollute Hot Sheet's tables even if it tries. 30-day default retention via the cleanup sweep; **Clear telemetry data** in Settings wipes the project's rows on demand.
+Security model: localhost-bound OTLP receiver + `hotsheet_project` resource-attribute filter — foreign OTLP traffic from other tools on the same machine can't pollute Hot Sheet's tables even if it tries. Telemetry is stored per-project with a configurable retention window (30-day default) enforced by a periodic sweep with per-table windows and a row cap, so the database can't grow without bound; **Clear telemetry data** in Settings wipes the project's rows on demand.
 
 <p align="center">
   <img src="docs/demo-13.png" alt="Cross-project telemetry stats page with cost-over-time chart, cost-by-project table, model donut, and hourly activity heatmap" width="900">

package/dist/channel.js

@@ -10283,6 +10283,19 @@ import { z as z3 } from "zod";
 
 // src/routes/validation.ts
 import { z as z2 } from "zod";
+
+// src/announcer/models.ts
+var APPLE_FOUNDATION_MODEL_ID = "apple-foundation";
+var LOCAL_MODEL_ID = "local";
+var ANNOUNCER_PRICING = {
+  [APPLE_FOUNDATION_MODEL_ID]: { inputPerMTok: 0, outputPerMTok: 0 },
+  [LOCAL_MODEL_ID]: { inputPerMTok: 0, outputPerMTok: 0 },
+  "claude-haiku-4-5": { inputPerMTok: 1, outputPerMTok: 5 },
+  "claude-sonnet-4-6": { inputPerMTok: 3, outputPerMTok: 15 },
+  "claude-opus-4-8": { inputPerMTok: 5, outputPerMTok: 25 }
+};
+
+// src/routes/validation.ts
 var TicketPrioritySchema = z2.enum(["highest", "high", "default", "low", "lowest"]);
 var TicketStatusSchema = z2.enum(["not_started", "started", "completed", "verified", "backlog", "archive", "deleted"]);
 var SortBySchema = z2.enum(["created", "modified", "priority", "category", "status"]);
@@ -10422,6 +10435,16 @@ var DashboardConfigSchema = z2.object({
   // made after HS-8406 landed could persist across relaunches.
   activeVisibilityGroupingIdByScope: z2.record(z2.string(), z2.string()).optional()
 }).strict();
+var KeyTypeSchema = z2.enum(["anthropic_api_key"]);
+var SecretKeyMetaSchema = z2.object({
+  id: z2.string(),
+  type: KeyTypeSchema,
+  name: z2.string(),
+  // HS-8760 — provenance shown in the API Keys row ("Created/Updated …").
+  // Optional for back-compat with keys created before HS-8760.
+  created_at: z2.string().optional(),
+  updated_at: z2.string().optional()
+});
 var GlobalConfigSchema = z2.object({
   channelEnabled: z2.boolean().optional(),
   shareTotalSeconds: z2.number().optional(),
@@ -10434,7 +10457,65 @@ var GlobalConfigSchema = z2.object({
   terminalWebglOptOut: z2.boolean().optional(),
   // HS-8497 — billing model for telemetry cost display. See
   // `global-config.ts` for the contract.
-  telemetryCostMode: z2.enum(["api", "subscription"]).optional()
+  telemetryCostMode: z2.enum(["api", "subscription"]).optional(),
+  // HS-8751 — global API-key registry (metadata only; values in the keychain).
+  keys: z2.array(SecretKeyMetaSchema).optional(),
+  // HS-8754 — Announcer playback speed multiplier (1 = normal). Global because
+  // it's a listening preference, not project-specific. Clamped 0.5×–2×.
+  announcerSpeechRate: z2.number().min(0.5).max(2).optional(),
+  // HS-8764 — Announcer summarization model. Global; defaults to the cheapest
+  // (Haiku) when unset. See `src/announcer/models.ts`. HS-8853 — the Anthropic
+  // list is now discovered dynamically from the user's key, so this accepts any
+  // `claude-*` id (not just the static set) plus the two on-device pseudo-ids.
+  announcerModel: z2.string().refine(
+    (v) => v === APPLE_FOUNDATION_MODEL_ID || v === LOCAL_MODEL_ID || v.startsWith("claude-"),
+    { message: "must be an on-device provider id or a claude-* model id" }
+  ).optional(),
+  // HS-8792 — local-provider config (used only when `announcerModel === 'local'`).
+  // `Endpoint` is the OpenAI-compatible base URL (default `http://localhost:11434/v1`);
+  // `Model` is the concrete local model name (e.g. `llama3.1`). Both global.
+  announcerLocalEndpoint: z2.string().optional(),
+  announcerLocalModel: z2.string().optional(),
+  // HS-8891 — optional fallback model used ONLY when the primary is Apple
+  // Foundation Models and it fails at inference (the HS-8883 "code 4" class). A
+  // non-apple id: a `claude-*` model (cloud backup, spends on the user's key) or
+  // the local pseudo-id. Empty string / unset = no fallback (Apple failure → no
+  // narration, the pre-HS-8891 behavior). The auto-selected-on-device fallback
+  // (HS-8805) is separate and unaffected.
+  announcerFallbackModel: z2.string().refine(
+    (v) => v === "" || v === LOCAL_MODEL_ID || v.startsWith("claude-"),
+    { message: "must be empty, the local provider id, or a claude-* model id" }
+  ).optional(),
+  // HS-8781 — verbally announce permission checks (TTS only, no API cost).
+  // Global; default ON, so `undefined`/unset is treated as enabled by the
+  // client (`announcerSpeakPermissions !== false`).
+  announcerSpeakPermissions: z2.boolean().optional(),
+  // HS-8874 — one-time marker that the per-project telemetry migration
+  // (`migratePerProjectTelemetry`) has run. Set after a successful, non-
+  // destructive copy of legacy launch-default telemetry rows into each row's
+  // owning project DB / the central store. Skipped on subsequent startups.
+  telemetryMigratedV1: z2.boolean().optional(),
+  // HS-8874 (migration efficiency) — per-source-DB resumability for the
+  // telemetry migration. Each source project dir is appended here once all its
+  // foreign rows have been copied, so a crash/quit mid-migration resumes at the
+  // first incomplete DB instead of restarting from zero (the boot-loop the
+  // end-only `telemetryMigratedV1` flag caused). Cleared when migration completes.
+  telemetryMigrationV1DoneDirs: z2.array(z2.string()).optional(),
+  // HS-8877 — retention window (days) for the centralized non-project telemetry
+  // store (`~/.hotsheet/telemetry`). Projects have a per-project
+  // `telemetry_retention_days`; central isn't a project, so its sweep window
+  // lives here. Unset → the §67.6 default (30 days). `0` keeps central forever.
+  centralTelemetryRetentionDays: z2.number().int().min(0).optional(),
+  // HS-8890 (§85.2.2) — retention window (days) for `otel_spans` in the central
+  // store. Spans (§68 enhanced tracing) are high-volume, so they age out faster
+  // than metrics/events: unset → the §85 default of 7 days (vs 30 for
+  // metrics/events via `centralTelemetryRetentionDays`); `0` keeps spans forever.
+  centralSpanRetentionDays: z2.number().int().min(0).optional(),
+  // HS-8884 — last time a `VACUUM FULL` reclaim ran per telemetry DB dir
+  // (`<dataDir>/db` or the central store), keyed by that dir's absolute path →
+  // ISO timestamp. Throttles the heavy, exclusive-lock full reclaim to at most
+  // once per `FULL_VACUUM_THROTTLE_DAYS`; routine plain VACUUMs aren't tracked.
+  telemetryVacuumFullAt: z2.record(z2.string(), z2.string()).optional()
 }).strict();
 var PluginActionSchema = z2.object({
   actionId: z2.string(),
@@ -10577,6 +10658,15 @@ var QueryTicketsInputSchema = z3.object({
   required_tag: z3.string().optional().describe("When set, only tickets carrying this tag are included"),
   include_archived: z3.boolean().optional()
 });
+var AnnounceInputSchema = z3.object({
+  title: z3.string().min(1).describe('A few words naming the moment (e.g. "Fixed the data-loss bug").'),
+  highlight: z3.string().min(1).describe("One or two short sentences of natural spoken English to read aloud \u2014 what happened and why it matters."),
+  diff: z3.object({
+    oldStr: z3.string().describe("The code BEFORE the change (the focused snippet you changed, not the whole file)."),
+    newStr: z3.string().describe("The code AFTER the change."),
+    filePath: z3.string().optional().describe("Optional file path shown as the diff header.")
+  }).optional().describe("Optional code diff to display with this highlight \u2014 supply the before/after of the focused change you want to show off.")
+});
 async function dispatchUpdateTicket(args2, settings, fetchFn) {
   const parsed = UpdateTicketInputSchema.safeParse(args2);
   if (!parsed.success) {
@@ -10707,6 +10797,13 @@ async function dispatchDeleteNote(args2, settings, fetchFn) {
   const { ticket_id, note_id } = parsed.data;
   return await proxyRequest(settings, `/api/tickets/${String(ticket_id)}/notes/${encodeURIComponent(note_id)}`, { method: "DELETE" }, fetchFn);
 }
+async function dispatchAnnounce(args2, settings, fetchFn) {
+  const parsed = AnnounceInputSchema.safeParse(args2);
+  if (!parsed.success) {
+    return errorResult(`hotsheet_announce \u2014 validation failed: ${parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`);
+  }
+  return await proxyRequest(settings, "/api/announcer/announce", { method: "POST", body: parsed.data }, fetchFn);
+}
 async function dispatchQueryTickets(args2, settings, fetchFn) {
   const parsed = QueryTicketsInputSchema.safeParse(args2);
   if (!parsed.success) {
@@ -10799,6 +10896,13 @@ var TOOLS = [
     description: 'Run a custom-view-style query: combine field/operator/value conditions via AND (logic="all") or OR (logic="any"), with optional sort_by / sort_dir / required_tag / include_archived. Returns the matching tickets. For agents that need to dig deeper than the worklist provides.',
     inputSchema: QueryTicketsInputSchema,
     call: dispatchQueryTickets
+  },
+  // HS-8771 — hybrid Announcer generation (§80).
+  {
+    name: "hotsheet_announce",
+    description: `Push a curated Announcer highlight for a genuinely notable moment ("fixed a data-loss bug", "shipped the export"). It pre-empts the derived narration queue with a low-latency, high-intent entry (no AI summarization). Use sparingly, only for moments worth interrupting for. No-op if the project hasn't enabled the Announcer.`,
+    inputSchema: AnnounceInputSchema,
+    call: dispatchAnnounce
   }
 ];
 function listTools() {
@@ -10964,6 +11068,16 @@ var TicketSchema = z6.object({
   last_read_at: z6.string().nullable()
 });
 var TagsArraySchema = z6.array(z6.string());
+var EmphasisArraySchema = z6.array(z6.string());
+var DiffVisualSchema = z6.object({
+  type: z6.literal("diff"),
+  oldStr: z6.string(),
+  newStr: z6.string(),
+  filePath: z6.string().nullable().default(null),
+  replaceAll: z6.boolean().default(false)
+});
+var VisualSchema = z6.discriminatedUnion("type", [DiffVisualSchema]);
+var VisualsArraySchema = z6.array(VisualSchema);
 var AutoContextEntrySchema = z6.object({
   type: z6.enum(["category", "tag"]),
   key: z6.string(),
@@ -11039,6 +11153,20 @@ var PermissionResultBodySchema = z6.object({
 var GithubCommentsArraySchema = z6.array(z6.object({
   body_html: z6.string().optional()
 }).loose());
+var CustomViewConditionSchema = z6.object({
+  field: z6.string(),
+  operator: z6.string(),
+  value: z6.string()
+}).loose();
+var CustomViewSchema = z6.object({
+  id: z6.string(),
+  name: z6.string(),
+  tag: z6.string().optional(),
+  includeArchived: z6.boolean().optional(),
+  logic: z6.enum(["all", "any"]).default("all"),
+  conditions: z6.array(CustomViewConditionSchema).default([])
+}).loose();
+var CustomViewArraySchema = z6.array(CustomViewSchema);
 
 // src/channel-config.ts
 var McpConfigSchema = z7.object({
@@ -11279,7 +11407,7 @@ function installStdioDisconnectHandler(opts) {
 }
 
 // src/channel.ts
-var CHANNEL_VERSION = 9;
+var CHANNEL_VERSION = 11;
 var dataDir = ".hotsheet";
 var args = process.argv.slice(2);
 for (let i = 0; i < args.length; i++) {