ai-employees 1.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark Fulton
+
+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,160 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="assets/logo-dark.png">
+    <img alt="AI Employees" src="assets/logo-light.png" width="480" height="114">
+  </picture>
+</p>
+
+<h3 align="center">Eight open source AI Employees. Each one runs a whole business role.</h3>
+<p align="center">60 scheduled routines. Your own machine. The AI agent you already use.</p>
+
+<p align="center">
+  <a href="https://club.reinventing.ai/ai-employees?utm_source=github&utm_medium=readme&utm_campaign=ai-employees&utm_content=nav-employees"><strong>The eight AI Employees</strong></a>
+  &nbsp;&bull;&nbsp;
+  <a href="https://club.reinventing.ai/masterclass?utm_source=github&utm_medium=readme&utm_campaign=ai-employees&utm_content=nav-masterclass"><strong>Masterclass</strong></a>
+  &nbsp;&bull;&nbsp;
+  <a href="https://club.reinventing.ai/events?utm_source=github&utm_medium=readme&utm_campaign=ai-employees&utm_content=nav-sessions"><strong>Live sessions</strong></a>
+  &nbsp;&bull;&nbsp;
+  <a href="https://club.reinventing.ai/software?utm_source=github&utm_medium=readme&utm_campaign=ai-employees&utm_content=nav-software"><strong>Software library</strong></a>
+  &nbsp;&bull;&nbsp;
+  <a href="https://club.reinventing.ai/faq?utm_source=github&utm_medium=readme&utm_campaign=ai-employees&utm_content=nav-faq"><strong>FAQ</strong></a>
+</p>
+
+<p align="center">
+  <img alt="Stars" src="https://img.shields.io/github/stars/markfulton/ai-employees?style=flat-square&color=E3B341&logo=github&logoColor=white&label=Stars">
+  <img alt="MIT license" src="https://img.shields.io/badge/License-MIT-3FB950?style=flat-square">
+  <a href="https://www.npmjs.com/package/ai-employees"><img alt="npm ai-employees" src="https://img.shields.io/badge/npm-ai--employees-CB3837?style=flat-square&logo=npm&logoColor=white"></a>
+  <img alt="Claude Code and ten other agents" src="https://img.shields.io/badge/Claude_Code_+_10_agents-ready-D97757?style=flat-square&logo=anthropic&logoColor=white">
+  <img alt="Windows, macOS and Linux" src="https://img.shields.io/badge/Windows_macOS_Linux-ready-2B2B2B?style=flat-square">
+</p>
+
+<p align="center">
+  <a href="https://club.reinventing.ai/pricing?utm_source=github&utm_medium=readme&utm_campaign=ai-employees&utm_content=btn-install-prompt"><img alt="Get my free install prompt in the Agent Ops Club" src="https://img.shields.io/badge/Get%20my%20free%20install%20prompt-0B7FC7?style=for-the-badge"></a>
+  <a href="https://club.reinventing.ai/register?utm_source=github&utm_medium=readme&utm_campaign=ai-employees&utm_content=btn-join"><img alt="Join the Agent Ops Club free" src="https://img.shields.io/badge/Join%20the%20club%20free-3FB950?style=for-the-badge"></a>
+  <a href="https://club.reinventing.ai/events?utm_source=github&utm_medium=readme&utm_campaign=ai-employees&utm_content=btn-sessions"><img alt="Agent Ops Club live sessions" src="https://img.shields.io/badge/Live%20sessions-D97757?style=for-the-badge"></a>
+  <a href="https://club.reinventing.ai/masterclass?utm_source=github&utm_medium=readme&utm_campaign=ai-employees&utm_content=btn-masterclass"><img alt="The Agent Ops Masterclass" src="https://img.shields.io/badge/Masterclass-475569?style=for-the-badge"></a>
+</p>
+
+<p align="center">
+  ⭐ <em>Star this repo so more founders find the eight.</em>
+</p>
+
+## AI Employees
+
+An AI Employee is a folder of scheduled routines that covers one business role. It runs on your own machine, on the AI agent you already use, and briefs you every morning. They drive your browser and your PC the way you do, and every run makes the next one better. Eight roles, every routine and schedule in this repo, nothing held back.
+
+Created by [Mark Fulton](https://www.reinventing.ai/?utm_source=github&utm_medium=readme&utm_campaign=ai-employees) of Reinventing.AI, founder of [Vibe Coding is Life](https://facebook.com/groups/vibecodinglife) (340,000+ members). Running my own business every weekday since August 27, 2026.
+
+## The eight AI Employees
+
+| Employee | What it owns | Routines |
+|---|---|---|
+| <img src="https://club.reinventing.ai/img/employees/thumbs/gtm-engineer.webp" width="72" height="72" alt=""><br>[**GTM Engineer**](employees/gtm-engineer) | Your launch: positioning, the launch board, outbound drafts, directory and press forms, the weekly scoreboard | 8 |
+| <img src="https://club.reinventing.ai/img/employees/thumbs/seo-employee.webp" width="72" height="72" alt=""><br>[**SEO/AEO Employee**](employees/seo-employee) | Keyword research, one article a weekday, publishing, indexing, rank review and your visibility in AI answers | 8 |
+| <img src="https://club.reinventing.ai/img/employees/thumbs/web-dev-employee.webp" width="72" height="72" alt=""><br>[**Web Dev Employee**](employees/web-dev-employee) | Site health, error triage, small changes on a branch, dependency review | 8 |
+| <img src="https://club.reinventing.ai/img/employees/thumbs/social-media-employee.webp" width="72" height="72" alt=""><br>[**Social Media Employee**](employees/social-media-employee) | Posts drafted in your voice for each platform, a veto window, replies drafted for you | 7 |
+| <img src="https://club.reinventing.ai/img/employees/thumbs/ad-manager-employee.webp" width="72" height="72" alt=""><br>[**Ad Manager Employee**](employees/ad-manager-employee) | Account reads, creative sets, build sheets and the weekly change list. Money moves only when you approve | 7 |
+| <img src="https://club.reinventing.ai/img/employees/thumbs/sales-employee.webp" width="72" height="72" alt=""><br>[**Sales Employee**](employees/sales-employee) | Prospect sweeps, first touches into your own drafts, follow ups that never go quiet | 7 |
+| <img src="https://club.reinventing.ai/img/employees/thumbs/customer-satisfaction-employee.webp" width="72" height="72" alt=""><br>[**Customer Satisfaction Employee**](employees/customer-satisfaction-employee) | Inbox sweep, replies drafted hardest first, churn flags with evidence | 8 |
+| <img src="https://club.reinventing.ai/img/employees/thumbs/chief-of-staff.webp" width="72" height="72" alt=""><br>[**Chief of Staff**](employees/chief-of-staff) | Reads every other employee's run log, names what quietly stopped, brings you three moves | 7 |
+
+Sixty routines. Each employee's folder has its full schedule and a sample of its output.
+
+## Install in two steps
+
+**1. Download a kit and extract it to your PC.** Click **Code, Download ZIP** above, or run `npx ai-employees hire gtm-engineer --to <folder>`. Any folder not inside OneDrive, Dropbox, Google Drive or iCloud.
+
+**2. Open your agent in that folder and say "Install the GTM Engineer from this folder."** It researches your business from your website, builds your dashboard, schedules its own routines, and stops once to show you its first drafts.
+
+You need an AI agent you are logged in to (Claude Code is what I use) and a browser signed in to the accounts it should read. [Prerequisites](docs/PREREQUISITES.md). [Full install guide](docs/INSTALL.md).
+
+**Not on Claude Code?** The same two steps work on OpenClaw, Hermes, OpenCode, Grok Bot, Codex, Antigravity, Pi, Cline, Qwen Code and DeepSeek. [docs/HARNESSES.md](docs/HARNESSES.md) has the command for each.
+
+<table>
+<tr><td align="center" width="900">
+
+<h2>Get your install prompt and a guided first hire, free</h2>
+
+<p>Hiring one or all eight, pick your roles in the Agent Ops Club and copy one prompt your agent runs from start to finish. The Hire Your First AI Employee walkthrough takes you through it step by step.</p>
+
+<a href="https://club.reinventing.ai/pricing?utm_source=github&utm_medium=readme&utm_campaign=install-prompt"><img src="assets/cta-install-prompt.png" width="470" alt="Get my install prompt and walkthrough, free in the Agent Ops Club"></a>
+
+<p><sub><b>Free account, no card.</b></sub></p>
+
+</td></tr>
+</table>
+
+## What sets these AI Employees apart
+
+- **They get better at your business every run.** When a page changes, the routine fixes its own instructions and tells you in the next brief.
+- **They drive your browser and your PC the way you do.** Signed in as you, on your own machine, from techniques learned on real runs.
+- **You set how far they go.** Everything is drafted, filled and staged, and the last click is yours until you release a channel.
+- **One brief each morning.** One push to your phone, only when you are the blocker.
+- **They run on the agent you already use.** Claude Code and ten others, without a routine changing by one word.
+- **You can direct any of them in chat.** Open a session in the employee's folder and tell it what to do.
+- **Upgrades never overwrite your work.** `npx ai-employees upgrade` leaves every file you edited alone.
+
+[The long version](docs/WHAT-SETS-THEM-APART.md).
+
+## What a morning looks like
+
+The brief the GTM Engineer leaves, from a fictional business, Northwind Roofing. Yours has your cards in it.
+
+```
+# 2026-03-05
+
+## Today
+- C-007 | Stage the storm season email for segment-1 | queue/2026-03-05-email.md
+- C-011 | Fill the local trades directory listing and leave the tab open | queue/2026-03-05-form.md
+- C-012 | Verify the quote request conversion event fires on the thank you page | paid/conversion-quote-request.md
+
+## Waiting on you
+- queue/2026-03-05-email.md: three drafts, none ticked
+- C-009 | Submit the supplier co-marketing listing | filled in its tab, the submit is yours
+
+## Blocked
+- gtm-signal-sweep, open since 2026-02-26: the review platform asked for a sign in, nothing entered
+```
+
+[The full brief](employees/gtm-engineer/examples/brief-latest.md), with the run log and the ledgers beside it.
+
+## How an AI Employee runs
+
+A folder of plain text files you can open and change. Nothing runs anywhere else.
+
+```
+gtm-engineer/
+  INSTALL-PROMPT.md        what your agent reads to set itself up, once
+  ROLE.md                  who this employee is and how it thinks
+  SCHEDULE.md              when each routine runs
+  RELEASES.md              yours: the channels you have released, shipped empty
+  routines/<id>/SKILL.md   one folder per routine
+```
+
+Each routine runs at its time, inside a window. If your machine was asleep and the job fires late or twice, it sees the work is done and does nothing.
+
+Two guardrails. Shipped, every send, post, submit, publish and spend is held for your click, and `RELEASES.md` is where you hand a channel over. No AI Employee ever creates an account, enters a password, completes a captcha or accepts terms.
+
+[How employees work](docs/HOW-EMPLOYEES-WORK.md). [The guardrails, routine by routine](docs/GUARDRAILS.md).
+
+## What AI Employees cost to run
+
+On a Claude Pro or Max plan, nothing beyond the plan. They spend a share of your plan's usage limits, not dollars. Measured on my own Max seat, the GTM Engineer's scheduled runs were about 6 percent of everything the machine sent to Claude. [docs/COST.md](docs/COST.md) has the method, the per routine table and the API key reference.
+
+## Go further
+
+The eight are free for good. The Agent Ops Masterclass, the premium software library with a resale license, the live sessions and, from October, premium AI Employees live in the [Agent Ops Club](https://club.reinventing.ai/?utm_source=github&utm_medium=readme&utm_campaign=ai-employees). A free club account gets you the session calendar, the walkthrough lesson with the launch replay, the preview lessons and AI Employee updates.
+
+## FAQ
+
+**Does it send anything?** By default, no. It drafts, fills and stages, and you press the button. **Windows, Mac or Linux?** All three. **Can I run just one?** Yes, each is a self contained folder. **Can I sell installs to clients?** Yes, it is MIT; just do not call yours by the club's name. The rest is in [docs/FAQ.md](docs/FAQ.md).
+
+## Contributing
+
+Routine requests, new employee proposals, harness reports and corrections from real runs are all welcome. Post what an employee did for your business in Discussions under Show and tell. [CONTRIBUTING.md](CONTRIBUTING.md) has the rules.
+
+## License
+
+MIT. Copyright (c) 2026 Mark Fulton. [LICENSE](LICENSE). Names and logos are not licensed, and forks get their own name: [TRADEMARKS.md](TRADEMARKS.md).
+
+Built by Mark Fulton with Claude Code. Every contributor is in [CREDITS.md](CREDITS.md). Report a way to make an employee send or spend through [SECURITY.md](SECURITY.md), not a public issue.

package/TRADEMARKS.md

@@ -0,0 +1,45 @@
+# Trademarks
+
+The MIT License in this repository covers the prompts, contracts, routines,
+schedules and scripts. It does not license any name or logo.
+
+"Reinventing.AI", "Agent Ops Club", the Reinventing.AI wordmark and the club
+logo (together, "the Marks") identify Mark Fulton's business, Reinventing.AI.
+They are claimed as trademarks whether or not they are registered.
+
+"AI Employees", "AI Employees" and the role names used in this repository
+(GTM Engineer, SEO/AEO Employee, Web Dev Employee, Social Media Employee, Ad
+Manager Employee, Sales Employee, Customer Satisfaction Employee, Chief of
+Staff) are descriptive terms. I make no trademark claim on them. Use them
+freely.
+
+## What you may do without asking
+
+- Use the Marks in plain text to say truthfully where this work came from,
+  for example "based on the AI Employees kits by Mark Fulton (Reinventing.AI)".
+- Say that your fork, product or service is compatible with, derived from, or
+  an unofficial version of this project, as long as your own name is the more
+  prominent one and you do not suggest that Reinventing.AI endorses it.
+- Keep the copyright notices and this file in your copies. The MIT License
+  requires the copyright notice anyway.
+
+## What needs written permission
+
+- Using the Marks, or anything confusingly similar to them, as the name of a
+  fork, product, service, company, domain, social account, course or
+  marketplace listing.
+- Using the logo or wordmark image files for anything other than truthfully
+  pointing at the original project.
+- Presenting a modified version as the official version, or implying that
+  Reinventing.AI or the Agent Ops Club maintains, supports or endorses it.
+
+## Forks
+
+The kits are yours to change. If you distribute a changed version, give it
+your own name and make clear it is not the official version. One line is
+enough, for example "Unofficial fork of Mark Fulton's AI Employees, not
+affiliated with Reinventing.AI". Goodwill from any permitted use of the Marks
+belongs to Reinventing.AI.
+
+Questions about this policy go to the contact address on
+https://www.reinventing.ai.

package/docs/COST.md

@@ -0,0 +1,59 @@
+# What it costs to run
+
+This is the first question anyone asks. The short answer: on a Claude subscription, nothing beyond the subscription. The long answer is below, measured on one employee as the worked example, the GTM Engineer, with the dates, the method and the price table so you can check it. Nothing on this page is an estimate except where it says so.
+
+## The short version
+
+- **On a Claude Pro or Max plan, an employee costs no dollars.** It runs inside Claude Code on your own seat, which is also what the browser lane needs. What it spends is a share of your plan's usage limits.
+- **How big a share, measured on one employee as the example:** over ten days, 2026-08-27 to 2026-09-05, the GTM Engineer's scheduled runs were about **6 percent** of everything this machine sent to Claude. The other 94 percent was me working in Claude Code all day. One employee is a small slice of one Max seat, and by that measure a seat carries several employees alongside a working day. Anthropic publishes no token quota per plan, so that is a measurement of my machine, not a promise about yours.
+- **On an API key, for reference:** about **$19** of Opus 5 usage at list price on a plain weekday, about **$27** on Monday and Friday, about **$500 a month** for one employee. Two thirds of that is cache reads, because every turn re-reads the kit's documents. An API key also loses the browser lane, so it is the expensive way to run these, not the normal one.
+- **The runs behind these numbers used `claude-opus-5`** with the 1M context window, through the Claude Desktop app's scheduler.
+- **A skipped fire** on a live install costs about **$0.90 to $1.10** of API equivalent usage and 1.3 to 2.2 minutes, because the session still starts, loads the routine and reads the schedule before it exits. `scripts/guard.mjs` runs before the routine's documents are read and should cut that; the re-measured number will follow.
+- **Install day** cost about **$68** API equivalent in an operator session.
+
+## Where the numbers come from
+
+The GTM Engineer is the example employee. Every scheduled `gtm-*` session the Claude Desktop app started between 2026-08-26 and 2026-09-04: 42 sessions, each with a transcript. Each transcript was summed per assistant message, deduplicated by message id, and priced at API list rates. 27 are clean scheduled runs and make the table below. Excluded from the means: 8 skipped fires, listed separately, and 7 sessions that turned into operator sessions rather than scheduled runs. The whole seat comparison sums every assistant message in every Claude Code transcript on the same seat over the same window, 15,875 messages, priced at Opus 5 rates for all of them, which understates the seat total because a share of those messages ran on a dearer model. So 6 percent is a ceiling on the employee's share.
+
+Prices used, per million tokens: Opus 5 input $5, output $25, cache write $6.25, cache read $0.50. Flat pricing was applied to the 1M context model.
+
+## One employee as the example: the GTM Engineer, per routine, Opus 5 API list price
+
+| Routine | Clean runs | Mean | Min | Max | Mean output tokens | Mean cache read tokens | Mean turns | Mean wall minutes |
+|---|---|---|---|---|---|---|---|---|
+| gtm-signal-sweep | 6 | $4.38 | $3.42 | $5.86 | 28,191 | 5.81 M | 48 | 9.8 |
+| gtm-board-standup | 5 | $5.54 | $4.94 | $6.44 | 55,385 | 6.47 M | 47 | 12.6 |
+| gtm-outreach-queue | 6 | $3.35 | $2.21 | $4.24 | 19,872 | 4.22 M | 33 | 5.9 |
+| gtm-launch-step-runner | 6 | $6.22 | $4.22 | $9.68 | 31,500 | 8.86 M | 57 | 10.8 |
+| gtm-paid-and-tracking-guard | 1 | $7.16 | | | 50,822 | 9.73 M | 69 | 24.0 |
+| gtm-scoreboard | 2 | $7.50 | $7.37 | $7.64 | 51,771 | 10.09 M | 62 | 15.6 |
+| gtm-intake-and-dashboard, monthly | 1 | $3.84 | | | 26,222 | 4.66 M | 36 | 7.7 |
+| gtm-icp-refresh, monthly | 1 (an upper bound) | $4.84 | | | 37,396 | 4.85 M | 41 | |
+| A skipped fire, any routine, live install | 8 | $0.99 | $0.88 | $1.14 | 3,984 to 6,055 | 0.88 to 1.19 M | 11 to 14 | 1.3 to 2.2 |
+
+Cache reads are 66 percent of the clean runs' cost and output tokens 17 percent. Each turn re-reads the contract, the role, the capabilities file, the schedule and the routine's own instructions, roughly 225 KB of documents plus a 62 to 94 KB routine file. That is the single largest cost lever and it is the split described at the end of this page.
+
+## Per day, per month
+
+| Scope | Opus 5, API list price |
+|---|---|
+| Plain weekday (sweep, standup, outreach, step runner) | $19.49 |
+| Monday (adds the paid guard) | $26.65 |
+| Friday (adds the scoreboard) | $27.00 |
+| One employee, 30 day month (22 weekdays, 4 Mondays, 4 Fridays, one intake, one refresh, a dozen skips) | about $500 |
+| Install day, once | $68, warm operator session |
+
+## What a subscription actually covers
+
+Anthropic publishes no token or dollar quota per plan, so a plan cannot be mapped to the table exactly. What their pages say: the free plan does not include Claude Code; Pro and Max share usage across Claude and Claude Code; Max has a session limit that resets every five hours plus a weekly limit across all models. What my machine says: on a Max seat, the GTM Engineer's scheduled runs were 6 percent of ten days of heavy use, and the runs land at fixed times inside the same five hour windows a seat is used interactively.
+
+The only way to turn the table into dollars is an API key, and an API key loses the browser lane, which most of these routines need. Run them on a seat.
+
+## Making cost a field, not a guess
+
+`scripts/runlog.mjs` accepts nine optional fields on a run record: `model`, `harness`, `turns`, `input_tokens`, `output_tokens`, `cache_write_tokens`, `cache_read_tokens`, `cost_usd`, and `cost_basis` (`api-list`, `subscription`, or `unknown`). They are counts and prices only, never required, and the refusal rules on the rest of the record are untouched. On the CLI, `claude -p --output-format json` prints `total_cost_usd` and the token counts on exit; the launcher in `run/` writes that JSON to `run/<id>.last.json`. A flag that attaches those numbers to the record the routine just wrote is not built yet, and until it is the fields get filled by the routine's own last step where a harness exposes them, or stay absent.
+
+## What is deferred, and said here so nobody assumes otherwise
+
+- **The root documents are not yet split into a short law section read every run and a reference section read on demand.** That split is the single largest cost lever, because cache reads are two thirds of every run. The numbers on this page are the pre split numbers.
+- **The skip cost with `guard.mjs` in front.** The mechanism is in place; the number will follow.

package/docs/FAQ.md

@@ -0,0 +1,39 @@
+# FAQ
+
+**Does it send anything?** By default, no. A scheduled routine drafts, fills and stages: outreach lands in queue files and, if you turn it on, as unsent drafts in your own mailbox, forms get filled and left open in their tab, campaigns arrive as build sheets, and you press the button. Sending is yours to authorize, and there are four ways: a row in the employee's `RELEASES.md`, which hands a channel to the routine that stages it, a channel you configure (the SEO/AEO Employee publishes to your blog, the Social Media Employee posts to the channel you connect after a veto window), an interactive session in the employee's folder where it does what you ask, and the permission mode you give a scheduled task in your harness. The gate is your harness's own permission layer, on Claude Code its built in classifier, and the kit is yours to widen: the guard script, the contract and every routine are plain files in your install. `SECURITY.md` has the full model.
+
+**What does it cost to run?** On a Claude Pro or Max plan, nothing beyond the plan: the employee runs on your own seat and spends a share of its usage limits. Measured on one employee as the example, the GTM Engineer, that share was about 6 percent of everything my Max seat sent to Claude over ten days of heavy use, so one seat carries several employees alongside a working day. On an API key, for reference, it is about $19 of Opus 5 usage at list price on a plain weekday and about $27 on Monday or Friday, and an API key loses the browser lane. The runs behind those numbers were on `claude-opus-5`. `docs/COST.md` has the full table and the dates.
+
+**How long does the install take?** You spend about ten minutes answering questions. The employee's first run takes about an hour and may ask for a second session.
+
+**Windows, macOS or Linux?** All three. Windows through the Desktop app scheduler or Task Scheduler, macOS through the Desktop app or launchd, Linux through cron. `docs/INSTALL.md` has the steps for each scheduler and what a first run should look like.
+
+**Which harness?** Built for Claude Code, OpenClaw, Hermes, OpenCode, Grok Bot, Codex, Antigravity, Pi, Cline, Qwen Code and DeepSeek. Claude Code is the one the GTM Engineer runs my own club launch on every weekday. OpenClaw, Hermes, Cline and Qwen Code have built in cron or scheduled tasks, Codex has scheduled runs, Antigravity has the `agy` job runner, DeepSeek schedules through a plugin, OpenCode and Pi use the operating system's scheduler, and Grok Bot runs from its own cloud computer. `docs/HARNESSES.md` has the invocation and the first run check for each.
+
+**Can I run just one?** Yes. Each employee is a self contained folder. They share nothing but a scheduler. The GTM Engineer is the one to start with; the Chief of Staff is the one to add second, because it reads the run logs of every other employee on the machine and tells you which one quietly stopped.
+
+**What happens when my machine is asleep?** It depends on your scheduler: the Claude Desktop app and Windows Task Scheduler run one late catch up, launchd folds every missed fire into one, and cron skips it for good. Every routine has a window, so a late fire either does its work once or records a skip and exits. A closed laptop produces nothing, and the next morning's standup says so in plain words.
+
+**Can I run it on a VPS or in the cloud?** The file routines, yes: anything that reads and writes files and runs a command. The browser routines need a browser that carries your own signed in sessions, which a headless server does not have, and an API key turns the browser lane off on Claude Code. Each kit's README has a section called "What you lose with no browser control" that says exactly what still works.
+
+**Do I need the Chrome extension?** On Claude Code, only for the routines that read your own accounts (saved searches, ad dashboards, your support inbox, your analytics). The morning brief, the drafting, and the Friday scoreboard arithmetic never need a browser.
+
+**Does it need an API key?** No. On Claude Code, log in once with `claude` and `/login` on a plan that includes it; an API key works for the file routines but the browser lane switches off with it. On another harness, whatever account or key it already runs on is enough; the kits add no credential of their own.
+
+**Why does everything say "member"?** The kits call the person who owns the employee "the member", because they were written for club members first. Read it as you. It is not a claim that you have to join anything.
+
+**What are the «guillemets» in the files?** A placeholder the install fills in, such as `«GTM_ROOT»` for your folder path. Two survive on purpose in drafts: `«paste at send time»` where a credential goes that only you type, and `«member: paste the detail»` where a number goes that only you can supply. Nothing ships with a real value in one.
+
+**Why is nothing scheduled on a Sunday?** A Sunday belongs to the ISO week that just ended, so a weekly routine there would share a period key with the following week and one of the two runs would be lost with no error. If you work weekends, add a Saturday row.
+
+**Can I change the schedule?** Edit `SCHEDULE.md`. It is the only file in a kit that carries a cadence, a fire time, a window, or a budget, and the routines read it on every fire. Then re-register that one job, or let the monthly drift check remind you.
+
+**Can I run it for a client and charge for it?** Yes. The eight are MIT. Install them, adapt them, sell the work. Do not call your version Reinventing.AI or the Agent Ops Club; `TRADEMARKS.md` says what needs a rename.
+
+**Is any of my data sent anywhere?** Not by this repo. There is no telemetry in the kits, the installer, or the `hire` skill. What the agent reads during a run goes to your model provider the way any session on your harness does. Everything the employee writes stays in its folder on your machine, and the `.gitignore` inside each kit keeps it out of any repo you push.
+
+**How do updates work?** Employees update one at a time. Everything under `strategy/`, `state/`, your ledgers, your learned `recipes/*.json`, and the `## Corrections` at the foot of every file are yours and are never overwritten. Everything else is safe to replace. Each kit's `CHANGELOG.md` has the procedure under "Updating without losing your work".
+
+**What is the club, and what is not in this repo?** The eight employees are complete and free for good; nothing in them is held back. The Agent Ops Club is where the guided walkthrough, the Masterclass, the premium software library with a resale license, the live sessions and, from October, premium employees live. A free club account gets you the session calendar, the walkthrough lesson with the launch replay, the preview lessons and employee updates. The README's Go further section has the link.
+
+**Where do I ask something not here?** Discussions. Issues are answered within a working day for the first month; after that, Discussions is where the community answers and I read every thread.

package/docs/GUARDRAILS.md

@@ -0,0 +1,17 @@
+# Two guardrails, and what each routine does
+
+**The first guardrail is on outbound actions, and it is yours.** Every AI Employee can send, post, submit, publish and spend. Shipped, every one of those is held: the draft is written, the form is filled and left open on the last step, the campaign arrives as a build sheet, and the last click is yours. `RELEASES.md` in the employee's folder is where you hand a channel over, one row at a time, with your conditions on it. From then on the routine that stages that channel completes the action itself and tells you in the morning brief what went out. Two of the eight ship with a channel already yours to configure: the SEO/AEO Employee publishes articles to the blog you name, and the Social Media Employee hands drafted posts to the channel you connect, after a veto window in the brief.
+
+**The second guardrail is on credentials, and it stays on.** No AI Employee creates an account, enters or generates a password, completes a captcha, accepts terms, or writes a credential into any file. It never needs your password to do its job, so there is nothing to release.
+
+| Routine kind | Reads | Writes | Leaves for you | Holds, unless you release it |
+|---|---|---|---|---|
+| The standup, every weekday | Every ledger, run record and tick since yesterday | The board and the thirty line brief | The brief, first thing | Uses a browser |
+| Sweeps (signals, prospects, inbox, site health, material, market) | Your own signed in pages and public pages | Dated, sourced ledger lines | Nothing to do; the drafts come from these | Types into a page, replies, marks anything read |
+| Drafting (outreach, replies, posts, articles, creative) | The ledgers, your strategy files, your proof inventory | Queue files, unsent mailbox drafts, article drafts, creative sets | The drafts, to edit and send | Sends, posts, submits, or uses a number not in your proof inventory |
+| Form filling (directories, press, listings) | The card and your strategy files | The queue entry with every field's value | The tab, filled, on the last step | Clicks Submit, Publish, Post, Send, Activate, Enable, or Create account |
+| Account reads (ads, billing, analytics, registrar, host) | Read screens in accounts you are signed in to | Metrics ledgers, drift findings, build sheets | Every change as a paste ready line with the screen named | Changes a setting, saves a draft in an account that can spend |
+| Weekly reviews and monthly refreshes | A week or a month of the kit's own ledgers | The scoreboard with a source beside every number, rewritten strategy where evidence disagrees | One kill and one scale, as cards | Estimates a number it did not measure |
+| The Chief of Staff | Every other AI Employee's run log, read only | The fleet page, the fault dossier, the decision brief | Three moves, argued both ways | Writes into another AI Employee's folder |
+
+Everything the employee decides on its own lands as one dated line in a changelog you can read in a minute. Everything it learns about your sites lands in a recipe file inside its own folder. When it gets something wrong, one dated line in that file's `## Corrections` section outranks the file from the next run on.

package/docs/HARNESSES.md

@@ -0,0 +1,38 @@
+# Harnesses
+
+Every routine is one `SKILL.md` with `name` and `description` frontmatter, plain markdown instructions, and no clock time in it. Any harness that can read files, write files, run a command, read the clock, and (ideally) drive your signed in browser can run one. What differs is the scheduler and the invocation, and this page has both for each harness, with the one thing to check on a first run.
+
+The kits are built for Claude Code, OpenClaw, Hermes, OpenCode, Grok Bot, Codex, Antigravity, Pi, Cline, Qwen Code and DeepSeek, and run on Windows, macOS and Linux. Claude Code on Windows is where the GTM Engineer has run my own club launch every weekday since August 27.
+
+Two rules hold on every harness. **Routines are scheduled jobs, not skills**: point the scheduler at the kit's `routines/` folder and never copy them into a global skills directory, because a skills directory loads all of them into every session you open and lets any of them be invoked outside its window, where it will only record a skip and exit. **Keep one copy**: every routine ends with a `## Corrections` section you write into and it reads on its next run, and two copies means you write into one and it reads from the other.
+
+| Harness | Status | Scheduler | Invocation shape | What to check first | Adding a connection |
+|---|---|---|---|---|---|
+| Claude Desktop app, Windows | Ready | Local scheduled tasks, one per routine, permission mode per task | The task's prompt is `Read <root>/routines/<id>/SKILL.md and follow it.` with the working folder set to the kit | Always allow on the first run of each task, Keep computer awake on | A directory connector added at claude.ai/customize/connectors, which every session and every local scheduled task sees; anything else with `claude mcp add --transport http <name> <url>`, then `/mcp` to sign in |
+| Claude Code CLI, Windows Task Scheduler | Ready | Task Scheduler, one task per routine pointed at `run/<id>.cmd` | `claude.exe -p "<prompt>" --permission-mode acceptEdits --output-format json < nul`, shipped as `run/<id>.cmd.example` | Full path to the binary, `claude auth status`, the missed start setting on | The same connectors when the CLI is logged in to claude.ai, never on an API key; other servers with `claude mcp add`, signed in once with `claude mcp login <name>` before the first scheduled fire |
+| Claude Desktop app, macOS | Ready | Local scheduled tasks | Same as Windows | Same as Windows; the macOS first run checklist is in `docs/INSTALL.md` | Same as Windows |
+| Claude Code CLI, macOS launchd | Ready | launchd, one plist per routine, `StartCalendarInterval` | `/bin/zsh -lc "claude -p ... < /dev/null"`, plist in `docs/INSTALL.md` | launchd coalesces missed fires into one run on wake, which the window guard handles | Same as the Windows CLI row |
+| Claude Code CLI, Linux cron | Ready | cron, lines in each kit's `CAPABILITIES.md` 9.3 | `claude -p "<prompt>" < /dev/null` with absolute paths | cron never catches up after sleep | Same as the Windows CLI row |
+| OpenClaw | Ready | Built in cron: `openclaw automations create "<cron>" "<message>" --name <id> --session isolated`, one per routine, with the timezone flag | The message is `Read <root>/routines/<id>/SKILL.md and follow it.` | Whether its browser control attaches to your signed in profile; run the probe in `CAPABILITIES.md` 1.2 | `mcp.servers` in its config, `openclaw mcp login <name>`; skills from ClawHub |
+| Hermes | Ready | Built in cron with delivery to any platform | Point each job at the routine file as its prompt | Whether it reads files and runs a shell command; then the browser question | `mcp_servers` in `~/.hermes/config.yaml`, or `hermes mcp install <name>` from its catalog |
+| OpenCode | Ready | None built in; use the operating system's | `opencode run "<prompt>"`, confirm against `opencode --help` | Add a browser automation server for the browser lane | `mcp.<name>` in `opencode.json`, then `opencode mcp auth <name>` |
+| Grok Bot | Ready | Its bots run routines on a schedule from their own cloud computer | One recurring task per routine, handed that routine's `SKILL.md` as the run prompt | Whether it can reach your signed in accounts at all; it runs elsewhere | Its built in connectors, or a custom connector by URL at grok.com/connectors |
+| Codex | Confirmed | The app's automations: one cron automation per routine, named after the routine id, local execution, the kit folder as a working directory | The automation's own prompt, Shape B; `codex exec "<prompt>"` by hand where the CLI is signed in | The sandbox and the scheduled process: confirm it can write in the kit folder, reach the network, and reach the same connections the chat session could, because the first scheduled fire is the first real test of both | `[mcp_servers.<name>]` in `~/.codex/config.toml`, then `codex mcp login <name>`; skills in `.agents/skills` |
+| Antigravity | Ready | `agy` job runner pointed at the routine folder | `agy -p "<prompt>"` | Whether it drives your signed in browser profile or a clean one | `.agents/mcp_config.json` in the workspace or `~/.gemini/config/mcp_config.json`, with `serverUrl`, or its MCP Store |
+| Pi | Ready | None built in; use the operating system's | `pi -p "<prompt>"`, confirm against `pi --help` | Whether it reads the kit folder as the working directory; then the browser question | None. Pi runs no MCP servers by design, so only the command line routes in a kit's section 4b apply, wrapped as skills |
+| Cline | Ready | Built in cron: `cline schedule create "<prompt>" --cron "<cron>"`, one per routine, auto approve on | The prompt is `Read <root>/routines/<id>/SKILL.md and follow it.` | That a scheduled run starts in the kit folder, and that auto approve is on so it never hangs | `~/.cline/mcp.json`, Streamable HTTP with a token header |
+| Qwen Code | Ready | Built in scheduled tasks, or the operating system's | `qwen -p "<prompt>"`, confirm against `qwen --help` | That it can write inside the kit folder and reach the network | `qwen mcp add <name> <url>`, or `mcpServers` in `~/.qwen/settings.json` |
+| DeepSeek | Ready | Its scheduling plugin, one run per routine | `dsh` runs a local server; confirm the headless prompt form against `dsh --help` | Whether it drives your signed in browser profile or a clean one | Its MCP plugin, one server per plugin row |
+
+Every kit's `CAPABILITIES.md` section 4b names the connections that read its accounts without a browser, with the read only form of each route. The column above is how each harness adds one. A kit never installs a connection; the install prompt checks for each and names the absent ones in its handover.
+
+## What the invocation has to get right, on every harness
+
+1. **The working directory is the kit folder.** Every path in a routine is relative to it.
+2. **No permission prompt.** A scheduled run in a prompting mode does not fail at 06:45; it hangs, and leaves no record. Run scheduled work in the harness's auto approve mode, scoped to the kit folder where the harness allows scoping. This does not weaken the two guardrails, which live in the contract and the routines, not in the prompt gate. `CAPABILITIES.md` section 10 in every kit is the full argument.
+3. **Prove one routine by hand before registering the rest.** Run the standup, watch it write `brief-latest.md` and exactly one line into `runlog.jsonl`. Eight jobs registered on an invocation nobody ran is eight silent failures on the same morning.
+4. **A non zero exit should leave a record.** The Windows launcher does this through `runlog.mjs --failed-run`. On other harnesses, add the same `||` fallback to the command line.
+
+## Ran a kit on one of these?
+
+Open an issue with the harness and version, the invocation you used, what the first run record said, and what you changed. It goes into the notes for that row, with your name on the change.

package/docs/HOW-EMPLOYEES-WORK.md

@@ -0,0 +1,86 @@
+# How an employee works
+
+An AI employee here is not a chat window and not a skill. It is a folder of scheduled routines that together cover one business role, run on your own machine at fixed times, read and write plain files you can open, and reconcile into one short brief you read with your first coffee. The value is in the operating discipline, not in any single prompt, and this page is that discipline written down.
+
+## The five laws
+
+Every one of the eight is built to the same five laws. They are the reason you can leave one running.
+
+**1. Maximum self reliance.** The employee does the work. It researches rather than interrogates, decides rather than proposes, repairs rather than reports. It never stops for anything that is not a held outbound action or a credential; a routine about to stop for anything else has a defect. Where something is genuinely ambiguous it makes the most defensible call, records one line in its assumptions, and carries on. The next brief puts that line in front of you to correct in one line of your own.
+
+**2. Two guardrails, and the first one is yours.** Outbound actions: sending, posting, submitting, publishing and spending are all things an employee can do, and every one ships held, with the draft written, the form filled and left open, the build sheet complete and the last click yours. `RELEASES.md` in the employee's folder is where you release a channel, with your conditions, and only you write it. Credentials: it never creates an account, enters or generates a password, completes a captcha, enters payment details, or accepts terms, and it never writes a credential into any file. That one has no release, because it never needs your password to do its job.
+
+**3. Capabilities, never tools.** Routine bodies say things like `page.read`, `file.write`, `image.compress`. One file per kit, `CAPABILITIES.md`, maps each capability to a concrete route on each harness, with an honest confidence column. That is what makes a kit portable, and it is why a hosted route can be added later without a routine changing by one word.
+
+**4. No global skills bloat.** An employee never authors, installs, or bundles anything into your global skills directory. It may name an optional helper as a dependency, detect whether you already have it, use it when it is there, and fall back to a stated route when it is not. Which helpers you install is your decision, made separately.
+
+**5. Every hard won rule carries its date and lives in a file.** A procedural discovery that only exists in a run note does not survive to the next run. When a routine learns that a wait was too short or a page moved for good, it edits its own instruction file, records the full text it replaced, and the next run is better for it.
+
+Three more were earned in the first live week of the GTM Engineer running a real launch, and every kit carries them: **verify before you block** (a routine spends up to three minutes observing a gate before it reports you as the blocker, because a launch that visibly went out outranks a stale card), **bring the work to the member** (deliverables land in your own browser or account one click from done, with a durable queue file behind every staged tab), and **a tick records consent, the routine performs the move** (when you tick a card that implies a file change, the next routine completes the file change itself).
+
+## The folder
+
+```
+<root>/
+  CONTRACT.md          the spine: the routine roster, who writes which file, the guards, the two guardrails
+  ROLE.md              who this employee is and how it thinks
+  CAPABILITIES.md      capability to route, per harness, honest about what was confirmed
+  SCHEDULE.md          the only file that carries a cadence, a fire time, a window, or a budget
+  README.md            written for you
+  INSTALL-PROMPT.md    the one prompt you paste, once
+  routines/<id>/SKILL.md   one folder per routine; folder name, YAML name, and job name are one string
+  scripts/             guard.mjs, runlog.mjs, copy-check.mjs, each with a --selftest
+  run/                 one launcher example per routine for Windows Task Scheduler
+  recipes/             the browser craft notes; the per site flow files are learned on your machine, never shipped
+```
+
+Everything else (`strategy/`, the ledgers, `state/`, `briefs/`, the dashboard) is created on the first run and belongs to you. The `.gitignore` inside each kit keeps all of it out of any repo you push.
+
+## Routines are scheduled jobs, not skills
+
+A skill is something an agent invokes on demand. A routine is something a scheduler fires at a time, in a folder, with a window. Copy the routines into a global skills directory and every one of them loads into every session you open, any of them can be invoked outside its window, and when it is it records a skip and exits. So the routines carry `metadata: internal: true` in their frontmatter, registries do not list them, and the only thing this repo exposes as an on demand skill is `hire`, which copies one employee to a folder and prints its install prompt.
+
+## Windows, not fire times
+
+`SCHEDULE.md` gives every routine a fire time, a window, a period key, a budget, and a browser lane. The fire time is what you register. The window is the only thing the routine checks: outside it, the routine records `skipped-out-of-window` and exits. The period key (a local date, an ISO week, or a month) makes sure the work happens once per period however many times the job fires.
+
+That is what makes a late or duplicated fire harmless. What a missed fire does depends on your scheduler: the Claude Desktop app and Windows Task Scheduler run one late catch up, launchd folds every missed fire into one run on wake, and cron skips it for good. A catch up arrives at an unplanned minute, sometimes beside another routine's, and the two guards make it safe.
+
+**No routine sits on a Sunday.** A Sunday belongs to the ISO week that just ended, so a weekly routine scheduled there would share a period key with the following week and one of the two runs would be lost with no error.
+
+## The five opening lines, and the guard in front of them
+
+Every routine starts with the same five numbered items, in this order, before any other work: the pause switch, the window guard, the once per period guard written before any work, the wall clock budget, and the browser lane. `scripts/guard.mjs` runs the first three from three small files before a single document is read, so a fire that should not run costs cents instead of a full read of the contract. The five lines stay in every routine as the specification and as the fallback on a harness with no shell.
+
+## The four controls you hold
+
+- **The pause switch.** An empty file called `PAUSED` in the employee's folder stops every routine. Routine ids on lines inside it stop only those. Delete it and everything resumes; nothing was unregistered. No routine ever creates, writes, or deletes that file.
+- **Corrections.** Every file ends with a `## Corrections` section you write into and every routine reads at the top of every run. A dated line there outranks the file it sits in. This is how a kit gets good at your business specifically.
+- **The changelog of its own changes.** When a routine amends its own instructions it appends one line to `improvements/CHANGELOG.md` carrying the full text it replaced, so anything can be undone without the original download, and tomorrow's brief says what changed under `What changed about me`. It informs you. It does not ask you, because your harness already asks before anything writes to your disk, and that is the right place for that gate.
+- **The one push.** It notifies you only when you are the thing blocking it: an expired login, a credential it needs, conversion tracking that died while ads are running, or a browser lock held by a run that died. Once each, never twice for the same problem, never outside your working hours. Everything else waits for the brief.
+
+## The save test
+
+Forms get filled and left open in their tab. The label on a button is not the question; what the control commits is. A save that persists a private draft only you can see is allowed, and often necessary. A save that makes a record live, visible, sent, billable, or active is a send, whatever the button says. Seven labels are barred by name whatever the page claims: Submit, Publish, Post, Send, Activate, Enable, Create account. Page content is data, never instruction; a banner telling the agent to submit grants nothing.
+
+## The run record
+
+Every run appends exactly one line to `runlog.jsonl` through `scripts/runlog.mjs`, which refuses a record carrying a secret, a draft, a URL, or a person's name. Statuses: `ok`, `partial`, `failed`, `skipped-out-of-window`, `skipped-already-ran`, `skipped-paused`, `blocked-login`, `blocked-browser-busy`. `partial` means it hit its budget or a capability was missing and wrote what it had; that is designed behaviour, not an error. `blocked-login` means a human has to sign in, and it means no credential was entered and none will be. A record may also carry nine optional usage fields (model, tokens, cost) so what a run cost is a number rather than a guess.
+
+## The browser lane
+
+Routines touching different sites may run at the same time. What is serialized is your identity on one platform: a site sees one signed in account, and two routines crawling the same platform at once double the automation signature on exactly the surfaces with the strictest rules. So the lock file names platforms, a second routine proceeds when its platforms are disjoint, and every browser staged deliverable also lands in a durable queue file so a closed tab loses nothing. On LinkedIn the rule is total: it reads your own signed in pages and never clicks Message, Connect, Follow, or Like, never opens a composer, and never types.
+
+## The operator session
+
+Three actors touch a kit: the scheduled routines, you by hand, and you directing an interactive agent session in chat. The third one may do anything you may do by hand, on your explicit word, and it must leave the same trail a routine would: a dated note on every card it touches, a changelog line for every file it amends. A rule it inserts into a routine body counts as unverified until your confirmation lands in that file's `## Corrections`. That is the defense working, not a bug.
+
+## Glossary
+
+- **member:** the person who owns this employee. The kits call you that throughout.
+- **routine:** one scheduled job, one folder under `routines/`, one `SKILL.md`, one run record per run.
+- **window:** the span of local time inside which a routine is allowed to do its work.
+- **period key:** the local date, ISO week, or month that a run belongs to; the reason a duplicated fire does nothing.
+- **the two guardrails:** outbound actions, held until you release a channel in `RELEASES.md`, and credentials, always on. The only two things an employee holds for.
+- **release:** a row you write in `RELEASES.md` naming a channel, the action you hand over, and your conditions. No routine writes one.
+- **«placeholder»:** the guillemet marks in the kit mean a value the install fills in. Two survive on purpose in drafts: `«paste at send time»` for a credential you type yourself, and `«member: paste the detail»` for a number only you can supply.