trismegistus 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jessekaff
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,189 @@
+# trismegistus
+
+A local persistent daemon that runs Claude Code sessions from a task queue. Add tasks to a markdown file, start the daemon, and walk away — it works through your list overnight, retries failures with context, and lets you steer it from your phone.
+
+## Install
+
+```bash
+npm install -D trismegistus
+```
+
+Or install globally:
+
+```bash
+npm install -g trismegistus
+```
+
+### Prerequisites
+
+- Node.js >= 18
+- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) installed and authenticated (`npm install -g @anthropic-ai/claude-code`)
+
+## Quick Start
+
+```bash
+# Initialize in your project
+npx tmg init
+
+# Add tasks from the CLI
+npx tmg add "Migrate user model to TypeScript"
+npx tmg add "Write tests for the payment module"
+
+# Start the daemon
+npx tmg start
+```
+
+The daemon picks up tasks one at a time, runs each in a full Claude Code session with `--dangerously-skip-permissions`, commits the work, and moves on to the next.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `tmg init` | Create `.trismegistus/` folder with config, tasks, and notes files |
+| `tmg add "task"` | Add a task to the queue |
+| `tmg start` | Start the daemon — runs tasks continuously until the queue is empty |
+| `tmg status` | Show counts of pending, in-progress, done, retrying, and gave-up tasks |
+| `tmg remote` | Open a VS Code tunnel with QR code for phone access |
+| `tmg reset` | Reset all gave-up `[!!!]` tasks back to pending `[ ]` |
+| `tmg -v` | Show version |
+
+## Task File Format
+
+Tasks live in `.trismegistus/tasks.md` — plain markdown with checkbox syntax:
+
+```markdown
+- [ ] Add authentication to the API
+- [ ] Write tests for the payment module
+- [ ] Refactor database queries to use connection pooling
+```
+
+The daemon updates statuses as it works:
+
+| Marker | Meaning |
+|--------|---------|
+| `[ ]` | Pending — waiting to run |
+| `[~]` | In progress — currently running |
+| `[x]` | Done |
+| `[!]` | Failed once — will retry |
+| `[!!]` | Failed twice — will retry |
+| `[!!!]` | Gave up — exceeded max retries |
+
+## Workflows & Use Cases
+
+### Run tasks overnight
+
+The core use case. Queue up a list of tasks before bed, start the daemon, and wake up to completed work.
+
+```bash
+# Add your tasks
+cat >> .trismegistus/tasks.md << 'EOF'
+- [ ] Migrate user model to TypeScript
+- [ ] Add input validation to all API routes
+- [ ] Write integration tests for the checkout flow
+EOF
+
+# Start and let it run
+tmg start
+```
+
+Each task gets a full Claude Code session with autonomous permissions — it can read files, write code, run commands, and commit.
+
+### Leave notes for Claude
+
+While the daemon is running, drop notes in `.trismegistus/notes.md`. The daemon reads and clears them before starting the next task — so you can steer it locally or from any device that can edit the file.
+
+```bash
+echo "Use Prisma instead of raw SQL for the database tasks" >> .trismegistus/notes.md
+```
+
+Notes are passed to Claude with priority, so you can redirect approach, add context, or give instructions without stopping the daemon. You can even ask Claude to add new tasks — it will edit `tasks.md` itself, and the daemon picks them up next cycle.
+
+### Add tasks while it's running
+
+The task file is just markdown. Add new lines while the daemon is running and it will pick them up when the current task finishes.
+
+```bash
+echo "- [ ] Fix the bug in the login form" >> .trismegistus/tasks.md
+```
+
+### Monitor from your phone
+
+`tmg remote` creates a secure VS Code tunnel through Microsoft's Azure relay and prints a QR code. Scan it on your phone to get a full VS Code UI — including terminal access — right in the browser. No port forwarding or same-network requirement.
+
+```bash
+tmg remote
+```
+
+Prerequisites: VS Code `code` CLI installed, GitHub account (one-time device auth on first use).
+
+You can set a custom tunnel name:
+
+```bash
+tmg remote --name my-machine
+```
+
+### Check progress remotely
+
+```bash
+tmg status
+```
+
+```
+  TMG Status
+  ─────────────
+  Pending:       3
+  In Progress:   1
+  Done:          5
+  Retrying (!):  0
+  Retrying (!!): 0
+  Gave up (!!!): 1
+```
+
+### Retry failed tasks
+
+When a task fails 3 times, it's marked `[!!!]` and skipped. After fixing the underlying issue, reset all gave-up tasks:
+
+```bash
+tmg reset
+tmg start
+```
+
+### Automatic handoff between retries
+
+When a task fails, Claude writes a handoff summary to `.trismegistus/handoff`. The next attempt receives this context so it can pick up where the previous session left off rather than starting from scratch.
+
+## Configuration
+
+Edit `.trismegistus/config` to tune the daemon:
+
+```
+MAX_RETRIES=3           # Attempts per task before giving up
+TIMEOUT_MINUTES=30      # Max runtime per task
+IDLE_POLL_SECONDS=10    # Poll interval when no tasks available
+TASK_DELAY_SECONDS=5    # Pause between tasks
+```
+
+## How It Works
+
+1. `tmg start` runs preflight checks (directory exists, Claude CLI installed)
+2. The daemon polls `tasks.md` for the next pending or retryable task
+3. It reads any human notes from `notes.md` (then clears the file)
+4. It reads any handoff context from a previous failed attempt
+5. It spawns `claude --dangerously-skip-permissions` with a constructed prompt
+6. On success: marks the task `[x]` and moves on
+7. On failure: escalates the status (`[ ]` -> `[!]` -> `[!!]` -> `[!!!]`), saves handoff context, and retries
+8. When the queue is empty, it idles and watches for new tasks
+
+## Project Structure
+
+```
+.trismegistus/
+  config          # Daemon configuration
+  tasks.md        # Your task queue
+  notes.md        # Notes for Claude (cleared after each read)
+  handoff         # Context passed between retry attempts (auto-managed)
+```
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,569 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import { createRequire as createRequire2 } from "module";
+import { hostname } from "os";
+import qrcode from "qrcode-terminal";
+
+// src/init.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+
+// src/types.ts
+var DEFAULT_CONFIG = {
+  maxRetries: 3,
+  timeoutMinutes: 30,
+  idlePollSeconds: 10,
+  taskDelaySeconds: 5
+};
+var DIR_NAME = ".trismegistus";
+var CONFIG_FILE = "config";
+var TASKS_FILE = "tasks.md";
+var NOTES_FILE = "notes.md";
+var HANDOFF_FILE = "handoff";
+var TASKS_TEMPLATE = `# Tasks \u2014 one per line
+# - [ ] = pending   - [x] = done
+# - [!] = failed once (retrying)  - [!!] = twice  - [!!!] = gave up
+
+- [ ] Example: replace with your first real task
+`;
+var NOTES_TEMPLATE = `# Notes for Claude \u2014 write here, cleared after each read
+`;
+var CONFIG_TEMPLATE = `# Trismegistus Configuration
+MAX_RETRIES=3
+TIMEOUT_MINUTES=30
+IDLE_POLL_SECONDS=10
+TASK_DELAY_SECONDS=5
+`;
+var STATUS_PRIORITY = [" ", "!", "!!"];
+
+// src/init.ts
+function initProject(projectDir) {
+  const tmgDir = join(projectDir, DIR_NAME);
+  const result = { created: [], skipped: [] };
+  if (!existsSync(tmgDir)) {
+    mkdirSync(tmgDir, { recursive: true });
+  }
+  const files = [
+    { name: CONFIG_FILE, content: CONFIG_TEMPLATE },
+    { name: TASKS_FILE, content: TASKS_TEMPLATE },
+    { name: NOTES_FILE, content: NOTES_TEMPLATE }
+  ];
+  for (const file of files) {
+    const path = join(tmgDir, file.name);
+    if (existsSync(path)) {
+      result.skipped.push(file.name);
+    } else {
+      writeFileSync(path, file.content);
+      result.created.push(file.name);
+    }
+  }
+  return result;
+}
+
+// src/tasks.ts
+import { readFileSync, writeFileSync as writeFileSync2, existsSync as existsSync2, unlinkSync } from "fs";
+import { join as join2 } from "path";
+var TASK_REGEX = /^- \[([^\]]*)\] (.+)$/;
+function tasksPath(projectDir) {
+  return join2(projectDir, DIR_NAME, TASKS_FILE);
+}
+function notesPath(projectDir) {
+  return join2(projectDir, DIR_NAME, NOTES_FILE);
+}
+function handoffPath(projectDir) {
+  return join2(projectDir, DIR_NAME, HANDOFF_FILE);
+}
+function parseTasks(content) {
+  const tasks = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(TASK_REGEX);
+    if (match) {
+      const status = match[1];
+      tasks.push({ status, text: match[2], line: i + 1 });
+    }
+  }
+  return tasks;
+}
+function readTasks(projectDir) {
+  const path = tasksPath(projectDir);
+  if (!existsSync2(path)) return [];
+  return parseTasks(readFileSync(path, "utf-8"));
+}
+function getNextTask(projectDir) {
+  const tasks = readTasks(projectDir);
+  for (const status of STATUS_PRIORITY) {
+    const task = tasks.find((t) => t.status === status);
+    if (task) return task;
+  }
+  return null;
+}
+function setTaskStatus(projectDir, taskText, newStatus) {
+  const path = tasksPath(projectDir);
+  const content = readFileSync(path, "utf-8");
+  const lines = content.split("\n");
+  let found = false;
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(TASK_REGEX);
+    if (match && match[2] === taskText) {
+      lines[i] = `- [${newStatus}] ${taskText}`;
+      found = true;
+      break;
+    }
+  }
+  if (found) {
+    writeFileSync2(path, lines.join("\n"));
+  }
+  return found;
+}
+function getTaskCounts(projectDir) {
+  const tasks = readTasks(projectDir);
+  return {
+    pending: tasks.filter((t) => t.status === " ").length,
+    inProgress: tasks.filter((t) => t.status === "~").length,
+    done: tasks.filter((t) => t.status === "x").length,
+    failed1: tasks.filter((t) => t.status === "!").length,
+    failed2: tasks.filter((t) => t.status === "!!").length,
+    gaveUp: tasks.filter((t) => t.status === "!!!").length
+  };
+}
+function resetGaveUpTasks(projectDir) {
+  const path = tasksPath(projectDir);
+  if (!existsSync2(path)) return 0;
+  const content = readFileSync(path, "utf-8");
+  const lines = content.split("\n");
+  let count = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(TASK_REGEX);
+    if (match && match[1] === "!!!") {
+      lines[i] = `- [ ] ${match[2]}`;
+      count++;
+    }
+  }
+  if (count > 0) writeFileSync2(path, lines.join("\n"));
+  return count;
+}
+function readAndClearNotes(projectDir) {
+  const path = notesPath(projectDir);
+  if (!existsSync2(path)) return "";
+  const content = readFileSync(path, "utf-8");
+  const notes = content.split("\n").filter((l) => !l.startsWith("#") && l.trim() !== "").slice(0, 50).join("\n");
+  writeFileSync2(
+    path,
+    "# Notes for Claude \u2014 write here, cleared after each read\n"
+  );
+  return notes;
+}
+function readHandoff(projectDir) {
+  const path = handoffPath(projectDir);
+  if (!existsSync2(path)) return "";
+  return readFileSync(path, "utf-8");
+}
+function writeHandoff(projectDir, content) {
+  writeFileSync2(handoffPath(projectDir), content);
+}
+function deleteHandoff(projectDir) {
+  const path = handoffPath(projectDir);
+  if (existsSync2(path)) {
+    unlinkSync(path);
+  }
+}
+function getAttemptFromStatus(status) {
+  switch (status) {
+    case "!":
+      return 2;
+    case "!!":
+      return 3;
+    default:
+      return 1;
+  }
+}
+function addTask(projectDir, text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    throw new Error("Task text cannot be empty.");
+  }
+  const path = tasksPath(projectDir);
+  if (!existsSync2(path)) {
+    throw new Error(
+      "No tasks file found. Run `tmg init` first."
+    );
+  }
+  const content = readFileSync(path, "utf-8");
+  const line = `- [ ] ${trimmed}
+`;
+  const separator = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+  writeFileSync2(path, content + separator + line);
+}
+function getFailureStatus(attempt) {
+  if (attempt === 1) return "!";
+  if (attempt === 2) return "!!";
+  return "!!!";
+}
+
+// src/daemon.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { execFileSync } from "child_process";
+
+// src/config.ts
+import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+var KEY_MAP = {
+  MAX_RETRIES: "maxRetries",
+  TIMEOUT_MINUTES: "timeoutMinutes",
+  IDLE_POLL_SECONDS: "idlePollSeconds",
+  TASK_DELAY_SECONDS: "taskDelaySeconds"
+};
+function parseConfigFile(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    const value = trimmed.slice(eqIndex + 1).trim();
+    const configKey = KEY_MAP[key];
+    if (!configKey) continue;
+    const num = parseInt(value, 10);
+    if (!isNaN(num) && num >= 0) {
+      result[configKey] = num;
+    }
+  }
+  return result;
+}
+function loadConfig(projectDir) {
+  const configPath = join3(projectDir, DIR_NAME, CONFIG_FILE);
+  if (!existsSync3(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  const content = readFileSync2(configPath, "utf-8");
+  const overrides = parseConfigFile(content);
+  return { ...DEFAULT_CONFIG, ...overrides };
+}
+
+// src/runner.ts
+import { spawn } from "child_process";
+function runClaude(prompt, timeoutMs, projectDir, spawnFn = spawn) {
+  return new Promise((resolve) => {
+    const ac = new AbortController();
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      ac.abort();
+    }, timeoutMs);
+    const child = spawnFn(
+      "claude",
+      ["--dangerously-skip-permissions", "-p", prompt],
+      {
+        cwd: projectDir,
+        stdio: "inherit",
+        signal: ac.signal
+      }
+    );
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({
+        success: !timedOut && code === 0,
+        exitCode: timedOut ? 124 : code ?? 1,
+        timedOut
+      });
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({
+        success: false,
+        exitCode: 1,
+        timedOut: timedOut || err.name === "AbortError"
+      });
+    });
+  });
+}
+
+// src/daemon.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var VERSION = require2("../package.json").version;
+function preflight(projectDir) {
+  const errors = [];
+  const warnings = [];
+  const tmgDir = join4(projectDir, DIR_NAME);
+  if (!existsSync4(tmgDir)) {
+    errors.push(`.trismegistus/ not found. Run: tmg init`);
+    return { ok: false, errors, warnings };
+  }
+  if (!existsSync4(join4(tmgDir, TASKS_FILE))) {
+    errors.push(`tasks.md not found in .trismegistus/. Run: tmg init`);
+    return { ok: false, errors, warnings };
+  }
+  try {
+    execFileSync("which", ["claude"], { stdio: "ignore" });
+  } catch {
+    errors.push(
+      "Claude Code CLI not found. Install: npm install -g @anthropic-ai/claude-code"
+    );
+    return { ok: false, errors, warnings };
+  }
+  try {
+    execFileSync("claude", ["--version"], { stdio: "ignore" });
+  } catch {
+    warnings.push(
+      "Claude CLI found but 'claude --version' failed. Authentication may be needed."
+    );
+  }
+  return { ok: errors.length === 0, errors, warnings };
+}
+function buildPrompt(taskText, attempt, maxRetries, notes, handoff) {
+  let prompt = `You are running autonomously overnight (attempt ${attempt}/${maxRetries}). Complete this task fully, commit your work, don't ask questions.
+
+If you are running low on time, write a summary of what you did and what remains to .trismegistus/handoff so the next session can continue.`;
+  if (notes) {
+    prompt += `
+
+NOTES FROM HUMAN (priority):
+${notes}`;
+  }
+  if (handoff) {
+    prompt += `
+
+CONTEXT FROM PREVIOUS ATTEMPT (pick up where this left off):
+${handoff}`;
+  }
+  prompt += `
+
+Task: ${taskText}`;
+  return prompt;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function runDaemon(opts) {
+  const { projectDir, spawnFn, maxIterations, onLog } = opts;
+  const log = onLog ?? ((msg) => console.log(msg));
+  const config = loadConfig(projectDir);
+  log(`  TMG v${VERSION} \u2014 ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
+  log(`  Project: ${projectDir}`);
+  log(`  Timeout: ${config.timeoutMinutes}m | Max retries: ${config.maxRetries}`);
+  log("");
+  let iterations = 0;
+  while (true) {
+    if (maxIterations !== void 0 && iterations >= maxIterations) break;
+    iterations++;
+    const task = getNextTask(projectDir);
+    if (!task) {
+      log(`[${time()}] No tasks. Watching...`);
+      await sleep(config.idlePollSeconds * 1e3);
+      continue;
+    }
+    const attempt = getAttemptFromStatus(task.status);
+    const notes = readAndClearNotes(projectDir);
+    const handoff = readHandoff(projectDir);
+    log("");
+    log("\u2501".repeat(47));
+    log(`\u25B6 [${time()}] ${task.text} (attempt ${attempt}/${config.maxRetries})`);
+    log("\u2501".repeat(47));
+    setTaskStatus(projectDir, task.text, "~");
+    const prompt = buildPrompt(
+      task.text,
+      attempt,
+      config.maxRetries,
+      notes,
+      handoff
+    );
+    const result = await runClaude(
+      prompt,
+      config.timeoutMinutes * 60 * 1e3,
+      projectDir,
+      spawnFn
+    );
+    if (result.success) {
+      setTaskStatus(projectDir, task.text, "x");
+      deleteHandoff(projectDir);
+      log(`[${time()}] Done: ${task.text}`);
+    } else {
+      if (result.timedOut) {
+        log(`[${time()}] Timed out`);
+      } else {
+        log(`[${time()}] Exited (${result.exitCode})`);
+      }
+      if (!existsSync4(join4(projectDir, DIR_NAME, "handoff"))) {
+        const reason = result.timedOut ? "timed out" : "failed";
+        writeHandoff(
+          projectDir,
+          `Previous attempt ${reason}. Check git log and codebase to see what was done. Continue from there.`
+        );
+      }
+      if (attempt >= config.maxRetries) {
+        setTaskStatus(projectDir, task.text, "!!!");
+        deleteHandoff(projectDir);
+        log(`Gave up after ${config.maxRetries} attempts: ${task.text}`);
+      } else {
+        const failStatus = getFailureStatus(attempt);
+        setTaskStatus(projectDir, task.text, failStatus);
+        log(`  \u2192 Will retry with handoff context...`);
+      }
+    }
+    await sleep(config.taskDelaySeconds * 1e3);
+  }
+}
+function time() {
+  const now = /* @__PURE__ */ new Date();
+  return `${now.getHours().toString().padStart(2, "0")}:${now.getMinutes().toString().padStart(2, "0")}`;
+}
+
+// src/tunnel.ts
+import { execFileSync as execFileSync2, spawn as spawn2 } from "child_process";
+function checkCodeCli() {
+  try {
+    execFileSync2("which", ["code"], { stdio: "ignore" });
+  } catch {
+    throw new Error(
+      "VS Code CLI (code) not found. Install VS Code or download the standalone CLI: https://code.visualstudio.com/docs/editor/command-line"
+    );
+  }
+}
+function startTunnel(name) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2(
+      "code",
+      ["tunnel", "--name", name, "--accept-server-license-terms"],
+      { stdio: ["ignore", "pipe", "pipe"] }
+    );
+    let stderr = "";
+    let settled = false;
+    const TIMEOUT_MS = 6e4;
+    function settle(fn) {
+      if (!settled) {
+        settled = true;
+        fn();
+      }
+    }
+    const timer = setTimeout(() => {
+      child.kill();
+      const msg = stderr ? `Timed out waiting for tunnel URL. stderr:
+${stderr}` : "Timed out waiting for tunnel URL. You may need to authenticate \u2014 run `code tunnel` manually first.";
+      settle(() => reject(new Error(msg)));
+    }, TIMEOUT_MS);
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.stdout?.on("data", (chunk) => {
+      const text = chunk.toString();
+      const match = text.match(/(https:\/\/vscode\.dev\/tunnel\/[^\s]+)/);
+      if (match) {
+        clearTimeout(timer);
+        settle(() => resolve({ url: match[1], process: child }));
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      settle(() => reject(err));
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      settle(() => reject(new Error(`code tunnel exited with code ${code}. stderr:
+${stderr}`)));
+    });
+  });
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("tmg").description("Trismegistus \u2014 Task Manager for Claude Code").version(
+  (() => {
+    const req = createRequire2(import.meta.url);
+    return req("../package.json").version;
+  })(),
+  "-v, --version"
+);
+program.command("init").description("Create .trismegistus/ folder in current directory").action(() => {
+  const result = initProject(process.cwd());
+  for (const name of result.created) {
+    console.log(`  Created ${name}`);
+  }
+  for (const name of result.skipped) {
+    console.log(`  Skipped ${name} (already exists)`);
+  }
+  console.log("");
+  console.log("  Add your tasks to .trismegistus/tasks.md, then run: tmg start");
+  console.log("");
+});
+program.command("status").description("Show task counts").action(() => {
+  const counts = getTaskCounts(process.cwd());
+  console.log("");
+  console.log("  TMG Status");
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log(`  Pending:       ${counts.pending}`);
+  console.log(`  In Progress:   ${counts.inProgress}`);
+  console.log(`  Done:          ${counts.done}`);
+  console.log(`  Retrying (!):  ${counts.failed1}`);
+  console.log(`  Retrying (!!): ${counts.failed2}`);
+  console.log(`  Gave up (!!!): ${counts.gaveUp}`);
+  console.log("");
+});
+program.command("start").description("Start the daemon \u2014 continuously runs tasks from the queue").action(async () => {
+  const check = preflight(process.cwd());
+  for (const err of check.errors) {
+    console.error(`  Error: ${err}`);
+  }
+  for (const warn of check.warnings) {
+    console.warn(`  Warning: ${warn}`);
+  }
+  if (!check.ok) {
+    process.exit(1);
+  }
+  console.log("");
+  await runDaemon({ projectDir: process.cwd() });
+});
+program.command("add").description("Add a task to the queue").argument("<text>", "Task description").action((text) => {
+  try {
+    addTask(process.cwd(), text);
+    console.log(`Added: ${text}`);
+  } catch (e) {
+    console.error(e instanceof Error ? e.message : String(e));
+    process.exit(1);
+  }
+});
+program.command("reset").description("Reset all gave-up [!!!] tasks back to pending [ ]").action(() => {
+  const count = resetGaveUpTasks(process.cwd());
+  if (count === 0) {
+    console.log("  No gave-up tasks to reset.");
+  } else {
+    console.log(`  Reset ${count} task(s) back to pending.`);
+  }
+});
+program.command("remote").description("Open a VS Code tunnel for phone access (QR code)").option("--name <name>", "Tunnel name").action(async (opts) => {
+  const tunnelName = opts.name ?? hostname();
+  try {
+    checkCodeCli();
+  } catch (e) {
+    console.error(e instanceof Error ? e.message : String(e));
+    process.exit(1);
+  }
+  console.log("Starting VS Code tunnel...");
+  try {
+    const { url, process: tunnelProc } = await startTunnel(tunnelName);
+    console.log("");
+    console.log(`  URL: ${url}`);
+    console.log("");
+    qrcode.generate(url, { small: true }, (code) => {
+      console.log(code);
+    });
+    console.log("  Scan the QR code or open the URL on your phone");
+    console.log("  Press Ctrl+C to stop the tunnel");
+    console.log("");
+    const cleanup = () => {
+      tunnelProc.kill();
+      process.exit(0);
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  } catch (e) {
+    console.error(e instanceof Error ? e.message : String(e));
+    process.exit(1);
+  }
+});
+program.parse();

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "trismegistus",
+  "version": "0.1.0",
+  "description": "A local persistent daemon that runs AI sessions from a task queue, with mobile support.",
+  "type": "module",
+  "main": "./dist/cli.js",
+  "bin": {
+    "tmg": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/cli.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "task-manager",
+    "daemon",
+    "automation",
+    "ai"
+  ],
+  "author": "jessekaff",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jessekaff/trismegistus.git"
+  },
+  "homepage": "https://github.com/jessekaff/trismegistus#readme",
+  "bugs": {
+    "url": "https://github.com/jessekaff/trismegistus/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "commander": "^13.0.0",
+    "qrcode-terminal": "^0.12.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/qrcode-terminal": "^0.12.2",
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}