@codyswann/lisa 2.189.6 → 2.189.8

package/plugins/src/rails/skills/e2e-coverage-gaps/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: e2e-coverage-gaps
-description: Playwright/e2e coverage-gap explorer that FEEDS THE LIFECYCLE. Use when asked to find paths the automated end-to-end suite does NOT cover — routes with no test at all, or flows that are only happy-path tested (missing error, validation, permission, empty, loading, and edge states). It inventories the app's routes and the existing Playwright tests, explores the running app to confirm each uncovered or under-covered path is real and reachable, and files one build-ready missing-test ticket per gap via lisa:tracker-write. For human usability/experience issues (confusing, cramped, or broken UI), use the exploratory-qa skill instead.
+description: Playwright/e2e coverage-gap explorer that FEEDS THE LIFECYCLE. Use when asked to find paths the automated end-to-end suite does NOT cover — routes with no test at all, or flows that are only happy-path tested (missing error, validation, permission, empty, loading, and edge states). It inventories the app's routes and the existing Playwright tests, explores the running app to confirm each uncovered or under-covered path is real and reachable, and files one build-ready missing-test ticket per gap via lisa-tracker-write. For human usability/experience issues (confusing, cramped, or broken UI), use the lisa-exploratory-qa skill instead.
 ---
 
 # E2E Coverage Gaps
@@ -14,7 +14,7 @@ is real and reachable, then file each gap as a **build-ready missing-test work i
 Lisa lifecycle.
 
 This skill is purely about **automated-coverage gaps**. It does not judge whether the UI is confusing
-or pretty — for human usability findings, use the `exploratory-qa` skill.
+or pretty — for human usability findings, use the `lisa-exploratory-qa` skill.
 
 ## Parameters
 
@@ -67,7 +67,7 @@ Map routes/flows against existing coverage and classify each gap:
 
 ### 6. File One Ticket Per Gap
 
