@constraint/cli 0.4.1 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constraint/cli",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Install, publish, and report Agent Skills with Constraint",
   "type": "module",
   "bin": {
@@ -8,8 +8,7 @@
   },
   "files": [
     "bin",
-    "src",
-    "skills"
+    "src"
   ],
   "scripts": {
     "check": "node --check bin/constraint.js && node --check src/cli.js",

package/src/cli.js

@@ -8,24 +8,19 @@ import { rejectUnknown, takeFlag, takeOption } from './arguments.js';
 import { login, logout } from './auth.js';
 import { loadConfig } from './config.js';
 import { mediaType } from './files.js';
-import { AGENTS, detectAgents, findProjectRoot, normalizeAgent } from './paths.js';
+import { AGENTS, agentPaths, detectAgents, findProjectRoot, normalizeAgent } from './paths.js';
 import {
   begin,
   chooseAgents,
-  chooseMode,
   chooseScope,
   confirmPlan,
   finish,
   note,
   taskSpinner,
 } from './prompts.js';
-import {
-  installCompanionSkill,
-  setupPlan,
-  setupStatus,
-} from './setup.js';
 import {
   configuredAgents,
+  identifyLocalSkill,
   installSkill,
   installedSkills,
   manageableDomainRecords,
@@ -35,16 +30,14 @@ import {
   uploadSkill,
 } from './skills.js';
 
-const VERSION = '0.4.1';
+const VERSION = '0.4.3';
 
 const HELP = `Constraint Skills CLI
 
 Usage:
   constraint login | logout | whoami
-  constraint setup [--agent codex|claude-code]... [--dry-run] [--yes]
   constraint doctor [--agent codex|claude-code]...
   constraint skills list [--search <text>]
-  constraint skills list --installed [--project|--global] [--agent <agent>]...
   constraint skills domains
   constraint skills inspect <skill> [--version <version>] [--files]
   constraint skills install <skill> [--version <version>] [--agent <agent>]...
@@ -52,10 +45,10 @@ Usage:
   constraint skills update <skill> [--agent <agent>]... [--project|--global]
                            [--copy] [--yes]
   constraint skills update --all [--agent <agent>]... [--project|--global] [--yes]
-  constraint skills upload <path> --domain <domain>
+  constraint skills upload <path> [--domain <domain>]
   constraint report <transcript-path> --skill <skill> [--client <client>] [--session <id>]
-  constraint skills run list [--team <team>]... [--user <user>]... [--skill <skill>]...
-  constraint skills run get <run-id>... [--raw] [--output <path>]  (always writes a file, prints summary + path)
+  constraint skills run list [--team <team>]... [--skill <skill>]...
+  constraint skills run get <run-id> [--raw] [--output <path>]  (writes a file, prints summary + path)
 
 Global options: --json --quiet --no-color --help --version`;
 
@@ -88,14 +81,8 @@ function humanize(value) {
   return String(value || '').replaceAll('_', ' ').replace(/\b\w/g, (letter) => letter.toUpperCase());
 }
 
-export function skillListPresentation(items, { installed = false, search = null, scope = 'project' } = {}) {
+export function skillListPresentation(items, { search = null } = {}) {
   if (items.length === 0) {
-    if (installed) {
-      return {
-        title: 'No installed skills',
-        message: `Nothing is installed in ${scope} scope yet.\n\nBrowse available skills:\nconstraint skills list`,
-      };
-    }
     if (search) {
       return {
         title: 'No matching skills',
@@ -108,20 +95,10 @@ export function skillListPresentation(items, { installed = false, search = null,
     };
   }
 
-  if (installed) {
-    return {
-      title: `${items.length} installed skill${items.length === 1 ? '' : 's'}`,
-      message: items.map((item) => [
-        `${item.slug} · v${item.version} · ${item.agent}`,
-        `${humanize(item.scope)} · ${humanize(item.mode)} · ${item.path}`,
-      ].join('\n')).join('\n\n'),
-    };
-  }
-
   return {
     title: `${items.length} available skill${items.length === 1 ? '' : 's'}`,
     message: items.map((item) => [
-      `${item.name} (${item.slug}) · v${item.latest_version} · ${humanize(item.domain)}`,
+      `${item.name} · v${item.latest_version} · ${humanize(item.domain)}`,
       item.description,
     ].join('\n')).join('\n\n'),
   };
@@ -193,7 +170,7 @@ async function resolveAgents(provided, out, { prompt = true } = {}) {
 async function chooseDomain(domains) {
   if (domains.length === 0) throw new Error('You do not have permission to upload skills.');
   if (domains.length === 1) return domains[0];
-  if (!process.stdin.isTTY) throw new Error('Upload has more than one permitted domain and requires an interactive terminal.');
+  if (!process.stdin.isTTY) throw new Error(`Choose a team with --domain. You can upload to: ${domains.join(', ')}`);
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   domains.forEach((domain, index) => process.stdout.write(`${index + 1}. ${domain}\n`));
   const answer = await rl.question('Choose the skill domain: ');
@@ -222,74 +199,14 @@ async function authCommand(command, args, config, out) {
     await logout(config);
     out.line('Logged out.');
   } else {
-    out.data(await apiRequest(config, '/me'));
-  }
-}
-
-async function setupCommand(args, out) {
-  let agents = takeAgents(args);
-  const dryRun = takeFlag(args, '--dry-run');
-  const yes = takeFlag(args, '--yes');
-  rejectUnknown(args);
-  if (args.length) throw new Error('setup does not accept positional arguments');
-  const useUi = interactive(out) && !dryRun;
-  if (useUi) begin('Constraint Skills setup');
-  if (!agents.length) {
-    const configured = await configuredAgents();
-    const detected = configured.length ? configured : await detectAgents();
-    agents = useUi && !yes ? await chooseAgents(detected) : detected;
-  }
-  if (!agents.length) throw new Error('Choose at least one agent with --agent.');
-  const plans = await Promise.all(agents.map(setupPlan));
-  const conflicts = plans.filter((plan) => plan.skill.action === 'conflict');
-  if (conflicts.length) {
-    throw new Error(`Local Constraint skill has uncommitted changes and was not replaced: ${conflicts.map((plan) => plan.skill.path).join(', ')}`);
-  }
-  if (dryRun) {
-    out.data(plans.map((plan) => ({
-      agent: plan.agent,
-      skill: { path: plan.skill.path, scope: 'global', action: plan.skill.action },
-    })));
-    return;
-  }
-  const hasSkillChanges = plans.some((plan) => plan.skill.action !== 'current');
-  if (!useUi && !yes && hasSkillChanges) {
-    throw new Error('Non-interactive setup has pending changes. Pass --yes or use --dry-run.');
-  }
-
-  let installSkill = true;
-  if (useUi) {
-    note(
-      [
-        'Skill: constraint-skills',
-        'Scope: Global',
-        '',
-        ...plans.flatMap((plan) => [
-          `${humanize(plan.agent)} destination:`,
-          `${plan.skill.path} · ${plan.skill.action === 'current' ? 'already current' : plan.skill.action}`,
-          '',
-        ]),
-      ].join('\n').trim(),
-      'Install Constraint Skills',
-    );
-    installSkill = !hasSkillChanges || yes || await confirmPlan(`Install globally for ${agents.map(humanize).join(' and ')}?`);
-  }
-
-  const result = { skill: [] };
-  if (installSkill) {
-    const spinner = taskSpinner(useUi && hasSkillChanges);
-    for (const plan of plans) {
-      spinner.message(`Installing Constraint Skills for ${humanize(plan.agent)}`);
-      result.skill.push(await installCompanionSkill(plan.agent));
+    const me = await apiRequest(config, '/me');
+    if (out.json) {
+      out.data(me);
+      return;
     }
-    spinner.stop('Constraint Skills installed globally.');
+    const teams = (me.domains || []).map((domain) => domain.name || domain.slug);
+    out.line(`Signed in as ${me.workos_user_id} · ${me.roles?.join(', ') || 'member'} · ${teams.length} team${teams.length === 1 ? '' : 's'}${teams.length ? ` (${teams.join(', ')})` : ''}`);
   }
-  if (useUi) {
-    finish([
-      'Setup complete.',
-      `Skill: ${installSkill ? `installed for ${agents.map(humanize).join(' and ')}` : 'skipped'}`,
-    ].join('\n'));
-  } else out.data(result);
 }
 
 async function doctorCommand(args, config, out) {
@@ -304,30 +221,35 @@ async function doctorCommand(args, config, out) {
   } catch (error) {
     authError = error.message;
   }
-  out.data({
-    api_url: config.apiUrl,
-    authenticated: Boolean(identity),
-    identity,
-    auth_error: authError,
-    agents: await Promise.all(agents.map(setupStatus)),
-  });
+  const statuses = await Promise.all(agents.map(async (agent) => {
+    const selected = normalizeAgent(agent);
+    try {
+      await fs.stat(path.join(agentPaths(selected).skills, 'constraint-skills', 'SKILL.md'));
+      return { agent: selected, skill: true };
+    } catch {
+      return { agent: selected, skill: false };
+    }
+  }));
+  if (out.json) {
+    out.data({
+      api_url: config.apiUrl,
+      authenticated: Boolean(identity),
+      identity,
+      auth_error: authError,
+      agents: statuses,
+    });
+    return;
+  }
+  out.line(identity ? `Signed in against ${config.apiUrl}.` : `Not signed in (${authError || 'run constraint login'}).`);
+  for (const status of statuses) {
+    out.line(`${humanize(status.agent)}: companion skill ${status.skill ? 'installed' : 'missing — run constraint skills install constraint-skills --global'}.`);
+  }
 }
 
 async function listSkills(args, config, out) {
   const search = takeOption(args, '--search');
-  const installed = takeFlag(args, '--installed');
-  const scopeFlag = takeScope(args);
-  const agents = takeAgents(args);
   rejectUnknown(args);
   if (args.length) throw new Error('skills list does not accept positional arguments');
-  if (installed) {
-    if (search) throw new Error('--search cannot be combined with --installed.');
-    const scope = scopeFlag || 'project';
-    const skills = await installedSkills({ scope, agents });
-    printSkillList(skills, { installed: true, scope }, out);
-    return;
-  }
-  if (scopeFlag || agents.length) throw new Error('--project, --global, and --agent require --installed.');
   const query = search ? `?search=${encodeURIComponent(search)}` : '';
   const skills = await apiRequest(config, `/skills${query}`);
   printSkillList(skills, { search }, out);
@@ -364,13 +286,11 @@ async function installCommand(args, config, out, update = false) {
       .map((item) => item.agent))];
   }
   agents = await resolveAgents(agents, out, { prompt: !yes && !update });
-  if (!copyRequested && useUi && !yes) copy = (await chooseMode()) === 'copy';
   if (useUi) {
     note([
-      `${update ? 'Update' : 'Install'}: ${args[0]}${version ? ` v${version}` : ' (latest)'}`,
-      `Agents: ${agents.join(', ')}`,
-      `Scope: ${scope}${root ? ` (${root})` : ''}`,
-      `Mode: ${copy === undefined ? 'preserve installed mode' : copy ? 'copy' : 'shared package'}`,
+      `${update ? 'Update' : 'Install'} ${args[0]}${version ? ` v${version}` : ''}`,
+      `For: ${agents.map(humanize).join(' and ')}`,
+      scope === 'project' ? `Available only in this project${root ? ` (${root})` : ''}` : 'Available everywhere on this computer',
     ].join('\n'));
     if (!yes && !(await confirmPlan(`${update ? 'Update' : 'Install'} this skill?`))) {
       finish('No changes made.');
@@ -481,7 +401,31 @@ async function reportCommand(args, config, out) {
   if (!resolvedClient || !resolvedSession) {
     throw new Error('Could not tell the client and session from this path. Pass --client and --session.');
   }
+
+  // Version attribution: hash the local skill folder and match it against the
+  // published versions, so the run records what actually ran — not "latest".
+  let detail;
+  try {
+    detail = await apiRequest(config, `/skills/${encodeURIComponent(skill)}`);
+  } catch (error) {
+    if (/not found/i.test(error.message)) {
+      const projectRoot = await findProjectRoot();
+      const hint = await identifyLocalSkill(config, { skill_id: skill, slug: skill, latest_version: 0 }, { projectRoot })
+        .then((found) => found.localPath)
+        .catch(() => null);
+      throw new Error(
+        `${skill} is not on Constraint.` +
+        (hint ? ` Found a local skill at ${hint} — upload it first:
+  constraint skills upload ${hint} --domain <domain>` : ' Upload it first with constraint skills upload.'),
+      );
+    }
+    throw error;
+  }
+  const projectRoot = await findProjectRoot();
+  const identified = await identifyLocalSkill(config, detail, { projectRoot });
+
   const query = new URLSearchParams({ skill, client: resolvedClient, session: resolvedSession });
+  if (identified.verified) query.set('version', String(identified.version));
   const run = await apiRequest(config, `/skill-reports?${query.toString()}`, {
     method: 'POST',
     headers: { 'Content-Type': mediaType(transcript.absolute), 'X-Transcript-Filename': transcript.filename },
@@ -491,6 +435,10 @@ async function reportCommand(args, config, out) {
     run_id: run.run_id,
     skill: run.skill_slug,
     version: run.skill_version,
+    version_verified: identified.verified,
+    ...(identified.localPath && !identified.verified
+      ? { warning: `local copy at ${identified.localPath} does not match any published version` }
+      : {}),
     state: run.state,
     client: run.client,
     session: run.client_session_id,
@@ -501,7 +449,6 @@ async function reportCommand(args, config, out) {
 async function runList(args, config, out) {
   const query = new URLSearchParams();
   for (const value of takeOption(args, '--team', { multiple: true })) query.append('team', value);
-  for (const value of takeOption(args, '--user', { multiple: true })) query.append('user', value);
   for (const value of takeOption(args, '--skill', { multiple: true })) query.append('skill', value);
   for (const name of ['--after', '--before', '--limit', '--cursor']) {
     const value = takeOption(args, name);
@@ -526,9 +473,7 @@ async function runGet(args, config, out) {
   const raw = takeFlag(args, '--raw');
   const output = takeOption(args, '--output');
   rejectUnknown(args);
-  if (!args.length) throw new Error('Usage: constraint skills run get <run-id>...');
-  if (output && args.length !== 1) throw new Error('--output accepts exactly one run ID');
-  if (raw && args.length !== 1) throw new Error('--raw accepts exactly one run ID');
+  if (args.length !== 1) throw new Error('Usage: constraint skills run get <run-id> [--raw] [--output <path>]');
   if (raw) {
     const response = await apiRequest(config, `/skill-runs/${encodeURIComponent(args[0])}/transcript`, { rawResponse: true });
     const content = Buffer.from(await response.arrayBuffer());
@@ -537,25 +482,21 @@ async function runGet(args, config, out) {
     out.data({ run_id: args[0], bytes: content.length, path: destination });
     return;
   }
-  const summaries = [];
-  for (const runId of args) {
-    const run = await apiRequest(config, `/skill-runs/${encodeURIComponent(runId)}`);
-    const destination = await runGetDestination(output, runId, '.json');
-    await fs.writeFile(destination, `${JSON.stringify(run, null, 2)}\n`);
-    const events = Array.isArray(run.normalized_events) ? run.normalized_events : [];
-    summaries.push({
-      run_id: run.run_id,
-      skill: run.skill_slug,
-      version: run.skill_version,
-      state: run.state,
-      client: run.client,
-      completed_at: run.completed_at,
-      events: events.length,
-      events_with_text: events.filter((event) => event.content).length,
-      path: destination,
-    });
-  }
-  out.data(summaries.length === 1 ? summaries[0] : summaries);
+  const run = await apiRequest(config, `/skill-runs/${encodeURIComponent(args[0])}`);
+  const destination = await runGetDestination(output, args[0], '.json');
+  await fs.writeFile(destination, `${JSON.stringify(run, null, 2)}\n`);
+  const events = Array.isArray(run.normalized_events) ? run.normalized_events : [];
+  out.data({
+    run_id: run.run_id,
+    skill: run.skill_slug,
+    version: run.skill_version,
+    state: run.state,
+    client: run.client,
+    completed_at: run.completed_at,
+    events: events.length,
+    events_with_text: events.filter((event) => event.content).length,
+    path: destination,
+  });
 }
 
 async function runCommand(args, config, out) {
@@ -593,7 +534,6 @@ export async function main(argv) {
   const command = args.shift();
   const config = await loadConfig();
   if (['login', 'logout', 'whoami'].includes(command)) return authCommand(command, args, config, out);
-  if (command === 'setup') return setupCommand(args, out);
   if (command === 'doctor') return doctorCommand(args, config, out);
   if (command === 'report') return reportCommand(args, config, out);
   if (command === 'skills') return skillsCommand(args, config, out);

package/src/config.js

@@ -28,9 +28,6 @@ export async function loadConfig() {
   return {
     apiUrl: (process.env.CONSTRAINT_API_URL || saved.apiUrl || DEFAULT_API_URL).replace(/\/$/, ''),
     agents: Array.isArray(saved.agents) ? saved.agents : Array.isArray(saved.clients) ? saved.clients : [],
-    companion_hashes: saved.companion_hashes && typeof saved.companion_hashes === 'object'
-      ? saved.companion_hashes
-      : {},
   };
 }
 

package/src/files.js

@@ -43,7 +43,9 @@ export async function readSkillDirectory(input) {
 
 export function packageDigest(files) {
   const hash = crypto.createHash('sha256');
-  for (const file of [...files].sort((a, b) => a.path.localeCompare(b.path))) {
+  // Sort by code points, not locale: this digest must match the server's,
+  // which sorts paths with plain string comparison.
+  for (const file of [...files].sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0))) {
     hash.update(file.path);
     hash.update('\0');
     hash.update(file.content);

package/src/prompts.js

@@ -31,20 +31,10 @@ export async function chooseAgents(initial = []) {
 
 export async function chooseScope() {
   return cancelled(await p.select({
-    message: 'Where should the skill be installed?',
+    message: 'Where should this skill be available?',
     options: [
-      { value: 'project', label: 'This project', hint: 'portable lockfile, repository-local skill' },
-      { value: 'global', label: 'Globally', hint: 'available in every project for this user' },
-    ],
-  }));
-}
-
-export async function chooseMode() {
-  return cancelled(await p.select({
-    message: 'How should agent directories reference the package?',
-    options: [
-      { value: 'symlink', label: 'Shared package', hint: 'recommended; one managed copy' },
-      { value: 'copy', label: 'Copy files', hint: 'use when links are unavailable' },
+      { value: 'project', label: 'Only in this project' },
+      { value: 'global', label: 'Everywhere on this computer' },
     ],
   }));
 }

package/src/skills.js

@@ -231,6 +231,42 @@ export async function installedSkills({ scope = 'project', projectRoot, agents }
   return Object.values(lock.installations || {}).filter((item) => !selected || selected.has(item.agent));
 }
 
+// Version attribution for reports: find the skill's local folder (managed
+// symlink or plain folder — agents read both from the same directories), hash
+// it with the registry's package digest, and match against published versions.
+export async function identifyLocalSkill(config, detail, { projectRoot = null } = {}) {
+  const candidates = [];
+  if (projectRoot) {
+    for (const agent of ['claude-code', 'codex']) {
+      candidates.push(path.join(agentPaths(agent, { scope: 'project', projectRoot }).skills, detail.slug));
+    }
+  }
+  for (const agent of ['claude-code', 'codex']) {
+    candidates.push(path.join(agentPaths(agent).skills, detail.slug));
+  }
+  let local = null;
+  for (const candidate of candidates) {
+    try {
+      const digest = packageDigest(await readSkillDirectory(candidate));
+      local = { path: candidate, digest };
+      break;
+    } catch {
+      // not present here; keep looking
+    }
+  }
+  if (!local) return { localPath: null, version: null, verified: false };
+  for (let version = detail.latest_version; version >= 1; version -= 1) {
+    const candidate = await apiRequest(
+      config,
+      `/skills/${encodeURIComponent(detail.skill_id)}/versions/${version}`,
+    );
+    if (candidate.version.content_sha256 === local.digest) {
+      return { localPath: local.path, version, verified: true };
+    }
+  }
+  return { localPath: local.path, version: null, verified: false };
+}
+
 export async function readTranscript(file) {
   const absolute = path.resolve(file);
   return { absolute, filename: path.basename(absolute), content: await fs.readFile(absolute) };

package/skills/constraint-skills/SKILL.md

@@ -1,71 +0,0 @@
----
-name: constraint-skills
-description: Operate governed Agent Skills with the Constraint terminal CLI. Use when an agent needs to authenticate or diagnose Constraint access; discover upload domains; inspect, install, update, or upload skills; review run history; or report a session transcript when the user asks to put skill work on the record.
----
-
-# Constraint Skills
-
-Use the `constraint` command for organization-authorized skills. Do not edit its
-config, lockfiles, installation receipts, or authorization tokens directly.
-
-## Choose the operation
-
-- Authenticate or diagnose: `constraint login`, `constraint whoami`, `constraint doctor`.
-- Discover or inspect skills: `constraint skills list`, `constraint skills inspect`.
-- Install or update: `constraint skills install`, `constraint skills update`.
-- Discover upload destinations: `constraint skills domains --json`.
-- Upload a local skill folder: `constraint skills upload`.
-- Report a session: `constraint report`.
-- Review runs: `constraint skills run list`, `constraint skills run get`.
-
-Read [references/commands.md](references/commands.md) before constructing flags
-or handling a less common operation.
-
-## Upload skills
-
-Upload the skill directory, not an individual `SKILL.md`. Before every upload, run:
-
-```bash
-constraint skills domains --json
-```
-
-Use one returned `slug` exactly as `--domain`. Never guess a slug from a display
-name or reuse a domain from another organization. If multiple destinations are
-valid and ownership is unclear, ask the user.
-
-```bash
-constraint skills upload <skill-directory> --domain <returned-slug>
-```
-
-## Install skills
-
-Choose the target agent and scope explicitly. Prefer `--project`; use
-`--global` only when the user wants the skill across projects. Prefer managed
-links and use `--copy` only when independent files are required. Never
-overwrite locally edited installed skills.
-
-## Report a run
-
-A run is the posting of a transcript in which a skill was invoked, and the user
-drives it: report only when the user asks to put a session on the record. Never
-report automatically or unprompted.
-
-When asked, locate the current session's real JSON or JSONL transcript file and run:
-
-```bash
-constraint report <transcript-path> --skill <skill-name>
-```
-
-Pass the explicit local path to the transcript as it exists at that moment.
-Use the invoked skill's frontmatter `name`. Client and session id are read
-from the transcript path; re-reporting the same session later supersedes the
-earlier report. Never create a replacement transcript, summarize it, copy it
-elsewhere first, or pass a temporary file. If the transcript path cannot be
-determined, say so instead of guessing.
-
-## Work safely
-
-- Use `--json` when parsing output.
-- Respect WorkOS authorization failures; never bypass domain permissions.
-- Do not invent an uninstall workflow.
-- After mutations, report the affected skill, version, agent, scope, domain, or run ID as applicable.

package/skills/constraint-skills/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "Constraint Skills"
-  short_description: "Operate and report governed agent skills"
-  default_prompt: "Use $constraint-skills to manage a governed skill and report its run."

package/skills/constraint-skills/references/commands.md

@@ -1,76 +0,0 @@
-# Constraint CLI command reference
-
-## Install, authenticate, and configure
-
-```bash
-npm install --global @constraint/cli
-constraint --version
-constraint login
-constraint whoami
-constraint logout
-constraint setup
-constraint doctor
-```
-
-`login` uses WorkOS device authorization. Never request or embed an API key or client secret. `setup` detects Codex and Claude Code and installs this skill globally. It never touches instruction files.
-
-## Discover, inspect, install, and update
-
-```bash
-constraint skills list
-constraint skills list --search <text>
-constraint skills inspect <skill> [--version <number>] [--files]
-
-constraint skills install <skill> --agent codex --project
-constraint skills install <skill> --agent claude-code --global
-constraint skills list --installed --project
-constraint skills update <skill> --project
-constraint skills update --all --global
-```
-
-The catalog is already authorization-filtered. Project installs create `skills-lock.json`. Global receipts live in Constraint's per-user configuration directory.
-
-## Discover upload domains and upload
-
-```bash
-constraint skills domains
-constraint skills domains --json
-constraint skills upload <skill-directory> --domain <returned-slug>
-```
-
-`skills domains` returns only domains where the authenticated user can manage skills. JSON objects contain the exact `slug`, display `name`, and `description`. Discover first and pass one returned slug. Ask the user when multiple domains fit and ownership is unclear.
-
-## Report and review runs
-
-```bash
-constraint report <actual-transcript-path> --skill <skill-name>
-constraint report <actual-transcript-path> --skill <skill-name> --client codex --session <id>
-
-constraint skills run list
-constraint skills run list --team <domain> --user <workos-user-id> --skill <skill>
-constraint skills run get <run-id>
-constraint skills run get <run-id> --raw
-```
-
-`report` is user-driven: run it only when the user asks to put a session on the
-record. Client and session id are read from the transcript path itself (Claude
-Code project transcripts and Codex rollouts are named by session id);
-`--client`/`--session` are only needed for files outside those locations.
-Re-reporting the same session supersedes the earlier report.
-
-Repeat `--team`, `--user`, or `--skill` to request subsets. Review visibility is permission-controlled.
-
-`run get` never prints a transcript to stdout: it writes the run JSON (or the
-original transcript file with `--raw`) under the system temp directory and
-prints a one-object summary containing the file `path`. Read the file from
-that path. Pass `--output <path>` to choose the destination (single run only).
-
-## Automation and recovery
-
-Global flags: `--json`, `--quiet`, `--no-color`, `--help`, and `--version`. Installer workflows also accept `--yes`.
-
-- Authentication failure: run `constraint login`, then `constraint whoami`.
-- Setup uncertainty: run `constraint doctor`.
-- Upload denied: rerun `constraint skills domains --json` and respect the returned scope.
-- Install conflict: preserve local edits.
-- Missing transcript: locate the real client JSON or JSONL file before reporting; if it cannot be found, tell the user instead of guessing.

package/src/setup.js

@@ -1,97 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { loadConfig, saveConfig } from './config.js';
-import { packageDigest, readSkillDirectory, writeSkillDirectory } from './files.js';
-import { agentPaths, normalizeAgent } from './paths.js';
-
-async function companionFiles() {
-  const here = path.dirname(fileURLToPath(import.meta.url));
-  return readSkillDirectory(path.resolve(here, '..', 'skills', 'constraint-skills'));
-}
-
-export function expectedCompanionHash(config, selected, currentHash) {
-  const direct = config.companion_hashes?.[selected] || null;
-  if (direct) return direct;
-  const recorded = Object.values(config.companion_hashes || {});
-  return currentHash && recorded.includes(currentHash) ? currentHash : null;
-}
-
-async function skillPlan(selected, paths) {
-  const files = await companionFiles();
-  const bundledHash = packageDigest(files);
-  const config = await loadConfig();
-  const target = path.join(paths.skills, 'constraint-skills');
-  let currentHash = null;
-  try {
-    currentHash = packageDigest(await readSkillDirectory(target));
-  } catch (error) {
-    if (error && error.code !== 'ENOENT') throw error;
-  }
-  const expectedHash = expectedCompanionHash(config, selected, currentHash);
-  const action = currentHash === bundledHash
-    ? 'current'
-    : currentHash === null
-      ? 'install'
-      : expectedHash && currentHash === expectedHash
-        ? 'update'
-        : 'conflict';
-  return { path: target, action, bundledHash, expectedHash };
-}
-
-export async function setupPlan(agent) {
-  const selected = normalizeAgent(agent);
-  const paths = agentPaths(selected);
-  return {
-    agent: selected,
-    skill: await skillPlan(selected, paths),
-  };
-}
-
-async function recordConfiguredAgent(selected, config = null) {
-  const next = config || await loadConfig();
-  next.agents = [...new Set([...next.agents.map(normalizeAgent), selected])];
-  await saveConfig(next);
-}
-
-export async function installCompanionSkill(agent) {
-  const selected = normalizeAgent(agent);
-  const paths = agentPaths(selected);
-  const files = await companionFiles();
-  const config = await loadConfig();
-  config.companion_hashes ||= {};
-  const target = path.join(paths.skills, 'constraint-skills');
-  const plan = await skillPlan(selected, paths);
-  const result = await writeSkillDirectory(target, files, {
-    expectedHash: plan.expectedHash,
-  });
-  config.companion_hashes[selected] = result.hash;
-  await recordConfiguredAgent(selected, config);
-  return { agent: selected, path: target, changed: result.changed, applied: true };
-}
-
-export async function setupAgent(agent, {
-  dryRun = false,
-  output = console.log,
-} = {}) {
-  const selected = normalizeAgent(agent);
-  const plan = await setupPlan(selected);
-  if (dryRun) {
-    output(`Install constraint-skills globally at ${plan.skill.path} (${plan.skill.action}).`);
-    return { agent: selected, skill: plan.skill, applied: false };
-  }
-  const skillResult = await installCompanionSkill(selected);
-  return { agent: selected, skill: skillResult, applied: true };
-}
-
-export async function setupStatus(agent) {
-  const selected = normalizeAgent(agent);
-  const paths = agentPaths(selected);
-  try {
-    const skill = await fs.stat(path.join(paths.skills, 'constraint-skills', 'SKILL.md'));
-    return { agent: selected, skill: skill.isFile() };
-  } catch {
-    return { agent: selected, skill: false };
-  }
-}