MarketplaceDeveloper Mode

A marketplace that ships several personas usually wants them to agree on the same facts: who the company is, what it sells, how it talks. The Knowledge step is where that material lives. Write the documents in the wizard, name the result once, and every persona in the marketplace carries it. On disk it is a plain folder of markdown beside marketplace.json, and it installs as an ordinary skill, so the assistant finds it the same way it finds any other. Correct a document once and everyone on the plan is correct.

• Documents are ordinary markdown in a knowledge-base folder next to marketplace.json. Add, rename, edit and remove them in the Knowledge step
• Plexon writes the SKILL.md front door itself: an index of the documents, not a copy of them, so a long knowledge base costs one line per file in the prompt
• Every persona in the marketplace picks it up automatically. Narrow it to a few of them with the persona chips when a department wants its own
• Clone the repository, link the folder, edit a document and publish. The next sync carries it to everyone on the plan

Each picked item lands in the marketplace with one of three personalities. Bundle an artifact you installed (the wizard copies its files into the marketplace folder and strips the install-only stamps that would otherwise lock the marketplace to your local version). Scaffold a fresh placeholder (Plexon writes a working template the consumer can read). Or declare a Plexon-bundled artifact (the manifest names it, no files copied, the consumer's binary already ships the bytes). Declared items are how Plexon's own templates ship without bloating every author's marketplace.

• Bundling: copies SKILL.md / AGENT.md / persona YAML / plugin tree into the marketplace, strips .bundled-hash, .linksrc, and frontmatter version: lines so the marketplace re-stamps cleanly on install
• Placeholders: a sample-skill, sample-agent, sample-persona, sample-plugin (the bundled document-toolkit), or stub .mcp.json gets written to the right kind directory
• Declared: the manifest item points at no files. The install resolver short-circuits to the consumer's bundled extraction, so Plexon-shipped artifacts never get re-shipped
• Inline mcpConfig for Tools entries: the manifest carries the transport spec inline, no per-server folder needed on disk

Browse picks up a folder that already has a marketplace.json and the wizard loads it into the form: manifest fields populated, every item from items[] surfaced as a declared plan pointing at the same folder. Rename in the Name field and click Create to fork it, or pick a different output folder to clone-and-edit. There is no second 'load existing' button. Browse is the single entry point.

• Manifest fields, owner, author, marketplaces[], items[] all round-trip cleanly
• A clear banner tells you which folder you loaded from and what the create button will do
• Refuses to overwrite an existing marketplace.json at the same path. Pick a different folder or rename first
• Live-reload watcher attaches after create. Editing the marketplace.json in your editor refreshes Plexon instantly

Sync on the Sources row runs the whole collaboration loop: your store-backed edits land in the folder, everything commits with a generated summary line, your teammates' changes come in, and yours publish. Staging is scoped to the marketplace's own directories, so a stray note or .env in the folder never rides along. A validation gate refuses to publish while marketplace.json fails validation, protecting everyone who installed your marketplace. The same pipeline answers to chat: tell the AI 'push my marketplace changes' and it drives the plexon_marketplace_sync tool.

• Commit summaries are written for you from the diff, with a plain fallback like "Update 2 workflows, 1 skill" when offline
• Auto-sync chip: opt in per marketplace and Plexon syncs a few minutes after your edits settle
• History on the row lists every change by the items it touched, who made it, and when. No hashes anywhere
• Offline? Your changes commit locally and publish on the next sync
• First publish included: a marketplace with no repo yet routes into the Publish to GitHub flow

A marketplace your company manages arrives read-only for everyone who receives it. When somebody has to maintain it, an admin names them a developer of it on the Marketplaces page, and their Sources row grows a Develop button. Plexon clones the repository into a folder they choose, links it in developer mode, and from then on Sync and the revision card's Publish push with a token the server mints at that moment. Nobody pastes a GitHub credential, and none is stored on the developer's machine.

• The grant lives on the marketplace row. A Plexon admin, or the company's own admin, adds a member of a group or company that marketplace is linked to
• The push token is minted per publish, lives about an hour, carries write access to repository contents and read access to metadata, and cannot write GitHub Actions workflow files
• It only ever opens a repository inside the owner company's own connected GitHub organization. A repository outside it is refused by name, before anything is cloned or pushed
• Take the grant away and the next publish is refused with the reason. The developer keeps the folder and its history
• Each push reports its commit and version back, so the marketplace row on plexon.ai shows what is live

A new price list lands, a policy gets rewritten, three trip reports come back from the field. Update from documents points Plexon at the folder and lets it work out what in your marketplace has to change. Three steps: pick the bundle and, if you want, narrow it to a single persona; choose the documents and read the scan of what is in them; tick which kinds of file this run may touch and start. Or skip the steps: drop the files on the persona card and the dialog opens with them already named. The request Plexon writes for the assistant sits under Show the request on the last step, if you want to read or edit it. Documents the bundle has folded before are recognised by their content, even after a browser renamed the download, and stay unticked; a new version of a known file is ticked and read. A document the bundle already cites says so on its row, with the number of files citing it and the date they were last reviewed, so the run checks those for what changed instead of reading the bundle again. With Fast decisions on, the documents are checked while the list loads: one that looks unrelated to the bundle is flagged, and unticked when it came in with a folder (a file you dropped yourself is only flagged), a new version that changed only cosmetically is unticked, and a kind of file the documents do not seem to touch is turned off, all of it yours to put back. Documents the bundle folded from that folder before and that are no longer in it are listed as gone, with the passages that still cite them; tick Retire on one and the run rewrites or removes what rested only on it. Start opens the revision first and the chat second, so a refusal (nothing linked, a revision already open) lands in the wizard rather than in a chat with nowhere to put the work.

• Opens from the Sources row of a linked marketplace, or from a persona card that marketplace owns. A bundle you received from your company is never offered, because you are not its author
• The documents step scans the folder before a single file is read, and counts the ones that need a visual read separately, since each of those costs a model request
• The check before a fold never holds up Start and never overrides a tick you made yourself. Turn it off under Settings, Fast decisions
• A document you removed from the folder can be retired from the bundle in the same run, or on its own, with no new document at all
• The kinds you can tick are read out of your own bundle, so every group on offer is a group the assistant can actually change
• Drop the folder on the dialog, browse for it, or type the path
• The request is shown section by section with a caption on each, and it is yours to edit before it is sent
• The chat opens on the marketplace it is revising, and Source Control moves there with it

Nothing reaches your folder while the assistant is working. Each edit is staged into a revision instead, one file at a time, and when it submits, a card appears in the chat with every file it wants to change: the differences, a one-line note saying what changed, and the document the change came from. Every file starts ticked. Untick the ones you are not ready for, approve the rest, and only the ticked files are written. Ask for changes sends the whole thing back with your feedback and the assistant carries on in the same revision.

• With Fast decisions on, the files come riskiest first and the ones worth a careful look carry a Read this one tag; the version bump and the changelog entry always sit last
• If a file moved on disk after it was staged, the approve is refused, nothing at all is written, and the card names the file
• The version bump and the CHANGELOG entry are staged in the same card as the content, so the release half is something you read rather than something you remember
• Undo an applied revision from the Revisions list on the Sources row. It works file by file, and anything you have edited since is refused by name instead of being overwritten
• Keep a copy of the documents in the bundle is on by default: the sources land under knowledge-base/sources/ in a dated folder, so a citation in a reference file still resolves next year
• Sync when you are happy with it and the team gets the result the usual way

When you and a teammate change the same file, Sync stops and shows each conflicted file with the two versions side by side and three choices: keep yours, take the team's, or let AI merge both. Your versions are copied to a snapshot folder before anything is applied, so nothing is lost whichever way you decide. AI merges are validated with the same parsers the installer uses (a merged workflow.json must still be a valid workflow) before they reach the repo.

• Conflicts are named by item ("workflow Invoice Reminder"), not by file path
• One Apply resolves every file together; the sync finishes and publishes on its own
• The AI merge favors your version when both sides changed the same lines, and the result says so
• A conflicts chip on the Sources row and a toast reopen the resolution screen any time

The Inspector pane is a read-only view of what Plexon understands about your marketplace right now. Manifest validation errors, per-item frontmatter, the global symlink target, and encryption mode for every item, all in one pass. Subscribes to the live-reload watcher so editing marketplace.json in your editor refreshes the inspector instantly.

• Surfaces manifest validation and per-item parse errors before you publish
• Open in editor, Reveal in folder, and Copy path for every resolved file
• VS Code, Cursor, and Sublime auto-detected from PATH
• Same parser ladder the install flow uses, so fixes here are fixes consumers never have to see

Edits to marketplace.json, SKILL.md, AGENT.md, or any persona YAML reload Plexon's catalogs the moment you save. No refresh click, no re-install round-trip. The watcher debounces editor burst-saves into a single reload and ignores the noise (git, lockfiles, images, editor folders) so your workflow stays quiet.

• 350ms debounce collapses rename-write-rename editor saves into one event
• Allowlist filters out images, lockfiles, and CSS so a screenshot save is silent
• Ignores .git, node_modules, .vscode, and .idea so a rebase is invisible
• Red badge on the Sources row warns you the moment manifest validation fails

Pick Bump version on a linked-marketplace row and choose Patch, Minor, or Major. Plexon parses your current version, increments the segment, writes the file atomically, and runs git add marketplace.json so the change is staged for your next commit through the Source Control sidebar.

• Tolerates empty, v-prefixed, and pre-release versions
• Strips -beta and +sha1 suffixes on output so the bumped version is clean numeric semver
• Refuses to bump consumer-mode entries (those clones are Plexon-managed and would be clobbered on Refresh)
• Never auto-commits. You drive the commit message, identity, and signing