-Each confirmed gap becomes a leaf **missing-test** work item created via `lisa:tracker-write` (the
+Each confirmed gap becomes a leaf **missing-test** work item created via `lisa-tracker-write` (the
 vendor-neutral writer — it dispatches to the configured tracker and runs the validation gate; never
 call a vendor `*-write-*` skill directly), `issue_type: Task`, **build-ready per the `ready` flag
 (default `true`)**. Pass `build_ready` explicitly on every create. Each ticket MUST specify:
@@ -101,5 +101,5 @@ No report file. Emit a concise in-session summary:
 - Every ticket must stand alone for an implementer who was not in the session and must be concretely
   automatable (named route, behavior, and stable hook).
 - Do not refile gaps already covered or already ticketed (marker check).
-- This skill is about automated coverage only — route human usability issues to `exploratory-qa`.
+- This skill is about automated coverage only — route human usability issues to `lisa-exploratory-qa`.
 - Preserve unrelated repo changes.

package/scripts/fix-namespace-test-assertions.mjs

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+/**
+ * Fix test assertions and a few skill references after lisa-* skill / lisa: command namespace migration.
+ */
+import { readFileSync, writeFileSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+/** @param {string} file */
+function patchFile(file, replacements) {
+  let content = readFileSync(file, "utf8");
+  let changed = false;
+  for (const [from, to] of replacements) {
+    if (content.includes(from)) {
+      content = content.split(from).join(to);
+      changed = true;
+    }
+  }
+  if (changed) {
+    writeFileSync(file, content);
+    console.log("patched", path.relative(ROOT, file));
+  }
+}
+
+const testPatches = [
+  // prd-verified-lifecycle-docs skill/agent paths
+  [
+    "tests/unit/strategies/prd-verified-lifecycle-docs.test.ts",
+    [
+      [
+        "`skills/${vendor}-prd-intake/SKILL.md`",
+        "`skills/lisa-${vendor}-prd-intake/SKILL.md`",
+      ],
+    ],
+  ],
+  // Skill invocation refs in tests (colon → hyphen for skills)
+  [
+    "tests/unit/strategies/prd-intake-s10-hard-gate.test.ts",
+    [
+      ["lisa:tracker-validate", "lisa-tracker-validate"],
+      ["lisa:task-decomposition", "lisa-task-decomposition"],
+    ],
+  ],
+  [
+    "tests/unit/strategies/github-linked-pr-project-membership.test.ts",
+    [["lisa:github-project-v2", "lisa-github-project-v2"]],
+  ],
+  [
+    "tests/unit/strategies/github-writer-project-membership.test.ts",
+    [["lisa:github-project-v2", "lisa-github-project-v2"]],
+  ],
+  // agent-transformer output uses normalized skill names
+  [
+    "tests/unit/codex/agent-transformer.test.ts",
+    [
+      [
+        'expect(instructions).toContain("- bug-triage");',
+        'expect(instructions).toContain("- lisa-bug-triage");',
+      ],
+      [
+        'expect(instructions).toContain("- tdd-implementation");',
+        'expect(instructions).toContain("- lisa-tdd-implementation");',
+      ],
+      [
+        'expect(instructions).toContain("- jsdoc-best-practices");',
+        'expect(instructions).toContain("- lisa-jsdoc-best-practices");',
+      ],
+    ],
+  ],
+  [
+    "tests/unit/opencode/agent-transformer.test.ts",
+    [
+      [
+        'expect(out).toContain("- codebase-research");',
+        'expect(out).toContain("- lisa-codebase-research");',
+      ],
+      [
+        'expect(out).toContain("- task-decomposition");',
+        'expect(out).toContain("- lisa-task-decomposition");',
+      ],
+    ],
+  ],
+  // Stack / codex tests: exploratory-qa is not lisa-prefixed in frontmatter
+  [
+    "tests/unit/codex/skill-frontmatter-parser.test.ts",
+    [['name: "lisa-exploratory-qa"', 'name: "exploratory-qa"']],
+  ],
+  [
+    "tests/unit/codex/skill-agents-walk.test.ts",
+    [
+      [
+        'const EXPLORATORY_QA = "lisa-exploratory-qa";',
+        'const EXPLORATORY_QA = "exploratory-qa";',
+      ],
+    ],
+  ],
+  // prd-intake-verify-dispatch: rule cites /lisa:verify-prd command
+  [
+    "tests/unit/strategies/prd-intake-verify-dispatch.test.ts",
+    [
+      [
+        'const VERIFY = "lisa-verify-prd";',
+        'const VERIFY = "/lisa:verify-prd";',
+      ],
+    ],
+  ],
+  // harper-fabric template script name unchanged
+  [
+    "tests/unit/strategies/harper-fabric-template-no-advisory-pollution.test.ts",
+    [['"lisa-verify"', '"verify"']],
+  ],
+  // cli doctor subcommand name unchanged
+  [
+    "tests/unit/cli/index.test.ts",
+    [
+      [
+        'expect.arrayContaining(["version", "update", "lisa-doctor"])',
+        'expect.arrayContaining(["version", "update", "doctor"])',
+      ],
+      [
+        '["lisa-doctor", DEST, "--json", "--offline"]',
+        '["doctor", DEST, "--json", "--offline"]',
+      ],
+    ],
+  ],
+  // usage-accounting openai token
+  [
+    "tests/unit/strategies/usage-accounting-skill.test.ts",
+    [['"Use $usage-accounting:', '"Use $lisa-usage-accounting:']],
+  ],
+];
+
+for (const [rel, replacements] of testPatches) {
+  patchFile(path.join(ROOT, rel), replacements);
+}
+
+// Stack e2e-coverage-gaps: skill refs use hyphen namespace
+for (const stack of ["expo", "rails", "harper-fabric"]) {
+  const skillPath = path.join(
+    ROOT,
+    "plugins/src",
+    stack,
+    "skills/e2e-coverage-gaps/SKILL.md"
+  );
+  patchFile(skillPath, [
+    ["lisa:tracker-write", "lisa-tracker-write"],
+    ["`exploratory-qa`", "`lisa-exploratory-qa`"],
+    ["exploratory-qa skill", "lisa-exploratory-qa skill"],
+  ]);
+}
+
+// Base writer skills: reference lisa-usage-accounting skill slug
+const writerSkills = [
+  "lisa-tracker-write",
+  "lisa-prd-source-write",
+  "lisa-github-write-prd",
+  "lisa-github-write-issue",
+  "lisa-linear-write-prd",
+  "lisa-linear-write-issue",
+  "lisa-jira-write-ticket",
+  "lisa-notion-write-prd",
+  "lisa-confluence-write-prd",
+];
+for (const slug of writerSkills) {
+  const skillPath = path.join(
+    ROOT,
+    "plugins/src/base/skills",
+    slug,
+    "SKILL.md"
+  );
+  patchFile(skillPath, [
+    ["`usage-accounting`", "`lisa-usage-accounting`"],
+    ["usage-accounting` contract", "lisa-usage-accounting` contract"],
+    ["shared `usage-accounting`", "shared `lisa-usage-accounting`"],
+  ]);
+}
+
+// prd-lifecycle-rollup Citation section skill slugs
+patchFile(
+  path.join(ROOT, "plugins/src/base/rules/reference/prd-lifecycle-rollup.md"),
+  [
+    ["(`prd-backlink`)", "(`lisa-prd-backlink`)"],
+    ["(`prd-ticket-coverage`)", "(`lisa-prd-ticket-coverage`)"],
+    ["(`github-prd-intake`)", "(`lisa-github-prd-intake`)"],
+    [
+      "(`linear-prd-intake`, `confluence-prd-intake`, `notion-prd-intake`)",
+      "(`lisa-linear-prd-intake`, `lisa-confluence-prd-intake`, `lisa-notion-prd-intake`)",
+    ],
+    ["(`repair-intake`)", "(`lisa-repair-intake`)"],
+  ]
+);
+
+console.log("done");

package/scripts/fix-test-assertions-pass2.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * Second-pass fixes for test files after skill/command namespace migration.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPO_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  ".."
+);
+const baseSkills = fs
+  .readdirSync(path.join(REPO_ROOT, "plugins/src/base/skills"))
+  .filter(n => n.startsWith("lisa-"))
+  .map(n => n.slice("lisa-".length));
+
+/** @param {string} s */
+function esc(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/** @param {string} content */
+function rewrite(content) {
+  let out = content;
+  for (const name of [...baseSkills].sort((a, b) => b.length - a.length)) {
+    const prefixed = `lisa-${name}`;
+
+    // Path segments
+    out = out.replace(
+      new RegExp(`skills/${esc(name)}/`, "g"),
+      `skills/${prefixed}/`
+    );
+    out = out.replace(
+      new RegExp(`skills/${esc(name)}",`, "g"),
+      `skills/${prefixed}",`
+    );
+    out = out.replace(
+      new RegExp(`readSkill\\([^,]+,\\s*"${esc(name)}"\\)`, "g"),
+      match => match.replace(`"${name}"`, `"${prefixed}"`)
+    );
+    out = out.replace(new RegExp(`"${esc(name)}"`, "g"), `"${prefixed}"`);
+    out = out.replace(new RegExp(`'${esc(name)}'`, "g"), `'${prefixed}'`);
+
+    // Skill-tool arming / invocation in tests
+    out = out.replace(
+      new RegExp(`skill=lisa:${esc(name)}`, "g"),
+      `skill=${prefixed}`
+    );
+
+    // Content assertions for migrated skill references (not slash commands)
+    out = out.replace(
+      new RegExp(`(?<!/|/)lisa:${esc(name)}(?![:/a-z])`, "g"),
+      prefixed
+    );
+    out = out.replace(
+      new RegExp(`toContain\\("lisa:${esc(name)}"\\)`, "g"),
+      `toContain("${prefixed}")`
+    );
+    out = out.replace(
+      new RegExp(`not\\.toContain\\("lisa:${esc(name)}"\\)`, "g"),
+      `not.toContain("${prefixed}")`
+    );
+  }
+
+  // Undo accidental double-prefix from repeated runs
+  out = out.replace(/lisa-lisa-/g, "lisa-");
+
+  return out;
+}
+
+/** @param {string} dir */
+function walk(dir) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) walk(p);
+    else if (entry.name.endsWith(".ts")) {
+      const original = fs.readFileSync(p, "utf8");
+      const updated = rewrite(original);
+      if (updated !== original) fs.writeFileSync(p, updated);
+    }
+  }
+}
+
+walk(path.join(REPO_ROOT, "tests"));
+console.log("Applied second-pass test fixes.");

