@maycombhq/atticus 2.0.0-beta.18 → 2.0.0-beta.21

package/dist/{chunk-MMB2OHUY.js → chunk-ODMBPDDV.js}

@@ -5,13 +5,13 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 
 // packages/core/dist/schema/version.js
-var SCHEMA_VERSION = 4;
+var SCHEMA_VERSION = 5;
 
 // packages/core/dist/fs.js
 import { randomBytes } from "node:crypto";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { hostname } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 async function writeFileAtomic(path, data) {
   await mkdir(dirname(path), { recursive: true });
   const tmp = `${path}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
@@ -23,6 +23,32 @@ async function writeFileAtomic(path, data) {
     throw e;
   }
 }
+var FileChangedError = class extends Error {
+  path;
+  constructor(path) {
+    super(`${path} changed since it was read (another edit, or a person's): nothing was written. Read it again and redo the change.`);
+    this.path = path;
+  }
+};
+var writing = /* @__PURE__ */ new Map();
+function writeFileIfUnchanged(path, before, data) {
+  const key = resolve(path);
+  const prev = writing.get(key) ?? Promise.resolve();
+  const work = async () => {
+    const now = await readFile(path, "utf8").catch(() => void 0);
+    if (now !== before)
+      throw new FileChangedError(path);
+    await writeFileAtomic(path, data);
+  };
+  const next = prev.then(work, work);
+  const tail = next.catch(() => void 0);
+  writing.set(key, tail);
+  void tail.then(() => {
+    if (writing.get(key) === tail)
+      writing.delete(key);
+  });
+  return next;
+}
 var BUSY = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
 async function renameRetrying(from, to, tries = 9) {
   for (let i = 0; ; i++) {
@@ -39,12 +65,15 @@ async function renameRetrying(from, to, tries = 9) {
 }
 var LockHeldError = class extends Error {
   held;
-  constructor(held) {
-    super(`Another ${held.what} is running (process ${held.pid} on ${held.host}, since ${held.startedAt}). Wait for it to finish.`);
+  file;
+  constructor(held, file) {
+    super(`Another ${held.what} is running (process ${held.pid} on ${held.host}, since ${held.startedAt}). Wait for it to finish${file ? `; if nothing is running, delete ${file}` : ""}.`);
     this.held = held;
+    this.file = file;
     this.name = "LockHeldError";
   }
 };
+var heldHere = /* @__PURE__ */ new Set();
 var lockFileOf = (root, name) => join(root, ".atticus", "locks", `${name}.json`);
 function alive(pid) {
   try {
@@ -54,16 +83,19 @@ function alive(pid) {
     return e.code === "EPERM";
   }
 }
-async function readLock(root, name) {
+async function readLock(root, name, o = {}) {
   try {
-    const info = JSON.parse(await readFile(lockFileOf(root, name), "utf8"));
-    const stale = info.host === hostname() ? !alive(info.pid) : false;
+    const file = lockFileOf(root, name);
+    const info = JSON.parse(await readFile(file, "utf8"));
+    const here = info.host === hostname();
+    const age = (o.now ?? (() => /* @__PURE__ */ new Date()))().getTime() - Date.parse(info.startedAt);
+    const stale = here && (!alive(info.pid) || info.pid === process.pid && !heldHere.has(file)) || o.maxAgeMs !== void 0 && Number.isFinite(age) && age > o.maxAgeMs;
     return { ...info, stale };
   } catch {
     return void 0;
   }
 }
-async function acquireLock(root, name, what, now = () => /* @__PURE__ */ new Date()) {
+async function acquireLock(root, name, what, now = () => /* @__PURE__ */ new Date(), o = {}) {
   const file = lockFileOf(root, name);
   await ensureLocalIgnore(root);
   await mkdir(dirname(file), { recursive: true });
@@ -77,18 +109,20 @@ async function acquireLock(root, name, what, now = () => /* @__PURE__ */ new Dat
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
       await writeFile(file, JSON.stringify(info), { encoding: "utf8", flag: "wx" });
+      heldHere.add(file);
       const release = async () => {
         const cur = await readLock(root, name);
         if (cur && cur.pid === info.pid && cur.startedAt === info.startedAt)
           await rm(file, { force: true });
+        heldHere.delete(file);
       };
       return interrupted ? { release, interrupted } : { release };
     } catch (e) {
       if (e.code !== "EEXIST")
         throw e;
-      const held = await readLock(root, name);
+      const held = await readLock(root, name, { ...o, now });
       if (held && !held.stale)
-        throw new LockHeldError(held);
+        throw new LockHeldError(held, file);
       if (held) {
         const { stale: _s, ...rest } = held;
         interrupted = rest;
@@ -116,11 +150,10 @@ async function ensureLocalIgnore(root) {
   const missing = LOCAL_ONLY.filter((l) => !have.has(l));
   if (!missing.length)
     return;
-  await mkdir(dirname(file), { recursive: true });
   const prefix = text && !text.endsWith("\n") ? `${text}
 ` : text;
-  await writeFile(file, `${prefix}${prefix ? "" : "# This machine's own files: never committed.\n"}${missing.join("\n")}
-`, "utf8");
+  await writeFileAtomic(file, `${prefix}${prefix ? "" : "# This machine's own files: never committed.\n"}${missing.join("\n")}
+`);
 }
 
 // packages/core/dist/log.js
@@ -245,6 +278,8 @@ var NO_LOG = {
 export {
   SCHEMA_VERSION,
   writeFileAtomic,
+  FileChangedError,
+  writeFileIfUnchanged,
   renameRetrying,
   LockHeldError,
   lockFileOf,

package/dist/chunk-OKUB6RJA.js

@@ -0,0 +1,533 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  originOf
+} from "./chunk-THN26IEF.js";
+import {
+  isAdopted,
+  orgPackDirOf,
+  require_dist
+} from "./chunk-PAINMSID.js";
+import {
+  writeFileAtomic
+} from "./chunk-ODMBPDDV.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/skills-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { lstatSync, realpathSync } from "node:fs";
+import { mkdir, readdir, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, sep } from "node:path";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+var sha = (t) => createHash("sha256").update(t).digest("hex").slice(0, 16);
+var lf = (t) => t.replace(/\r\n?/g, "\n");
+var NAME = /^[a-z0-9][a-z0-9-]{0,62}$/;
+var MARK = (src, h) => `<!-- atticus: written from ${src} (${h}); edit the source, or keep your edit here: atticus skills write leaves an edited file alone -->`;
+var packRel = (root) => isAdopted(root) ? ".atticus/org-pack" : "org-pack";
+function splitFm(text) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(text);
+  if (!m)
+    return { fm: {}, body: text };
+  try {
+    const fm = (0, import_yaml.parse)(m[1]);
+    return { fm: fm && typeof fm === "object" ? fm : {}, body: m[2] };
+  } catch {
+    return { fm: {}, body: m[2] };
+  }
+}
+var fmText = (o) => `---
+${(0, import_yaml.stringify)(o, { lineWidth: 0 }).trimEnd()}
+---
+`;
+async function filesUnder(dir, rel = "", links) {
+  const out = [];
+  for (const e of await readdir(dir, { withFileTypes: true }).catch(() => [])) {
+    const r = rel ? `${rel}/${e.name}` : e.name;
+    if (e.isSymbolicLink())
+      links?.push(r);
+    else if (e.isDirectory())
+      out.push(...await filesUnder(join(dir, e.name), r, links));
+    else if (e.isFile())
+      out.push(r);
+  }
+  return out.sort();
+}
+var REF = /^(?!.*(?:\.\.|\/\/|\.lock(?:\/|$)|\/$|\.$))[A-Za-z0-9][A-Za-z0-9._/-]{0,199}$/;
+async function sourcesOf(root) {
+  const pack = orgPackDirOf(root);
+  const rel = packRel(root);
+  const out = [];
+  const scan = async (sub, team) => {
+    const sk = join(pack, "skills", sub);
+    for (const e of await readdir(sk, { withFileTypes: true }).catch(() => [])) {
+      if (!e.isDirectory() || e.name === "imported")
+        continue;
+      const d = join(sk, e.name);
+      const raw = await readFile(join(d, "SKILL.md"), "utf8").catch(() => void 0);
+      if (raw === void 0)
+        continue;
+      const text = lf(raw);
+      const files = (await filesUnder(d)).filter((f) => f !== "SKILL.md");
+      out.push({
+        kind: "skill",
+        name: e.name,
+        source: `${rel}/skills/${sub ? `${sub}/` : ""}${e.name}`,
+        ...team ? { team } : {},
+        text,
+        files: await Promise.all(files.map(async (f) => ({ path: f, text: lf(await readFile(join(d, f), "utf8")) })))
+      });
+    }
+    for (const [kind, folder] of [
+      ["agent", "agents"],
+      ["instructions", "instructions"]
+    ]) {
+      const d = join(pack, folder, sub);
+      for (const e of await readdir(d, { withFileTypes: true }).catch(() => [])) {
+        if (!e.isFile() || !e.name.endsWith(".md"))
+          continue;
+        out.push({
+          kind,
+          name: e.name.slice(0, -3),
+          source: `${rel}/${folder}/${sub ? `${sub}/` : ""}${e.name}`,
+          ...team ? { team } : {},
+          text: lf(await readFile(join(d, e.name), "utf8")),
+          files: []
+        });
+      }
+    }
+  };
+  await scan("");
+  const teams = /* @__PURE__ */ new Set();
+  for (const folder of ["skills", "agents", "instructions"])
+    for (const e of await readdir(join(pack, folder, "imported"), { withFileTypes: true }).catch(() => []))
+      if (e.isDirectory())
+        teams.add(e.name);
+  for (const t of [...teams].sort())
+    await scan(`imported/${t}`, t);
+  return out.sort((a, b) => a.kind + a.name < b.kind + b.name ? -1 : 1);
+}
+var TEAM_KEYS = {
+  skill: /* @__PURE__ */ new Set(["name", "description"]),
+  agent: /* @__PURE__ */ new Set(["name", "description", "tools", "disallowedTools"]),
+  instructions: /* @__PURE__ */ new Set(["name", "description"])
+};
+var TEAM_READ_TOOLS = ["Read", "Grep", "Glob"];
+var TEAM_COPILOT_TOOLS = ["read", "search"];
+var namesOf = (v) => (Array.isArray(v) ? v.map(String) : typeof v === "string" ? v.split(",") : []).map((x) => x.trim()).filter(Boolean);
+function teamFrontmatter(kind, fm) {
+  const keep = TEAM_KEYS[kind];
+  const out = Object.fromEntries(Object.entries(fm).filter(([k]) => keep.has(k)));
+  let readOnly = false;
+  let toolsLeft = [];
+  if (kind === "agent") {
+    const asked = namesOf(fm.tools);
+    const kept = asked.filter((t) => TEAM_READ_TOOLS.includes(t));
+    toolsLeft = asked.filter((t) => !kept.includes(t));
+    readOnly = kept.length === 0;
+    out.tools = (readOnly ? [...TEAM_READ_TOOLS] : kept).join(", ");
+  }
+  return { fm: out, dropped: Object.keys(fm).filter((k) => !keep.has(k)), readOnly, toolsLeft };
+}
+function outputsOf(i) {
+  const { fm: all, body } = splitFm(i.text);
+  const fm = i.team ? teamFrontmatter(i.kind, all).fm : all;
+  const description = typeof fm.description === "string" && fm.description.trim() ? fm.description.trim() : (body.split("\n").find((l) => l.trim() && !l.startsWith("#")) ?? i.name).trim().slice(0, 200);
+  const from = i.team ? `${i.source} (${i.team})` : i.source;
+  const h = sha(i.text + i.files.map((f) => f.path + f.text).join(""));
+  const mark = MARK(from, h);
+  switch (i.kind) {
+    case "skill":
+      return [
+        {
+          path: `.claude/skills/${i.name}/SKILL.md`,
+          // Another team's skill is run by a person only, never picked by the model on its own
+          // (Claude Code and VS Code both read SKILL.md from here and honour this).
+          text: `${fmText({ ...fm, name: i.name, description, ...i.team ? { "disable-model-invocation": true } : {} })}${mark}
+${body}`
+        },
+        ...i.files.map((f) => ({ path: `.claude/skills/${i.name}/${f.path}`, text: f.text })),
+        {
+          path: `.github/prompts/${i.name}.prompt.md`,
+          // Another team's runs in ask mode (it reads; it edits nothing and runs no command).
+          text: `${fmText({ description, agent: i.team ? "ask" : "agent" })}${mark}
+${body}${i.files.length ? `
+
+This skill's files are in \`.claude/skills/${i.name}/\`: ${i.files.map((f) => `\`${f.path}\``).join(", ")}.
+` : ""}`
+        }
+      ];
+    case "agent":
+      return [
+        {
+          path: `.claude/agents/${i.name}.md`,
+          text: `${fmText({ ...fm, name: i.name, description })}${mark}
+${body}`
+        },
+        {
+          path: `.github/agents/${i.name}.agent.md`,
+          // Another team's reads only in Copilot too (an agent with no tools there gets them all).
+          text: `${fmText({ name: i.name, description, ...i.team ? { tools: [...TEAM_COPILOT_TOOLS] } : {} })}${mark}
+${body}`
+        }
+      ];
+    case "instructions":
+      return [
+        {
+          path: `.github/instructions/${i.name}.instructions.md`,
+          // Applied by itself only where its source says (`applyTo`): with none, a person attaches
+          // it, so another team's words never reach a session (Atticus's own reads among them)
+          // that didn't ask for them. Another team's never apply by themselves: a person attaches
+          // them (their `applyTo` could reach every file, the reading sessions' too).
+          text: `${fmText({ description, ...typeof fm.applyTo === "string" && !i.team ? { applyTo: fm.applyTo } : {} })}${mark}
+${body}`
+        }
+      ];
+  }
+}
+function claudeBlock(items) {
+  const ins = items.filter((i) => i.kind === "instructions");
+  if (!ins.length)
+    return "";
+  const own = ins.filter((i) => !i.team);
+  const others = ins.filter((i) => i.team);
+  return [
+    "<!-- atticus:team-instructions:begin (written by atticus skills write; edit the sources in the org pack) -->",
+    "## Team instructions",
+    "",
+    ...own.map((i) => `- @${i.source}`),
+    ...others.length ? [
+      ...own.length ? [""] : [],
+      "Other teams' instructions, reviewed in the org pack; mention one to use it:",
+      "",
+      ...others.map((i) => `- \`${i.source}\` (from ${i.team})`)
+    ] : [],
+    "<!-- atticus:team-instructions:end -->"
+  ].join("\n");
+}
+var STATE = (root) => join(orgPackDirOf(root), "skills", ".written.yaml");
+async function planWrite(root) {
+  const items = await sourcesOf(root);
+  const written = ((0, import_yaml.parse)(await readFile(STATE(root), "utf8").catch(() => "") || "{}") ?? {}).files ?? {};
+  const write = [];
+  const kept = [];
+  const clashes = [];
+  let current = 0;
+  const seen = /* @__PURE__ */ new Map();
+  const ordered = [...items].sort((a, b) => (a.team ?? "") < (b.team ?? "") ? -1 : (a.team ?? "") > (b.team ?? "") ? 1 : 0);
+  const used = [];
+  for (const i of ordered) {
+    const k = `${i.kind}:${i.name}`;
+    const first = seen.get(k);
+    if (first) {
+      clashes.push(`${i.source} and ${first.source} are both ${i.kind} ${i.name}: ${first.source} is written; rename one`);
+      continue;
+    }
+    seen.set(k, i);
+    used.push(i);
+  }
+  for (const i of used)
+    for (const o of outputsOf(i)) {
+      const raw = await readFile(join(root, ...o.path.split("/")), "utf8").catch(() => void 0);
+      const on = raw === void 0 ? void 0 : lf(raw);
+      if (on === lf(o.text)) {
+        current++;
+        continue;
+      }
+      const was = written[o.path];
+      const ours = raw !== void 0 && (was === sha(on) || was === sha(raw));
+      if (on !== void 0 && was && !ours)
+        kept.push(o.path);
+      else if (on !== void 0 && !written[o.path])
+        kept.push(o.path);
+      else
+        write.push(o);
+    }
+  const block = claudeBlock(used);
+  const claudePath = join(root, "CLAUDE.md");
+  const claude = await readFile(claudePath, "utf8").catch(() => "");
+  const re = /<!-- atticus:team-instructions:begin[\s\S]*?atticus:team-instructions:end -->/;
+  const next = block ? re.test(claude) ? claude.replace(re, () => block) : `${claude.trimEnd()}${claude.trim() ? "\n\n" : ""}${block}
+` : claude.replace(re, "").trimEnd() + (claude.trim() ? "\n" : "");
+  return { write, kept, current, clashes, ...next !== claude ? { claude: next } : {} };
+}
+async function skillsWriteCommand(root, o, io) {
+  const p = await planWrite(root);
+  for (const c of p.clashes)
+    io.err(c);
+  if (o.check) {
+    for (const f of p.write)
+      io.out(`behind: ${f.path}`);
+    if (p.claude)
+      io.out("behind: CLAUDE.md (team instructions)");
+    for (const k of p.kept)
+      io.out(`edited here, kept: ${k}`);
+    const behind = p.write.length + (p.claude ? 1 : 0);
+    io.out(behind ? `${behind} files are behind the org pack: atticus skills write` : "The skills, agents and instructions written are current.");
+    return behind ? 1 : 0;
+  }
+  const state = ((0, import_yaml.parse)(await readFile(STATE(root), "utf8").catch(() => "") || "{}") ?? {}).files ?? {};
+  for (const f of p.write) {
+    await mkdir(dirname(join(root, ...f.path.split("/"))), { recursive: true });
+    await writeFileAtomic(join(root, ...f.path.split("/")), f.text);
+    state[f.path] = sha(lf(f.text));
+    io.out(`wrote ${f.path}`);
+  }
+  if (p.claude !== void 0) {
+    await writeFileAtomic(join(root, "CLAUDE.md"), p.claude);
+    io.out("wrote CLAUDE.md (team instructions)");
+  }
+  for (const k of p.kept)
+    io.out(`kept ${k}: it was edited here; remove it to have it written again`);
+  await mkdir(dirname(STATE(root)), { recursive: true });
+  await writeFileAtomic(STATE(root), (0, import_yaml.stringify)({ schemaVersion: 1, files: Object.fromEntries(Object.entries(state).sort()) }));
+  io.out(`${p.write.length} written, ${p.current} current, ${p.kept.length} kept as edited.`);
+  return 0;
+}
+function factsWithoutSource(text) {
+  const claims = /\b(topic|queue|schema|endpoint|field|payload|contract|route)s?\b/i.test(text);
+  const grounded = /\batticus (ask|query|guide|show|contracts|flows|map|catalog)\b|\/atticus-/i.test(text);
+  return claims && !grounded;
+}
+function inside(dir, rel) {
+  try {
+    const top = realpathSync(dir);
+    const p = realpathSync(join(dir, ...rel.split("/")));
+    return p === top || p.startsWith(top + sep);
+  } catch {
+    return false;
+  }
+}
+async function theirs(dir) {
+  const out = [];
+  const has = (p) => {
+    try {
+      return lstatSync(join(dir, ...p.split("/"))).isFile();
+    } catch {
+      return false;
+    }
+  };
+  for (const base of [".claude/skills", "org-pack/skills"])
+    for (const e of await readdir(join(dir, ...base.split("/")), { withFileTypes: true }).catch(() => []))
+      if (e.isDirectory() && e.name !== "imported" && has(`${base}/${e.name}/SKILL.md`))
+        out.push({
+          kind: "skill",
+          name: e.name,
+          path: `${base}/${e.name}/SKILL.md`,
+          folder: `${base}/${e.name}`
+        });
+  for (const [base, suffix] of [
+    [".claude/agents", ".md"],
+    ["org-pack/agents", ".md"],
+    [".github/agents", ".agent.md"],
+    [".github/chatmodes", ".chatmode.md"]
+  ])
+    for (const e of await readdir(join(dir, ...base.split("/")), { withFileTypes: true }).catch(() => []))
+      if (e.isFile() && e.name.endsWith(suffix))
+        out.push({
+          kind: "agent",
+          name: e.name.slice(0, -suffix.length),
+          path: `${base}/${e.name}`
+        });
+  for (const [base, suffix] of [
+    [".github/instructions", ".instructions.md"],
+    ["org-pack/instructions", ".md"]
+  ])
+    for (const e of await readdir(join(dir, ...base.split("/")), { withFileTypes: true }).catch(() => []))
+      if (e.isFile() && e.name.endsWith(suffix))
+        out.push({
+          kind: "instructions",
+          name: e.name.slice(0, -suffix.length),
+          path: `${base}/${e.name}`
+        });
+  const seen = /* @__PURE__ */ new Set();
+  return out.filter((x) => inside(dir, x.folder ?? x.path) && !seen.has(`${x.kind}:${x.name}`) && !!seen.add(`${x.kind}:${x.name}`));
+}
+async function skillsImportCommand(root, from, o, io) {
+  if (!from || !o.team) {
+    io.err("Usage: atticus skills import <their repo folder> --team <their team> [--at <tag>] [--only <names>]");
+    return 2;
+  }
+  if (!NAME.test(o.team)) {
+    io.err("--team is lower case, digits and dashes.");
+    return 2;
+  }
+  if (o.at !== void 0 && !REF.test(o.at)) {
+    io.err(`${o.at} isn't a tag or branch name.`);
+    return 2;
+  }
+  let dir = from;
+  let tmp;
+  if (o.at) {
+    tmp = join(tmpdir(), `atticus-import-${o.team}-${Date.now()}`);
+    try {
+      await mkdir(dirname(tmp), { recursive: true });
+      await run("git", [
+        "-C",
+        from,
+        "-c",
+        `core.hooksPath=${tmp}.no-hooks`,
+        "worktree",
+        "add",
+        "--detach",
+        "--",
+        tmp,
+        `${o.at}^{commit}`
+      ]);
+      dir = tmp;
+    } catch (e) {
+      io.err(`${from} has no ${o.at}: ${e.message.split("\n")[0]}`);
+      return 2;
+    }
+  }
+  try {
+    const only = o.only ? new Set(o.only.split(",").map((x) => x.trim())) : void 0;
+    const found = (await theirs(dir)).filter((x) => !only || only.has(x.name));
+    if (!found.length) {
+      io.err(`${from} has no skills (.claude/skills/<name>/SKILL.md), agents or instructions${only ? ` named ${[...only].join(", ")}` : ""}.`);
+      return 2;
+    }
+    const pack = orgPackDirOf(root);
+    const provPath = join(pack, "imported", `${o.team}.yaml`);
+    const prov = (0, import_yaml.parse)(await readFile(provPath, "utf8").catch(() => "") || "{}") ?? {};
+    const was = new Map((prov.items ?? []).map((x) => [`${x.kind}:${x.name}`, x.files]));
+    const items = [];
+    const origin = await originOf(from, (a) => run("git", a));
+    const notes = [];
+    const taken = new Map((await sourcesOf(root)).filter((x) => x.team !== o.team).map((x) => [`${x.kind}:${x.name}`, x.team ?? "this organisation"]));
+    for (const f of found) {
+      const owner = taken.get(`${f.kind}:${f.name}`);
+      if (owner) {
+        notes.push(`skipped ${f.kind} ${f.name}: ${owner} has one of that name already (the written files are one set); rename theirs or yours`);
+        continue;
+      }
+      if (!NAME.test(f.name)) {
+        notes.push(`skipped ${f.path}: ${f.name} isn't a name Atticus writes (lower case, digits, dashes)`);
+        continue;
+      }
+      const dest = f.kind === "skill" ? join(pack, "skills", "imported", o.team, f.name) : join(pack, f.kind === "agent" ? "agents" : "instructions", "imported", o.team);
+      const files = {};
+      let copied = true;
+      const copy = async (src, to, key) => {
+        if (!inside(dir, src)) {
+          copied = false;
+          notes.push(`left out ${src}: it isn't in their repo (a link to somewhere else)`);
+          return;
+        }
+        const text = await readFile(join(dir, ...src.split("/")), "utf8");
+        const on = await readFile(to, "utf8").catch(() => void 0);
+        const before = was.get(`${f.kind}:${f.name}`)?.[key];
+        if (on !== void 0 && before && sha(on) !== before && sha(on) !== sha(text) && !o.replace) {
+          notes.push(`kept ${to.slice(root.length + 1)}: edited here since the last import (--replace takes theirs)`);
+          files[key] = before;
+          return;
+        }
+        await mkdir(dirname(to), { recursive: true });
+        await writeFileAtomic(to, text);
+        files[key] = sha(text);
+      };
+      if (f.kind === "skill") {
+        const links = [];
+        const all = await filesUnder(join(dir, ...f.folder.split("/")), "", links);
+        if (links.length)
+          notes.push(`${f.name}: left out ${links.join(", ")}: a link to a file elsewhere is never copied`);
+        for (const p of all)
+          await copy(`${f.folder}/${p}`, join(dest, ...p.split("/")), p);
+        const theirsNow = new Set(all);
+        for (const p of (await filesUnder(dest).catch(() => [])).filter((x) => !theirsNow.has(x))) {
+          const here = await readFile(join(dest, ...p.split("/")), "utf8").catch(() => void 0);
+          const before = was.get(`${f.kind}:${f.name}`)?.[p];
+          if (here !== void 0 && !before) {
+            notes.push(`kept ${f.name}/${p}: added here, not one of ${o.team}'s`);
+          } else if (here !== void 0 && before && sha(here) !== before && !o.replace) {
+            notes.push(`kept ${f.name}/${p}: ${o.team} removed it, but it was edited here`);
+            files[p] = before;
+          } else {
+            await rm(join(dest, ...p.split("/")), { force: true });
+            notes.push(`removed ${f.name}/${p}: ${o.team} no longer has it`);
+          }
+        }
+        const scripts = all.filter((p) => !/\.(md|txt|ya?ml|json)$/i.test(p));
+        if (scripts.length)
+          notes.push(`${f.name} carries files that may run (${scripts.join(", ")}): review them in the PR; nothing ran here`);
+        const skillText = await readFile(join(dest, "SKILL.md"), "utf8");
+        if (factsWithoutSource(skillText))
+          notes.push(`${f.name} states things about the estate (topics, fields, routes) with no atticus command to get them: a reviewer checks it against the map`);
+      } else
+        await copy(f.path, join(dest, `${f.name}.md`), `${f.name}.md`);
+      const mainFile = f.kind === "skill" ? join(dest, "SKILL.md") : join(dest, `${f.name}.md`);
+      const t = teamFrontmatter(f.kind, splitFm(await readFile(mainFile, "utf8").catch(() => "")).fm);
+      if (t.dropped.length && copied)
+        notes.push(`${f.name}: left out of what the assistants read: ${t.dropped.join(", ")} (another team's file can't give itself these here; set them in your own copy if you want them)`);
+      if (f.kind === "agent" && copied)
+        notes.push(t.toolsLeft.length ? `${f.name} asks for ${t.toolsLeft.join(", ")}: another team's agent reads only here (${TEAM_READ_TOOLS.join(", ")}); give it more in your own copy if you want` : t.readOnly ? `${f.name} names no read tools, so it is written to read only (${TEAM_READ_TOOLS.join(", ")})` : `${f.name} reads only, as its tools say`);
+      items.push({ kind: f.kind, name: f.name, files, from: origin, at: o.at ?? "working copy" });
+    }
+    await mkdir(dirname(provPath), { recursive: true });
+    await writeFileAtomic(provPath, (0, import_yaml.stringify)({
+      schemaVersion: 1,
+      team: o.team,
+      // Where it came from, as the metarepo sees it (no one's home folder in a committed file).
+      from: origin,
+      at: o.at ?? "working copy",
+      // An import of some (--only) keeps the record of the rest.
+      items: [
+        ...(prov.items ?? []).filter((x) => !items.some((y) => y.kind === x.kind && y.name === x.name)),
+        ...items
+      ].sort((a, b) => `${a.kind}:${a.name}`.localeCompare(`${b.kind}:${b.name}`))
+    }));
+    io.out(`Imported ${items.length} from ${o.team}${o.at ? ` at ${o.at}` : ""} into ${packRel(root)}/{skills,agents,instructions}/imported/${o.team}/, provenance in ${packRel(root)}/imported/${o.team}.yaml.`);
+    for (const n of notes)
+      io.out(`  ${n}`);
+    io.out("Review the copy in a pull request; then atticus skills write puts it where Claude and Copilot read it.");
+    return 0;
+  } finally {
+    if (tmp) {
+      await run("git", ["-C", from, "worktree", "remove", "--force", tmp]).catch(() => void 0);
+      await rm(tmp, { recursive: true, force: true }).catch(() => void 0);
+    }
+  }
+}
+async function skillsListCommand(root, o, io) {
+  const items = await sourcesOf(root);
+  if (o.json) {
+    io.out(JSON.stringify(items.map((i) => ({
+      kind: i.kind,
+      name: i.name,
+      source: i.source,
+      team: i.team,
+      writes: outputsOf(i).map((x) => x.path)
+    })), null, 2));
+    return 0;
+  }
+  if (!items.length) {
+    io.out(`No skills, agents or instructions in ${packRel(root)} yet. Take another team's: atticus skills import <their repo> --team <team> --at <tag>.`);
+    return 0;
+  }
+  for (const i of items)
+    io.out(`${i.kind} ${i.name}${i.team ? ` (from ${i.team})` : ""}: ${i.source} \u2192 ${outputsOf(i).filter((x) => !x.path.includes("/" + i.name + "/") || x.path.endsWith("SKILL.md")).map((x) => x.path).join(", ")}`);
+  return 0;
+}
+
+export {
+  splitFm,
+  REF,
+  sourcesOf,
+  teamFrontmatter,
+  outputsOf,
+  claudeBlock,
+  planWrite,
+  skillsWriteCommand,
+  factsWithoutSource,
+  inside,
+  skillsImportCommand,
+  skillsListCommand
+};

package/dist/{chunk-MKFYQQ5Q.js → chunk-OMPENNWY.js}

@@ -3,6 +3,9 @@ import { fileURLToPath as __atticusFileURLToPath } from "node:url";
 var require = __atticusCreateRequire(import.meta.url);
 var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  isInPlace
+} from "./chunk-XOL3GFW2.js";
 
 // packages/cli/dist/repo-ids.js
 function repoIdKey(id) {
@@ -10,7 +13,7 @@ function repoIdKey(id) {
 }
 function cloneUrlKey(url) {
   const u = url.trim();
-  if (!u || u === "." || u.startsWith("./") || u.startsWith("../"))
+  if (!u || isInPlace(u) || /^\.\.[\\/]/.test(u))
     return void 0;
   return u.replace(/[/\\]+$/, "").replace(/\.git$/i, "").replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").replace(/^[^@/]+@/, "").replace(/^([^/:]+):(?!\d+\/)/, "$1/").toLowerCase();
 }