argos-harness 0.1.0

package/dist/lib/settings-merge.js

@@ -0,0 +1,373 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, isAbsolute, relative, resolve, sep } from "node:path";
+import { writeFileAtomic } from "./atomic-write.js";
+/**
+ * Surgical merge of Argos's `hooks.PreToolUse` entries into
+ * `~/.claude/settings.json` — the JSON analogue of the managed-block model
+ * used for CLAUDE.md (see `lib/markers.ts`): Argos manages only its own
+ * entries and leaves every other key, hook, and array position in the
+ * user's file untouched.
+ *
+ * Ownership identification: a hook command is Argos-owned when it points at
+ * a script under `.../hooks/argos-*` — `isArgosHookCommand` below is the
+ * general check (any Argos hook), while the merge itself pins each entry to
+ * ONE specific `scriptPath`, so re-running `argos init` updates the exact
+ * same array slot instead of appending a duplicate.
+ */ const ARGOS_HOOK_PATH_RE = /\/hooks\/argos-/;
+const BASH_HOOK_COMMAND_RE = /^bash "(.+)"$/;
+const ARGOS_HOOK_BASENAME_RE = /^argos-/;
+/**
+ * True when a hook `command` string points at an Argos-owned script (`.../hooks/argos-*`).
+ *
+ * This is a bare substring match — good enough for the non-destructive
+ * `doctor` diagnostic that uses it, but NOT anchored to any real directory.
+ * Destructive operations (deleting hook entries from the user's
+ * settings.json) must use `isArgosOwnedHookCommand` below instead, which
+ * requires the script to actually resolve inside the managed hooks
+ * directory.
+ */ export function isArgosHookCommand(command) {
+    return typeof command === "string" && ARGOS_HOOK_PATH_RE.test(command);
+}
+/** Extract the script path from Argos's own `bash "<scriptPath>"` hook command shape (see `buildHookCommand`). */ function extractBashScriptPath(command) {
+    return BASH_HOOK_COMMAND_RE.exec(command)?.[1];
+}
+/** True when `candidate` resolves to a path inside (a descendant of) `dir`, via real path resolution — not string matching. */ function isPathInsideDir(candidate, dir) {
+    const rel = relative(resolve(dir), resolve(candidate));
+    if (rel === "" || isAbsolute(rel)) return false;
+    return rel !== ".." && !rel.startsWith(`..${sep}`);
+}
+/**
+ * True when a hook `command` string is Argos-owned for the purposes of
+ * DESTRUCTIVE removal: it must match Argos's own `bash "<scriptPath>"`
+ * invocation shape, have a basename starting with `argos-`, AND resolve to a
+ * location actually inside `hooksDir` (the real, resolved
+ * `<claudeDir>/hooks` directory this install manages).
+ *
+ * This is intentionally stricter than `isArgosHookCommand`/`ARGOS_HOOK_PATH_RE`,
+ * which only substring-match `/hooks/argos-` anywhere in the command string.
+ * A user's own hook living at an unrelated path that happens to contain that
+ * substring — e.g. `/Users/x/my/hooks/argos-custom.sh`, which is NOT under
+ * the managed hooks directory — would false-match the substring check and be
+ * silently deleted. Anchoring to the resolved hooks directory (via
+ * `path.resolve` + an ancestor check, not `.includes()`) closes that hole.
+ */ function isArgosOwnedHookCommand(command, hooksDir) {
+    if (typeof command !== "string") return false;
+    const scriptPath = extractBashScriptPath(command);
+    if (!scriptPath) return false;
+    if (!ARGOS_HOOK_BASENAME_RE.test(basename(scriptPath))) return false;
+    return isPathInsideDir(scriptPath, hooksDir);
+}
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function buildHookCommand(spec) {
+    const hook = {
+        type: "command",
+        command: `bash "${spec.scriptPath}"`
+    };
+    if (spec.timeout !== undefined) hook.timeout = spec.timeout;
+    if (spec.statusMessage !== undefined) hook.statusMessage = spec.statusMessage;
+    return hook;
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/**
+ * Merge `specs` into `settingsPath` (normally `resolveClaudeDir()/settings.json`).
+ *
+ * - Missing file → starts from `{}` (created).
+ * - An existing hook entry whose command already targets a spec's
+ *   `scriptPath` → overwritten in place, at its current array index (never
+ *   moved, never removed).
+ * - No existing entry for a spec → appended into the first `PreToolUse`
+ *   bucket whose `matcher` equals the spec's matcher, or a new bucket is
+ *   pushed at the end of `PreToolUse` if none matches. Every other bucket,
+ *   hook, and top-level key is left exactly as found.
+ * - `options.removeScriptPaths` → any existing entry whose command targets
+ *   one of those paths is stripped out entirely (not replaced) — for a hook
+ *   whose script write just failed, so it never leaves a dangling entry.
+ * - Corrupt JSON (unparsable, not an object, `hooks` present but not an
+ *   object, or `hooks.PreToolUse` present but not an array) → returns
+ *   `status: "error"` and writes NOTHING. Never clobber a file the caller
+ *   can't safely reason about, and never silently discard a foreign `hooks`
+ *   value just because its shape is unexpected.
+ * - Concurrency guard: the file's mtime is captured at read time and
+ *   re-checked immediately before the write; if it moved, someone else wrote
+ *   settings.json in the meantime and this call refuses with `status:
+ *   "error"` rather than silently clobbering that write (last-writer-wins).
+ * - The write itself is atomic (temp file + rename, see
+ *   lib/atomic-write.ts) — a crash mid-write can never leave settings.json
+ *   torn, which would otherwise hard-block every subsequent Bash call.
+ *
+ * The file is always re-serialized with 2-space indentation on a write —
+ * this normalizes the user's original formatting/whitespace, but every key
+ * and value it did not own is preserved (structurally byte-identical
+ * content, not necessarily byte-identical bytes).
+ */ export function mergeHooksIntoSettings(settingsPath, specs, options = {}) {
+    const existed = existsSync(settingsPath);
+    let raw = "{}";
+    let mtimeAtRead;
+    if (existed) {
+        try {
+            raw = readFileSync(settingsPath, "utf-8");
+            mtimeAtRead = statSync(settingsPath).mtimeMs;
+        } catch (err) {
+            return {
+                status: "error",
+                detail: errorMessage(err)
+            };
+        }
+    }
+    let settings;
+    try {
+        const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw);
+        if (!isPlainObject(parsed)) {
+            return {
+                status: "error",
+                detail: "settings.json existente no es un objeto JSON — arreglalo a mano."
+            };
+        }
+        settings = parsed;
+    } catch (err) {
+        return {
+            status: "error",
+            detail: `settings.json existente tiene JSON inválido (${errorMessage(err)}) — arreglalo a mano y volvé a correr argos init.`
+        };
+    }
+    const before = JSON.stringify(settings);
+    if (settings.hooks !== undefined && !isPlainObject(settings.hooks)) {
+        return {
+            status: "error",
+            detail: "settings.json tiene hooks que no es un objeto — arreglalo a mano."
+        };
+    }
+    const hooksRoot = isPlainObject(settings.hooks) ? settings.hooks : {};
+    const preToolUseRaw = hooksRoot.PreToolUse;
+    if (preToolUseRaw !== undefined && !Array.isArray(preToolUseRaw)) {
+        return {
+            status: "error",
+            detail: "settings.json tiene hooks.PreToolUse que no es un array — arreglalo a mano."
+        };
+    }
+    const preToolUse = Array.isArray(preToolUseRaw) ? preToolUseRaw : [];
+    const removeScriptPaths = options.removeScriptPaths ?? [];
+    if (removeScriptPaths.length > 0) {
+        for (const bucket of preToolUse){
+            if (!isPlainObject(bucket) || !Array.isArray(bucket.hooks)) continue;
+            bucket.hooks = bucket.hooks.filter((h)=>{
+                if (!isPlainObject(h) || typeof h.command !== "string") return true;
+                const command = h.command;
+                return !removeScriptPaths.some((p)=>command.includes(p));
+            });
+        }
+    }
+    for (const spec of specs){
+        const desired = buildHookCommand(spec);
+        // Find our own previous entry anywhere in PreToolUse (matched by
+        // scriptPath), to update it in place without moving it.
+        let found = false;
+        for (const bucket of preToolUse){
+            if (!isPlainObject(bucket) || !Array.isArray(bucket.hooks)) continue;
+            const bucketHooks = bucket.hooks;
+            const idx = bucketHooks.findIndex((h)=>isPlainObject(h) && typeof h.command === "string" && h.command.includes(spec.scriptPath));
+            if (idx >= 0) {
+                bucketHooks[idx] = desired;
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            let bucket = preToolUse.find((b)=>isPlainObject(b) && b.matcher === spec.matcher && Array.isArray(b.hooks));
+            if (!bucket) {
+                bucket = {
+                    matcher: spec.matcher,
+                    hooks: []
+                };
+                preToolUse.push(bucket);
+            }
+            bucket.hooks.push(desired);
+        }
+    }
+    hooksRoot.PreToolUse = preToolUse;
+    settings.hooks = hooksRoot;
+    if (existed && JSON.stringify(settings) === before) {
+        return {
+            status: "unchanged"
+        };
+    }
+    options.onBeforeWrite?.();
+    // Cheap concurrency guard: this is a read-modify-write with no locking, so
+    // re-stat the file right before writing and bail if its mtime moved since
+    // we read it — someone else wrote settings.json in between, and a plain
+    // last-writer-wins here would silently drop their change.
+    if (existed && mtimeAtRead !== undefined) {
+        let mtimeNow;
+        try {
+            mtimeNow = statSync(settingsPath).mtimeMs;
+        } catch  {
+            mtimeNow = undefined;
+        }
+        if (mtimeNow !== undefined && mtimeNow !== mtimeAtRead) {
+            return {
+                status: "error",
+                detail: "settings.json cambió durante el merge — reintenta."
+            };
+        }
+    }
+    try {
+        writeFileAtomic(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+    } catch (err) {
+        return {
+            status: "error",
+            detail: errorMessage(err)
+        };
+    }
+    return {
+        status: existed ? "updated" : "created"
+    };
+}
+/**
+ * Symmetric counterpart to `mergeHooksIntoSettings`: strips every Argos-owned
+ * hook entry (any command matched by `isArgosOwnedHookCommand` against
+ * `hooksDir`, not just the current `HOOK_IDS`) out of `hooks.PreToolUse`,
+ * wherever it's found. Foreign hooks, buckets, and every other top-level key
+ * are left exactly as found — same ownership/refusal contract as the merge
+ * path:
+ * - `hooksDir` is the resolved `<claudeDir>/hooks` directory this install
+ *   manages (normally `join(resolveClaudeDir(), "hooks")`). A hook is only
+ *   ever treated as Argos-owned — and therefore deletable — when its script
+ *   path actually resolves inside `hooksDir` AND its basename starts with
+ *   `argos-`; this is deliberately NOT the same as `isArgosHookCommand`'s
+ *   bare `/hooks/argos-` substring match, which would also match (and
+ *   delete) an unrelated user hook at a path like
+ *   `/Users/x/my/hooks/argos-custom.sh`.
+ * - Missing file, or no `hooks`/`hooks.PreToolUse` at all → "unchanged",
+ *   nothing to remove.
+ * - Corrupt JSON (unparsable, not an object, `hooks` present but not an
+ *   object, or `hooks.PreToolUse` present but not an array) → `status:
+ *   "error"`, writes NOTHING. Never guess at a shape it can't verify.
+ * - A `PreToolUse` bucket that becomes empty after removing Argos's own
+ *   entries is dropped entirely (it only ever existed to hold them — see
+ *   `mergeHooksIntoSettings`, which creates a fresh bucket per matcher on
+ *   demand); a bucket that still has foreign hooks left (including one with
+ *   ZERO Argos-owned hooks in it) keeps its matcher, its hooks, and its
+ *   position untouched.
+ * - Same mtime concurrency guard and atomic write as the merge path.
+ */ export function removeAllArgosHooksFromSettings(settingsPath, hooksDir, options = {}) {
+    if (!existsSync(settingsPath)) return {
+        status: "unchanged",
+        removedCount: 0
+    };
+    let raw;
+    let mtimeAtRead;
+    try {
+        raw = readFileSync(settingsPath, "utf-8");
+        mtimeAtRead = statSync(settingsPath).mtimeMs;
+    } catch (err) {
+        return {
+            status: "error",
+            detail: errorMessage(err),
+            removedCount: 0
+        };
+    }
+    let settings;
+    try {
+        const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw);
+        if (!isPlainObject(parsed)) {
+            return {
+                status: "error",
+                detail: "settings.json existente no es un objeto JSON — arreglalo a mano.",
+                removedCount: 0
+            };
+        }
+        settings = parsed;
+    } catch (err) {
+        return {
+            status: "error",
+            detail: `settings.json existente tiene JSON inválido (${errorMessage(err)}) — arreglalo a mano.`,
+            removedCount: 0
+        };
+    }
+    if (settings.hooks !== undefined && !isPlainObject(settings.hooks)) {
+        return {
+            status: "error",
+            detail: "settings.json tiene hooks que no es un objeto — arreglalo a mano.",
+            removedCount: 0
+        };
+    }
+    const hooksRoot = settings.hooks;
+    if (!hooksRoot) return {
+        status: "unchanged",
+        removedCount: 0
+    };
+    const preToolUseRaw = hooksRoot.PreToolUse;
+    if (preToolUseRaw !== undefined && !Array.isArray(preToolUseRaw)) {
+        return {
+            status: "error",
+            detail: "settings.json tiene hooks.PreToolUse que no es un array — arreglalo a mano.",
+            removedCount: 0
+        };
+    }
+    if (!Array.isArray(preToolUseRaw) || preToolUseRaw.length === 0) {
+        return {
+            status: "unchanged",
+            removedCount: 0
+        };
+    }
+    let removedCount = 0;
+    const nextPreToolUse = [];
+    for (const bucket of preToolUseRaw){
+        if (!isPlainObject(bucket) || !Array.isArray(bucket.hooks)) {
+            nextPreToolUse.push(bucket);
+            continue;
+        }
+        const before = bucket.hooks.length;
+        const filteredHooks = bucket.hooks.filter((h)=>!(isPlainObject(h) && isArgosOwnedHookCommand(h.command, hooksDir)));
+        removedCount += before - filteredHooks.length;
+        if (filteredHooks.length === 0) continue; // bucket only ever held Argos's own entries
+        nextPreToolUse.push({
+            ...bucket,
+            hooks: filteredHooks
+        });
+    }
+    if (removedCount === 0) return {
+        status: "unchanged",
+        removedCount: 0
+    };
+    if (options.dryRun) return {
+        status: "removed",
+        removedCount
+    };
+    hooksRoot.PreToolUse = nextPreToolUse;
+    settings.hooks = hooksRoot;
+    options.onBeforeWrite?.();
+    // Same cheap concurrency guard as mergeHooksIntoSettings.
+    let mtimeNow;
+    try {
+        mtimeNow = statSync(settingsPath).mtimeMs;
+    } catch  {
+        mtimeNow = undefined;
+    }
+    if (mtimeNow !== undefined && mtimeNow !== mtimeAtRead) {
+        return {
+            status: "error",
+            detail: "settings.json cambió durante el remove — reintenta.",
+            removedCount: 0
+        };
+    }
+    try {
+        writeFileAtomic(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+    } catch (err) {
+        return {
+            status: "error",
+            detail: errorMessage(err),
+            removedCount: 0
+        };
+    }
+    return {
+        status: "removed",
+        removedCount
+    };
+}
+
+//# sourceMappingURL=settings-merge.js.map

package/dist/lib/settings-merge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/settings-merge.ts"],"sourcesContent":["import { existsSync, readFileSync, statSync } from \"node:fs\";\nimport { basename, isAbsolute, relative, resolve, sep } from \"node:path\";\nimport { writeFileAtomic } from \"./atomic-write.js\";\n\n/**\n * Surgical merge of Argos's `hooks.PreToolUse` entries into\n * `~/.claude/settings.json` — the JSON analogue of the managed-block model\n * used for CLAUDE.md (see `lib/markers.ts`): Argos manages only its own\n * entries and leaves every other key, hook, and array position in the\n * user's file untouched.\n *\n * Ownership identification: a hook command is Argos-owned when it points at\n * a script under `.../hooks/argos-*` — `isArgosHookCommand` below is the\n * general check (any Argos hook), while the merge itself pins each entry to\n * ONE specific `scriptPath`, so re-running `argos init` updates the exact\n * same array slot instead of appending a duplicate.\n */\n\nconst ARGOS_HOOK_PATH_RE = /\\/hooks\\/argos-/;\nconst BASH_HOOK_COMMAND_RE = /^bash \"(.+)\"$/;\nconst ARGOS_HOOK_BASENAME_RE = /^argos-/;\n\n/**\n * True when a hook `command` string points at an Argos-owned script (`.../hooks/argos-*`).\n *\n * This is a bare substring match — good enough for the non-destructive\n * `doctor` diagnostic that uses it, but NOT anchored to any real directory.\n * Destructive operations (deleting hook entries from the user's\n * settings.json) must use `isArgosOwnedHookCommand` below instead, which\n * requires the script to actually resolve inside the managed hooks\n * directory.\n */\nexport function isArgosHookCommand(command: unknown): command is string {\n  return typeof command === \"string\" && ARGOS_HOOK_PATH_RE.test(command);\n}\n\n/** Extract the script path from Argos's own `bash \"<scriptPath>\"` hook command shape (see `buildHookCommand`). */\nfunction extractBashScriptPath(command: string): string | undefined {\n  return BASH_HOOK_COMMAND_RE.exec(command)?.[1];\n}\n\n/** True when `candidate` resolves to a path inside (a descendant of) `dir`, via real path resolution — not string matching. */\nfunction isPathInsideDir(candidate: string, dir: string): boolean {\n  const rel = relative(resolve(dir), resolve(candidate));\n  if (rel === \"\" || isAbsolute(rel)) return false;\n  return rel !== \"..\" && !rel.startsWith(`..${sep}`);\n}\n\n/**\n * True when a hook `command` string is Argos-owned for the purposes of\n * DESTRUCTIVE removal: it must match Argos's own `bash \"<scriptPath>\"`\n * invocation shape, have a basename starting with `argos-`, AND resolve to a\n * location actually inside `hooksDir` (the real, resolved\n * `<claudeDir>/hooks` directory this install manages).\n *\n * This is intentionally stricter than `isArgosHookCommand`/`ARGOS_HOOK_PATH_RE`,\n * which only substring-match `/hooks/argos-` anywhere in the command string.\n * A user's own hook living at an unrelated path that happens to contain that\n * substring — e.g. `/Users/x/my/hooks/argos-custom.sh`, which is NOT under\n * the managed hooks directory — would false-match the substring check and be\n * silently deleted. Anchoring to the resolved hooks directory (via\n * `path.resolve` + an ancestor check, not `.includes()`) closes that hole.\n */\nfunction isArgosOwnedHookCommand(command: unknown, hooksDir: string): command is string {\n  if (typeof command !== \"string\") return false;\n  const scriptPath = extractBashScriptPath(command);\n  if (!scriptPath) return false;\n  if (!ARGOS_HOOK_BASENAME_RE.test(basename(scriptPath))) return false;\n  return isPathInsideDir(scriptPath, hooksDir);\n}\n\nexport interface ArgosHookSpec {\n  /** Absolute path to the installed hook script, e.g. `<claudeDir>/hooks/argos-guard-destructive.sh`. */\n  scriptPath: string;\n  /** Claude Code hook matcher, e.g. \"Bash\". */\n  matcher: string;\n  /** Hook timeout in seconds (Claude Code's own outer bound on the hook process). */\n  timeout?: number;\n  statusMessage?: string;\n}\n\nexport type SettingsMergeStatus = \"created\" | \"updated\" | \"unchanged\" | \"error\";\n\nexport interface SettingsMergeResult {\n  status: SettingsMergeStatus;\n  detail?: string;\n}\n\nexport interface MergeHooksOptions {\n  /**\n   * Script paths whose entries should be stripped out of `hooks.PreToolUse`\n   * entirely (not overwritten with a new `specs` entry — REMOVED), wherever\n   * they're found. Used by `argos init` for a hook whose script write just\n   * failed: an entry pointing at a script that doesn't exist (or is broken)\n   * is a dangling PreToolUse entry that hard-blocks every Bash call, whether\n   * it was never written this run or used to work and just broke.\n   */\n  removeScriptPaths?: string[];\n  /**\n   * Test-only seam: invoked immediately before the pre-write mtime re-check\n   * (see the concurrency guard below), so a test can simulate a concurrent\n   * writer racing this merge — mutate `settingsPath` from inside the\n   * callback, then let the merge proceed and observe it refuse. Never used\n   * outside tests.\n   */\n  onBeforeWrite?: () => void;\n}\n\nfunction isPlainObject(v: unknown): v is Record<string, unknown> {\n  return typeof v === \"object\" && v !== null && !Array.isArray(v);\n}\n\nfunction buildHookCommand(spec: ArgosHookSpec): Record<string, unknown> {\n  const hook: Record<string, unknown> = { type: \"command\", command: `bash \"${spec.scriptPath}\"` };\n  if (spec.timeout !== undefined) hook.timeout = spec.timeout;\n  if (spec.statusMessage !== undefined) hook.statusMessage = spec.statusMessage;\n  return hook;\n}\n\nfunction errorMessage(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n\n/**\n * Merge `specs` into `settingsPath` (normally `resolveClaudeDir()/settings.json`).\n *\n * - Missing file → starts from `{}` (created).\n * - An existing hook entry whose command already targets a spec's\n *   `scriptPath` → overwritten in place, at its current array index (never\n *   moved, never removed).\n * - No existing entry for a spec → appended into the first `PreToolUse`\n *   bucket whose `matcher` equals the spec's matcher, or a new bucket is\n *   pushed at the end of `PreToolUse` if none matches. Every other bucket,\n *   hook, and top-level key is left exactly as found.\n * - `options.removeScriptPaths` → any existing entry whose command targets\n *   one of those paths is stripped out entirely (not replaced) — for a hook\n *   whose script write just failed, so it never leaves a dangling entry.\n * - Corrupt JSON (unparsable, not an object, `hooks` present but not an\n *   object, or `hooks.PreToolUse` present but not an array) → returns\n *   `status: \"error\"` and writes NOTHING. Never clobber a file the caller\n *   can't safely reason about, and never silently discard a foreign `hooks`\n *   value just because its shape is unexpected.\n * - Concurrency guard: the file's mtime is captured at read time and\n *   re-checked immediately before the write; if it moved, someone else wrote\n *   settings.json in the meantime and this call refuses with `status:\n *   \"error\"` rather than silently clobbering that write (last-writer-wins).\n * - The write itself is atomic (temp file + rename, see\n *   lib/atomic-write.ts) — a crash mid-write can never leave settings.json\n *   torn, which would otherwise hard-block every subsequent Bash call.\n *\n * The file is always re-serialized with 2-space indentation on a write —\n * this normalizes the user's original formatting/whitespace, but every key\n * and value it did not own is preserved (structurally byte-identical\n * content, not necessarily byte-identical bytes).\n */\nexport function mergeHooksIntoSettings(\n  settingsPath: string,\n  specs: ArgosHookSpec[],\n  options: MergeHooksOptions = {},\n): SettingsMergeResult {\n  const existed = existsSync(settingsPath);\n  let raw = \"{}\";\n  let mtimeAtRead: number | undefined;\n  if (existed) {\n    try {\n      raw = readFileSync(settingsPath, \"utf-8\");\n      mtimeAtRead = statSync(settingsPath).mtimeMs;\n    } catch (err) {\n      return { status: \"error\", detail: errorMessage(err) };\n    }\n  }\n\n  let settings: Record<string, unknown>;\n  try {\n    const parsed: unknown = raw.trim().length === 0 ? {} : JSON.parse(raw);\n    if (!isPlainObject(parsed)) {\n      return { status: \"error\", detail: \"settings.json existente no es un objeto JSON — arreglalo a mano.\" };\n    }\n    settings = parsed;\n  } catch (err) {\n    return {\n      status: \"error\",\n      detail: `settings.json existente tiene JSON inválido (${errorMessage(err)}) — arreglalo a mano y volvé a correr argos init.`,\n    };\n  }\n\n  const before = JSON.stringify(settings);\n\n  if (settings.hooks !== undefined && !isPlainObject(settings.hooks)) {\n    return {\n      status: \"error\",\n      detail: \"settings.json tiene hooks que no es un objeto — arreglalo a mano.\",\n    };\n  }\n  const hooksRoot: Record<string, unknown> = isPlainObject(settings.hooks)\n    ? (settings.hooks as Record<string, unknown>)\n    : {};\n\n  const preToolUseRaw = hooksRoot.PreToolUse;\n  if (preToolUseRaw !== undefined && !Array.isArray(preToolUseRaw)) {\n    return {\n      status: \"error\",\n      detail: \"settings.json tiene hooks.PreToolUse que no es un array — arreglalo a mano.\",\n    };\n  }\n  const preToolUse: unknown[] = Array.isArray(preToolUseRaw) ? preToolUseRaw : [];\n\n  const removeScriptPaths = options.removeScriptPaths ?? [];\n  if (removeScriptPaths.length > 0) {\n    for (const bucket of preToolUse) {\n      if (!isPlainObject(bucket) || !Array.isArray(bucket.hooks)) continue;\n      bucket.hooks = (bucket.hooks as unknown[]).filter((h) => {\n        if (!isPlainObject(h) || typeof h.command !== \"string\") return true;\n        const command = h.command;\n        return !removeScriptPaths.some((p) => command.includes(p));\n      });\n    }\n  }\n\n  for (const spec of specs) {\n    const desired = buildHookCommand(spec);\n\n    // Find our own previous entry anywhere in PreToolUse (matched by\n    // scriptPath), to update it in place without moving it.\n    let found = false;\n    for (const bucket of preToolUse) {\n      if (!isPlainObject(bucket) || !Array.isArray(bucket.hooks)) continue;\n      const bucketHooks = bucket.hooks as unknown[];\n      const idx = bucketHooks.findIndex(\n        (h) => isPlainObject(h) && typeof h.command === \"string\" && h.command.includes(spec.scriptPath),\n      );\n      if (idx >= 0) {\n        bucketHooks[idx] = desired;\n        found = true;\n        break;\n      }\n    }\n\n    if (!found) {\n      let bucket = preToolUse.find(\n        (b): b is Record<string, unknown> => isPlainObject(b) && b.matcher === spec.matcher && Array.isArray(b.hooks),\n      );\n      if (!bucket) {\n        bucket = { matcher: spec.matcher, hooks: [] };\n        preToolUse.push(bucket);\n      }\n      (bucket.hooks as unknown[]).push(desired);\n    }\n  }\n\n  hooksRoot.PreToolUse = preToolUse;\n  settings.hooks = hooksRoot;\n\n  if (existed && JSON.stringify(settings) === before) {\n    return { status: \"unchanged\" };\n  }\n\n  options.onBeforeWrite?.();\n\n  // Cheap concurrency guard: this is a read-modify-write with no locking, so\n  // re-stat the file right before writing and bail if its mtime moved since\n  // we read it — someone else wrote settings.json in between, and a plain\n  // last-writer-wins here would silently drop their change.\n  if (existed && mtimeAtRead !== undefined) {\n    let mtimeNow: number | undefined;\n    try {\n      mtimeNow = statSync(settingsPath).mtimeMs;\n    } catch {\n      mtimeNow = undefined;\n    }\n    if (mtimeNow !== undefined && mtimeNow !== mtimeAtRead) {\n      return {\n        status: \"error\",\n        detail: \"settings.json cambió durante el merge — reintenta.\",\n      };\n    }\n  }\n\n  try {\n    writeFileAtomic(settingsPath, `${JSON.stringify(settings, null, 2)}\\n`);\n  } catch (err) {\n    return { status: \"error\", detail: errorMessage(err) };\n  }\n\n  return { status: existed ? \"updated\" : \"created\" };\n}\n\nexport type RemoveHooksStatus = \"removed\" | \"unchanged\" | \"error\";\n\nexport interface RemoveHooksResult {\n  status: RemoveHooksStatus;\n  detail?: string;\n  /** Count of Argos-owned hook entries actually removed (0 for \"unchanged\"/\"error\"). */\n  removedCount: number;\n}\n\nexport interface RemoveHooksOptions {\n  /**\n   * Compute what WOULD be removed without writing anything — `argos remove`'s\n   * preview mode. Corrupt-JSON refusal still applies identically in dry-run:\n   * a caller must not be told \"removed\" for a file it can't safely reason\n   * about.\n   */\n  dryRun?: boolean;\n  /** Same test-only seam as `MergeHooksOptions.onBeforeWrite` above. */\n  onBeforeWrite?: () => void;\n}\n\n/**\n * Symmetric counterpart to `mergeHooksIntoSettings`: strips every Argos-owned\n * hook entry (any command matched by `isArgosOwnedHookCommand` against\n * `hooksDir`, not just the current `HOOK_IDS`) out of `hooks.PreToolUse`,\n * wherever it's found. Foreign hooks, buckets, and every other top-level key\n * are left exactly as found — same ownership/refusal contract as the merge\n * path:\n * - `hooksDir` is the resolved `<claudeDir>/hooks` directory this install\n *   manages (normally `join(resolveClaudeDir(), \"hooks\")`). A hook is only\n *   ever treated as Argos-owned — and therefore deletable — when its script\n *   path actually resolves inside `hooksDir` AND its basename starts with\n *   `argos-`; this is deliberately NOT the same as `isArgosHookCommand`'s\n *   bare `/hooks/argos-` substring match, which would also match (and\n *   delete) an unrelated user hook at a path like\n *   `/Users/x/my/hooks/argos-custom.sh`.\n * - Missing file, or no `hooks`/`hooks.PreToolUse` at all → \"unchanged\",\n *   nothing to remove.\n * - Corrupt JSON (unparsable, not an object, `hooks` present but not an\n *   object, or `hooks.PreToolUse` present but not an array) → `status:\n *   \"error\"`, writes NOTHING. Never guess at a shape it can't verify.\n * - A `PreToolUse` bucket that becomes empty after removing Argos's own\n *   entries is dropped entirely (it only ever existed to hold them — see\n *   `mergeHooksIntoSettings`, which creates a fresh bucket per matcher on\n *   demand); a bucket that still has foreign hooks left (including one with\n *   ZERO Argos-owned hooks in it) keeps its matcher, its hooks, and its\n *   position untouched.\n * - Same mtime concurrency guard and atomic write as the merge path.\n */\nexport function removeAllArgosHooksFromSettings(\n  settingsPath: string,\n  hooksDir: string,\n  options: RemoveHooksOptions = {},\n): RemoveHooksResult {\n  if (!existsSync(settingsPath)) return { status: \"unchanged\", removedCount: 0 };\n\n  let raw: string;\n  let mtimeAtRead: number;\n  try {\n    raw = readFileSync(settingsPath, \"utf-8\");\n    mtimeAtRead = statSync(settingsPath).mtimeMs;\n  } catch (err) {\n    return { status: \"error\", detail: errorMessage(err), removedCount: 0 };\n  }\n\n  let settings: Record<string, unknown>;\n  try {\n    const parsed: unknown = raw.trim().length === 0 ? {} : JSON.parse(raw);\n    if (!isPlainObject(parsed)) {\n      return {\n        status: \"error\",\n        detail: \"settings.json existente no es un objeto JSON — arreglalo a mano.\",\n        removedCount: 0,\n      };\n    }\n    settings = parsed;\n  } catch (err) {\n    return {\n      status: \"error\",\n      detail: `settings.json existente tiene JSON inválido (${errorMessage(err)}) — arreglalo a mano.`,\n      removedCount: 0,\n    };\n  }\n\n  if (settings.hooks !== undefined && !isPlainObject(settings.hooks)) {\n    return {\n      status: \"error\",\n      detail: \"settings.json tiene hooks que no es un objeto — arreglalo a mano.\",\n      removedCount: 0,\n    };\n  }\n  const hooksRoot = settings.hooks as Record<string, unknown> | undefined;\n  if (!hooksRoot) return { status: \"unchanged\", removedCount: 0 };\n\n  const preToolUseRaw = hooksRoot.PreToolUse;\n  if (preToolUseRaw !== undefined && !Array.isArray(preToolUseRaw)) {\n    return {\n      status: \"error\",\n      detail: \"settings.json tiene hooks.PreToolUse que no es un array — arreglalo a mano.\",\n      removedCount: 0,\n    };\n  }\n  if (!Array.isArray(preToolUseRaw) || preToolUseRaw.length === 0) {\n    return { status: \"unchanged\", removedCount: 0 };\n  }\n\n  let removedCount = 0;\n  const nextPreToolUse: unknown[] = [];\n  for (const bucket of preToolUseRaw) {\n    if (!isPlainObject(bucket) || !Array.isArray(bucket.hooks)) {\n      nextPreToolUse.push(bucket);\n      continue;\n    }\n    const before = bucket.hooks.length;\n    const filteredHooks = (bucket.hooks as unknown[]).filter(\n      (h) => !(isPlainObject(h) && isArgosOwnedHookCommand(h.command, hooksDir)),\n    );\n    removedCount += before - filteredHooks.length;\n    if (filteredHooks.length === 0) continue; // bucket only ever held Argos's own entries\n    nextPreToolUse.push({ ...bucket, hooks: filteredHooks });\n  }\n\n  if (removedCount === 0) return { status: \"unchanged\", removedCount: 0 };\n  if (options.dryRun) return { status: \"removed\", removedCount };\n\n  hooksRoot.PreToolUse = nextPreToolUse;\n  settings.hooks = hooksRoot;\n\n  options.onBeforeWrite?.();\n\n  // Same cheap concurrency guard as mergeHooksIntoSettings.\n  let mtimeNow: number | undefined;\n  try {\n    mtimeNow = statSync(settingsPath).mtimeMs;\n  } catch {\n    mtimeNow = undefined;\n  }\n  if (mtimeNow !== undefined && mtimeNow !== mtimeAtRead) {\n    return {\n      status: \"error\",\n      detail: \"settings.json cambió durante el remove — reintenta.\",\n      removedCount: 0,\n    };\n  }\n\n  try {\n    writeFileAtomic(settingsPath, `${JSON.stringify(settings, null, 2)}\\n`);\n  } catch (err) {\n    return { status: \"error\", detail: errorMessage(err), removedCount: 0 };\n  }\n\n  return { status: \"removed\", removedCount };\n}\n"],"names":["existsSync","readFileSync","statSync","basename","isAbsolute","relative","resolve","sep","writeFileAtomic","ARGOS_HOOK_PATH_RE","BASH_HOOK_COMMAND_RE","ARGOS_HOOK_BASENAME_RE","isArgosHookCommand","command","test","extractBashScriptPath","exec","isPathInsideDir","candidate","dir","rel","startsWith","isArgosOwnedHookCommand","hooksDir","scriptPath","isPlainObject","v","Array","isArray","buildHookCommand","spec","hook","type","timeout","undefined","statusMessage","errorMessage","err","Error","message","String","mergeHooksIntoSettings","settingsPath","specs","options","existed","raw","mtimeAtRead","mtimeMs","status","detail","settings","parsed","trim","length","JSON","parse","before","stringify","hooks","hooksRoot","preToolUseRaw","PreToolUse","preToolUse","removeScriptPaths","bucket","filter","h","some","p","includes","desired","found","bucketHooks","idx","findIndex","find","b","matcher","push","onBeforeWrite","mtimeNow","removeAllArgosHooksFromSettings","removedCount","nextPreToolUse","filteredHooks","dryRun"],"mappings":"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"}

