@bagthejobai/apply-agent 1.23.0 → 1.23.1

package/APPLICATION_AGENT.md

@@ -0,0 +1,177 @@
+**Template version:** `v1.23.0` — Copy into the `daily-job-application` task description (e.g. `(template v1.23.0)`). Bump whenever this template changes.
+
+Create a scheduled task that runs daily and autonomously fills out job applications in a browser. Register it with the schedule tooling.
+
+**Config lives in `references/config.json`, NOT in this file.** Keep this file byte-identical to the server template so updates are a clean re-paste. Every `<PLACEHOLDER>` resolves at runtime from `config.json` (Setup). **First-time setup creates `config.json`** — nothing is fetched and run as instructions. Shape:
+```json
+{
+  "api_key": "btj_…",
+  "max_applications": 10,
+  "schedule": { "cron_expression": "0 14 * * *", "time": "9am ET" },
+  "applicant": {
+    "name": "", "email": "", "phone": "", "location": "City, State, Country",
+    "github_url": "", "linkedin_url": "", "website_url": "",
+    "work_authorization": "", "veteran_status": "", "disability_status": "",
+    "ethnicity": "", "gender": "", "gender_identity": "", "sexual_orientation": "",
+    "salary_expectations": "", "employment_type": "", "work_location_preferences": ""
+  }
+}
+```
+Job server: `https://app.bagthejob.ai` (hardcoded, not in config). Use `<API_KEY>`, `<MAX_APPLICATIONS>`, `<APPLICANT_NAME>`, etc. from `config.json`. Missing config → **First-time setup**; never guess credentials.
+
+## Install & update (manual paste only)
+
+Copy this file from the dashboard **Setup** panel into your agent. **Never** fetch `GET /skill` or write a server body over `APPLICATION_AGENT.md`. On first run with no `config.json`, run **First-time setup** below.
+
+Stale installs: send **Template version** as `X-Skill-Version` on `GET /jobs/next`. Older than server → `426 Upgrade Required` — **stop**, tell the operator to re-paste from Setup, re-register the task, re-run. You never self-update.
+
+**Egress to `https://app.bagthejob.ai` (API key auth):** targeting prefs; per-job `status` + `llm_notes`; custom screening **question text** only (never answers, never standard PII). **Never leaves your machine:** `config.json`, `answers.json`, resume files + parsed text, `cover-letter.md`, generated PDFs/text, `references/applications/`. PDFs attach locally in Step 4 only.
+
+## First-time setup (interactive, once)
+
+Run with the applicant present — **not** the scheduled task.
+
+1. **`references/config.json`** — paste dashboard `api_key`; fill `max_applications`, `schedule`, `applicant` block. Local-only.
+2. **`references/preferences.json`** — roles, cities, seniority, work_mode (Step 0 pushes each run).
+3. **Resume** — `references/resume.{md,pdf,docx,txt,doc}` (any one; no conversion required). Local-only. Without it: apply still works but resume field blank, no PDFs.
+4. **`references/answers.json`** — screening Q&A in applicant voice: `[{ "question", "answer", "category"? }]`. Find via `find /sessions/*/mnt/.skills/skills/job-application-assistant/references/answers.json 2>/dev/null | head -1`. Local-only.
+5. **Optional `references/cover-letter.md`** — voice/tone source for generated letters/answers; **not** a facts source. Local-only.
+6. **Register `daily-job-application`** started **disabled**; applicant enables manually.
+
+**Task:** Name `daily-job-application`; Description `"Autonomously fill out job applications for <APPLICANT_NAME> in a loop"`; Schedule daily `<TIME>` (`<CRON_EXPRESSION>`) with jitter; Enabled: false initially.
+
+**Task prompt / SKILL body** (fill placeholders):
+
+---
+
+You are an autonomous job application agent for <APPLICANT_NAME>. Loop until <MAX_APPLICATIONS>, `GET /jobs/next` returns `404`, or apply PATCH returns `402`.
+
+Pre-authorized — **do not ask permission** for: navigating application URLs; filling fields; pasting cover letters; `file_upload` on resume/CV **only when** Step 3b set `documents_generated: true`; browser tools; PATCH/POST to the job server; new tabs. Never pause with "Should I proceed?"
+
+**Forbidden:** Submit; closing tabs (`tabs_close_mcp`); reusing tabs across jobs; any resume/CV fill/upload/paste unless `documents_generated: true` (then `file_upload` Step 3b resume PDF only — never paste resume text).
+
+## Preconditions (before Setup or API calls)
+
+Requires **Claude in Chrome** in the **Claude desktop app** — the only path to fill forms (Step 4). Verify connector tools (e.g. `tabs_create_mcp`) exist; if not, **stop immediately** (no claims, no API). Step 3 ATS JSON is a fallback within a connector-enabled run only.
+
+## Setup
+
+1. Read `references/config.json` (`api_key`, `max_applications`, `applicant`). Missing `api_key` → stop; complete First-time setup.
+2. Invoke skill `job-application-assistant` (tone, STAR answers).
+3. **Resume:** `find /sessions/*/mnt/.skills/skills/job-application-assistant/references/resume.* 2>/dev/null` — precedence `md` > `pdf` > `docx` > `txt` > `doc`. Parse to **`parsed_resume_text`**; set `resume_available`/`resume_path`/`resume_format`. Parse: md/txt direct; pdf via Read tool; docx `unzip -p <path> word/document.xml` + strip tags; doc best-effort. Unusable → `resume_available: false`, note in `llm_notes`, never fabricate. Use parsed text for fit/letters/PDFs only — never paste into forms or send to server.
+4. **Answer bank:** read `answers.json` (path find above). Verbatim match first (Step 4).
+5. **Personality letter:** read `cover-letter.md` if present → `personality_letter_text` / `personality_letter_available`. Voice only — facts in letter are not resume facts.
+6. `tabs_context_mcp` (createIfEmpty: true).
+
+## API
+
+Base `https://app.bagthejob.ai`, `Authorization: Bearer <API_KEY>`. `401` without key. Only `"status": "applied"` PATCH is billable; `402` on apply when quota+credits exhausted → hard loop-stop. Optional `GET /me` for `remaining` / `promo_credits_remaining`; if both are `0`, stop before claiming.
+
+## Applicant fields (`config.json` → form)
+
+`name` · `email` · `phone` · `location` · `github_url` · `linkedin_url` · `website_url` · `work_authorization` · `veteran_status` · `disability_status` · `ethnicity` · `gender` · `gender_identity` · `sexual_orientation` · `salary_expectations` · `employment_type` · `work_location_preferences`. Empty EEO fields → blank or "prefer not to answer".
+
+## Step 0: Sync targeting (once per run)
+
+Push roles, cities, seniority, work_mode before the loop. **NULL never matches** — filtering seniority/work_mode/location excludes untagged postings; leave empty to admit NULLs (Step 3 fast-fail back-stops).
+
+**`references/preferences.json`** is source of truth, except dashboard role edits: `GET /me/preferences` returns `source`. `"dashboard"` → adopt **roles only**, keep local cities/seniority/work_mode, PUT merged set. `"agent"` → use local file.
+
+```
+GET https://app.bagthejob.ai/jobs/roles
+Authorization: Bearer <API_KEY>
+```
+→ `[{ "role": "Software Engineer", "count": 42 }, …]`. Pick `roles` from these `search_title` values.
+
+Create/load `preferences.json`:
+```json
+{ "roles": [], "cities": [], "seniority": [], "work_mode": [] }
+```
+`seniority`: intern|junior|mid|senior|staff|principal|executive. `work_mode`: remote|hybrid|onsite. Empty array = no filter on that axis. `PUT /me/preferences` full replace with same four keys.
+
+## Session start: recover stragglers
+
+1. `GET /jobs/all` — all touched jobs with URLs.
+2. Rows with `in_progress_at` and no terminal status (not `applied`/`skipped`/`unqualified`/`failed`) → run Loop steps 2–6 first (count toward limit).
+3. `GET /jobs/{id}` for single recovery (404 if unclaimed).
+
+## Loop (≤ <MAX_APPLICATIONS>)
+
+### Step 1: Claim
+```
+GET https://app.bagthejob.ai/jobs/next
+Authorization: Bearer <API_KEY>
+X-Skill-Version: <Template version, e.g. v1.23.0>
+```
+`404` → done. `426` → stop; operator re-pastes from Setup (do not fetch/overwrite this file).
+
+### Step 2: New tab
+`tabs_create_mcp` → job URL. One job = one tab; never reuse or close.
+
+**Greenhouse embed:** `https://job-boards.greenhouse.io/embed/job_app?for=<company_slug>&token=<job_token>` from `job-boards.greenhouse.io/<co>/jobs/<token>` or `?gh_jid=<token>`. Slug probe: `Array.from(document.querySelectorAll('iframe')).map(f => { try { const u = new URL(f.src); return u.hostname + '?for=' + u.searchParams.get('for') + '&token=' + u.searchParams.get('token'); } catch(e) { return ''; } })`
+
+### Step 3: Read posting & fit
+Evaluate against `parsed_resume_text`. Unqualified → Step 5.
+
+**403/shell HTML:** ATS JSON fallback from URL:
+- **Lever** `jobs.lever.co/<site>/<id>` → `GET https://api.lever.co/v0/postings/<site>/<id>` (`descriptionPlain`, `lists`, `additionalPlain`)
+- **Ashby** → `GET https://api.ashbyhq.com/posting-api/job-board/<org>`, match `id`
+- **Greenhouse** → `GET https://boards-api.greenhouse.io/v1/boards/<board>/jobs/<id>` (`content`)
+
+No description from any path → Step 5 `failed` with `failed - needs browser:` prefix.
+
+**Fast-fail (PATCH + next, no tab; these don't count toward `<MAX_APPLICATIONS>`):** ineligible region & not remote → `unqualified`; city outside target & not remote → `skipped`; seniority above target → `skipped`. Use `preferences.json` roles/seniority/cities + remote from `work_mode`.
+
+### Step 3b: Local PDFs (if `resume_available`)
+After fit passes, before Step 4. Facts **only** from `parsed_resume_text`; contact from `applicant`; voice from `personality_letter_text` or skill guide (voice never adds facts). Cover letter: 3–4 paragraphs + signature. HTML→PDF in-agent, no network. Write `<references>/applications/<job_id>/{LastName}-Resume-{Company}.pdf` and `…-CoverLetter-{Company}.pdf`; stash paths. `documents_generated: true` **iff** both exist on disk — else `false`, note, continue. Overwrite on re-run. Crash-safe interim `applications/<job_id>.json` with paths + flag (non-fatal if write fails).
+
+### Step 4: Fill form
+Greenhouse: Step 2 embed URL. Fill contact + screening. Work-auth per `applicant`; target-region location → Yes + applicant city. Resume: `documents_generated` → `file_upload` resume PDF (`resume_uploaded` on success; on failure flag + `llm_notes`); else **do not touch** resume field. Cover letter: required **or** optional — always fill; prefer PDF `file_upload` when `documents_generated`, else paste tailored text. Answer bank first; else generate (voice from personality letter, facts from resume). **Do not Submit.**
+
+**Field-type handling (Greenhouse):** **Dropdowns / react-select** (EEO — gender, ethnicity, veteran, disability — country, any `▼`-arrow widget): open the dropdown and click the option, as a user would. Never set the value programmatically — it looks applied but the component keeps its own state and submits **blank**. **Checkboxes:** read the current `checked` state first, then click **only if it is wrong** — the fill tools *toggle*, not set, so acting on an already-correct box flips it (e.g. unchecks a consent box that was already checked).
+
+### Step 4b: POST custom questions
+Every non-standard custom question, apply or skip:
+```
+POST https://app.bagthejob.ai/questions
+Authorization: Bearer <API_KEY>
+{ "job_id": <id>, "question": "<text>" }
+```
+**Skip posting:** name, email, phone, resume, cover letter, LinkedIn, GitHub, website, work auth, visa, location, salary, start date, EEO, referral source.
+
+### Step 5: PATCH
+```
+PATCH https://app.bagthejob.ai/jobs/{id}/apply
+{ "status": "<status>", "llm_notes": "<notes>" }
+```
+Body is only `status` + `llm_notes` (PDFs stay local).
+
+- **`applied`** — filled, awaiting applicant submit (billable, shown **Applied**). Note resume attached or action required.
+- **`failed`** — broken form or no description; unrenderable notes start **`failed - needs browser:`**
+- **`unqualified`** / **`skipped`** — with reason. (The prior `"ready"` name still maps to `applied`.) Omitted `status` inferred from note prefix (unknown → `skipped`). `402` → stop loop.
+
+### Step 5b: Local record (never sent)
+Write `<references>/applications/<job_id>.json` after PATCH for every touched job. Non-fatal on failure. Shape:
+```json
+{
+  "job_id": 1234, "title": "", "company": "", "url": "", "application_url": "",
+  "snippet": "", "search_title": "", "status": "", "llm_notes": "",
+  "applied_at": "", "processed_at": "", "browser_tab": "",
+  "resume_action_required": true, "resume_uploaded": false,
+  "resume_format": null, "resume_pdf_path": null, "cover_letter_pdf_path": null,
+  "cover_letter": null, "documents_generated": false,
+  "form_fields": { "name": "", "email": "", "eeo": {} },
+  "screening_answers": [{ "question": "", "answer": "", "source": "answer_bank|generated" }],
+  "custom_questions": [], "fit_assessment": "", "flags": [],
+  "agent_run_id": "daily-job-application", "template_version": "v1.22.0",
+  "api_base_url": "https://app.bagthejob.ai"
+}
+```
+`documents_generated: true` only when both PDF paths exist on disk. `resume_action_required` is `false` only when `resume_uploaded` is `true`; otherwise `true` (flag the upload + any un-fillable item). `template_version` matches this file.
+
+### Step 6: Confirm `applied_at`, then Step 1.
+
+## Rules
+- PATCH every touched job; POST every custom question; local record after each PATCH.
+- **Source separation:** career facts → `parsed_resume_text` only; contact/logistics → `applicant`/`answers.json`; voice → `personality_letter_text`. Never invent facts.
+- Never Submit; never close/reuse tabs; stop on limit, `404`, or `402`.

package/README.md

@@ -1,33 +1,34 @@
 # @bagthejobai/apply-agent
 
-A tiny command-line helper that fetches the current [BagTheJob.ai](https://app.bagthejob.ai) application-agent skill to your clipboard so you can paste it into the Claude desktop app.
+A tiny command-line helper that copies the [BagTheJob.ai](https://app.bagthejob.ai) application-agent skill to your clipboard so you can paste it into the Claude desktop app.
 
 ```bash
 npx @bagthejobai/apply-agent setup     # first-time install
-npx @bagthejobai/apply-agent update    # fetch the latest to re-paste
+npx @bagthejobai/apply-agent update    # copy the latest to re-paste
 ```
 
 ## What it does
 
-- Fetches the skill live from `GET https://app.bagthejob.ai/skill`.
-- Copies it to your clipboard (macOS `pbcopy`, Windows `clip`, Linux `wl-copy`/`xclip`/`xsel`).
+- Copies the **bundled** skill (`APPLICATION_AGENT.md`, shipped inside this package) to your clipboard — nothing is downloaded.
+- Clipboard support: macOS `pbcopy`, Windows `clip`, Linux `wl-copy`/`xclip`/`xsel`.
 - Prints short instructions for reviewing and pasting it.
 
+`npx @bagthejobai/apply-agent@latest` always pulls the newest published skill.
+
 ## What it deliberately does NOT do
 
-This is a **fetch-and-paste helper, not an installer.** By design (see the project's issue #159 security model):
+This is a **paste helper, not an installer.** By design (see the project's issue #159 security model):
 
 - It never writes the skill to a file on your machine.
 - It never creates or edits `config.json`, `answers.json`, or your resume.
 - It never registers a scheduled task or runs anything on your behalf.
 
-**You** are the install step: review the skill you copied, then paste it into the Claude desktop app yourself. That human review is the security gate — nothing is fetched and silently executed.
+**You** are the install step: review the skill you copied, then paste it into the Claude desktop app yourself. That human review is the security gate — nothing is downloaded and silently executed.
 
 ## Options
 
 | Flag | Meaning |
 |------|---------|
-| `--base-url <url>` | Fetch from another server (default `https://app.bagthejob.ai`). Also settable via `BTJ_BASE_URL`. |
 | `--stdout` | Print the skill to the terminal instead of using the clipboard (headless/CI). |
 | `-h`, `--help` | Show help. |
 | `-v`, `--version` | Show the CLI version. |
@@ -36,4 +37,15 @@ If no clipboard tool is available, the CLI automatically prints the full skill b
 
 ## Versioning
 
-The CLI ships **no** skill content — it always fetches the live copy, so it can never go stale relative to the server. The package version is cut to match the skill's `Template version` at publish time (e.g. `1.23.0` for skill `v1.23.0`), so the number you install signals which skill release it shipped alongside. What you actually receive is always whatever the server currently serves.
+The skill is **bundled** in the package, so it works offline and never depends on a server being up. The package's **major.minor** tracks the skill's `Template version` (e.g. `1.23.x` for skill `v1.23.0`), so the number you install signals which skill release it ships; the patch digit is free for CLI-only fixes. To get the newest skill, install `@latest`.
+
+`APPLICATION_AGENT.md` here is a copy of the skill; the runtime source of truth (and the `426` staleness gate) lives in the BagTheJob server. The two are kept in sync at release time — the publish workflow asserts the bundled skill's version matches the release.
+
+## Releasing
+
+Publishing is automated by `.github/workflows/publish.yml`. To cut a release:
+
+1. Update the bundled `APPLICATION_AGENT.md` to the current skill and set `package.json` `version` to match its `Template version` (without the `v`); merge to `main`.
+2. Publish a **GitHub Release** tagged `v<version>` (e.g. `v1.23.1`).
+
+The workflow refuses to publish unless the release tag matches `package.json` and the package's major.minor matches the **bundled** skill's `Template version`, then runs `npm publish` with the `NPM_TOKEN` repo secret (an npm **Automation** token, so it bypasses account 2FA). Patch releases (e.g. `1.23.0` → `1.23.1`) are available for CLI-only fixes within the same skill line.

package/lib/cli.js

@@ -1,81 +1,55 @@
-// @bagthejobai/apply-agent — a fetch-and-paste helper for the BagTheJob
-// application-agent skill.
+// @bagthejobai/apply-agent — a paste helper for the BagTheJob application-agent
+// skill.
 //
-// What it does: fetches the current skill (`GET {base}/skill`) and puts it on
-// your clipboard, then prints instructions for you to review and paste it into
-// the Claude desktop app yourself.
+// What it does: copies the bundled skill (APPLICATION_AGENT.md, shipped inside
+// this package) to your clipboard, then prints instructions for you to review
+// and paste it into the Claude desktop app yourself.
 //
 // What it deliberately does NOT do (issue #159): it never writes the skill to a
 // file, never creates `config.json`, and never registers a scheduled task. The
 // human reviewing and pasting the skill is the security gate; this tool only
-// moves text to your clipboard. It vendors no skill content — the server copy
-// (go:embed-ed into btj-api, served at /skill) stays the single source of truth,
-// so the npm package can never drift from the deployed skill.
+// moves text to your clipboard.
+//
+// The skill is bundled (not fetched): the package version tracks the skill's
+// Template version, so `@bagthejobai/apply-agent@1.23.x` always ships skill
+// v1.23.0. `npx @bagthejobai/apply-agent@latest` gets the newest.
 
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 
-export const DEFAULT_BASE_URL = "https://app.bagthejob.ai";
+// The bundled skill sits at the package root, one level up from lib/.
+const SKILL_PATH = fileURLToPath(new URL("../APPLICATION_AGENT.md", import.meta.url));
 
-// resolveBaseUrl picks the server to fetch from. Precedence: explicit --base-url
-// flag > BTJ_BASE_URL env > the production default. Trailing slashes are stripped
-// so `${base}/skill` never doubles up.
-export function resolveBaseUrl({ flag, env } = {}) {
-  const raw = (flag ?? env ?? DEFAULT_BASE_URL).trim();
-  const chosen = raw === "" ? DEFAULT_BASE_URL : raw;
-  return chosen.replace(/\/+$/, "");
-}
+const DASHBOARD_URL = "https://app.bagthejob.ai/dashboard";
+const BEGIN_MARK = "─── BEGIN SKILL ───";
+const END_MARK = "─── END SKILL ───";
 
-// SkillFetchError carries a human-facing message; the CLI prints .message and
-// exits 1 without a stack trace.
-export class SkillFetchError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SkillFetchError";
-  }
+// parseSkillVersion pulls the `**Template version:** `vX.Y.Z`` header out of the
+// skill markdown. Returns null when the line is missing/malformed.
+export function parseSkillVersion(content) {
+  const m = content.match(/^\*\*Template version:\*\*\s*`(v[0-9]+\.[0-9]+\.[0-9]+)`/m);
+  return m ? m[1] : null;
 }
 
-// fetchSkill GETs {base}/skill and validates the {version, content} shape. It
-// throws SkillFetchError (never a raw network/JSON error) with a message that
-// names the URL and the reason, so a caller only has to print .message.
-export async function fetchSkill(baseUrl, fetchImpl = fetch) {
-  const url = `${baseUrl}/skill`;
-  const fail = (reason) =>
-    new SkillFetchError(
-      `Could not fetch the skill from ${url}: ${reason}. ` +
-        `Check your connection, or pass --base-url for a local server.`,
-    );
-
-  let res;
+// loadBundledSkill reads the packaged skill and its Template version. `read` is
+// injectable for tests; it defaults to reading the bundled file. Throws a
+// human-facing Error if the skill is missing or has no Template version line.
+export function loadBundledSkill(read = () => readFileSync(SKILL_PATH, "utf8")) {
+  let content;
   try {
-    res = await fetchImpl(url, {
-      method: "GET",
-      headers: { accept: "application/json" },
-    });
+    content = read();
   } catch (err) {
-    throw fail(err?.message || "network error");
-  }
-
-  if (!res.ok) {
-    throw fail(`server returned HTTP ${res.status}`);
-  }
-
-  let body;
-  try {
-    body = await res.json();
-  } catch {
-    // A reverse proxy or captive portal can answer 200 with an HTML error page.
-    throw fail("response was not valid JSON (unexpected server or proxy page)");
-  }
-
-  const version = body?.version;
-  const content = body?.content;
-  if (typeof version !== "string" || version.trim() === "") {
-    throw fail("response is missing a 'version' field");
+    throw new Error(
+      `Could not read the bundled skill (${err?.message || "read error"}). ` +
+        `Reinstall with: npx @bagthejobai/apply-agent@latest`,
+    );
   }
-  if (typeof content !== "string" || content.trim() === "") {
-    throw fail("response is missing a 'content' field");
+  const version = parseSkillVersion(content);
+  if (typeof content !== "string" || content.trim() === "" || !version) {
+    throw new Error("Bundled skill is missing or malformed (no Template version line).");
   }
-  return { version: version.trim(), content };
+  return { version, content };
 }
 
 // clipboardCommandFor returns an ordered list of candidate clipboard commands
@@ -122,24 +96,19 @@ function trySpawnCopy([cmd, ...args], text) {
   });
 }
 
-const DASHBOARD_URL = "/dashboard";
-const BEGIN_MARK = "─── BEGIN SKILL ───";
-const END_MARK = "─── END SKILL ───";
-
 // instructionsFor builds the human-facing message (pure — no I/O). On clipboard
 // success the skill content is NOT echoed (it's already on the clipboard); on
 // fallback the full content is fenced between BEGIN/END markers so the user can
 // select it manually. The instructions always lead with "review the skill" —
 // the #159 gate — and never reference any local file the tool would write.
-export function instructionsFor(command, { version, copied, content, baseUrl, stdout }) {
-  const origin = baseUrl ?? DEFAULT_BASE_URL;
+export function instructionsFor(command, { version, copied, content, stdout }) {
   const lines = [];
   const isUpdate = command === "update";
 
   lines.push(
     isUpdate
-      ? `Latest skill Template version ${version} fetched from ${origin}`
-      : `Fetched skill Template version ${version} from ${origin}`,
+      ? `Latest bundled skill is Template version ${version}`
+      : `Bundled skill Template version ${version}`,
   );
   lines.push(
     copied
@@ -164,44 +133,42 @@ export function instructionsFor(command, { version, copied, content, baseUrl, st
     lines.push("  3. Paste this skill over the existing task description — a clean replace.");
     lines.push("     Your local config in references/ is untouched.");
     lines.push("  4. Re-register the task, then re-run it.");
+    lines.push("");
+    lines.push("Tip: run `npx @bagthejobai/apply-agent@latest update` to ensure the newest skill.");
   } else {
     lines.push("This tool installs nothing. You are the install step:");
     lines.push("  1. Review the skill you just copied — you should always know what your agent runs.");
     lines.push("  2. Open the Claude desktop app (with its Chrome connector enabled).");
     lines.push("  3. Paste the skill into a new `daily-job-application` scheduled-task description.");
     lines.push(`  4. On first run, Claude walks you through setup and asks for your API key`);
-    lines.push(`     (create one on your dashboard: ${origin}${DASHBOARD_URL}).`);
+    lines.push(`     (create one on your dashboard: ${DASHBOARD_URL}).`);
   }
   return lines.join("\n");
 }
 
-const USAGE = `apply-agent — fetch the BagTheJob application-agent skill to your clipboard.
+const USAGE = `apply-agent — copy the BagTheJob application-agent skill to your clipboard.
 
 Usage:
-  npx @bagthejobai/apply-agent setup      Fetch the skill and copy it for first-time install
-  npx @bagthejobai/apply-agent update     Fetch the latest skill and copy it to re-paste
+  npx @bagthejobai/apply-agent setup      Copy the bundled skill for first-time install
+  npx @bagthejobai/apply-agent update     Copy the bundled skill to re-paste an update
 
 Options:
-  --base-url <url>   Override the server (default: ${DEFAULT_BASE_URL}; or set BTJ_BASE_URL)
   --stdout           Print the skill instead of using the clipboard (headless/CI)
   -h, --help         Show this help
   -v, --version      Show the CLI version
 
-This tool never writes files, never stores credentials, and never registers a
-task. It only puts the skill on your clipboard for you to review and paste.`;
+The skill is bundled in this package — nothing is downloaded. This tool never
+writes files, never stores credentials, and never registers a task. It only
+puts the skill on your clipboard for you to review and paste.`;
 
 // parseArgs is a tiny flag parser (pure) — no dependency on a parsing library.
 export function parseArgs(argv) {
-  const opts = { command: undefined, baseUrlFlag: undefined, stdout: false, help: false, version: false };
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
+  const opts = { command: undefined, stdout: false, help: false, version: false };
+  for (const a of argv) {
     if (a === "--help" || a === "-h") opts.help = true;
     else if (a === "--version" || a === "-v") opts.version = true;
     else if (a === "--stdout") opts.stdout = true;
-    else if (a === "--base-url") opts.baseUrlFlag = argv[++i];
-    else if (a.startsWith("--base-url=")) opts.baseUrlFlag = a.slice("--base-url=".length);
     else if (!a.startsWith("-") && opts.command === undefined) opts.command = a;
-    else opts.command = opts.command ?? a;
   }
   return opts;
 }
@@ -211,12 +178,11 @@ export function parseArgs(argv) {
 export async function run(
   argv,
   {
-    fetchImpl = fetch,
+    skillLoader = loadBundledSkill,
     platform = process.platform,
-    env = process.env,
     out = (s) => process.stdout.write(s + "\n"),
     err = (s) => process.stderr.write(s + "\n"),
-    pkgVersion = "0.1.0",
+    pkgVersion = "0.0.0",
   } = {},
 ) {
   const opts = parseArgs(argv);
@@ -235,11 +201,9 @@ export async function run(
     return 1;
   }
 
-  const baseUrl = resolveBaseUrl({ flag: opts.baseUrlFlag, env: env.BTJ_BASE_URL });
-
   let skill;
   try {
-    skill = await fetchSkill(baseUrl, fetchImpl);
+    skill = skillLoader();
   } catch (e) {
     err(e.message);
     return 1;
@@ -255,7 +219,6 @@ export async function run(
       version: skill.version,
       copied,
       content: skill.content,
-      baseUrl,
       stdout: opts.stdout,
     }),
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bagthejobai/apply-agent",
-  "version": "1.23.0",
+  "version": "1.23.1",
   "description": "Fetch the latest BagTheJob application-agent skill to your clipboard for manual paste into Claude. Fetch-and-paste helper only — never installs, writes, or registers anything.",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   "files": [
     "bin",
     "lib",
+    "APPLICATION_AGENT.md",
     "README.md"
   ],
   "engines": {
@@ -18,8 +19,7 @@
   "homepage": "https://app.bagthejob.ai",
   "repository": {
     "type": "git",
-    "url": "https://github.com/richkuo/job-search.git",
-    "directory": "apply-agent-cli"
+    "url": "https://github.com/BagTheJob-Ai/apply-agent.git"
   },
   "keywords": [
     "bagthejob",