@headways/cli 0.4.2 → 1.0.0

package/README.md

@@ -1,9 +1,16 @@
 # @headways/cli
 
-The official CLI for [Headways](https://headways.ai) — author skills, sync them to your team, and capture workflows directly from Claude Code.
+The official CLI for [Headways](https://headways.ai). Two responsibilities:
+
+1. **Skill authoring** — talk to the backend API: scaffold, push drafts, list, submit feedback.
+2. **Claude Code runtime helpers** — small binaries that Claude Code hooks shell out to (`prime`, `emit`, `skill-run start`).
+
+Anything that mutates this machine's state — installing skill bundles, syncing the catalog, editing `~/.claude/settings.json` — lives in the [Headways desktop app](https://headways.ai/download) (macOS for now). The desktop auto-installs this CLI under `~/.local/bin/headways` on first launch.
 
 ## Installation
 
+The desktop app installs the CLI for you. For dev / local work:
+
 ```bash
 npm install -g @headways/cli
 ```
@@ -11,63 +18,66 @@ npm install -g @headways/cli
 ## Setup
 
 ```bash
-headways configure
-# Prompts for your API key (sk_…). Validates and saves org automatically.
+headways login
+# Browser SSO. Saves credentials + org to ~/.headways/config.json.
 ```
 
-Options:
-
 ```bash
-headways configure --token <key>              # non-interactive
-headways configure --api-url http://localhost:3001  # local dev
-headways configure status                    # show saved key + org
-headways configure clear                     # remove credentials
+headways config status                       # show saved token + org + URLs
+headways config clear                        # remove credentials
 ```
 
 ## Commands
 
-### Skills
+### Authoring
 
 ```bash
-headways skills new                          # scaffold a new skill interactively
+headways skills new                          # scaffold a new skill (creates ./<slug>/)
 headways skills new --slug <slug> --headline "<headline>"  # non-interactive
-headways skills import <path>               # ingest an existing file or directory
-headways skills push <slug>                 # sync local edits to the skill draft
-headways skills list                        # list skills in the active org
-headways skills capture                     # capture a workflow from Claude Code
+headways skills import <path>                # ingest an existing file or directory
+headways skills push <slug>                  # push local edits as a draft
+headways skills list                         # list skills in the active org
+headways skills feedback <slug>              # submit feedback on a skill
+headways skills guide                        # authoring reference (run before creating a skill)
 ```
 
-### Sync
+### Runtime helpers (invoked by Claude Code hooks; rarely run by hand)
 
 ```bash
-headways sync start                         # register device + pull updates once
-headways sync start --daemon                # poll every 60s for background updates
-headways sync status                        # show pending skill updates
-headways accept <skill>                     # install a pending update
+headways prime                               # print workflow context for AI agents
+headways emit --hook <namespace>.<name>      # emit a skill-run event
+headways skill-run start                     # create a run from a UserPromptSubmit hook
 ```
 
-### Other
+### Connections
 
 ```bash
-headways feedback <skillSlug>               # submit feedback on a skill run
-headways org use <slug>                     # switch active org
+headways connections list                    # list MCP connector authorizations
 ```
 
 ## Creating a skill from scratch
 
 ```bash
 cd ~/my-skills
-headways skills new                         # creates ./<slug>/ with SKILL.md,
-                                            # headways.yaml, capabilities.yaml,
-                                            # hooks.yaml
-# Edit the skill
-vim <slug>/SKILL.md
-# Push as a draft
-headways skills push <slug>
-# Publish via the web UI when ready
+headways skills new                          # creates ./<slug>/ with SKILL.md,
+                                             # headways.yaml, capabilities.yaml,
+                                             # hooks.yaml
+vim <slug>/SKILL.md                          # edit
+headways skills push <slug>                  # push as draft
+# Then publish via the web UI at app.headways.ai/skills/<slug>
 ```
 
-Installed skill bundles land in `~/.claude/skills/<slug>/`. Config is stored in `~/.headways/config.json`.
+Once published, the skill shows up in the desktop app's Library view with an **Install** button.
+
+## Where things live
+
+| Path | Purpose |
+|---|---|
+| `~/.headways/config.json` | API token, org, URLs |
+| `~/.headways/installed/<slug>.json` | Local install manifests (written by the desktop) |
+| `~/.headways/runs/<session_id>` | Active run id per Claude Code session (written by `skill-run start`) |
+| `~/.claude/skills/<slug>/` | Materialized skill bundles (written by the desktop) |
+| `~/.claude/settings.json` | Claude Code hook wiring (written by the desktop) |
 
 ## Local development
 

package/dist/{api-5EKGGFQ6.js → api-H34ZX4FL.js}

@@ -2,8 +2,8 @@
 import {
   apiRequest,
   rawRequest
-} from "./chunk-2INXZHRG.js";
-import "./chunk-UUFIIGTZ.js";
+} from "./chunk-GN2N6M4B.js";
+import "./chunk-COGZMSYS.js";
 export {
   apiRequest,
   rawRequest

package/dist/{chunk-UUFIIGTZ.js → chunk-COGZMSYS.js}

@@ -8,6 +8,7 @@ var HEADWAYS_DIR = join(homedir(), ".headways");
 var CONFIG_FILE = join(HEADWAYS_DIR, "config.json");
 var CATALOG_FILE = join(HEADWAYS_DIR, "catalog.json");
 var INSTALLED_DIR = join(HEADWAYS_DIR, "installed");
+var RUNS_DIR = join(HEADWAYS_DIR, "runs");
 var CLAUDE_SKILLS_DIR = join(homedir(), ".claude", "skills");
 function readConfig() {
   if (!existsSync(CONFIG_FILE)) return {};
@@ -43,6 +44,7 @@ export {
   CONFIG_FILE,
   CATALOG_FILE,
   INSTALLED_DIR,
+  RUNS_DIR,
   CLAUDE_SKILLS_DIR,
   readConfig,
   writeConfig,

package/dist/{chunk-2INXZHRG.js → chunk-GN2N6M4B.js}

@@ -2,7 +2,7 @@
 import {
   getApiUrl,
   requireAuth
-} from "./chunk-UUFIIGTZ.js";
+} from "./chunk-COGZMSYS.js";
 
 // src/lib/api.ts
 async function rawRequest(path, token, options = {}, apiUrl) {

package/dist/{config-XQHAXREA.js → config-APIR4RCR.js}

@@ -5,18 +5,20 @@ import {
   CONFIG_FILE,
   HEADWAYS_DIR,
   INSTALLED_DIR,
+  RUNS_DIR,
   getApiUrl,
   getAppUrl,
   readConfig,
   requireAuth,
   writeConfig
-} from "./chunk-UUFIIGTZ.js";
+} from "./chunk-COGZMSYS.js";
 export {
   CATALOG_FILE,
   CLAUDE_SKILLS_DIR,
   CONFIG_FILE,
   HEADWAYS_DIR,
   INSTALLED_DIR,
+  RUNS_DIR,
   getApiUrl,
   getAppUrl,
   readConfig,

package/dist/index.js

@@ -2,21 +2,17 @@
 import {
   apiRequest,
   rawRequest
-} from "./chunk-2INXZHRG.js";
-import {
-  registerSetupCommand,
-  registerSyncCommands,
-  registerUninstallCommand
-} from "./chunk-XTEQBKIN.js";
+} from "./chunk-GN2N6M4B.js";
 import {
   CLAUDE_SKILLS_DIR,
   INSTALLED_DIR,
+  RUNS_DIR,
   getApiUrl,
   getAppUrl,
   readConfig,
   requireAuth,
   writeConfig
-} from "./chunk-UUFIIGTZ.js";
+} from "./chunk-COGZMSYS.js";
 
 // src/index.ts
 import "dotenv/config";
@@ -25,7 +21,7 @@ import { program } from "commander";
 // package.json
 var package_default = {
   name: "@headways/cli",
-  version: "0.4.2",
+  version: "1.0.0",
   type: "module",
   description: "Headways CLI \u2014 authoring, sync, and runtime SDK",
   license: "MIT",
@@ -285,6 +281,12 @@ function registerNewCommand(program2) {
       console.error("slug and headline are required.");
       process.exit(1);
     }
+    if (headline.length > 90) {
+      console.error(
+        `Headline is ${headline.length} chars \u2014 must be \u2264 90. Shorten to one sentence.`
+      );
+      process.exit(1);
+    }
     const dir = path.join(process.cwd(), slug);
     await fs.mkdir(dir, { recursive: true });
     await fs.writeFile(
@@ -356,96 +358,63 @@ runtimes: [claude-code]
 
 // src/commands/skills/import.ts
 import "commander";
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+
+// src/commands/skills/push.ts
+import "commander";
 import * as fs2 from "fs/promises";
 import * as path2 from "path";
-var ORG_PROFILES = {
-  hippocratic: {
-    connectorHints: ["ehr.read", "ehr.write", "phi.access"],
-    fixtureTemplate: "patient-encounter",
-    channelPolicy: "stable"
-  },
-  revive: {
-    connectorHints: ["email.read", "calendar.read", "ads.read"],
-    fixtureTemplate: "campaign-brief",
-    channelPolicy: "beta"
-  }
-};
-function registerImportCommand(program2) {
-  program2.command("import <path>").description("Import a skill from a file, directory, or URL").option("--slug <slug>", "Override derived slug").option(
-    "--org <orgProfile>",
-    "Apply org-specific connector hints + fixture templates (hippocratic, revive)"
-  ).action(async (inputPath, opts) => {
-    requireAuth();
-    let source;
-    let format = "auto";
+import { watch, existsSync } from "fs";
+var RESERVED_TOP_LEVEL = /* @__PURE__ */ new Set([
+  "SKILL.md",
+  "headways.yaml",
+  "capabilities.yaml",
+  "connections.yaml",
+  "hooks.yaml"
+]);
+var IGNORE_NAMES = /* @__PURE__ */ new Set([".git", "node_modules", ".DS_Store", ".gitkeep"]);
+async function collectExtraFiles(dir) {
+  const result = {};
+  async function walk(current, prefix) {
+    let entries;
     try {
-      const stat2 = await fs2.stat(inputPath);
-      if (stat2.isDirectory()) {
-        const skillMdPath = path2.join(inputPath, "SKILL.md");
-        source = await fs2.readFile(skillMdPath, "utf-8");
-        format = "skill-md";
-      } else {
-        source = await fs2.readFile(inputPath, "utf-8");
-        if (inputPath.endsWith(".yaml") || inputPath.endsWith(".yml")) {
-          format = "headways-yaml";
-        } else {
-          format = "markdown";
-        }
-      }
+      entries = await fs2.readdir(current, { withFileTypes: true });
     } catch {
-      console.error(`Cannot read '${inputPath}': file or directory not found.`);
-      process.exit(1);
-    }
-    const profile = opts.org ? ORG_PROFILES[opts.org] : void 0;
-    if (opts.org && !profile) {
-      console.warn(
-        `Unknown org profile '${opts.org}'. Known profiles: ${Object.keys(ORG_PROFILES).join(", ")}`
-      );
+      return;
     }
-    const derivedSlug = opts.slug ?? path2.basename(inputPath, path2.extname(inputPath)).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-    const result = await apiRequest("/v1/skills/import", {
-      method: "POST",
-      body: JSON.stringify({
-        source,
-        format,
-        suggestedSlug: derivedSlug,
-        connectorHints: profile?.connectorHints,
-        channelPolicy: profile?.channelPolicy
-      })
-    });
-    console.log(`Imported as '${result.slug}' (format: ${result.detectedFormat})`);
-    console.log(`  Headline: ${result.headline}`);
-    console.log(`  Skill ID: ${result.skillId}`);
-    if (profile) {
-      console.log(`  Org profile: ${opts.org}`);
-      console.log(`  Connector hints: ${profile.connectorHints.join(", ")}`);
-      console.log(`  Fixture template: ${profile.fixtureTemplate}`);
+    for (const entry of entries) {
+      if (IGNORE_NAMES.has(entry.name) || entry.name.startsWith(".")) continue;
+      const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const abs = path2.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(abs, rel);
+      } else if (!prefix && RESERVED_TOP_LEVEL.has(entry.name)) {
+      } else {
+        result[rel] = await fs2.readFile(abs, "utf-8");
+      }
     }
-    console.log(`  Run 'headways skills push ${result.slug}' to sync edits.`);
-  });
+  }
+  await walk(dir, "");
+  return result;
 }
-
-// src/commands/skills/push.ts
-import "commander";
-import * as fs3 from "fs/promises";
-import * as path3 from "path";
-import { watch, existsSync } from "fs";
 var catchMissing = (e) => {
   if (e.code === "ENOENT") return null;
   throw e;
 };
 async function readSkillDir(dir) {
-  const skillMdPath = path3.join(dir, "SKILL.md");
+  const skillMdPath = path2.join(dir, "SKILL.md");
   let body;
   try {
-    body = await fs3.readFile(skillMdPath, "utf-8");
+    body = await fs2.readFile(skillMdPath, "utf-8");
   } catch {
     throw new Error(`SKILL.md not found in ${dir}`);
   }
-  const [headwaysYaml, capabilitiesYaml, connectionsYaml] = await Promise.all([
-    fs3.readFile(path3.join(dir, "headways.yaml"), "utf-8").catch(catchMissing),
-    fs3.readFile(path3.join(dir, "capabilities.yaml"), "utf-8").catch(catchMissing),
-    fs3.readFile(path3.join(dir, "connections.yaml"), "utf-8").catch(catchMissing)
+  const [headwaysYaml, capabilitiesYaml, connectionsYaml, hooksYaml] = await Promise.all([
+    fs2.readFile(path2.join(dir, "headways.yaml"), "utf-8").catch(catchMissing),
+    fs2.readFile(path2.join(dir, "capabilities.yaml"), "utf-8").catch(catchMissing),
+    fs2.readFile(path2.join(dir, "connections.yaml"), "utf-8").catch(catchMissing),
+    fs2.readFile(path2.join(dir, "hooks.yaml"), "utf-8").catch(catchMissing)
   ]);
   let headline;
   if (headwaysYaml) {
@@ -457,7 +426,15 @@ async function readSkillDir(dir) {
     const items = parseConnectionsYaml(connectionsYaml);
     if (items.length > 0) connections = items;
   }
-  return { body, headline, capabilities: capabilitiesYaml ?? void 0, connections };
+  const extraFiles = await collectExtraFiles(dir);
+  return {
+    body,
+    headline,
+    capabilities: capabilitiesYaml ?? void 0,
+    hooks: hooksYaml ?? void 0,
+    connections,
+    files: Object.keys(extraFiles).length > 0 ? extraFiles : void 0
+  };
 }
 function parseConnectionsYaml(yaml) {
   const items = [];
@@ -482,28 +459,36 @@ function parseConnectionsYaml(yaml) {
   return items;
 }
 async function pushSkill(slug, dir) {
-  const { body, headline, capabilities, connections } = await readSkillDir(dir);
+  const { body, headline, capabilities, hooks, connections, files } = await readSkillDir(dir);
+  if (headline && headline.length > 90) {
+    throw new Error(
+      `Headline is ${headline.length} chars \u2014 must be \u2264 90. Shorten to one sentence in headways.yaml.`
+    );
+  }
   await apiRequest(`/v1/skills/${slug}/draft`, {
     method: "PUT",
     body: JSON.stringify({
       body,
       ...headline ? { headline } : {},
       ...capabilities ? { capabilities } : {},
-      ...connections ? { connections } : {}
+      ...hooks ? { hooks } : {},
+      ...connections ? { connections } : {},
+      ...files ? { files } : {}
     })
   });
-  console.log(`Pushed '${slug}' draft`);
+  const fileCount = files ? Object.keys(files).length : 0;
+  console.log(`Pushed '${slug}' draft${fileCount > 0 ? ` (${fileCount} extra file${fileCount === 1 ? "" : "s"})` : ""}`);
 }
 function resolveSkillDir(slug) {
   if (!slug) return process.cwd();
-  const installedPath = path3.join(CLAUDE_SKILLS_DIR, slug);
+  const installedPath = path2.join(CLAUDE_SKILLS_DIR, slug);
   if (existsSync(installedPath)) return installedPath;
-  return path3.join(process.cwd(), slug);
+  return path2.join(process.cwd(), slug);
 }
 function registerPushCommand(program2) {
   program2.command("push [slug]").description("Push local skill files as a draft to Headways").option("--watch", "Watch for file changes and auto-push").option("--dir <dir>", "Skill directory (default: installed location, then ./<slug>)").action(async (slug, opts) => {
     requireAuth();
-    const resolvedSlug = slug ?? path3.basename(process.cwd());
+    const resolvedSlug = slug ?? path2.basename(process.cwd());
     const dir = opts.dir ?? resolveSkillDir(slug);
     await pushSkill(resolvedSlug, dir);
     if (opts.watch) {
@@ -525,6 +510,86 @@ function registerPushCommand(program2) {
   });
 }
 
+// src/commands/skills/import.ts
+var ORG_PROFILES = {
+  hippocratic: {
+    connectorHints: ["ehr.read", "ehr.write", "phi.access"],
+    fixtureTemplate: "patient-encounter",
+    channelPolicy: "stable"
+  },
+  revive: {
+    connectorHints: ["email.read", "calendar.read", "ads.read"],
+    fixtureTemplate: "campaign-brief",
+    channelPolicy: "beta"
+  }
+};
+function registerImportCommand(program2) {
+  program2.command("import <path>").description("Import a skill from a file, directory, or URL").option("--slug <slug>", "Override derived slug").option(
+    "--org <orgProfile>",
+    "Apply org-specific connector hints + fixture templates (hippocratic, revive)"
+  ).action(async (inputPath, opts) => {
+    requireAuth();
+    let source;
+    let format = "auto";
+    let extraFiles = {};
+    try {
+      const stat2 = await fs3.stat(inputPath);
+      if (stat2.isDirectory()) {
+        const skillMdPath = path3.join(inputPath, "SKILL.md");
+        source = await fs3.readFile(skillMdPath, "utf-8");
+        format = "skill-md";
+        extraFiles = await collectExtraFiles(inputPath);
+      } else {
+        source = await fs3.readFile(inputPath, "utf-8");
+        if (inputPath.endsWith(".yaml") || inputPath.endsWith(".yml")) {
+          format = "headways-yaml";
+        } else {
+          format = "markdown";
+        }
+      }
+    } catch {
+      console.error(`Cannot read '${inputPath}': file or directory not found.`);
+      process.exit(1);
+    }
+    const profile = opts.org ? ORG_PROFILES[opts.org] : void 0;
+    if (opts.org && !profile) {
+      console.warn(
+        `Unknown org profile '${opts.org}'. Known profiles: ${Object.keys(ORG_PROFILES).join(", ")}`
+      );
+    }
+    const derivedSlug = opts.slug ?? path3.basename(inputPath, path3.extname(inputPath)).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    const result = await apiRequest("/v1/skills/import", {
+      method: "POST",
+      body: JSON.stringify({
+        source,
+        format,
+        suggestedSlug: derivedSlug,
+        connectorHints: profile?.connectorHints,
+        channelPolicy: profile?.channelPolicy,
+        ...Object.keys(extraFiles).length > 0 ? { files: extraFiles } : {}
+      })
+    });
+    if (result.headline.length > 90) {
+      console.warn(
+        `  Warning: headline is ${result.headline.length} chars (\u2264 90 required to publish). Edit headways.yaml and run 'headways skills push ${result.slug}'.`
+      );
+    }
+    const fileCount = Object.keys(extraFiles).length;
+    console.log(`Imported as '${result.slug}' (format: ${result.detectedFormat})`);
+    console.log(`  Headline: ${result.headline}`);
+    console.log(`  Skill ID: ${result.skillId}`);
+    if (fileCount > 0) {
+      console.log(`  Files: ${fileCount} extra file${fileCount === 1 ? "" : "s"} uploaded`);
+    }
+    if (profile) {
+      console.log(`  Org profile: ${opts.org}`);
+      console.log(`  Connector hints: ${profile.connectorHints.join(", ")}`);
+      console.log(`  Fixture template: ${profile.fixtureTemplate}`);
+    }
+    console.log(`  Run 'headways skills push ${result.slug}' to sync edits.`);
+  });
+}
+
 // src/commands/skills/index.ts
 var SKILLS_GUIDE = `
 # Headways Skill Authoring Guide
@@ -544,12 +609,12 @@ headways skills push <slug>   # push local edits as a draft
 | Field          | Rule                                                           |
 |----------------|----------------------------------------------------------------|
 | \`slug\`         | \`^[a-z0-9-]+$\`, 1\u201364 chars, immutable after creation          |
-| \`headline\`     | 1\u2013200 chars at creation; **\u2264 90 chars to submit** (hard gate) |
+| \`headline\`     | **One short sentence, \u2264 90 chars** \u2014 hard gate at submit      |
 | \`name\`         | 1\u2013120 chars (display name, defaults to headline)               |
 | \`channel\`      | \`prompt\` (default) | \`auto\` | \`manual\`                       |
 | \`data_classes\` | \`none\` (default) | \`pii\` | \`phi\` | \`pci\`                   |
 
-> Critical: headline must be \u2264 90 characters or the web UI will block submission.
+> Critical: headline must be one short sentence, \u2264 90 characters. The web UI blocks submission if exceeded.
 
 ## File Bundle (\`<slug>/\`)
 
@@ -584,7 +649,7 @@ edge cases, and concrete examples. Vague goals produce poor results.
 \`\`\`yaml
 slug: my-skill
 name: My Skill
-headline: Verb-first summary of the outcome (\u226490 chars)
+headline: One short sentence, verb-first (\u2264 90 chars)
 channel: prompt   # prompt | auto | manual
 runtimes:
   - claude-code
@@ -602,8 +667,8 @@ auto_send: false    # true = skill may act without user confirmation
 
 ### connections.yaml (required for any skill that uses MCP connector tools)
 
-Declare every MCP connector the skill depends on. Users see this list on \`headways skills accept\`
-and the Headways app gates installation on the connectors being configured.
+Declare every MCP connector the skill depends on. Users see this list when they install the skill
+via the Headways desktop app, which gates installation on the connectors being configured.
 
 \`\`\`yaml
 - connector: slack    # connector identifier (e.g. slack, github, atlassian, linear, notion, google-drive, stripe, asana, hubspot, datadog)
@@ -614,6 +679,38 @@ and the Headways app gates installation on the connectors being configured.
 
 Omit the file entirely if the skill has no connector dependencies.
 
+## Runtime Events
+
+Skills can emit events during execution that show up in the Headways dashboard.
+Two layers fire events:
+
+1. **Automatic** \u2014 Claude Code hooks emit \`tool.*\` (per tool call) and \`turn.end\`
+   (per response turn) for every skill invocation. A \`skill.start\`-style record is created
+   by the desktop app's \`UserPromptSubmit\` hook when the user invokes \`/<slug>\`. You don't write these.
+
+2. **Manual** \u2014 Inside your skill body, call \`headways emit\` to record concrete
+   outcomes the agent produced.
+
+\`\`\`bash
+headways emit --hook outcome.pr_created -f url=https://github.com/...
+headways emit --hook outcome.email_sent -f to=user@example.com
+headways emit --hook outcome.doc_written -f path=wiki/pages/x.md
+\`\`\`
+
+### Hook name format
+
+All hook names must match \`<namespace>.<name>\` where namespace is one of:
+
+| Namespace   | Emitted by    | Example                              |
+|-------------|---------------|--------------------------------------|
+| \`skill.*\`   | Hook (auto)   | \`skill.start\`                        |
+| \`tool.*\`    | Hook (auto)   | \`tool.Read\`, \`tool.Bash\`             |
+| \`turn.*\`    | Hook (auto)   | \`turn.end\`                           |
+| \`outcome.*\` | Skill (manual)| \`outcome.pr_created\`, \`outcome.email_sent\` |
+
+Names outside these four namespaces are rejected with HTTP 422. Pick a short,
+verb-past-tense suffix for outcomes: \`pr_created\`, not \`creating_pr\`.
+
 ### hooks.yaml (omit if unused)
 
 \`\`\`yaml
@@ -666,7 +763,6 @@ local edits with \`headways skills push <slug>\`.
 
 ## Common Failure Modes
 
-- Headline > 90 chars \u2192 submit blocked with 422. Shorten before pushing.
 - Uppercase or special chars in slug \u2192 rejected at creation. Use \`a-z\`, \`0-9\`, \`-\` only.
 - Missing \`capabilities.yaml\` entries \u2192 skill silently blocked at runtime.
 - Missing \`connections.yaml\` for MCP-dependent skills \u2192 users install the skill but hit tool-not-found errors at runtime with no explanation. Always create this file when the skill calls MCP tools.
@@ -681,8 +777,8 @@ function registerSkillsCommands(program2) {
     console.log(SKILLS_GUIDE);
   });
   skills.command("list").description("List skills in the active org").action(async () => {
-    const { requireAuth: requireAuth2 } = await import("./config-XQHAXREA.js");
-    const { apiRequest: apiRequest2 } = await import("./api-5EKGGFQ6.js");
+    const { requireAuth: requireAuth2 } = await import("./config-APIR4RCR.js");
+    const { apiRequest: apiRequest2 } = await import("./api-H34ZX4FL.js");
     requireAuth2();
     const result = await apiRequest2("/v1/skills");
     if (result.data.length === 0) {
@@ -693,27 +789,6 @@ function registerSkillsCommands(program2) {
       }
     }
   });
-  skills.command("accept <slug>").description("Accept a pending skill update and install it locally").action(async (slug) => {
-    const { acceptSkill } = await import("./sync-Q3OQUWOD.js");
-    await acceptSkill(slug);
-    try {
-      const { apiRequest: apiRequest2 } = await import("./api-5EKGGFQ6.js");
-      const metadata = await apiRequest2(`/v1/skills/${slug}/bundle/metadata`);
-      const reqs = metadata.connectionRequirements ?? [];
-      if (reqs.length > 0) {
-        console.log("");
-        console.log("This skill requires the following connectors:");
-        console.log("");
-        for (const req of reqs) {
-          console.log(`  - ${req.connector.padEnd(20)} ${req.purpose}`);
-        }
-        console.log("");
-        console.log("To authorize these connectors, use the Headways desktop app");
-        console.log("or run: headways connections add <provider>");
-      }
-    } catch {
-    }
-  });
   skills.command("feedback <slug>").description("Submit feedback about a skill").option(
     "--reaction <type>",
     "thumbs_up, thumbs_down, wrong_output, missing_step",
@@ -762,14 +837,95 @@ function registerConnectionsCommands(program2) {
 
 // src/sdk/emit.ts
 import "commander";
+
+// src/lib/run-session.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { join as join4 } from "path";
+var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1e3;
+async function readHookStdin() {
+  if (process.stdin.isTTY) return null;
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function sessionFilePath(sessionId) {
+  return join4(RUNS_DIR, sessionId);
+}
+function writeSessionRun(sessionId, run) {
+  if (!existsSync2(RUNS_DIR)) mkdirSync(RUNS_DIR, { recursive: true });
+  writeFileSync(sessionFilePath(sessionId), JSON.stringify(run));
+}
+function readSessionRun(sessionId) {
+  const path4 = sessionFilePath(sessionId);
+  if (!existsSync2(path4)) return null;
+  try {
+    return JSON.parse(readFileSync(path4, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function cleanupStaleRuns(now = Date.now()) {
+  if (!existsSync2(RUNS_DIR)) return;
+  let entries;
+  try {
+    entries = readdirSync(RUNS_DIR);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const path4 = join4(RUNS_DIR, name);
+    try {
+      const stat2 = statSync(path4);
+      if (now - stat2.mtimeMs > THIRTY_DAYS_MS) unlinkSync(path4);
+    } catch {
+    }
+  }
+}
+
+// src/sdk/emit.ts
+var HOOK_NAME_RE = /^(skill|tool|turn|outcome)\.[A-Za-z0-9_]+$/;
+var HOOK_NAME_HELP = "Hook name must be <namespace>.<name> where namespace is one of: skill, tool, turn, outcome.\n  skill.*    lifecycle             (e.g. skill.start)\n  tool.*     tool call events      (e.g. tool.Read, tool.Bash)\n  turn.*     conversation turns    (e.g. turn.end)\n  outcome.*  concrete artifacts    (e.g. outcome.pr_created, outcome.email_sent)";
 function registerEmitCommand(program2) {
-  program2.command("emit").description("Emit a skill run event (used by Claude Code hooks)").option("--run-id <runId>", "Skill run ID (or set HEADWAYS_RUN_ID env var)").option("--hook <hookName>", "Hook name to emit").option("--event <event>", "Legacy alias for --hook").option("--status <status>", "Tool result status (true=error, false=ok)").option("-f, --field <entries...>", "Field values in key=value format").allowUnknownOption(true).action(
+  program2.command("emit").description(
+    "Emit a skill run event (used by Claude Code hooks and from inside skills).\n" + HOOK_NAME_HELP
+  ).option("--run-id <runId>", "Skill run ID (or set HEADWAYS_RUN_ID env var)").option("--hook <hookName>", "Hook name to emit, e.g. outcome.pr_created").option("--event <event>", "Legacy alias for --hook").option("--status <status>", "Tool result status (true=error, false=ok)").option("-f, --field <entries...>", "Field values in key=value format").allowUnknownOption(true).action(
     async (opts) => {
+      const hookName = opts.hook ?? opts.event ?? "tool.unknown";
+      if (!HOOK_NAME_RE.test(hookName)) {
+        console.error(`headways emit: invalid --hook "${hookName}"
+
+${HOOK_NAME_HELP}`);
+        process.exitCode = 1;
+        return;
+      }
       const cfg = readConfig();
       if (!cfg.token) return;
-      const runId = opts.runId ?? process.env["HEADWAYS_RUN_ID"];
+      let runId = opts.runId ?? process.env["HEADWAYS_RUN_ID"];
+      if (!runId) {
+        const input = await readHookStdin();
+        const sessionId = input?.session_id;
+        if (typeof sessionId === "string") {
+          const session = readSessionRun(sessionId);
+          if (session) runId = session.runId;
+        }
+      }
       if (!runId) return;
-      const hookName = opts.hook ?? opts.event ?? "tool.unknown";
       const payload = {};
       if (opts.status !== void 0) {
         payload["tool_result_is_error"] = opts.status === "true" || opts.status === "1";
@@ -800,8 +956,67 @@ function registerEmitCommand(program2) {
   );
 }
 
+// src/commands/skill-run.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
+import "commander";
+var SLASH_COMMAND_RE = /^\/([a-z0-9-]+(?::[a-z0-9-]+)?)\b/;
+function resolveSkillSlug(input, isInstalled) {
+  const direct = input.tool_input?.skill;
+  if (typeof direct === "string" && direct.length > 0) return direct;
+  if (typeof input.prompt === "string") {
+    const m = SLASH_COMMAND_RE.exec(input.prompt);
+    if (m && m[1]) {
+      const slug = m[1];
+      if (isInstalled(slug)) return slug;
+    }
+  }
+  return null;
+}
+function defaultIsInstalled(slug) {
+  return existsSync3(join5(INSTALLED_DIR, `${slug}.json`));
+}
+function registerSkillRunCommands(program2) {
+  const skillRun = program2.command("skill-run").description("Skill-run lifecycle commands (invoked by Claude Code hooks).");
+  skillRun.command("start").description(
+    "Create a skill run from a Claude Code hook. Accepts UserPromptSubmit (parses /<slug> from prompt) or PreToolUse(Skill) (tool_input.skill). POSTs /v1/skill-runs and writes ~/.headways/runs/<session_id>."
+  ).action(async () => {
+    cleanupStaleRuns();
+    const cfg = readConfig();
+    if (!cfg.token) return;
+    const input = await readHookStdin();
+    if (!input) return;
+    const sessionId = input.session_id;
+    if (typeof sessionId !== "string") return;
+    const skillSlug = resolveSkillSlug(input, defaultIsInstalled);
+    if (!skillSlug) return;
+    let runId;
+    try {
+      const res = await fetch(`${getApiUrl()}/v1/skill-runs`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${cfg.token}`
+        },
+        body: JSON.stringify({ skillSlug, runtime: "claude-code" })
+      });
+      if (!res.ok) return;
+      const body = await res.json();
+      if (!body.runId) return;
+      runId = body.runId;
+    } catch {
+      return;
+    }
+    writeSessionRun(sessionId, {
+      runId,
+      skill: skillSlug,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  });
+}
+
 // src/commands/prime.ts
-import { existsSync as existsSync2, readdirSync, readFileSync } from "fs";
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
 import "commander";
 function registerPrimeCommand(program2) {
   program2.command("prime").description("Output Headways workflow context for AI coding assistants").action(() => {
@@ -817,6 +1032,11 @@ function registerPrimeCommand(program2) {
       "> `--help` to discover full options, or run `headways skills guide` before authoring a skill.",
       "> Do not guess at flags or constraints \u2014 discover them at runtime.",
       "",
+      "## Responsibility split",
+      "",
+      "- **Desktop app (macOS):** installs skills, syncs the catalog, manages Claude Code hooks. Open it from `/Applications/Headways.app`.",
+      "- **CLI (this tool):** skill *authoring* (push, import, new, list) plus runtime helpers Claude Code shells out to (`prime`, `emit`, `skill-run start`).",
+      "",
       "## Auth & Config",
       "",
       `Status: ${cfg.token ? `Signed in (org: ${cfg.orgSlug ?? cfg.orgId ?? "unknown"})` : "Not signed in \u2014 run `headways login`"}`,
@@ -828,37 +1048,33 @@ function registerPrimeCommand(program2) {
       "headways login                     # Browser SSO sign-in",
       "headways logout                    # Remove stored credentials",
       "headways config status             # Show saved key, org, URLs",
-      "headways config clear              # Clear credentials + reset setup state",
-      "",
-      "headways sync start                # Pull catalog updates once",
-      "headways sync start --daemon       # Poll every 60s in background",
-      "headways sync status               # Show pending skill updates",
+      "headways config clear              # Clear credentials",
       "",
       "headways skills list               # List skills in your org",
       "headways skills new                # Scaffold a new skill",
       "headways skills import <path>      # Create a new skill from a local file or directory",
       "headways skills push <slug>        # Push edits to an existing skill (import or new first)",
-      "headways skills accept <slug>      # Install a pending skill update",
       "headways skills feedback <slug>    # Submit feedback on a skill",
       "headways skills guide              # Authoring reference (run before creating a skill)",
       "",
-      "headways setup claude              # Install Claude Code hooks (SessionStart + PreCompact)",
-      "headways prime                     # Print this context (used by hooks)",
+      "# Runtime helpers (invoked automatically by Claude Code hooks; rarely run by hand):",
+      "headways prime                     # Print this context",
+      "headways emit                      # Emit a skill-run event",
+      "headways skill-run start           # Start a skill run from a UserPromptSubmit hook",
       "```",
       "",
       "## Workflow",
       "",
-      "1. `headways sync start` \u2014 pull the latest catalog from your org",
-      "2. `headways accept <skill>` \u2014 install a skill locally",
-      "3. Skills are automatically available to Claude Code via `~/.claude/skills/<slug>/`",
-      "4. Run `headways sync start --daemon` to keep skills up to date in the background",
+      "1. Open the **Headways desktop app** \u2014 it syncs the catalog, shows pending updates, and clicks-to-install bundles.",
+      "2. New skill versions appear in the Library view; click **Install** to bring them onto this machine.",
+      "3. To author skills: `headways skills new` or `headways skills import <path>`, edit, then `headways skills push <slug>`. Publish via the web UI.",
       "",
       "## Installed Skills",
       ""
     ];
     if (skills.length === 0) {
       lines.push(
-        "No skills installed. Run `headways sync start` then `headways accept <skill>`."
+        "No skills installed. Open the Headways desktop app to sync your org's catalog."
       );
     } else {
       for (const skill of skills) {
@@ -877,12 +1093,12 @@ function registerPrimeCommand(program2) {
   });
 }
 function getInstalledSkills() {
-  if (!existsSync2(INSTALLED_DIR)) return [];
+  if (!existsSync4(INSTALLED_DIR)) return [];
   try {
-    return readdirSync(INSTALLED_DIR).filter((f) => f.endsWith(".json")).map((f) => {
+    return readdirSync2(INSTALLED_DIR).filter((f) => f.endsWith(".json")).map((f) => {
       const slug = f.replace(/\.json$/, "");
       try {
-        const raw = JSON.parse(readFileSync(`${INSTALLED_DIR}/${f}`, "utf8"));
+        const raw = JSON.parse(readFileSync2(`${INSTALLED_DIR}/${f}`, "utf8"));
         return {
           slug,
           version: String(raw.version ?? ""),
@@ -900,13 +1116,11 @@ function getInstalledSkills() {
 }
 
 // src/index.ts
-program.name("headways").description("Headways CLI \u2014 skill authoring, sync, and runtime SDK").version(package_default.version);
+program.name("headways").description("Headways CLI \u2014 skill authoring + Claude Code runtime helpers").version(package_default.version);
 registerAuthCommands(program);
 registerSkillsCommands(program);
 registerConnectionsCommands(program);
-registerSyncCommands(program);
 registerEmitCommand(program);
+registerSkillRunCommands(program);
 registerPrimeCommand(program);
-registerSetupCommand(program);
-registerUninstallCommand(program);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@headways/cli",
-  "version": "0.4.2",
+  "version": "1.0.0",
   "type": "module",
   "description": "Headways CLI — authoring, sync, and runtime SDK",
   "license": "MIT",

package/dist/chunk-XTEQBKIN.js

@@ -1,409 +0,0 @@
-#!/usr/bin/env node
-import {
-  CLAUDE_SKILLS_DIR,
-  HEADWAYS_DIR,
-  getApiUrl,
-  readConfig
-} from "./chunk-UUFIIGTZ.js";
-
-// src/commands/sync/index.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync, rmSync as rmSync2 } from "fs";
-import { join as join2 } from "path";
-import { createGunzip } from "zlib";
-import { Readable } from "stream";
-import "stream/promises";
-import "commander";
-
-// src/commands/setup.ts
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, join } from "path";
-import "commander";
-var CLAUDE_SETTINGS_GLOBAL = join(homedir(), ".claude", "settings.json");
-var CLAUDE_SETTINGS_LOCAL = join(".claude", "settings.json");
-var PRIME_HOOK = { type: "command", command: "headways prime" };
-var CLAUDE_MD_SECTION = `
-<!-- BEGIN HEADWAYS -->
-## Headways Skills
-
-This project uses [Headways](https://headways.ai) for AI skill management.
-
-- \`headways prime\` \u2014 load workflow context (called automatically by hooks)
-- \`headways sync start\` \u2014 pull latest skill updates from your org
-- \`headways accept <skill>\` \u2014 install a pending skill update
-- \`headways skills list\` \u2014 list skills in your org
-
-Skills are installed to \`~/.claude/skills/<slug>/\` and loaded automatically by Claude Code.
-<!-- END HEADWAYS -->
-`.trimStart();
-function registerUninstallCommand(program) {
-  program.command("uninstall").description("Remove all Headways hooks, skill files, and local state").option("--yes", "Skip confirmation prompt").action(async (opts) => {
-    const { createInterface } = await import("readline/promises");
-    if (!opts.yes) {
-      const rl = createInterface({ input: process.stdin, output: process.stdout });
-      const ans = await rl.question(
-        "This will remove all local Headways data (hooks, skill files, config). Continue? [y/N] "
-      );
-      rl.close();
-      if (ans.trim().toLowerCase() !== "y") {
-        console.log("Aborted.");
-        return;
-      }
-    }
-    removeHooks(CLAUDE_SETTINGS_GLOBAL);
-    removeHooks(CLAUDE_SETTINGS_LOCAL);
-    console.log("\u2713 Removed Claude Code hooks");
-    if (existsSync(CLAUDE_SKILLS_DIR)) {
-      rmSync(CLAUDE_SKILLS_DIR, { recursive: true, force: true });
-      console.log("\u2713 Removed ~/.claude/skills/");
-    }
-    const headwaysDir = join(homedir(), ".headways");
-    if (existsSync(headwaysDir)) {
-      rmSync(headwaysDir, { recursive: true, force: true });
-      console.log("\u2713 Removed ~/.headways/");
-    }
-    console.log(
-      "\nHeadways data removed. You can now delete the Headways.app from /Applications."
-    );
-  });
-}
-function registerSetupCommand(program) {
-  const setup = program.command("setup").description("Install Headways integration for AI coding assistants");
-  setup.command("claude").description("Install Claude Code hooks (SessionStart + PreCompact)").option("--project", "Install for this project only (default: global)").option("--remove", "Remove the integration").option("--check", "Check if integration is installed").action((opts) => {
-    const settingsPath = opts.project ? CLAUDE_SETTINGS_LOCAL : CLAUDE_SETTINGS_GLOBAL;
-    if (opts.check) {
-      const installed = isInstalled(settingsPath);
-      console.log(
-        installed ? `\u2713 Installed: ${settingsPath}` : `\u2717 Not installed: ${settingsPath}`
-      );
-      process.exit(installed ? 0 : 1);
-    }
-    if (opts.remove) {
-      removeHooks(settingsPath);
-      console.log(`Removed Headways hooks from ${settingsPath}`);
-      return;
-    }
-    installHooks(settingsPath, opts.project ?? false);
-    updateClaudeMd(opts.project ?? false);
-  });
-}
-function ensureClaudeHooks() {
-  if (!isInstalled(CLAUDE_SETTINGS_GLOBAL)) {
-    installHooks(CLAUDE_SETTINGS_GLOBAL, false, true);
-  }
-}
-function readSettings(path) {
-  if (!existsSync(path)) return {};
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function writeSettings(path, settings) {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, JSON.stringify(settings, null, 2) + "\n");
-}
-function isInstalled(settingsPath) {
-  const s = readSettings(settingsPath);
-  const hooks = s["hooks"];
-  if (!hooks) return false;
-  return ["SessionStart", "PreCompact"].every(
-    (event) => hooks[event]?.some(
-      (entry) => entry.hooks?.some((h) => h.command === PRIME_HOOK.command)
-    )
-  );
-}
-function installHooks(settingsPath, isProject, silent = false) {
-  const settings = readSettings(settingsPath);
-  const hooks = settings["hooks"] ?? {};
-  for (const event of ["SessionStart", "PreCompact"]) {
-    const entries = hooks[event] ?? [];
-    for (const entry of entries) {
-      entry.hooks = entry.hooks.filter((h) => h.command !== PRIME_HOOK.command);
-    }
-    const mainEntry = entries.find((e) => e.matcher === "" || e.matcher === void 0);
-    if (mainEntry) {
-      mainEntry.hooks.push(PRIME_HOOK);
-    } else {
-      entries.unshift({ matcher: "", hooks: [PRIME_HOOK] });
-    }
-    hooks[event] = entries;
-  }
-  settings["hooks"] = hooks;
-  writeSettings(settingsPath, settings);
-  if (!silent) {
-    console.log(`\u2713 Hooks installed: ${settingsPath}`);
-    if (!isProject) {
-      console.log("  SessionStart + PreCompact \u2192 headways prime");
-    }
-  }
-}
-function removeHooks(settingsPath) {
-  if (!existsSync(settingsPath)) return;
-  const settings = readSettings(settingsPath);
-  const hooks = settings["hooks"] ?? {};
-  for (const event of ["SessionStart", "PreCompact"]) {
-    if (hooks[event]) {
-      for (const entry of hooks[event]) {
-        entry.hooks = entry.hooks.filter((h) => h.command !== PRIME_HOOK.command);
-      }
-    }
-  }
-  settings["hooks"] = hooks;
-  writeSettings(settingsPath, settings);
-}
-function updateClaudeMd(isProject) {
-  const claudeMdPath = isProject ? "CLAUDE.md" : join(homedir(), "CLAUDE.md");
-  if (!existsSync(claudeMdPath)) return;
-  const content = readFileSync(claudeMdPath, "utf8");
-  if (content.includes("<!-- BEGIN HEADWAYS -->")) return;
-  writeFileSync(claudeMdPath, content.trimEnd() + "\n\n" + CLAUDE_MD_SECTION);
-  console.log(`\u2713 Updated ${claudeMdPath}`);
-}
-
-// src/commands/sync/index.ts
-var PENDING_FILE = join2(HEADWAYS_DIR, "pending.json");
-var SYNC_STATE_FILE = join2(HEADWAYS_DIR, "sync-state.json");
-var INSTALLED_DIR = join2(HEADWAYS_DIR, "installed");
-function readSyncState() {
-  if (!existsSync2(SYNC_STATE_FILE)) return {};
-  try {
-    return JSON.parse(readFileSync2(SYNC_STATE_FILE, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function writeSyncState(state) {
-  if (!existsSync2(HEADWAYS_DIR)) mkdirSync2(HEADWAYS_DIR, { recursive: true });
-  writeFileSync2(SYNC_STATE_FILE, JSON.stringify(state, null, 2) + "\n");
-}
-function readPending() {
-  if (!existsSync2(PENDING_FILE)) return [];
-  try {
-    return JSON.parse(readFileSync2(PENDING_FILE, "utf8"));
-  } catch {
-    return [];
-  }
-}
-function writePending(updates) {
-  if (!existsSync2(HEADWAYS_DIR)) mkdirSync2(HEADWAYS_DIR, { recursive: true });
-  writeFileSync2(PENDING_FILE, JSON.stringify(updates, null, 2) + "\n");
-}
-function deviceHeaders(state) {
-  return {
-    Authorization: `Bearer ${state.device_token ?? ""}`,
-    "x-headways-device-id": state.device_id ?? "",
-    "x-headways-timestamp": String(Math.floor(Date.now() / 1e3))
-  };
-}
-async function registerDevice(token, orgId, apiUrl) {
-  const existingId = readSyncState().device_id;
-  const pubKey = existingId ? Buffer.from(`desktop-${existingId}`).toString("base64url") : Buffer.from(`desktop-${Date.now()}-${Math.random()}`).toString("base64url");
-  const res = await fetch(`${apiUrl}/v1/sync/devices/register`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`,
-      "x-headways-org-id": orgId
-    },
-    body: JSON.stringify({
-      publicKey: pubKey,
-      platform: process.platform === "darwin" ? "macos" : process.platform === "win32" ? "windows" : "linux",
-      hostname: (await import("os")).hostname()
-    })
-  });
-  if (!res.ok) throw new Error(`Device registration failed: ${res.status}`);
-  const data = await res.json();
-  return { device_id: data.deviceId, device_token: data.deviceToken };
-}
-async function pollCatalog(state, apiUrl) {
-  const url = state.etag ? `${apiUrl}/v1/sync/catalog?since=${encodeURIComponent(state.etag)}` : `${apiUrl}/v1/sync/catalog`;
-  const res = await fetch(url, { headers: deviceHeaders(state) });
-  if (res.status === 304) return null;
-  if (!res.ok) throw new Error(`Catalog poll failed: ${res.status}`);
-  return res.json();
-}
-async function downloadAndMaterialize(slug, version, state, apiUrl) {
-  const res = await fetch(`${apiUrl}/v1/sync/bundles/${slug}/${version}`, {
-    redirect: "follow",
-    headers: deviceHeaders(state)
-  });
-  if (!res.ok) throw new Error(`Bundle fetch failed: ${res.status}`);
-  const buf = Buffer.from(await res.arrayBuffer());
-  const dest = join2(CLAUDE_SKILLS_DIR, slug);
-  const staging = join2(CLAUDE_SKILLS_DIR, `.${slug}-staging`);
-  mkdirSync2(staging, { recursive: true });
-  await extractTarGz(buf, staging);
-  if (existsSync2(dest)) rmSync2(dest, { recursive: true });
-  renameSync(staging, dest);
-  mkdirSync2(INSTALLED_DIR, { recursive: true });
-  writeFileSync2(
-    join2(INSTALLED_DIR, `${slug}.json`),
-    JSON.stringify(
-      { slug, version, runtime: "claude-code", installed_at: (/* @__PURE__ */ new Date()).toISOString() },
-      null,
-      2
-    )
-  );
-  console.log(`Materialized ${slug}@${version} \u2192 ${dest}`);
-}
-async function extractTarGz(buf, destDir) {
-  const decompressed = await new Promise((resolve, reject) => {
-    const chunks = [];
-    const gunzip = createGunzip();
-    const src = Readable.from(buf);
-    src.pipe(gunzip);
-    gunzip.on("data", (chunk) => chunks.push(chunk));
-    gunzip.on("end", () => resolve(Buffer.concat(chunks)));
-    gunzip.on("error", reject);
-  });
-  let offset = 0;
-  const { writeFileSync: wf, mkdirSync: md } = await import("fs");
-  const { dirname: dirname2 } = await import("path");
-  while (offset + 512 <= decompressed.length) {
-    const header = decompressed.slice(offset, offset + 512);
-    const name = header.slice(0, 100).toString("utf8").replace(/\0/g, "").trim();
-    if (!name) break;
-    const sizeOctal = header.slice(124, 136).toString("utf8").replace(/\0/g, "").trim();
-    const size = parseInt(sizeOctal, 8) || 0;
-    const typeFlag = header[156];
-    offset += 512;
-    if (typeFlag === 53 || name.endsWith("/")) {
-      md(join2(destDir, name), { recursive: true });
-    } else if (typeFlag === 0 || typeFlag === 48 || typeFlag === void 0) {
-      const filePath = join2(destDir, name);
-      md(dirname2(filePath), { recursive: true });
-      wf(filePath, decompressed.slice(offset, offset + size));
-    }
-    offset += Math.ceil(size / 512) * 512;
-  }
-}
-function registerSyncCommands(program) {
-  const sync = program.command("sync").description("Sync skills from Headways to local Claude Code");
-  sync.command("start").description("Register device and pull latest skill catalog from Headways").option("--daemon", "Run as background daemon (60s poll loop)").action(async (opts) => {
-    const cfg = readConfig();
-    if (!cfg.token || !cfg.orgId) {
-      console.error("Not logged in. Run: headways login");
-      process.exit(1);
-    }
-    const apiUrl = getApiUrl();
-    let state = readSyncState();
-    if (!state.device_id || !state.device_token) {
-      console.log("Registering device with Headways\u2026");
-      try {
-        const deviceState = await registerDevice(cfg.token, cfg.orgId, apiUrl);
-        state = { ...state, ...deviceState };
-        writeSyncState(state);
-        console.log(`Device registered: ${state.device_id}`);
-      } catch (err) {
-        console.error(`Registration failed: ${err instanceof Error ? err.message : String(err)}`);
-        process.exit(1);
-      }
-    }
-    const doPoll = async () => {
-      try {
-        ensureClaudeHooks();
-        const delta = await pollCatalog(state, apiUrl);
-        if (!delta) {
-          console.log("Catalog up to date.");
-          return;
-        }
-        state.etag = delta.etag;
-        state.last_poll = (/* @__PURE__ */ new Date()).toISOString();
-        writeSyncState(state);
-        const pendingMap = new Map(readPending().map((p) => [p.slug, p]));
-        for (const ev of delta.events) {
-          if (ev.kind === "version_published") {
-            if (ev.channel === "auto") {
-              console.log(`Auto-installing: ${ev.skill_slug}@${ev.version}`);
-              await downloadAndMaterialize(ev.skill_slug, ev.version, state, apiUrl);
-              pendingMap.delete(ev.skill_slug);
-            } else {
-              pendingMap.set(ev.skill_slug, {
-                slug: ev.skill_slug,
-                version: ev.version,
-                user_visible_change: ev.user_visible_change,
-                channel: ev.channel,
-                capabilities_delta_empty: ev.capabilities_delta_empty
-              });
-              console.log(
-                `Queued: ${ev.skill_slug}@${ev.version}${ev.user_visible_change ? ` \u2014 ${ev.user_visible_change}` : ""}`
-              );
-            }
-          } else if (ev.kind === "skill_archived" || ev.kind === "entitlement_revoked") {
-            pendingMap.delete(ev.skill_slug);
-            console.log(`Removed: ${ev.skill_slug}`);
-          }
-        }
-        writePending([...pendingMap.values()]);
-        console.log(`Synced. ETag: ${delta.etag}`);
-      } catch (err) {
-        console.error(`Poll error: ${err instanceof Error ? err.message : String(err)}`);
-      }
-    };
-    await doPoll();
-    if (opts.daemon) {
-      console.log("Running sync daemon (60s interval). Press Ctrl-C to stop.");
-      setInterval(doPoll, 6e4);
-    }
-  });
-  sync.command("status").description("Show current sync status and pending updates").action(() => {
-    const state = readSyncState();
-    const pending = readPending();
-    if (!state.device_id) {
-      console.log("Device not registered. Run: headways sync start");
-      return;
-    }
-    console.log(`Device ID  : ${state.device_id}`);
-    console.log(`Last poll  : ${state.last_poll ?? "never"}`);
-    console.log(`Catalog ETag: ${state.etag ?? "none"}`);
-    if (pending.length === 0) {
-      console.log("\nAll skills up to date. No pending updates.");
-    } else {
-      console.log(`
-Pending updates (${pending.length}):`);
-      for (const p of pending) {
-        const change = p.user_visible_change ? ` \u2014 ${p.user_visible_change}` : "";
-        const caps = p.capabilities_delta_empty ? "" : " [CAPS CHANGED]";
-        console.log(`  ${p.slug}@${p.version}${change}${caps}`);
-      }
-      console.log("\nRun `headways skills accept <skill>` to install.");
-    }
-  });
-}
-async function acceptSkill(skillSlug) {
-  const cfg = readConfig();
-  if (!cfg.token || !cfg.orgId) {
-    console.error("Not logged in. Run: headways login");
-    process.exit(1);
-  }
-  const pending = readPending();
-  const update = pending.find((p) => p.slug === skillSlug);
-  if (!update) {
-    console.error(`No pending update for skill: ${skillSlug}`);
-    console.log("Run `headways sync status` to see pending updates.");
-    process.exit(1);
-  }
-  const state = readSyncState();
-  if (!state.device_id || !state.device_token) {
-    console.error("Device not registered. Run: headways sync start");
-    process.exit(1);
-  }
-  console.log(`Accepting ${skillSlug}@${update.version}\u2026`);
-  await downloadAndMaterialize(skillSlug, update.version, state, getApiUrl());
-  writePending(pending.filter((p) => p.slug !== skillSlug));
-  console.log(
-    `${skillSlug} is ready \u2014 invoke it in Claude Code with the skill's invocation phrase.`
-  );
-}
-
-export {
-  registerUninstallCommand,
-  registerSetupCommand,
-  readSyncState,
-  writeSyncState,
-  registerDevice,
-  registerSyncCommands,
-  acceptSkill
-};

package/dist/sync-Q3OQUWOD.js

@@ -1,16 +0,0 @@
-#!/usr/bin/env node
-import {
-  acceptSkill,
-  readSyncState,
-  registerDevice,
-  registerSyncCommands,
-  writeSyncState
-} from "./chunk-XTEQBKIN.js";
-import "./chunk-UUFIIGTZ.js";
-export {
-  acceptSkill,
-  readSyncState,
-  registerDevice,
-  registerSyncCommands,
-  writeSyncState
-};