package/dist/lib/version.d.ts

@@ -0,0 +1,3 @@
+/** Read the `@argos/cli` package version (used to stamp every marker Argos writes). */
+export declare function readCliVersion(fromUrl?: string): string;
+//# sourceMappingURL=version.d.ts.map

package/dist/lib/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/lib/version.ts"],"names":[],"mappings":"AAIA,uFAAuF;AACvF,wBAAgB,cAAc,CAAC,OAAO,GAAE,MAAwB,GAAG,MAAM,CASxE"}

package/dist/lib/version.js

@@ -0,0 +1,13 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolvePackageRoot } from "./package-root.js";
+/** Read the `@argos/cli` package version (used to stamp every marker Argos writes). */ export function readCliVersion(fromUrl = import.meta.url) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(resolvePackageRoot(fromUrl), "package.json"), "utf-8"));
+        return pkg.version ?? "0.0.0";
+    } catch  {
+        return "0.0.0";
+    }
+}
+
+//# sourceMappingURL=version.js.map

package/dist/lib/version.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/version.ts"],"sourcesContent":["import { readFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { resolvePackageRoot } from \"./package-root.js\";\n\n/** Read the `@argos/cli` package version (used to stamp every marker Argos writes). */\nexport function readCliVersion(fromUrl: string = import.meta.url): string {\n  try {\n    const pkg = JSON.parse(readFileSync(join(resolvePackageRoot(fromUrl), \"package.json\"), \"utf-8\")) as {\n      version?: string;\n    };\n    return pkg.version ?? \"0.0.0\";\n  } catch {\n    return \"0.0.0\";\n  }\n}\n"],"names":["readFileSync","join","resolvePackageRoot","readCliVersion","fromUrl","url","pkg","JSON","parse","version"],"mappings":"AAAA,SAASA,YAAY,QAAQ,UAAU;AACvC,SAASC,IAAI,QAAQ,YAAY;AACjC,SAASC,kBAAkB,QAAQ,oBAAoB;AAEvD,qFAAqF,GACrF,OAAO,SAASC,eAAeC,UAAkB,YAAYC,GAAG;IAC9D,IAAI;QACF,MAAMC,MAAMC,KAAKC,KAAK,CAACR,aAAaC,KAAKC,mBAAmBE,UAAU,iBAAiB;QAGvF,OAAOE,IAAIG,OAAO,IAAI;IACxB,EAAE,OAAM;QACN,OAAO;IACT;AACF"}

