Return nonzero exit status for failed skill and agent checks while preserving JSON results. Propagate agent remote errors and prioritize dashboard check failures over the up-to-date summary.
Add regression coverage and document exit status in all command reference locales. Related to runkids/skillshare-app#85.
Nested packages sat in a grey inset panel and the folder tree drew one
straight line per level, so neither showed which row a child hangs from.
Both now use one faint spine under the parent with a rounded elbow into
each child that stops short of its checkbox or icon, in an opaque colour
so overlapping strokes leave no darker seam.
Opening and closing a package or folder now grows and shrinks instead of
jumping; collapsed content is inert while it shrinks, and reduced motion
turns the animation off. Nested row actions line up with top-level rows,
and a selected folder's block keeps straight sides.
* fix(ui): warn that uninstalling a package removes its nested skills
Uninstalling a skill moves its whole folder to the trash, so the skills
nested inside it go too, but the confirmation listed only the one skill.
It now counts them in the title, marks the package row and adds a note.
Selecting a package together with its nested skills (select all does this)
also sent every name to the server, which trashed the package first and
then failed on each child whose folder was already gone. The dialog now
sends only the outermost selected skills.
The success toast uses the same count as the title; it reported the
server's per-name count, which read as fewer removals than confirmed.
* fix(ui): keep nested skills of a linked folder root in uninstall
A linked folder whose root is itself a skill can only be unlinked, so the
server refuses to trash it. Collapsing the selection to that root dropped
its selected children from the request and none of them were removed.
A linked root no longer counts as holding its children: they are sent on
their own and the root row does not claim to remove them.
* feat(ui): show skill descriptions in the list and let expand all open packages
Reviewing a large library meant opening each detail page just to read
what a skill does (#627, proposal in #631). The resources list response
now carries each skill's and agent's frontmatter description, read in
the same pass as manual-only, and the list shows it truncated under the
name with the full text on hover.
The read now decodes the frontmatter once for both fields. An unquoted
": " in a description is invalid YAML, so a failed decode falls back to
the line scanner instead of dropping the description and manual-only.
Editing a skill refreshes the list too, so the new description shows
right away.
Expand all / Collapse all also opens and closes nested-skill packages
from #624; before, it only touched source and folder groups.
Closes#627
* feat(ui): redesign list packages as an inset panel with a description switch
The chevron-in-a-column nesting read as a second, unrelated table and gave
no room for the descriptions #627 asks for. A count pill after the package
name now opens its skills in one quiet inset panel, with deeper packages
indented under a faint guide, so the hierarchy stays readable at any depth.
The rest closes the gaps left against #627: a Show > Descriptions switch
keeps the compact list one click away, keyboard focus reveals the full
description, a search opens only the packages holding a match without
overwriting what the user left open, and the selection bar says how many
selected items are out of view. Only the name opens the detail page, since
whole-row clicks were easy to trigger by accident once rows held more text.
* fix(ui): keep linked-folder matches when searching a folder group
Searching while grouped by folder took package ancestors only from skills
whose folderOf matched the group key, but groupByFolder keys a linked
folder's skills by the link name. Every skill in a linked folder fell out
of its own group, so the header counted a match and drew no row. The
ancestor pool is now each folder group's unfiltered skills, keyed by
groupByFolder itself, which always contains the group's matches.
* fix(ui): keep the .ss-r .nm.m rule the design token export reads
Merging it into :is(.ss-r, .ss-nr) .nm.m removed the exact selector that
scripts/design/tokens.py looks up for the row name type scale, so the
design token tests failed in CI.
A package that ships its own SKILL.md plus nested skills used to list
every child as a peer, so one large package could fill the page and hide
which skills belong together (#624, proposal in #625).
The list view now puts each skill under the nearest skill whose folder
holds it, within its current group. Packages start collapsed with a
nested count, a search opens them so matches stay visible, and paging
counts top-level rows so a package is never split across pages.
Selection, select-all and bulk actions still work per skill.
Closes#624
* feat(check): show what changed in a skill since install
#622 made a hand-edited skill visible as modified and kept update from
overwriting it, but there was still no way to see the edits before
deciding to keep or discard them (#621).
LocalChanges compares the skill's files with the hashes recorded at
install, fetches the source at the recorded commit only when a recorded
file changed, and diffs each file against it, so the diff shows the
user's edits even after upstream moves on. A skill without a recorded
commit is refused rather than diffed against HEAD, which would show
upstream changes as the user's.
It backs `check <name> --diff`, GET /api/resources/{name}/local-changes,
and the dashboard: the Modified locally dialog on the skill page lists
the diffs, and the Updates tab links a modified skill to it. update's
skip hints now point at --diff. The route looks up the exact record and
refuses non-local names, so a nested or ../ path cannot borrow a
top-level skill's record or read outside the source. The file diff
helper moved to textdiff so the CLI and server share it.
* fix(install): diff local changes against the full installed commit
entry.Version holds the short SHA from `rev-parse --short`. A targeted
fetch needs the full SHA, so checkoutCommit fell back to fetching every
branch and tag with --unshallow: viewing one edited skill could download
the repository's whole history, and fail when the commit is only
reachable by its full SHA.
Use entry.Commit, the full SHA install records, when it is the same
commit as Version; a Commit left from an older install, or a legacy
record without one, falls back to Version.
* test(install): keep checkout line endings when editing in LocalChanges test
On Windows git checks the installed copy out with CRLF, so overwriting
SKILL.md with LF content made every line differ and the expected diff
failed. Edit the installed file in place, as an editor would, and compare
the diff without carriage returns.
* feat(update): flag and protect skills edited since install
A skill installed from a repository and then edited by hand looked
exactly like an untouched one: check said up to date, and update either
reported it current or silently reinstalled it over the edit (#621).
Install already records each file's hash, so check now compares a
remote skill's files with those hashes and reports "modified", and
update skips such a skill until --force (CLI single, --all/--group,
dashboard). --force, the dashboard's Force Retry on the skipped row, or
the confirmation on the skill page discards the edit and reinstalls.
Two hash paths had to be made reliable for this to be trusted: the
dashboard's folder-wide target edit refreshed hashes by basename, so a
nested skill looked edited after skillshare's own change, and a skill
whose files cannot be hashed now counts as modified instead of being
overwritten.
* fix(server): keep earlier local edits when a target change rewrites SKILL.md
Changing a skill's targets in the dashboard rewrites its SKILL.md, and
both the folder-wide and the single-skill handler then re-hashed the
whole directory as the new baseline. An edit the user had already made
to any file in the skill was absorbed into that baseline, so the skill
stopped counting as modified and the next update overwrote the edit
without --force.
Both handlers now move only SKILL.md's recorded hash, and only when the
file still matched it before the rewrite. skillshare's own target edit
no longer reads as a local change, and an earlier edit still does. The
whole-directory refresh helpers lost their last callers and are removed.
Importing one plugin per click closed the dialog each time, so the user
had to reopen it and scroll back to the next row. Ticked rows are now
imported in turn while the dialog stays open, and a blocked or failed row
stays ticked for a retry. Installs with resource filters still go through
the single reviewed import, because their preserved native fields need to
be seen first.
Release-As: 0.26.4
* fix(install): use frontmatter names for generic skill directories
Resolve meaningful defaults for generic containers while preserving explicit names, tracked paths, existing update destinations, and directory-based source selection. Fall back on unsafe or colliding names to prevent overwrites.
Cover global and project installs, local and Git sources, naming overrides, tracked reports, collision safety, and updates. Closes#616.
* fix(install): preserve names during source-based updates
Resolve source-based updates against existing metadata before choosing destinations. Reject ambiguous or colliding update targets before writes, and reserve case-insensitive discovery names across filesystems.
Add global/project regressions for local and Git source updates, legacy destinations, grouping, and upstream-added collisions.
* fix(install): retain update ownership and selection checks
Only allow a metadata-verified same-source update to bypass destination conflicts. Reject occupied fallback destinations for both local and Git sources unless overwrite is explicitly forced.
Resolve destinations after skill selection so unrelated conflicts do not block filtered updates. Cover cross-source and unmanaged destinations, selected/excluded updates, and collision aborts in global and project modes.
The Sync page offered "Stop syncing skills" for every target a folder
conflict asked to stop. For a project target that button opened the
skills-off dialog, whose preview and update calls the server refuses
with 400 because project targets are configured through their project.
Link those targets to their project's editor instead, and say so in the
doctor docs.
Fixes#612
* feat(targets): support OpenCode config directory accounts
OpenCode v2 introduces support for custom configuration directories
via OPENCODE_CONFIG_DIR, storing opencode.json and agent directories.
Previously, skillshare rejected OpenCode accounts configured with a
custom config directory because OpenCode was missing config_dir and
was excluded from accountAgents in hooks and MCP services.
- Define default config_dir (~/.config/opencode) in targets.yaml
- Add OpenCode to account agents and register OPENCODE_CONFIG_DIR
across hooks and MCP service handlers
- Route OpenCode account MCP configuration to opencode.json inside
the account config directory
Resolves#593.
* fix(targets): add OpenCode to schemas, completions and docs
Add opencode to the targetConfig.agent enum and config_dir description
in schemas/config.schema.json so configurations containing OpenCode
account targets pass schema validation.
Include opencode in the target --agent completion scripts for Bash,
Zsh, Fish, PowerShell, and Nushell.
Update website documentation and built-in skill references to describe
OpenCode accounts and OPENCODE_CONFIG_DIR management alongside other
account agents.
* fix(targets): support plugin accounts and overlap
Add OpenCode account recognition and OPENCODE_CONFIG_DIR resolution to
the plugin service so plugin sync works for OpenCode account targets.
Introduce TargetScanPaths to resolve cross-runtime scan paths using
TargetConfig.Agent for account targets while retaining the account's
own primary directory. Update path overlap detection, doctor checks,
and LeakedSkills to warn about leaked skills for account targets.
Update localized docs (zh-Hans, zh-Hant, ja, ko) and plugin references
to document OpenCode account targets and OPENCODE_CONFIG_DIR. Update
the available targets handler test to expect OpenCode's configDir.
* fix(targets): isolate OpenCode accounts and scan paths
Reject OPENCODE_CONFIG overrides when operating on OpenCode accounts
and clear OPENCODE_CONFIG in the account execution environment so
plugin operations target the account directory.
In TargetScanPaths, remap config-root paths to the account directory
while preserving external scan paths like Codex's ~/.agents/skills.
* fix(plugins): use account target in OpenCode update probe
Pass c.Target instead of a hardcoded "opencode" when probing whether
OpenCode supports plugin updates, ensuring account-configured CLI
binaries and account environment variables are used during preview.
* test(mcp): isolate XDG_CONFIG_HOME in account test service
Isolate XDG_CONFIG_HOME to the temporary test directory in
agentAccountService to prevent runner environment variables from leaking
into TestAccountEnvOverrideDoesNotPruneDefaultHome when testing OpenCode
account shell overrides.
---------
Co-authored-by: Willie <egg358358@gmail.com>
Go 1.26.10 and 1.27.3 make crypto/x509 reject chains that pass through
the compromised eMudhra intermediate CAs. Go 1.25 has no backport, so
binaries built from go.mod 1.25.5 would still trust forged certificates
from those intermediates on systems whose trust store has not been
updated. skillshare makes HTTPS requests for upgrade, update checks,
search and registry lookups, so release binaries need the fix.
Move go.mod, mise.toml, the three Docker images and the sandbox docs to
1.26.10. CI and release builds follow go.mod through go-version-file.
* fix(update): honor accepted findings in dashboard tracked updates
The dashboard ignored findings accepted through the CLI, so a tracked repo
that `update --force` let through was blocked again on the next dashboard
update, and every dashboard Force Retry had to be repeated. Regular skill
updates in the dashboard already honored and recorded acceptances, so only
tracked repos differed.
Tracked-repo updates now always honor accepted findings and record the ones
an override lets through, for both callers. The opt-in option and the
AuditGate flag it fed are removed, since no caller turns them off.
Dashboard agent tracked repos passed an empty source dir, so a nested repo
kept acceptances in its group folder under a different key than the CLI.
They now pass the agents source, as the CLI does.
* fix(update): reload the agents store after agent repo refresh
Dashboard agent tracked repos now refresh metadata in the agents source,
but a metadata change reloaded the skills store, leaving the agents store
as it was until the next request. Reload the store that matches the source.
Every caller of update.TrackedRepo now passes a source dir, so the
empty-dir guard and its doc no longer describe a supported mode. The new
agent test reuses the tracked fixture instead of rebuilding it.
* docs: clarify upstream skill and plugin tracking
The built-in skill recommends --track --all, which install rejects. Show valid scoped workflows for following upstream collections and native plugins, distinguish update from sync, and explain selection flags before users hit their conflicts.
* docs: clarify default-branch and retained-ref boundaries
Qualify default-branch guidance for unpinned sources so update examples do not imply that an existing ref is cleared. Clarify mixed resource collections and filter modes alongside the workflow.
* docs: address tracking workflow review feedback
Remove rejected tracking/selection combinations from enterprise recipes in all five languages, document incompatible flags in the install tables, and state the selection errors explicitly. Keep the built-in skill concise by routing detailed upstream workflows to its references.
* fix(plugins): honor native OMP marketplace builds
Resolve OMP entries from their native marketplace when present and inspect package.json extension-only plugins. Keep target-specific source paths, marketplace identities and components so Claude adoption and hybrid manifests remain valid.\n\nShow separate builds in text discovery without changing logical JSON selection, and cover native precedence, invalid catalogs, manifestless and hybrid packages, global/project materialization and CLI output with regression tests. Update the plugin docs and existing translations.\n\nFixes #587
* fix(plugins): preserve native build metadata across consumers
Keep OMP catalog versions in target discovery metadata and materialized marketplace entries so previews, cache guards, and native installs use the same version, including legacy catalog fallback. Cover catalog versions that differ from package manifests.
Show each dashboard discovery target's own version, components, and source path instead of presenting a merged candidate as one build.
* fix(plugins): avoid ambiguous shared build versions
Derive candidate versions from agreement across supported targets and recompute after catalog overrides. No-Agent records and lists no longer inherit an arbitrary native build version; equal versions remain available and unknown versions stay unknown.
Keep Cursor and Antigravity inventory target-specific when manifests disagree. Cover no-Agent preview and persistence, equal and unknown versions, catalog overrides, and mixed-manifest local inventories. Align English and translated plugin references.
* fix(plugins): accept Pi extension manifests for OMP catalogs
Reuse the existing OMP extension detector instead of requiring an OMP-specific manifest key. Native OMP accepts Pi extension manifests too, so the extra gate rejected supported native catalog entries.
Cover Pi-only discovery with scoped package names and global/project materialization. Align the English plugin references and all existing translations.
After a release changed the guidance text, outdated agents showed an
unchecked box in "Connect to agents", so updating looked like it
required disconnecting and reconnecting. An "Update to latest" button
now opens the same review with every outdated agent preselected and
its mode kept. Hand-edited blocks are "modified", not "outdated", so
they are never preselected and the backend still refuses to overwrite
them.
A pull with dozens of conflicting files meant clicking "Keep this
version" once per file. Two buttons now set every file to the same
side; individual files can still be switched afterwards.
* feat(hooks): read hook code and scripts from files next to the config
Code Agent extensions and command scripts lived as strings in
config.yaml, so a longer Pi extension or shell script was edited inside
a YAML block scalar with no editor support, and nothing type-checked or
linted it. A breaking change in an Agent's extension API went unnoticed
because the generated file is not part of any tsconfig.
A binding now takes `codeFile: path` instead of `code`, and a `files`
value may be `{from: path}` instead of the contents. Paths resolve
against the folder of the config that holds the entry and are read
every time the config is read, so the regular typecheck or shellcheck
can cover the real source. The revision and drift checks use the
resolved contents, so a file edited after a preview fails the apply as
stale.
Saving keeps the references: enable/disable, `hooks edit` and the
dashboard write `codeFile` and `{from}` back instead of inlining the
contents. JSON carries the contents plus `codeFile`/`filesFrom`, and an
entry echoed back with both must match the file, so an edit is refused
rather than silently dropped. Paths must stay inside the config folder
without symlinks, so a cloned project cannot pull in files from
elsewhere. References are taken from the YAML tree before one strict
decode, which keeps unknown-field checks and anchors shared across
bindings working.
Closes#585
* fix(hooks): refuse an emptied file sent with its reference
An empty files value stood for "contents not sent", so a file cleared in
the dashboard's Git YAML editor while its filesFrom reference stayed was
treated as unsent: the file was read again from disk and the save
reported success with the user's edit discarded.
A value read from {from: path} now keeps a dedicated mark until it is
resolved, so an empty value is compared with the file like any other
contents and refused when they differ. Code keeps using empty as unsent,
since a code binding can never be empty.
* fix(hooks): render referenced files as they are on disk
RenderNative rendered the contents the caller sent. The dashboard sends
the entry it loaded, so after a referenced file changed, View
configuration still showed the old contents while describing them as
what sync would write.
Render now drops sent contents for codeFile and {from} references and
reads every reference again, like preview and save. Draft, render and
config decoding are the only paths that take an entry, and all three now
resolve references.
* fix(hooks): accept file references in JSON entries and anchored values
Two inputs that config.yaml accepts failed to load elsewhere.
A `{from}` value carrying its own YAML anchor, aliased from another
binding, lost its anchor because the value node was replaced instead of
rewritten, so the alias no longer resolved. The node is now rewritten in
place with its anchor kept.
An entry JSON file (`hooks add|edit --file x.json`) could not write a
files value as `{"from": path}`, because JSON decoded straight into
string contents. Binding now decodes JSON files values as contents or a
reference, strictly, like YAML, so both entry formats and the Web API
take the same shapes.
* feat(mcp): serve an Executor skill index from mcp serve --http
Executor apps load remote skills with wellKnownSkills, but could only
reach Skillshare's skills through a copy in Git, so an edit saved with
apply_skill_edit never reached them without a commit and push. With
--http, mcp serve now also answers /.well-known/agent-skills/index.json
and the files it lists, built from the same catalog and token, so
Executor sees an edit on its next check.
The format is the one Executor's loader reads, not the agent-skills
discovery draft v0.2. One skill that loader rejects fails its whole
load, so the index leaves out skills it would reject (non-text metadata,
license or allowed-tools, files over 2 MB, non-UTF-8 files, file names
decodeURIComponent cannot handle, names used twice) and lists them in
--check and on stderr at startup. Versions are digests of each skill's
paths and file digests, and the output is stable while nothing changes,
because the loader reads the index twice and compares the bytes. An
index over Executor's file or byte limits answers with an error naming
--target.
Manifest files now record their path within the listing skill: a
parent's entry otherwise took its nested skill's paths, which would
have listed SKILL.md twice. The index route repeats the MCP handler's
DNS rebinding check for loopback servers without a token.
Closes#574
* fix(mcp): accept proxied hosts with a token and use Executor's app accounts
Behind the documented TLS proxy, a loopback mcp serve sees the proxy's
public Host, and the DNS rebinding check answered 403 even with a valid
bearer token. The index route had it, and so did the MCP endpoint through
the go-sdk's localhost protection. A rebinding page cannot send the token,
so both checks now apply only when no token is set; the docs say a
tokenless server behind a proxy needs a loopback Host.
The Executor example used the account form apps 0.0.1-beta.90 removed
(`{ accounts }` and `ctx.accounts`, now typed as never). It declares the
token as an app account and reads ctx.app.accounts, in all five locales.
The wellKnownSkills loader itself is unchanged at the v2 head (b98424d9).
* feat(mcp): write per-Agent native fields from the source
Some MCP settings have no portable form, such as Codex's
default_tools_approval_mode or Claude Code's per-server timeout. Sync
kept them only while an entry survived, so a recreated entry (for
example after a rename) lost them, and every machine needed them added
by hand again.
A server's `options` now holds these fields per Agent, and sync writes
them as given. The field ledger that piOptions used is extended to
every Agent, so sync removes an option it wrote once the source drops
it, and reports a conflict when the Agent changed it since.
Options are refused when they could break the entry or leak a secret:
fields Skillshare writes (including portable names some Agents rename),
values a native format cannot write back (null, arrays of tables),
options.pi (piOptions covers Pi), disabled entries, and credentials as
plain text, since the Agent's file may be committed.
The dashboard has no editor for options yet but keeps them on save.
Refs: #578
* fix(mcp): close gaps in per-Agent options found in review
- A credential option passed if it merely contained "${", so text around
a reference, or another Agent's syntax, was written out as plain text.
It must now be a whole-value reference in the Agent's own syntax, and
Codex and Antigravity options, which read no references, cannot hold one.
- The Kilo Code project check looked only at portable env references, so
an {env:VAR} in options reached a project file Kilo refuses to load.
- A replace resolution left the dropped-option conflict in place, so the
plan stayed blocked; replace now lets the source win and prunes those
fields.
- Adopting an entry that already matched skipped writing its options until
a later sync; the takeover now writes them.
* fix(mcp): refuse numeric credentials and constrain option values in the schema
- YAML reads an unquoted secret such as clientSecret: 123456 as a number,
which the credential check skipped, so sync wrote it out as plain text.
A mapping under a sensitive name such as credentials also hid its
plainly named fields. Sensitivity now carries down through mappings and
lists, and a number under a sensitive name is refused.
- The schema allowed any value inside an Agent's options, so editors
accepted null or nested lists that LoadSource then rejects. A recursive
optionValue definition now matches the runtime rules.
* feat(ui): edit other Agents' MCP options in the server dialog
The dialog only carried options through unchanged, so setting a field
such as Codex default_tools_approval_mode or Claude Code timeout still
meant editing mcp.yaml by hand. One Agent picker with a JSON editor keeps
the dialog short however many Agents are ticked; ticked Agents come first,
and an unticked Agent that still has settings stays listed so they can be
cleared. Anything but a JSON object blocks saving; the server checks the
fields themselves.
* fix(ui): offer every Agent in the options picker and document the editor
- The picker listed targets from the order, which includes accounts, so a
ticked account produced an options key the server refuses, and the
Agent the account writes to was not offered. Options are keyed by Agent,
so every Agent but Pi is offered, ticked ones first.
- An unticked Agent left the list as soon as its text was emptied, so its
settings could not be cleared and retyped.
- The editor was hidden on the Skillshare tab although its server takes
options too, and hidden invalid text could block Save there.
- The docs still said the dashboard had no options editor.
* fix(ui): open the options editor on a ticked account's Agent
The picker ranked Agents by the ticked targets, which hold account names,
so a server reaching only codex-work opened the Claude editor and what was
typed there was saved under options.claude. The MCP page now provides
each account's Agent, and the ranking uses it.
The retype test now asserts the saved options rather than the editor
staying visible.
* fix(ui): show the server's refusals of Agent options in the dashboard language
The dialog leaves field rules to the server, but its refusals (a field
Skillshare writes, a plain-text credential, a credential in an Agent that
reads no references, an unsupported value) reached the dialog in English.
describeError now maps each to a translated message naming the Agent and
field. The other option errors cannot come from the dialog: it offers no
Pi, no non-Agent key, and no options on an off switch.
* feat(mcp): write per-Agent native fields from the source
Some MCP settings have no portable form, such as Codex's
default_tools_approval_mode or Claude Code's per-server timeout. Sync
kept them only while an entry survived, so a recreated entry (for
example after a rename) lost them, and every machine needed them added
by hand again.
A server's `options` now holds these fields per Agent, and sync writes
them as given. The field ledger that piOptions used is extended to
every Agent, so sync removes an option it wrote once the source drops
it, and reports a conflict when the Agent changed it since.
Options are refused when they could break the entry or leak a secret:
fields Skillshare writes (including portable names some Agents rename),
values a native format cannot write back (null, arrays of tables),
options.pi (piOptions covers Pi), disabled entries, and credentials as
plain text, since the Agent's file may be committed.
The dashboard has no editor for options yet but keeps them on save.
Refs: #578
* fix(mcp): close gaps in per-Agent options found in review
- A credential option passed if it merely contained "${", so text around
a reference, or another Agent's syntax, was written out as plain text.
It must now be a whole-value reference in the Agent's own syntax, and
Codex and Antigravity options, which read no references, cannot hold one.
- The Kilo Code project check looked only at portable env references, so
an {env:VAR} in options reached a project file Kilo refuses to load.
- A replace resolution left the dropped-option conflict in place, so the
plan stayed blocked; replace now lets the source win and prunes those
fields.
- Adopting an entry that already matched skipped writing its options until
a later sync; the takeover now writes them.
* fix(mcp): refuse numeric credentials and constrain option values in the schema
- YAML reads an unquoted secret such as clientSecret: 123456 as a number,
which the credential check skipped, so sync wrote it out as plain text.
A mapping under a sensitive name such as credentials also hid its
plainly named fields. Sensitivity now carries down through mappings and
lists, and a number under a sensitive name is refused.
- The schema allowed any value inside an Agent's options, so editors
accepted null or nested lists that LoadSource then rejects. A recursive
optionValue definition now matches the runtime rules.
* docs(mcp): name every Agent whose options cannot hold a credential
The docs named only Codex and Antigravity, but Claude Desktop, Goose,
Junie, LM Studio and Warp read no environment references there either,
so a source such as options.goose.apiKey: "${GOOSE_KEY}" looked valid
while LoadSource refused it.
* 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.
The Playwright example now pins @0.0.83, so readers asked whether a
version is required. It is not: without an exact version (or with
latest, a tag or a range) mcp check only warns, and the server still
syncs and starts.
* 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.
The skill restated the audit topic in an older form: its flag grep matches
no file because the CLI parses its own arguments, and its fixed list of
mutating commands contradicts the topic's rule to judge from current
behavior. The audit topic stays the source for consistency audits.
The contributor page listed it, so it now lists skillshare-code-review in
its place, and uses the skills' real names, which gained the skillshare-
prefix in an earlier rename.
* 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.
* feat(ui): surface existing shared memory on the dashboard
Make shared notes visible through recent updates and direct links, with file timestamps and an introductory state for untouched starters. Keep the dashboard quiet until memory is configured, and preserve access to existing notes when starter files are missing.
* fix(memory): bound dashboard reads and remember preview expansion
Count vault entries from metadata and read at most the two starters and four recent candidates instead of hashing the full vault on dashboard load. Keep incomplete starter states accessible and refresh the overview after source and instruction changes. Remember preview expansion in browser storage and raise the collapsed height to 360px.
Updating several plugins from the dashboard was slow: each plugin took a
preview and an apply round trip, apply previewed again, every plugin cloned
its source on its own, and config reloaded after each one.
The dashboard now sends the picks to POST /api/plugins/update/stream. The
server holds the plugin lock once, previews each plugin once and applies that
plan, lets plugins from one source share a single read of it, and reloads
config once at the end. POST /api/plugins/update/stop lets the plugin under
way finish and starts no other; a closed page does not cut an install short.
The check-to-update safety moves to the server: an Agent whose source moved
since the check, or that no check showed, installs nothing. npm packages in
Pi are exempt, since Pi installs whatever npm names latest; the old
client-side comparison flagged them as moved on every update.
The update dialog follows the Skills update page, shows per-Agent old -> new
versions, fails rows a broken stream never finished, and lists every plugin
with its Agent and version when all are current.
Release-As: 0.25.6
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.
Since 0.25.4 reconcile adopts a skill moved by hand at the next
install, so the warning no longer claims the source link is lost;
it names what still does not follow.
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
Install records live in one .metadata.json keyed by skill path, so moving
an installed skill with mv leaves its record at the old path and the moved
copy loses its source link. Keep mv for self-created skills and document
uninstall + install --into for installed ones.
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.