* feat(mcp): let mcp serve clients edit listed skills
A remote assistant that reaches skills only through `mcp serve` could
read them but had to hand every change back to a person (#540). Skills
listed in `mcp.serve.edit.skills` can now be changed one existing file
at a time: `preview_skill_edit` writes nothing and returns the full
diff, the audit result and a preview id, and `apply_skill_edit` saves
exactly that preview, once.
Every save is tied to the revision the client read, so a file changed
in the meantime fails with a conflict instead of being overwritten.
Skills that `update` would overwrite stay read-only: tracked repos,
upstream installs, and skills nested inside an install. The skill is
validated and audited in a temporary copy before anything is written;
as with install, a finding at or above `audit.block_threshold` refuses
the edit unless it was accepted with `--force`, and findings are marked
new or existing so the client can see what its change adds.
The write is atomic, keeps the file mode, goes through sourcefs link
checks, and is recorded in the operation log. Native Skills extension
clients still see the edit tools, since the extension cannot write.
* fix(mcp): close gaps in mcp serve skill editing
Codex review of #577 found five ways the edit tools could do more, or
record less, than they promise:
- A blank pattern in mcp.serve.edit.skills was dropped by the filter,
and no patterns match every skill, so `skills: [' ']` made every skill
editable. Blank patterns are now a config error.
- preview_ttl was only checked when skills were listed, so the dashboard
could save an invalid value that later stopped mcp serve. It is now
checked whenever edit is present.
- Apply compared only the edited file's digest, so two previews of
different files, or an edit made elsewhere in between, could save a
skill state that was never validated or audited. Apply now checks and
audits the skill again as it will be saved.
- Edit audits were not written to audit.log, so blocked attempts left no
trace in `skillshare log --audit`. Each preview and apply audit is now
logged like install's audit gate.
- The writability check migrated legacy metadata, so a "writes nothing"
preview (and --check) could rewrite .metadata.json and delete
registry.yaml. It now reads the store without migrating; a legacy
registry.yaml keeps every skill read-only, and a legacy sidecar marks
its skill as installed.
Clients and gateways that gate tools by annotation treat a tool without
readOnlyHint as one that changes data. Executor v2 does, so every
list_skills or read_skill call could stop for approval even though both
only read the skills source. Marking them read-only lets those clients
call them without asking. Refs: #540.
0.25.12 changes two things users can notice that the docs never covered.
Token auth now goes through a host-scoped credential helper (#566), so the
token stays out of ps and git skips the user's own helper or keychain for
that host. Grouped updates now warn when a repository cannot be fetched
(#570), with credentials removed from the URL and error. Note both on the
install and update pages in every locale.
* fix(update): stop trusting tree hashes for skills with symlinks
Install copies a file symlink's target, but git stores the link as a blob
holding the target path, so a skill's subtree hash stays the same when a
target outside the folder changes. Batch update skipped such skills as
current and check reported them up to date, leaving stale content installed.
A subdir that holds a symlink now has no usable tree hash: install records
none, update falls back to a reinstall, and check reports the skill as
update_available. Check lists entries with -z so links with non-ASCII names
are not missed behind git's path quoting.
Closes#572
* fix(check): split ls-tree -z output on NUL only
parseLsTreeOutput also split on newlines so the old newline fixtures kept
passing, but with -z a newline belongs to the path. A directory or symlink
whose name holds a newline was cut in two, and a symlink under it was missed.
The fixtures now use NUL-terminated entries like real -z output.
Also writes both shortcut comments in the repo's one-line form and uses
testutil.RunGit in the new update test instead of a raw exec call.
* docs(update): note that skills with symlinks always reinstall
The update page says grouped updates leave skills whose folder did not
change alone. A skill with a symlink no longer has a usable tree hash, so it
is reinstalled whenever the upstream commit moves. State that exception on
the English page and its four translations.
* fix(update): read store in batch fast path
The grouped update fast path read per-skill .skillshare-meta.json
sidecars. The migration to .metadata.json deletes those files, so the
check never matched and update --all reinstalled every skill on every
run.
Read the central store instead, and refresh version and commit there
instead of writing a sidecar. Require SKILL.md on disk so the update
restores a deleted install. --force now skips the check and reinstalls
everything.
* test(update): cover legacy grouped metadata keys
Grouped skills can still be stored under a basename key with a Group
field. Check that the current-skill lookup finds that entry and that the
version refresh updates it in place instead of adding a new key.
* feat(update): report up-to-date skills
The summary lumped skills the fast path skipped in with failures. Count
them as "up to date" in the summary and as up_to_date in --json
output.
* feat(update): log up-to-date count in oplog
The operations log recorded updated, skipped, pruned, and blocked counts
for update but not the new up-to-date count. Record it as up_to_date
so the log matches the summary and --json output.
* test(update): cover up-to-date batch skills
update --all reinstalled every grouped skill on every run. Check that
unchanged skills report as up to date in global and project mode, that
an upstream change updates only the changed skill, and that --force
reinstalls everything.
* docs(update): describe up-to-date batch skills
Describe how update --all and --group leave unchanged skills alone and
report them as up to date, the up_to_date JSON field, and the new
meaning of --force.
* fix(update): keep lock pins on tree-only matches
A tree-hash match after upstream HEAD moved refreshed the full commit in
the store. A project lock pin follows that field, so an unrelated
upstream commit rewrote skills.lock.json even though the skill's files
did not change. Refresh only the version, as the old sidecar refresh
did. check compares the version, so it still reports the skill as up to
date.
The help text, docs and skill reference said --all and --group skip
current skills. The skip lives in the batch path, which runs for any
update of several skills, and a single skill always takes the reinstall
path. Say that instead.
* fix(update): load the store once per batch
Each skill skipped as current reloaded .metadata.json before comparing
its version, so an unchanged batch reparsed the whole store once per
skill. Compare the version already read from the snapshot first, and
refresh the skills that do lag HEAD with one load and save after the
loop. An unchanged batch of 400 skills drops from about 520ms to 64ms.
The help text and docs said any update of several skills takes this
path. In global mode, named and glob targets carry no metadata and
reinstall on the standalone path. Name what does take it: --all,
--group, and several skills named in project mode.
---------
Co-authored-by: Willie <egg358358@gmail.com>
An already-running UI server still reads lazy-loaded chunks from its versioned cache after the CLI binary is upgraded. Preserve the pre-upgrade version alongside the downloaded version so upgrade cleanup does not break page navigation.
Add a multi-version cleanup regression test and document the retention policy and accepted consecutive-upgrade limitation across all website locales.
* feat(mcp): pin tool definitions in mcp check --live and warn when they change
An Agent reads a server's tool names and descriptions as instructions,
and a server can change them after the user reviewed it (a "rug pull").
The MCP spec 2026-07-28 local-server security guide notes the protocol
does nothing about this and advises clients that re-prompt on a changed
definition; most clients do not.
`mcp check --live` now records one SHA-256 per tool over name,
description and inputSchema the first time a server answers, in
mcp/tool-pins.json of the state directory, keyed by scope and server.
Later probes report a changed or new tool as a `tool-change` warning and
a removed one as info, until `--accept-tools` (only with --live) records
the current definitions. Without --live the pins are never read or
written. An unreadable pin file is never rewritten, since it may hold
other servers' pins. The dashboard words both warnings in every locale.
* fix(mcp): keep schema numbers exact, name the scope to accept in, and log acceptance
Codex review on #560:
- Tool definitions were decoded through float64 before hashing, so a
schema bound changed from 9007199254740992 to 9007199254740993 hashed
the same and raised no warning. Numbers now keep their literal text.
- The suggested accept command left out -g/-p; run from inside a project
after a global check, it would accept the project's server instead.
It now names the scope of the check that warned.
- Accepting changed tool definitions approves a possible rug pull, but
left no record. --accept-tools now writes an operations log entry with
the servers it accepted.
* fix(mcp): log a tool acceptance only when its baseline was saved
Codex review on #560: when comparing succeeded but writing tool-pins.json
failed (lock held, state directory unwritable), the report kept its
"accepted" finding, so the operations log listed the server as accepted
with status ok although its old pins remained. Such a server is now
logged under `failed` and the entry's status is error.
* fix(mcp): log first pins as accepted and report errors in the accept entry
Codex review on #560:
- A check that accepted one server but found an error on another still
logged status ok, while the command itself exited 1. A server with an
error is now listed under `failed` and the entry's status is error.
- --accept-tools on a server's first probe records its baseline, but the
finding says "pinned", so the entry listed nothing as accepted. A first
pin counts as accepted now.
* chore(release): request version 0.25.11
The MCP pin checks (#559, #560) and the backup staging fix (#558) ship
as 0.25.11 instead of the computed 0.26.0, per maintainer decision.
Release-As: 0.25.11
* feat(mcp): warn when a local server runs an unpinned package or image
An entry such as `npx -y some-mcp` fetches whatever the registry serves
at every Agent start, so a compromised release reaches the machine on the
next launch without anyone noticing. The MCP local-server security guide
(spec 2026-07-28) names version pinning as a baseline and points out
that a container tag can move while a digest cannot.
`mcp check` now adds a `pin` finding from command and args alone, with no
network: npx, uvx and `pipx run` with no version or `latest`, and
`docker`/`podman run` with no tag or `latest`, are warnings; an image
pinned by tag but not by `@sha256:` digest is info. Value-taking run
flags are skipped so hardened lines such as `--cap-drop ALL` are not read
as the image. Warnings keep the exit code at 0, as before.
* fix(mcp): check every npx package, word pin warnings in the dashboard, document them in doctor
Codex review on #559:
- npx accepts --package more than once and fetches each one, but the pin
check stopped at the first, so `npx --package=lodash@4.17.21
--package=cowsay cowsay` passed although cowsay is unpinned. Every
--package/-p value is now checked.
- The dashboard words env, command and dns findings in the viewer's
language but showed the new pin warning in English. It now has its own
sentence for an unversioned package and for an untagged image in every
locale. The dashboard hides info findings, so the digest note needs none.
- doctor promotes check warnings, so an unpinned launcher now shows there;
its docs list the pin check.
The mcp check runbook gains a step for the pin check.
* fix(mcp): check uvx --with packages and ignore environment markers in pins
Codex review on #559:
- uvx --with (-w) installs each named package beside the tool, so an
unpinned one moves just like an unpinned tool, but the pin check
skipped it as a flag value. Every --with requirement is now checked
next to the --from or command package.
- In `--from 'mcp-server; python_version == "3.12"'` the == belongs to
the environment marker, not to the package, yet it read as a pinned
version. Only the requirement before ';' is inspected now.
* fix(mcp): treat only exact versions as pins, and pin the docs' own examples
Codex review on #559:
- npm resolves a dist-tag (`@next`) or a range (`@^1.2.3`) to whatever
release matches at launch, yet any selector but `latest` passed as
pinned. An npx package is pinned now only by an exact semver version,
the rule Pi bindings already use.
- `==1.*` is a prefix match in Python version specifiers, so
`uvx --from 'mcp-server==1.*'` can pick up a new 1.x release; it is no
longer read as a pin.
- The Context7, Playwright and filesystem examples in the docs and the
built-in skill launched unpinned packages, so copying them produced the
new warning at once. They now name the current registry version.
* fix(backup): reclaim abandoned staging directories safely
Interrupted backup copies leave hidden .snapshot-* directories that retention cleanup never discovers. Hold a shared process lock during copies and use an exclusive cleanup lock to reclaim orphaned staging without deleting active work.
Share retention planning with non-mutating dry runs, report busy manual cleanup in the CLI and API, and align dashboard messages and translated docs. Cover process interruption and automatic cleanup with regression tests and an executable E2E runbook.
Closes#556
* fix(backup): address staging cleanup review findings
Keep cleanup reachable for staging-only dashboard backups and disclose abandoned incomplete directory deletion in every confirmation locale. Cover the empty-state confirmation with a regression test.
Read staging entries before a read-only lock probe so first-use dry runs cannot count a newly active writer. Refresh entries only under the acquired lock and classify both backup-root reads in the filesystem guard.
* fix(backup): align cleanup guides and doctor status
Disclose abandoned incomplete directory removal in backup help, completion descriptions, and the daily backup guide with all four translations. Add help and completion regressions so these consumers stay aligned with cleanup.
Keep the doctor Backups row visible when only the persistent lock remains after cleanup, preserving the existing JSON check and covering the lock-only state.
* fix(backup): complete cleanup documentation disclosure
Cleanup reclaims abandoned incomplete directories regardless of retention, so retention-only summaries understated the action. Align the backup synopsis, option table and previews, related workflow guides, built-in reference and all four website translations. Scope the retention defaults to completed snapshots.
* feat(mcp): open an Agent's MCP config folder, and project files, from the dashboard
A user who wants their own editor (Notepad++ on Windows) found setting
both PATH and $EDITOR too much just to open a config file, and could not
find any entry point for the MCP files of an mcp.projects root (#538).
Each Agent row on the MCP page now also has Open folder, which opens the
folder holding the file in the file manager, so any program can open it
from there. Before the Agent has written its file, it opens the closest
folder that exists. The project MCP tab gets the same Agents list for
that project's files. The open endpoint resolves project paths from the
config, as it does global ones, so a request still cannot name another
file, and folder and file opens keep the same-machine and headless
guards. The file manager launch is shared with the extensions folder.
* fix(mcp): keep a project's existing Agent files listed for remote viewers
Codex review: the project MCP tab built its Agents list from the
project's targets plus the files this viewer could open. A viewer on a
LAN address or behind a proxy can open none, so an existing file of an
Agent outside the project's targets dropped off the list, although the
docs say it shows with its path and only the open buttons go.
The list now returns which files exist apart from whether this viewer
may open them, and the page shows the open buttons only when local.
* fix(mcp): list the Agents a project's own servers write to in its file rail
Codex review: a server that exists only in one project can pick Agents
outside the project's targets, and sync writes their project files, but
the project tab listed only the project's targets and files that already
existed. Before the first sync such an Agent had no row, so its path
could not be copied and its folder could not be opened.
The list now also takes the targets of the project's own servers. Global
servers reach a project only through its targets, so they add nothing.
The rule lives in mcpView as projectFileTargets, with a unit test.
* feat(mcp): open an Agent's MCP config file from the dashboard
Users asked to jump from the MCP page straight into a client's config
file, such as opencode.json or .cursor/mcp.json, instead of copying the
path and opening it by hand (#538).
The open uses the same editor chain as a skill's Open in editor, so the
dashboard opens files one way. The endpoint takes a target, not a path,
and only opens a file the MCP page already lists. It answers only
requests from the machine running the dashboard, because the editor
starts on that machine. The list now reports which files exist, so the
button is hidden for a client detected before it has a file.
* fix(mcp): hide Open in editor where the server would refuse it
Codex review: the dashboard can be opened through a LAN IP, but the
open endpoint answers only loopback requests, so the button showed and
every click returned 403, while the docs promised it would open.
The list now reports `openable` instead of `existing`: the files that
exist, and only when the request comes from the dashboard's machine. A
viewer elsewhere does not see the button, and the docs say where it
appears.
* fix(mcp): don't treat a reverse proxy's viewers as local for Open in editor
Codex review: the documented Nginx and Caddy setups connect from
127.0.0.1, so the loopback socket check let any browser behind the proxy
see the button and launch editors on the server.
The browser now counts as local only when the socket and the Host it
used are both loopback and no proxy forwarding header is present. Both
documented proxies keep the browser's Host and add X-Real-IP or
X-Forwarded-For, so their viewers no longer qualify.
* fix(sync): limit project adoption writes to moved skills
A stale install record could trigger a full project reconcile during sync, adding unrelated remote installs to the manifest, ignore rules and lockfile. Skip project writes when nothing was re-keyed, and update only moved declarations, ignore rules and existing pins while preserving full explicit reconcile behavior.
Cover the visible project directory sharing its global source with byte-identical no-move checks and a real move that preserves unrelated entries and audit acceptances.
* fix(sync): preserve existing move destination declarations
The adoption-only config rewrite could duplicate a destination already declared in the project manifest. Keep that destination declaration and remove the moved old entry, matching full reconcile behavior while preserving the destination fields.
Add a regression that fails with duplicate entries and passes with the existing destination branch retained. Re-run make check after the fix.
* fix(plugin): accept OMP 18.6.1 and later instead of exactly 18.6.1
The OMP adapter pinned the native version to exactly 18.6.1, so every
newer release was refused: the dashboard reported "Installation requires
OMP 18.6.1" for a user on 18.8.7, and removal and standalone extension
selection were blocked the same way.
The sources the adapter depends on (marketplace cache/manager/types,
plugin-cli output, the project anchor in discovery/helpers.ts, extension
loading and the pi-natives file lock) are unchanged from v18.6.1 through
v18.10.2, so the pin is now a minimum. The install, removal and selection
gates share one check built on the existing plainVersion helper;
unparsable, prerelease and older versions stay blocked.
Messages, all dashboard locales, the plugin reference docs and the
built-in skill now state 18.6.1+. A test keeps the English guidance text
in en.json equal to the Go strings the dashboard matches on.
* fix(docs): record the OMP 18.6.1+ boundary in the cache safety report
The safety report still said installation is allowed only for OMP 18.6.1
and that an unknown version blocks it, which no longer matches the gate.
It now states the minimum, which versions stay blocked, and the source
comparison and native 18.8.7 run that justify replacing the pin. The two
OMP runbooks no longer require exactly 18.6.1.
* fix(mcp): turn off a global server in OpenCode 2 projects
OpenCode 2 replaces a global server with the project entry of the same
name, and silently drops an entry without its type and command or url.
The project switch Skillshare wrote, {"enabled": false}, therefore left
the server on in OpenCode 2, while OpenCode 1 merged it by field.
Checked against OpenCode 2.0.27 and 1.19.0: OpenCode 2 still reads the
flat mcp.<name> shape and turns enabled: false into disabled: true, and
both read an entry with type and command or url. So no version detection
is needed. When the global config under mcp.projects defines the server,
the OpenCode switch now carries its type and executable, or its url
without the query, next to enabled: false. Args, env, headers and the
query stay out of a project file that may be committed, as the Pi switch
once did. A switch that already carries the endpoint keeps it when the
global server later leaves the config, unless it was edited since sync.
In project mode, or when the global config lacks the server, only the
bare switch can be written; the plan now says OpenCode 2 ignores it, in
the CLI and the dashboard.
Import also reads OpenCode 2's mcp.servers section, which its own
`mcp add` writes, instead of reporting it as one broken server.
Refs #538
* fix(mcp): keep secrets in a URL path out of the OpenCode switch
The OpenCode switch dropped only the query of the global server's URL.
Some MCP services put the key in the path instead, and an absolute
executable path names the user's home directory; both then reached a
project file that may be committed. A disabled server never starts, and
OpenCode 2 accepts any type with a command or url, so the switch now
carries only the executable's name or the URL's scheme and host.
Refs #538
* fix(mcp): skip OpenCode 2's timeout defaults when importing
OpenCode 2 keeps server defaults in mcp.timeout next to mcp.servers, so
import listed timeout as a broken server. It is dropped only together
with a recognized servers section, where it cannot be a v1 server.
Refs #538
* fix(mcp): read an empty OpenCode 2 servers section
An empty mcp.servers object was not recognized as OpenCode 2's section,
so import listed servers and timeout as broken servers instead of
finding no entries. The dashboard help for disabled also still said only
the switch is written, which is no longer true for opencode.
Refs #538
* fix(mcp): keep an OpenCode endpoint switch next to its own fields
The kept switch was matched by the whole native entry, so a field only
OpenCode reads, such as a per-server timeout, made the next sync drop the
type and command or url once the global server left the config, and
OpenCode 2 then ignored the switch. Match the fields Skillshare manages.
Refs #538
* fix(mcp): show the OpenCode endpoint switch in the dashboard preview
The dashboard renders a project's server alone, so the preview never saw
the same-named global server and showed the bare switch that OpenCode 2
ignores, while sync wrote the switch with the endpoint. Resolve the
global server the way sync does.
Refs #538
* fix(plugin): read OpenCode 2's version output
OpenCode 2 prints "opencode v2.0.27" for --version, while OpenCode 1
prints only "1.19.0". The adapter trimmed a leading "v" only, so plugin
sync to OpenCode 2 failed as an unrecognized version and imported
updates were skipped as if OpenCode 1 had no update command. Read the
last field, and decide the update check with the same parser.
Refs #538
* feat(memory): add host-owned review and verification workflows
Share scoped memory tools between Dashboard and Memory, and route retrospective and Dreaming requests through the built-in skill. Keep agent execution in the host, require approval for reviewed edits, and preserve versioned CLI write safeguards.
Confirm scope before exposing prompts and include the resolved root in recent memory responses. Update provenance guidance and localized documentation, with regressions for unavailable scope and protected review prompts.
* fix(memory): distinguish trial copy controls for screen readers
Include the localized step title in each trial copy control accessible name while keeping the short visible label. Update the existing clipboard test selector for the distinct names; no new test or local test rerun was requested for this label-only fix.
* fix(memory): point connection hints to the trial tools
Replace stale verification-prompt directions in all eleven locales with the current Memory tools and Try across sessions labels. Interpolate the existing localized labels so future naming changes remain aligned.
No new tests or local test reruns for this copy-only correction, as requested by the maintainer.
A successful source update does not always require a target sync: existing symlinks already expose the updated content. Recheck the per-kind diff before offering Sync Now, refresh it when resources change, and report check failures without claiming targets are current.
Cover stale previews and post-sync dismissal with regression tests, and align the dashboard, workflow, source/target, and built-in skill documentation across locales.
Prefixed naming rewrites name: in every copy to the entry name, so the
target folder and name: always agree. Requiring name: to equal the source
folder only skipped skills it could sync: a tracked repo that is itself a
skill lives in _<repo>, so its root SKILL.md could never pass.
Only standard naming now requires the match; name format rules still
apply to both. Sync lists the skills named this way, so a user looking
for _ooux in the target finds ooux.
The dashboard's skipped-skills hint always blamed folders that end in the
same name, even when skills were skipped for their name. The diff API now
reports naming skips apart from collisions and the hint names the cause.
Refs #530
After a plain mv, only install or Install missing moved an installed skill's record; sync now adopts it too (CLI global, CLI project, dashboard), never prunes, and skips on --dry-run. A hand-moved project skill keeps its lock pin; a same-name nested skill never takes a live record; metadata load failures are sync warnings.
The locale builds have no translated move page, so its relative
.md links did not resolve and the website build failed; the
migration anchor it points at did not exist in the translated
headings. Use absolute doc links and give the heading an explicit
id in every locale, as the other cross-linked headings do.
Add skillshare move and POST /api/resources/batch/move so skills and
whole folders can change folder inside the source while keeping their
.metadata.json entry, accepted audit findings, lockfile pin, config
group, .gitignore and literal .skillignore lines. Moving by hand lost
the record and made the next install start over. install --into now
refuses a folder inside a skill or a tracked checkout.
Refs #510
#508 made --track --force clone first and replace the existing tracked repo
only after the clone succeeds, and refuse a local source (path or file://
URL) that is, or lies inside, that tracked repo. Users relying on --force to
recover a broken repo need to know the old one is kept on failure, and why a
source under the destination is rejected.
* fix(collect,install): collect only real skills; let --track take a local git path
collect treated every directory in a target as a local skill, so a scratch
folder was listed and `collect --force` copied it into the source. A folder
now counts only when it holds SKILL.md; the dashboard scan shares
FindLocalSkills and the dashboard collect request rejects such a folder.
`install /path/to/repo --track` failed with "requires a git repository
source" while file:///path worked. A local path that is a git repository
root is now normalized to the same file:// clone URL for --track (also past
the --branch guard); other local folders get an error that names file://.
Help text, docs (English and i18n) and the built-in skill reference follow.
* fix(install): keep the drive letter in file:// clone URLs for local --track paths
A Windows path such as C:/repo produced file://C:/repo, which makes C: the
URI authority instead of part of the path, so a tracked install from a local
Windows repository could clone the wrong location. Prefix the missing slash
so the URL is file:///C:/repo; POSIX paths are unchanged. Also cover the
dashboard install endpoint with a local-path --track test.
* fix(collect,install): keep UNC file URLs intact; require SKILL.md to be a file
The drive-letter fix lived in the helper shared with explicit file:// URLs,
which rewrote file://server/share/repo into a local path. Keep the slash
logic in the local-path --track case only and leave explicit URLs as parsed.
A subdirectory named SKILL.md passed the existence check, so a scratch folder
holding one was still collected. Both collect entry points (scan and the
dashboard request) now share sync.HasSkillFile, which rejects directories.
* fix(install): escape the local path in the file:// URL used by --track
Git decodes a file:// URL, so a repository path containing %20, %2F, a space
or # was cloned from a different path than the one IsGitRepo accepted. Build
the URL with net/url so those characters are escaped; drive-letter and POSIX
paths keep their form. The integration test now installs from a directory
whose name contains a space and a literal %20.
* fix(install): accept a local bare repository path for --track
A bare repository has HEAD and objects at its root but no .git entry, so the
local-path check rejected it while file:///same/path cloned fine. Add
IsLocalGitRepo (working tree or bare) and use it for both the --track
normalization and the --branch guard.
* test(install): build the bare repo path from a Windows file URL correctly
makeRemote returns file:///C:/dir on Windows; trimming only file:// left
/C:/dir, which filepath.Abs turned into D:\C:\dir, so the bare-repo test
failed on the Windows runner. Drop the slash before the drive letter.
* fix(install): refuse a --track local source that is the install destination
--force removes the tracked destination before cloning. When the local path
given to --track is that same directory, the removal deleted the only clone
source (and any unpushed work) before the clone failed. Compare the two with
os.SameFile, which also covers symlinked paths, and stop before touching the
destination.
* fix(install,collect): keep a tracked source inside its destination; reject special SKILL.md files
--track --force removed the destination before cloning, so a local source
nested below it (or given as an explicit file:// URL) was deleted along with
any unpushed work, and the clone then failed. Resolve the source and refuse
when it is the destination or lies under it, for dry runs too.
HasSkillFile used a not-a-directory test, so a FIFO named SKILL.md counted as
a skill and the collect copy blocked on it. Require a regular file; a
symlinked SKILL.md still resolves through os.Stat.
* fix(install): treat file://localhost URLs as local clone sources
Git clones file://localhost/path from the local filesystem, but the
containment guard only recognised an empty authority, so --track --force
could still delete a source given that way. Accept localhost (any case) as
local.
* test(install): build the localhost file URL from a slash path
On Windows the temp path starts with a drive letter, so prefixing it onto
file://localhost produced file://localhostC:\... instead of a valid URL and
the case failed on the Windows runner. Convert to slashes and add the
separator explicitly.
* fix(install): clone --track --force into a staging dir and swap it in last
--force removed the existing tracked repo before cloning, so any source that
lived under it (plain path, file:///, file://localhost, UNC, symlink or 8.3
alias) was destroyed before git could read it, and a failed clone also lost
the old repo. Clone beside the destination, run the checks and the audit on
the staging copy, then move the old repo aside, rename the new one in and
drop the backup; on any failure the staging copy is removed and the old repo
stays. The pre-removal containment refusal now covers plain local paths only
(the url.Parse special-casing is gone).
* fix(install): refuse a file:// --track source inside the forced destination
The staged swap in 7375400 still lost data for a file:///, file://localhost
or UNC source nested under the destination: the clone succeeded, the old repo
(with the source inside it) was renamed to the backup, and removing the backup
deleted the source's uncommitted work, which a clone cannot carry.
Restore the file URL to local path mapping (now including UNC hosts) so the
containment refusal covers every local spelling, not only plain paths. The
test now keeps an uncommitted file in the source and requires it to survive.
* fix(install): apply the source-inside-destination refusal only to --force
The refusal ran before the --update branch, so `install <tracked repo path>
--track --update` was rejected even though an update pulls the existing
checkout in place and removes nothing. Only the forced replacement can
destroy a source that lives under the destination, so check there.
* fix(install): report a forced clone's root skill under its tracked name
With --force the repo is discovered in the .skillshare-clone-<stamp> staging
directory, and discoverSkills names a root SKILL.md after the directory, so
the CLI summary, dashboard response and oplog listed a random staging name
instead of _foo. Use the tracked name for the root entry.
* fix(install): stage fresh tracked clones so cleanup never hits another installer
A fresh tracked install cloned straight into the destination, and the
deferred cleanup removed it on any failure. If another process created the
same tracked repo between the existence check and the clone, the failing
install deleted that process's checkout. Clone every install into its own
staging directory and rename it in last; a claimed destination makes the
rename fail and only the staging copy is removed.
* fix(sync): replace copy-mode copies with links when switching back to merge
Switching a target from copy back to merge left every copy whose entry name
did not change as a real folder. Merge sync treated it as the user's own
folder, so status and doctor kept saying "run skillshare sync" while sync
changed nothing, and only `sync --force` turned it into a link.
Copy mode already replaces merge-mode links with copies on its own, so merge
sync now replaces a folder the manifest records with a checksum (a copy-mode
copy) with a link, without --force. Folders the manifest does not record, or
records as a link, stay untouched. The pre-sync target backup is unchanged.
The CLI and dashboard diffs name these entries as copies sync replaces
instead of suggesting --force, and the sync-modes docs describe the switch.
* fix(sync): keep copy-mode copies the user edited when switching to merge
The first version replaced any folder the manifest recorded as a copy-mode
copy. The manifest checksum is only a record, so a copy edited since copy
mode made it was deleted too, and `sync --json` and project-mode dashboard
sync take no pre-sync backup to restore it from.
Replace the folder only while it still hashes to the recorded checksum
(Manifest.OwnsCopy). An edited copy is kept and `sync --force` still
replaces it; diff keeps suggesting --force for it. A copy whose name: was
rewritten by prefixed naming, or that was made with custom ignore patterns,
no longer hashes to the source checksum and is kept the same way.
* fix(ui): say a copy-mode copy in a merge target is replaced by a link
The Sync page picks a row's text from the diff item's action alone. The
copy-mode copy that merge sync now replaces comes from the server as an
update, which the page worded as "Link is broken or points elsewhere. Will
be relinked" even though no link exists yet.
Match the server's reason and show "Copy made by copy mode. Will be replaced
by a link" instead, in all eleven dashboard languages.
* docs(sync): say only unedited copy-mode copies are replaced on merge sync
The sync-modes paragraph promised that copies copy mode made are replaced
with links without --force. Merge sync keeps a copy that no longer hashes to
the checksum copy mode recorded, so an edited copy, or one whose name: copy
mode rewrote for prefixed naming, still needs --force.
State the three cases in sync-modes and qualify the diff Modified and Local
override labels, in English and the ja, ko, zh-Hans and zh-Hant copies.
* fix(sync): keep the copy until its replacement link exists
Replacing a copy-mode copy removed the folder first and then created the
link. If creating the link failed (no symlink or junction rights on a
Windows or network filesystem), sync returned an error with the skill gone
from the target. This path now also runs on a plain sync, not only on
--force.
Park the folder beside the entry, create the link, then delete the parked
folder; on failure the folder is moved back. A parked folder left by a run
that died mid-way may be the only copy, so the next sync stops with a message
instead of deleting it. The manifest also forgets the copy-mode mtime and
naming records of an entry that is now a link.
* test(sourcefs): register replaceWithLink's target writes in the raw-write ratchet
The previous commit moved the merge-mode folder replacement into
replaceWithLink, which the ratchet reports as new raw os calls and the old
os.RemoveAll allowance as stale. All of them act on the sync target, not the
skills source, like the neighbouring entries.
* fix(sync): bound the parked copy's name and document the naming exception
The folder parked while a link is created was named after the entry, so an
entry near the 255-byte filename limit (a long flattened nested skill)
could not be moved aside and its replacement failed. The parked name is now
a fixed-length hash of the entry name.
sync-modes also says what happens when `target_naming` changes in the same
sync: the copy gets a new entry name and the prune pass removes it as an
orphan whether or not it was edited, as it did before this change.
* feat(sync): make prefixed target naming misconfigurations visible
Prefixed naming (#497) works, but several of its failure modes only showed up
at sync time or gave advice that cannot be followed:
- A collision that only prefixing creates told the user to "rename one in
SKILL.md", which a tracked skill cannot do, and never said the prefix caused
it. The hint now names the prefixing and points at renaming the other skill or
re-tracking the repo with --name.
- `target add` silently wrote mode: copy when the inherited naming is prefixed.
The CLI now says so.
- A target that resolves to prefixed outside copy mode was reported only by
sync. status, doctor and target list (plain and JSON) now flag it, and the
sync/validation and `--skills=true` errors say how to fix it.
- The dim "duplicate skill names (isolated by ...)" line printed on every sync
even when nothing was wrong, and before a failing sync. Isolated duplicates
are not a problem, so it is dropped; the website docs still showed an
outdated form of this output and are corrected in all locales.
* fix(status): flag prefixed-outside-copy in the TUI list and status --json
Codex review of #503 found two surfaces the new check missed:
- The interactive `target list` (the default on a terminal) never read the
item's naming error, so a prefixed + merge target looked healthy there. The
list row now marks the mode with "!" and the detail panel shows the fix.
- `status --json` (global and project) builds its target entries directly, so
scripts got no signal. Each target now carries a `warning` string, matching
`target list --json`.
* docs(troubleshooting): sync no longer prints a message for isolated duplicates
The collision troubleshooting tip still said sync shows an info message when
filters isolate duplicate skill names. That line was dropped, so the tip now
says sync prints nothing about them. Codex review of #503 flagged the stale
English page and its four translations.
* fix(config): point managed-project naming errors at the project settings
The "set mode: copy on the target" hint is wrong for a target a global
`projects:` entry expands into: it cannot be edited with `target` or under
`targets:`, and the mode lives in the project's skills settings. The hint now
depends on whether the target belongs to a managed project (Codex review of
#503).
The naming/mode check becomes a TargetConfig method so status, doctor and
target list share it, which also lets the hint see the project root. Along the
way: doctor reuses it, the TUI list renders the mode once, and
reportTargetAdded takes a flag instead of comparing a mode string.
* fix(config): hint the project settings for managed-project naming errors
ProjectNamingError (the config-load check for a global `projects:` entry) still
returned the bare naming error, so a project that inherits prefixed with a
non-copy mode got no fix. It now names the project's skills settings, like the
expanded targets do. The built-in skill's sync reference also mentions that
status, doctor and target list flag the misconfiguration before sync.
Found by the second /code-review pass on #503.
* fix(sync): detect prefix collisions from the colliding paths
reportCollisions decided a collision came from prefixing when its name was not
also a duplicate in the source. A tracked skill that joined two ordinary
skills already sharing the name was therefore sent to the "rename one in
SKILL.md" hint, which a tracked skill cannot follow (Codex review of #503).
A collision on a prefixed target that includes a tracked path now gets the
tracked-skill hint, whatever else shares the name. The wording no longer claims
prefixing renamed the skill, since a name that already starts with the repo
name is unchanged.
* fix(sync): use discovered repo metadata for the tracked-skill hint
The collision hint treated any path segment starting with "_" as a tracked
repo, so an ordinary skill under a folder such as org/_drafts (no .git) was
told it could not be renamed and to re-track a repo that does not exist. It now
uses DiscoveredSkill.IsInRepo, the same signal prefixed naming uses.
The prefixed docs also gain the fix for a target a global `projects:` entry
expands into (projects.<root>.skills.mode: copy), since `target` cannot edit
those. Both from Codex review of #503.
* fix(sync): keep both collision hints when targets disagree
The same name can clash on a prefixed target with a tracked skill and on
another target between ordinary skills only. The prefixed flag was OR-ed across
targets, so the second case lost its rename/filter hint. Track both kinds
separately while grouping, and print each hint that applies (Codex review of
#503).
* fix(sync): keep the rename hint inside a mixed collision group
When a tracked skill and two ordinary skills share a prefixed name, re-tracking
the repo fixes only the tracked one; the ordinary pair still clashes and is
excluded. The group now also shows the rename/filter hint when at least two of
its participants are not tracked (Codex review of #503).
* fix(sync): offer filters in the tracked-skill collision hint
Two tracked skills of the same repo with the same name collide after
prefixing, and neither renaming a tracked skill nor re-tracking the repo
separates them. The hint now also names include/exclude filters, so every
collision on a prefixed target has an actionable remedy (Codex review of #503).
* docs(sync-modes): limit the target list claim to targets under targets
target list builds from the config without project expansion, so it cannot
flag a target a `projects:` entry expands into; status and doctor can. The
prefixed paragraph and the built-in skill reference said all three flag it
(Codex review of #503).
* fix(sync): close gaps found while simulating the prefixed naming switch
Simulating the #497 reporter's switch from merge + flat to copy + prefixed
turned up four problems:
- `target X --mode copy --target-naming prefixed` applied only --mode, since
the setter dispatch returned after the first flag. Both flags given
together now check the final pair, then apply in an order that keeps the
saved pair valid (copy mode first, any other mode last).
- Skipped skills were only counted, so a prefixed name over 64 characters
vanished with "1 skill(s) skipped". Sync now names the first five with
their reason; the cap keeps huge sources from flooding the output.
- In copy mode a merge-mode link to the skill was not a managed entry, so
when a local folder held the new name the old link was pruned and the
skill left the target, contrary to the documented "old managed entry is
preserved". Copy mode now migrates such links like managed copies.
- PATCH /api/targets validated the mode/naming pair against the current
skills state, so disabling skills while changing mode was rejected. It now
checks the state the request leaves the target in.
* docs(target): drop stray space in the Japanese mode+naming sentence
* fix(diff): save paired target settings once and report kept legacy entries
- `target X --mode M --target-naming N` ran the two setters, each saving
the config, so a failed second save left half the change behind (Codex
on #504). Both fields are now set and saved once, after the final pair
is checked.
- When a local folder holds the name a skill's naming now gives it, sync
keeps the skill under its old entry and leaves the folder alone, even
with --force. diff still called the folder a "local copy" and suggested
`sync --force`, which does nothing for it. CLI and Web API diff, copy
and merge mode, now report the folder and the entry the skill stays at.
* fix(sync): migrate only links the manifest records as merge-made
Copy mode treated any link to the skill's source at an old naming's name as
the entry merge mode left behind, so a user's own link was renamed and
replaced with a copy (Codex on #504). A link now migrates only when the
manifest records it as "symlink", which merge mode writes for links it makes;
other links stay as the user left them. The value is now a named constant.
* fix(diff): mark kept legacy entries as unaffected by force
Two problems Codex found on #504:
- The Web API diff sent a local folder on a skill's new name as a "skip",
which the dashboard shows as an edited entry that Force replaces. Sync
keeps that folder and the legacy entry even with force, so the preview
promised a change that never happens. It is now its own "kept" action,
shown with its reason and not counted.
- `target X --mode M --target-naming N` printed the target's own naming as
the old value, so a target inheriting standard or prefixed showed
"flat -> ...". It now prints the naming the target had in effect.
* fix(diff): keep kept-name conflicts out of the sync count
Two problems Codex found on #504:
- A local folder on a skill's new name counted toward "N to sync" and
fell through to the plain `skillshare sync` hint, though sync changes
nothing there until the folder is renamed or removed. Such rows now
carry a kept flag, count as neither sync nor local, and print their own
hint; a target whose only row is kept still shows that row.
- The dashboard grouped targets by row name and icon only, so two targets
keeping the same skill at different old entries merged and showed one
target's old location for both. The row detail is now part of the key.
* fix(diff): do not list a kept local folder's files as deletions
A kept row (a local folder on a skill's new name) still pointed at that
folder, so `diff --stat` and `--patch` listed each of its files as removed,
though sync never touches the folder (Codex on #504). Kept rows no longer
point at a target directory, so no file-level diff is built for them in the
CLI or the TUI.
* fix(diff): report kept skills consistently in every diff view
An exhaustive review of the kept-row change (prompted by two Codex findings
on #504) found the same gap in several places:
- A target whose only rows were kept was summarized as "in sync", and mixed
summaries left it out of every count. Such targets now count as "N kept
under old name" with a warning mark, and the scan progress counts them.
- Plain output and the TUI hid where the skill stays; rows now read
"name (stays at old-name)". The TUI also lacked the kept Next hint and
called kept-only targets "differs"; it now matches the plain output.
- `diff --json` emitted kept rows as "remove", indistinguishable from
local-only folders; it now emits "kept", as the Web API does. The diff
docs' JSON example also showed actions the CLI never emits.
- Renamed rows whose old entry is a merge-made link showed a bogus file
stat, because the link was walked as a file; a link now stands for the
folder it points to.
- A dry-run migration printed "Would copy" to the old path; it now names
the new one.
* fix(sync): stop reporting kept folders and skipped skills as pending work (#509)
Three reports told users to do something sync cannot do, or hid what it
did:
- Copy and merge sync kept a folder the user made on a skill's name but
counted it as "up to date" with no hint. Sync now counts it as local and
adds one capped line per target naming the folders and saying that
`sync --force` replaces them. The line is added in SyncSkillTarget, so
the dashboard gets it too.
- status and doctor counted skills that sync skips on purpose (invalid
names under standard or prefixed naming, name collisions) as "not
synced — run skillshare sync". Running sync can never add them, so the
advice looped. They now compare against the skills sync places.
- diff marked a target whose only items were local-only folders as "to
sync" and `synced: false`. Those items are still listed, but they no
longer make the target pending.
* fix(target): apply every setting flag, require flag values, report no-ops as unchanged (#507)
* fix(target): apply every setting flag, require flag values, report no-ops as unchanged
`skillshare target <name>` dispatched --mode, --agent-mode and
--target-naming through an if-chain that returned after the first match,
so `--agent-mode copy --target-naming prefixed` applied one setting and
silently dropped the other. Filters, --skills and --dry-run had the same
early-return problem.
- Check --mode, --agent-mode and --target-naming as a whole and save
once, in global and project mode (one targetSettingsUpdate replaces six
per-flag functions).
- Reject --mode/--agent-mode/--target-naming combined with filters or
--skills, and --dry-run without --skills, instead of dropping them.
- A value flag followed by another flag (or an empty string) now reports
"<flag> requires a value"; `--target-naming -p` used to report an
invalid naming '-p'.
- A value the target already has is reported as unchanged and the config
is not rewritten.
* fix(target): leave the skills pair alone on agents-only changes
A target with skills off may keep target_naming prefixed with a merge
mode it cannot sync; validateGlobalTarget and validateProjectTarget only
check that pair for enabled skills. The combined settings update ran the
pair check for every setting, so `target claude --agent-mode copy` was
refused on such a target although the old agent-mode handler never looked
at skills settings. Check the pair only when --mode or --target-naming is
given.
* docs(target): show combined settings in --help and the built-in skill
The combined --mode/--agent-mode/--target-naming form is now the way to
move a target to copy + prefixed in one step, but neither the help
examples nor the built-in skill's target reference showed it.
Sync re-copies a managed copy whose recorded naming differs from the
current one, for example after a migration stopped between the rename
and the re-copy. Diff skipped it on the mtime fast path and reported the
target in sync while its SKILL.md kept the old name. Check the recorded
naming first in both the CLI and the dashboard diff.
The command reference, both schemas and the dashboard field help still
said skills target naming is ignored in symlink mode, while prefixed is
refused there.
After target_naming changes, sync renames the managed entry in place,
but diff looked only under the new name, so the CLI and the dashboard
showed the skill as new while hiding the old entry. Resolve the legacy
entry and report it as a rename instead.
Codex review on #499: the conflict pages said "none of these matter in
symlink mode", which reads as if a symlink target and a merge or copy
target on one folder were fine too. Mode still conflicts there; only
filters and naming stop mattering when both targets use symlink.
The sync command page said filters keep flat names only for standard
naming; prefixed names target entries from SKILL.md as well, so the same
caveat applies. Translations follow.
A /simplify pass on #499 found the symlink exception too narrow: symlink
mode links the whole folder to the source and reads neither target naming
nor include/exclude, yet two symlink targets with different filters were
still reported as undoing each other. State the rule once (same symlink
mode means same folder contents) instead of exempting only naming, and
resolve the mode with cmp.Or like sync's isSymlinkMode rather than a
local copy of the sync package's resolver. Docs now say none of these
settings matter in symlink mode.
Users need to know when prefixed helps (same-named skills from different
tracked repos), what name it produces, that it is copy-only, and that
switching between any two namings now renames managed entries in place.
The translated pages follow, the ja and zh-Hans naming headings get an
explicit target-naming id so the new links resolve, and the target_naming
runbook gains steps for prefixed sync, flat -> prefixed -> standard
migration and the merge-mode rejection.
Codex review on #499: the troubleshooting and doctor pages explained the
conflict as one target adding what the other filters out, and offered
"give both targets the same filters" as a fix. When the conflict comes
from mode or target naming, that fix does nothing and the explanation
doesn't match what happens (entries renamed, links swapped for copies).
Describe the conflict as each sync undoing the other's work and say all
three settings must agree, in English and the four translations.
Codex review on #499: after 588d29c7 the conflict check skips
target_naming when the shared mode is symlink, but the doctor, sync and
troubleshooting pages (and their translations) still said any naming
difference makes shared targets undo each other. That could lead users
to turn off a valid symlink target, so qualify the rule.
The warning now reads "different settings", but the explanatory prose
around it in the doctor and common-errors pages still described the
conflict as include/exclude filters only. Name mode and target_naming
there as well, in English and the four translated doc sets.
Two targets writing one skills folder with different target_naming or
mode undo each other on every sync (flat links vs standard names, merge
vs copy), but only include/exclude were compared, so sync and doctor
fell back to the generic shared-path hint.
Compare the effective mode and target naming too, so an unset value
equals the default it resolves to. The global default mode is not
carried on the target, so SkillsFolderConflicts takes it from its three
callers. The warning now says "different settings" instead of "different
filters".
Fixes#498
The dashboard page reference did not mention Install all, Prune, Discard
all, the unmatched filter notice, Edit target/Edit extra, or that New
skill and Link folder moved into the Install menu, so readers had no way
to find them from the docs.
The CLI's `--remove-target --prune` removed a symlink-mode target no matter
where it pointed, while the dashboard removed it only when it still linked
to the extra's source folder. A user who repointed that link at their own
folder could lose it from the CLI. Both now go through one shared
sync.ClearExtraTarget, so the safer rule applies everywhere; the CLI warns
and leaves anything that is not a link to the source instead of failing.
Refs #491
A directory extra used to sync every file to every target, so a tool that
only wanted a few docs got the whole folder. Each target can now set
gitignore-style include/exclude patterns, matched on the path inside the
source. Merge targets prune links to files that stop matching; copy targets
keep earlier copies, since nothing records which copied files are ours.
Filters are rejected for symlink mode and single-file extras, and sync warns
when an include matches nothing.
The dashboard previously forced users to delete and re-add a target or an
extra to change it. Edit target now changes the folder, file name, mode,
flatten and filters with a live preview; Edit extra renames an extra or
points it at another source folder. A moved target or source drops the
links left at the old place and syncs right away.
CLI: --include/--exclude on extras init, and --add-include, --add-exclude,
--remove-include, --remove-exclude on extras <name>.
Refs #435
The 0.25.2 fixes changed behavior the command pages still described
the old way: update said any .git/ directory makes a tracked repo, the
uninstall Project Mode section missed --into repos and the refusal
inside a tracked repo, and the audit rule table lacked
prompt-injection-5. Also translate the uninstall example comments that
were left in English in ja, ko, zh-Hans and zh-Hant.
Reuse the shared tracked checkout resolver after checking the typed path so uninstall org/team finds org/_team without taking precedence over an existing skill or folder. Classify tracked targets by the underscore checkout rule across CLI uninstall entry points, retaining ambiguity errors and the shared inside-repo refusal.
Codex review of #481 found three problems with the shorthand change:
- `update org/team -p` and the dashboard stream updated the org/_team
repo even when a skill exists at org/team, which used to win because
the shorthand was not rewritten there. FindTrackedCheckoutUnlessSkill
skips the nested shorthand when a directory exists at the typed path;
plain names keep their repo-first behavior.
- Global `update team/` cleaned the name for repo matching but not for
skill matching, so it silently updated `_team` instead of reporting the
skill/repo collision that `update team` reports. resolveByBasename now
cleans the name once for both.
- The update.md example sits in the Project Mode section but lacked -p
(also in the four translations).
A repo installed with `--track --into org` lives at `org/_team`. Only
POST /api/update accepted `org/team`; the dashboard stream and
`update -p` prefixed the whole name (`_org/team`), and global `update`
compared the full name with the basename, so each reported not found.
Move the candidate rule (the name as typed, then `_` added to the last
segment, never leaving the source root) into install.FindTrackedCheckout
and the basename match into install.MatchTrackedRepos, and use them from
the single update, the stream, project and global CLI update. A shorthand
resolves to its own `org/_team`, never to a top-level `_team`; plain names
and full paths keep their behavior.
Avoid blocking legitimate Markdown SDK parameters and ambiguous disclosure advice by default while retaining visible HIGH findings and strict-policy gating. Preserve explicit concealment, custom severity overrides, and shell dataflow coverage in HTML and comments. Add regression coverage and document rule-ID compatibility.
The CLI removed any skill or folder inside a tracked repo on its own:
`skillshare uninstall _team/foo` moved the skill out of the repo's
checkout, and `_team/vendor/_lib` (a submodule) was even treated as a
tracked repo because the CLI marks every git checkout as one. Either way
the repo was left dirty for the next update. The dashboard already
refused single skills inside a repo, but the rule lived only in its
handler.
The rule now lives in internal/uninstall, which both the CLI and the
dashboard go through: an item below a "_"-prefixed git checkout fails
with ErrInsideRepo in Preflight and Run, even with --force. A followed
source link is the user's own checkout, so skills below it can still be
removed one at a time.
The uninstall reference documents the rule and how to name a repo
installed with --into, with ja/ko/zh-Hans/zh-Hant translations.
The dashboard now asks again and force-uninstalls a tracked repo with
uncommitted changes or an unreadable git status, and a project's
sources.mcp file is refused when it resolves outside the project. The
ui and mcp command pages did not say either.
The leak check compared only source skills, so a skill the user keeps
in ~/.claude/skills (which merge mode preserves) passed as harmless,
although OpenCode loads it. Read the writer's folder too and count
entries sync did not put there and OpenCode's own folder lacks.
The wording no longer says these skills are left out by filters, and
the suggestion asks to sync them to opencode, which fits both causes.
Refs #458