package/dist/lib/which.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check whether a binary exists in PATH without spawning a shell — safer
+ * than `execSync('command -v ...')`, which risks shell interpretation of the
+ * name. Used to gate `argos workspace agents --apply` on the `openclaw`
+ * binary being present before it tries to spawn it.
+ */
+export declare function hasBinary(name: string): boolean;
+//# sourceMappingURL=which.d.ts.map

package/dist/lib/which.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"which.d.ts","sourceRoot":"","sources":["../../src/lib/which.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAoB/C"}

package/dist/lib/which.js

@@ -0,0 +1,30 @@
+import { existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Check whether a binary exists in PATH without spawning a shell — safer
+ * than `execSync('command -v ...')`, which risks shell interpretation of the
+ * name. Used to gate `argos workspace agents --apply` on the `openclaw`
+ * binary being present before it tries to spawn it.
+ */ export function hasBinary(name) {
+    const pathEnv = process.env.PATH ?? "";
+    const sep = process.platform === "win32" ? ";" : ":";
+    const dirs = pathEnv.split(sep).filter(Boolean);
+    const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";") : [
+        ""
+    ];
+    for (const dir of dirs){
+        for (const ext of exts){
+            const candidate = join(dir, name + ext);
+            if (existsSync(candidate)) {
+                try {
+                    if (statSync(candidate).isFile()) return true;
+                } catch  {
+                // Race between existsSync and statSync (file removed) — keep looking.
+                }
+            }
+        }
+    }
+    return false;
+}
+
+//# sourceMappingURL=which.js.map