package/scripts/fix-test-assertions.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPO_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  ".."
+);
+const baseSkills = fs
+  .readdirSync(path.join(REPO_ROOT, "plugins/src/base/skills"))
+  .filter(n => n.startsWith("lisa-"))
+  .map(n => n.slice("lisa-".length));
+
+/** @param {string} s */
+function esc(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/** @param {string} content */
+function rewrite(content) {
+  let out = content;
+  for (const name of [...baseSkills].sort((a, b) => b.length - a.length)) {
+    out = out.replace(
+      new RegExp(`/lisa:${esc(name)} skill`, "g"),
+      `/lisa-${name} skill`
+    );
+    out = out.replace(
+      new RegExp(`name:\\\\s\\*${esc(name)}(?![a-z0-9-])`, "g"),
+      `name:\\\\s*lisa-${name}`
+    );
+    out = out.replace(
+      new RegExp(`skills/${esc(name)}/`, "g"),
+      `skills/lisa-${name}/`
+    );
+    out = out.replace(
+      new RegExp(`\\["${esc(name)}",`, "g"),
+      `["lisa-${name}",`
+    );
+  }
+  return out;
+}
+
+/** @param {string} dir */
+function walk(dir) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) walk(p);
+    else if (entry.name.endsWith(".ts")) {
+      const original = fs.readFileSync(p, "utf8");
+      const updated = rewrite(original);
+      if (updated !== original) fs.writeFileSync(p, updated);
+    }
+  }
+}
+
+walk(path.join(REPO_ROOT, "tests"));
+console.log("Fixed test assertions.");