package/dist/lib/which.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/which.ts"],"sourcesContent":["import { existsSync, statSync } from \"node:fs\";\nimport { join } from \"node:path\";\n\n/**\n * Check whether a binary exists in PATH without spawning a shell — safer\n * than `execSync('command -v ...')`, which risks shell interpretation of the\n * name. Used to gate `argos workspace agents --apply` on the `openclaw`\n * binary being present before it tries to spawn it.\n */\nexport function hasBinary(name: string): boolean {\n  const pathEnv = process.env.PATH ?? \"\";\n  const sep = process.platform === \"win32\" ? \";\" : \":\";\n  const dirs = pathEnv.split(sep).filter(Boolean);\n  const exts =\n    process.platform === \"win32\" ? (process.env.PATHEXT ?? \".COM;.EXE;.BAT;.CMD\").split(\";\") : [\"\"];\n\n  for (const dir of dirs) {\n    for (const ext of exts) {\n      const candidate = join(dir, name + ext);\n      if (existsSync(candidate)) {\n        try {\n          if (statSync(candidate).isFile()) return true;\n        } catch {\n          // Race between existsSync and statSync (file removed) — keep looking.\n        }\n      }\n    }\n  }\n  return false;\n}\n"],"names":["existsSync","statSync","join","hasBinary","name","pathEnv","process","env","PATH","sep","platform","dirs","split","filter","Boolean","exts","PATHEXT","dir","ext","candidate","isFile"],"mappings":"AAAA,SAASA,UAAU,EAAEC,QAAQ,QAAQ,UAAU;AAC/C,SAASC,IAAI,QAAQ,YAAY;AAEjC;;;;;CAKC,GACD,OAAO,SAASC,UAAUC,IAAY;IACpC,MAAMC,UAAUC,QAAQC,GAAG,CAACC,IAAI,IAAI;IACpC,MAAMC,MAAMH,QAAQI,QAAQ,KAAK,UAAU,MAAM;IACjD,MAAMC,OAAON,QAAQO,KAAK,CAACH,KAAKI,MAAM,CAACC;IACvC,MAAMC,OACJT,QAAQI,QAAQ,KAAK,UAAU,AAACJ,CAAAA,QAAQC,GAAG,CAACS,OAAO,IAAI,qBAAoB,EAAGJ,KAAK,CAAC,OAAO;QAAC;KAAG;IAEjG,KAAK,MAAMK,OAAON,KAAM;QACtB,KAAK,MAAMO,OAAOH,KAAM;YACtB,MAAMI,YAAYjB,KAAKe,KAAKb,OAAOc;YACnC,IAAIlB,WAAWmB,YAAY;gBACzB,IAAI;oBACF,IAAIlB,SAASkB,WAAWC,MAAM,IAAI,OAAO;gBAC3C,EAAE,OAAM;gBACN,sEAAsE;gBACxE;YACF;QACF;IACF;IACA,OAAO;AACT"}