package/scripts/generate-codex-plugin-artifacts.mjs

@@ -219,7 +219,8 @@ const BRAND_NAMES = new Map([
  * @returns {string} The humanized, title-cased display name.
  */
 function humanizeName(raw) {
-  return raw
+  const stripped = raw.startsWith("lisa-") ? raw.slice("lisa-".length) : raw;
+  return stripped
     .split(/[-_\s]+/)
     .filter(word => word.length > 0)
     .map(word => {

package/scripts/migrate-skill-command-namespace.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+/**
+ * One-shot migration: namespace Lisa base-plugin skills and commands.
+ *
+ * - Skills: `implement` → `lisa-implement` (directory + frontmatter `name`)
+ * - Commands: nest under `commands/lisa/` for colon-scoped slash surfaces
+ * - Skill references: `lisa:foo-bar` → `lisa-foo-bar` (Skill tool / prose)
+ * - Command pass-throughs: `/lisa:foo-bar` → `/lisa-foo-bar` in delegator bodies
+ *
+ * @module scripts/migrate-skill-command-namespace
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPO_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  ".."
+);
+const BASE_SRC = path.join(REPO_ROOT, "plugins", "src", "base");
+const SKILLS_DIR = path.join(BASE_SRC, "skills");
+const COMMANDS_DIR = path.join(BASE_SRC, "commands");
+const LISA_COMMANDS_DIR = path.join(COMMANDS_DIR, "lisa");
+
+/** @param {string} name */
+function prefixedSkillName(name) {
+  return name.startsWith("lisa-") ? name : `lisa-${name}`;
+}
+
+/** Rename skill directories and frontmatter `name` fields. */
+function migrateSkills() {
+  const entries = fs
+    .readdirSync(SKILLS_DIR, { withFileTypes: true })
+    .filter(e => e.isDirectory())
+    .map(e => e.name)
+    .sort();
+
+  for (const oldName of entries) {
+    const newName = prefixedSkillName(oldName);
+    const oldDir = path.join(SKILLS_DIR, oldName);
+    const newDir = path.join(SKILLS_DIR, newName);
+    if (oldName !== newName) {
+      fs.renameSync(oldDir, newDir);
+    }
+    const skillMd = path.join(newDir, "SKILL.md");
+    if (!fs.existsSync(skillMd)) continue;
+    let content = fs.readFileSync(skillMd, "utf8");
+    content = content.replace(/^name:\s*.+$/m, `name: ${newName}`);
+    fs.writeFileSync(skillMd, content);
+  }
+}
+
+/** Move every command file under `commands/lisa/`, preserving subdirs. */
+function migrateCommands() {
+  if (!fs.existsSync(COMMANDS_DIR)) return;
+  fs.mkdirSync(LISA_COMMANDS_DIR, { recursive: true });
+
+  /** @param {string} dir @param {string} rel */
+  function walk(dir, rel = "") {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const entryRel = rel ? `${rel}/${entry.name}` : entry.name;
+      const src = path.join(dir, entry.name);
+      if (
+        entry.name === "lisa" &&
+        entry.isDirectory() &&
+        dir === COMMANDS_DIR
+      ) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        walk(src, entryRel);
+        continue;
+      }
+      if (!entry.name.endsWith(".md")) continue;
+      const dest = path.join(LISA_COMMANDS_DIR, entryRel);
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      fs.renameSync(src, dest);
+    }
+  }
+
+  walk(COMMANDS_DIR);
+
+  // Remove empty directories left behind (except commands/ and commands/lisa/).
+  /** @param {string} dir */
+  function pruneEmpty(dir) {
+    if (dir === COMMANDS_DIR || dir === LISA_COMMANDS_DIR) return;
+    if (!fs.existsSync(dir)) return;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) pruneEmpty(path.join(dir, entry.name));
+    }
+    if (fs.readdirSync(dir).length === 0) fs.rmdirSync(dir);
+  }
+  pruneEmpty(COMMANDS_DIR);
+}
+
+/**
+ * @param {string} content
+ * @returns {string}
+ */
+function rewriteSkillReferences(content) {
+  let out = content;
+
+  // Command pass-through delegators: `/lisa:foo` skill → `/lisa-foo` skill
+  out = out.replace(
+    /Use the \/lisa:([a-z][a-z0-9-]*) skill/g,
+    (_m, skill) => `Use the /${prefixedSkillName(skill)} skill`
+  );
+
+  // Inline skill refs without leading slash: `lisa:foo-bar` → `lisa-foo-bar`
+  // Skip slash commands like `/lisa:setup:jira` (multi-colon) and `/lisa:debrief:apply`.
+  out = out.replace(
+    /(?<![/:])lisa:([a-z][a-z0-9-]*)(?![a-z0-9-:])/g,
+    (_m, skill) => prefixedSkillName(skill)
+  );
+
+  return out;
+}
+
+/** Rewrite skill references across plugins/src/base. */
+function rewriteBaseReferences() {
+  /** @param {string} dir */
+  function walk(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const p = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(p);
+        continue;
+      }
+      if (!/\.(md|mdc|sh|json|agent\.md)$/i.test(entry.name)) continue;
+      const original = fs.readFileSync(p, "utf8");
+      const updated = rewriteSkillReferences(original);
+      if (updated !== original) fs.writeFileSync(p, updated);
+    }
+  }
+  walk(BASE_SRC);
+}
+
+migrateSkills();
+migrateCommands();
+rewriteBaseReferences();
+console.log("Migrated base plugin skill/command namespace.");