package/dist/lib/workspaces.d.ts

@@ -0,0 +1,133 @@
+export declare const WORKSPACES_FILENAME = "workspaces.json";
+export interface WorkspaceMatch {
+    remotes: string[];
+    paths: string[];
+}
+export interface WorkspaceRepoEntry {
+    name: string;
+    path: string;
+}
+export interface WorkspaceEntry {
+    match: WorkspaceMatch;
+    repos: WorkspaceRepoEntry[];
+}
+/** `name -> workspace` machine-local registry, per spec 0003. */
+export type WorkspaceRegistry = Record<string, WorkspaceEntry>;
+/**
+ * Thrown by `loadRegistry` when `workspaces.json` exists but isn't valid
+ * JSON. Typed so callers can tell "the registry is corrupt" apart from any
+ * other unexpected throw and surface a clean, structured message instead of
+ * an unhandled parse-error stack trace.
+ */
+export declare class RegistryError extends Error {
+    constructor(message: string);
+}
+/**
+ * Load `~/.argos/workspaces.json`. A missing file is a fresh install —
+ * returns `{}`. Throws `RegistryError` when the file exists but isn't valid
+ * JSON — callers must not let that crash bubble up as a raw stack trace
+ * (see commands/workspace.ts, commands/doctor.ts, commands/adopt.ts).
+ */
+export declare function loadRegistry(): WorkspaceRegistry;
+/** Persist the registry (pretty JSON, trailing newline), creating `~/.argos` if needed. */
+export declare function saveRegistry(registry: WorkspaceRegistry): void;
+export interface ResolveWorkspaceInput {
+    /** An explicit name the user passed on the command line, e.g. `workspace link bonum`. */
+    explicit?: string;
+    /** The `workspace` field from the repo's argos.config.json, if set. */
+    configWorkspace?: string;
+    /** The repo's `origin` remote URL, if it has one. */
+    remoteUrl?: string | null;
+    /** Absolute path to the repo, used for path-based match rules. */
+    repoPath: string;
+}
+export type ResolveMatchSource = "match-remote" | "match-path";
+export type ResolveSource = "explicit" | "config" | ResolveMatchSource;
+export type ResolveWorkspaceResult = {
+    kind: "resolved";
+    name: string;
+    source: ResolveSource;
+} | {
+    kind: "ambiguous";
+    candidates: string[];
+    source: ResolveMatchSource;
+} | {
+    kind: "unresolved";
+};
+/**
+ * Resolve which workspace a repo belongs to, per spec 0003's chain:
+ * explicit name > `workspace` in argos.config.json > match rules (remote
+ * substring match first, path prefix/glob as fallback) > unresolved.
+ * 2+ candidates at a match stage is ambiguous — resolution never guesses
+ * between identities, it reports the candidates for the caller to surface.
+ */
+export declare function resolveWorkspaceForRepo(registry: WorkspaceRegistry, input: ResolveWorkspaceInput): ResolveWorkspaceResult;
+export type LinkAction = "added" | "updated-path" | "unchanged";
+export interface LinkRepoResult {
+    workspaceName: string;
+    createdWorkspace: boolean;
+    action: LinkAction;
+    previousPath?: string;
+    /** Normalized (absolute, symlink-resolved) repo path that was stored. */
+    repoPath: string;
+}
+export interface LinkRepoOptions {
+    /**
+     * Bypass the name-collision refusal below and overwrite the existing
+     * entry's path anyway. Mirrors `argos workspace link --force`.
+     */
+    force?: boolean;
+}
+/**
+ * Thrown by `linkRepo` when `repo.name` is already registered in
+ * `workspaceName` pointing at a DIFFERENT path that still exists on disk —
+ * i.e. two distinct physical repos colliding on the same `config.name`.
+ * Overwriting silently here would evict the old entry with no trace (data
+ * loss for whoever relies on it), so `linkRepo` refuses unless `force` is
+ * passed. Carries both paths so the caller can print a clear diagnostic.
+ */
+export declare class WorkspaceNameCollisionError extends Error {
+    readonly workspaceName: string;
+    readonly repoName: string;
+    readonly oldPath: string;
+    readonly newPath: string;
+    constructor(workspaceName: string, repoName: string, oldPath: string, newPath: string);
+}
+/**
+ * Register `repo` under workspace `workspaceName`, creating the workspace if
+ * it doesn't exist yet. Re-linking the same repo name updates its path
+ * (idempotent no-op when the path is unchanged). The path is normalized to
+ * an absolute, symlink-resolved form before it's stored — `workspace show`
+ * and `workspace agents` then compare disk state against exactly what's on
+ * record. Throws when `repo.path` doesn't exist on disk.
+ *
+ * When an entry with the same name already exists at a DIFFERENT path, and
+ * that old path still exists on disk with a different realpath, this
+ * refuses with `WorkspaceNameCollisionError` instead of silently evicting
+ * the old entry — unless `options.force` is set. If the old path is gone
+ * from disk, it's treated as a legitimate move (repo relocated) and updated
+ * as before, force or not.
+ */
+export declare function linkRepo(workspaceName: string, repo: WorkspaceRepoEntry, options?: LinkRepoOptions): LinkRepoResult;
+export interface OfferMatchRuleInput {
+    createdWorkspace: boolean;
+    /** True when the workspace name came from an explicit `link <name>` argument. */
+    viaExplicitName: boolean;
+    remoteUrl?: string | null;
+    currentMatch: WorkspaceMatch;
+}
+export interface OfferMatchRuleResult {
+    shouldPersist: boolean;
+    identity?: string;
+}
+/**
+ * Decide whether a newly-created workspace should learn the repo's remote as
+ * a match rule. Per spec: only offered when the workspace is brand new AND
+ * the name was given explicitly (so it isn't a false positive from a match
+ * rule that already matched something else) AND the repo actually has a
+ * parseable remote that isn't already recorded.
+ */
+export declare function offerMatchRule(input: OfferMatchRuleInput): OfferMatchRuleResult;
+/** Append `identity` to a workspace's `match.remotes`, if it isn't already there. */
+export declare function addRemoteMatchRule(workspaceName: string, identity: string): void;
+//# sourceMappingURL=workspaces.d.ts.map

package/dist/lib/workspaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaces.d.ts","sourceRoot":"","sources":["../../src/lib/workspaces.ts"],"names":[],"mappings":"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"}