package/scripts/update-test-command-paths.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * Update test command paths after base-plugin command namespace migration.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPO_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  ".."
+);
+
+/** @param {string} content */
+function rewrite(content) {
+  let out = content;
+
+  // Base command paths: commands/<file> -> commands/lisa/<file>
+  out = out.replace(/commands\/((?!lisa\/)[^"'`\s]+\.md)/g, "commands/lisa/$1");
+
+  // Lifecycle skill folder reads: skills/<lifecycle>/SKILL.md in test arrays
+  for (const skill of [
+    "debrief",
+    "implement",
+    "intake",
+    "monitor",
+    "plan",
+    "research",
+    "verify",
+  ]) {
+    out = out.replace(
+      new RegExp(`(["\`])${skill}(["\`])`, "g"),
+      `$1lisa-${skill}$2`
+    );
+    out = out.replace(new RegExp(`/%s/${skill}"`, "g"), `/%s/lisa-${skill}"`);
+    out = out.replace(
+      new RegExp(`skills/${skill}/`, "g"),
+      `skills/lisa-${skill}/`
+    );
+  }
+
+  // Build-intake skills in orchestration tests
+  for (const skill of [
+    "github-build-intake",
+    "jira-build-intake",
+    "linear-build-intake",
+    "github-prd-intake",
+    "prd-backlink",
+    "tracker-write",
+    "usage-accounting",
+  ]) {
+    out = out.replace(
+      new RegExp(`skills/${skill}/`, "g"),
+      `skills/lisa-${skill}/`
+    );
+  }
+
+  // Command delegator expectations
+  out = out.replace(
+    /delegates to\s+\n?\s*`\/lisa:doctor`/g,
+    "delegates to `/lisa:doctor`"
+  );
+  out = out.replace(
+    /Use the \/lisa:doctor skill/g,
+    "Use the /lisa-doctor skill"
+  );
+
+  return out;
+}
+
+/** @param {string} dir */
+function walk(dir) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walk(p);
+      continue;
+    }
+    if (!/\.(ts|md)$/.test(entry.name)) continue;
+    const original = fs.readFileSync(p, "utf8");
+    const updated = rewrite(original);
+    if (updated !== original) fs.writeFileSync(p, updated);
+  }
+}
+
+walk(path.join(REPO_ROOT, "tests"));
+console.log("Updated test command paths.");

package/scripts/update-test-skill-paths.mjs

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * Update test file skill paths after base-plugin skill namespace migration.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPO_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  ".."
+);
+const BASE_SKILLS_DIR = path.join(
+  REPO_ROOT,
+  "plugins",
+  "src",
+  "base",
+  "skills"
+);
+
+const baseSkillNames = fs
+  .readdirSync(BASE_SKILLS_DIR, { withFileTypes: true })
+  .filter(e => e.isDirectory())
+  .map(e => e.name)
+  .filter(name => name.startsWith("lisa-"))
+  .map(name => name.slice("lisa-".length));
+
+/** @param {string} content */
+function rewrite(content) {
+  let out = content;
+  for (const name of baseSkillNames.sort((a, b) => b.length - a.length)) {
+    const oldPath = `skills/${name}/`;
+    const newPath = `skills/lisa-${name}/`;
+    out = out.split(oldPath).join(newPath);
+    // readSkill(root, "implement") style
+    out = out.replace(
+      new RegExp(`readSkill\\(([^,]+),\\s*"${name}"\\)`, "g"),
+      `readSkill($1, "lisa-${name}")`
+    );
+    out = out.replace(new RegExp(`%s/${name}"`, "g"), `%s/lisa-${name}"`);
+  }
+  return out;
+}
+
+/** @param {string} dir */
+function walk(dir) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walk(p);
+      continue;
+    }
+    if (!/\.(ts|md|sh)$/.test(entry.name)) continue;
+    const original = fs.readFileSync(p, "utf8");
+    const updated = rewrite(original);
+    if (updated !== original) fs.writeFileSync(p, updated);
+  }
+}
+
+walk(path.join(REPO_ROOT, "tests"));
+walk(path.join(REPO_ROOT, "plugins", "src", "base", "hooks"));
+console.log("Updated test and hook skill paths.");

package/plugins/lisa/commands/analyze-claude-remote.md

@@ -1,6 +0,0 @@
----
-description: "Audit whether this repository can run as a Claude Code remote routine (cloud session) and inventory everything Lisa AND the host project must install or configure in the cloud environment — CLIs/binaries, environment variables/secrets, startup hooks, MCP scope/auth, and the user-scoped config and auto-memory gaps that don't replicate remotely. Read-only; emits grouped findings plus a machine-readable inventory."
-argument-hint: "[--section=<name>] [--json]"
----
-
-Use the /lisa:analyze-claude-remote skill to audit this repository's readiness to run as a Claude Code remote routine and inventory what the cloud environment must install and configure. $ARGUMENTS