Rosetta is a meta-prompting, context engineering, and centralized instructions management for AI coding agents. R2 is the production release that moves teams from individual developer prompting to governed, organization wide AI assisted development.
- Zero friction developer onboarding through HTTP mode and IDE plugins
- Multi agent execution with specialized roles and review gates
- Architecture aware AI development through automatic pattern extraction
- Modular instructions aligned with native coding agent capabilities
- Structured workflows for requirements, prompts, and debugging
- HTTP mode. Developers connect to Rosetta over HTTP with OAuth. No local installation, no CLI setup, and no dependencies on developer machines. Add one JSON config to the IDE and start working.
- Plugins for Claude Code and Cursor. Installation is available from IDE marketplaces with one click. Additional IDE plugins are planned.
- Reduced bootstrap size. Smaller initial prompts load faster and use less context, leaving more room for the actual task.
- Subagent orchestration. Work is split into phases handled by specialized agents. One can implement while another reviews, potentially on a different model. Architect, engineer, reviewer, and validator each work with focused context and a clear scope.
- Deterministic plan manager. Execution plans are tracked step by step with phase completion gates. It is in battle testing with limited scope and is designed to make AI work resumable and auditable.
- Large workspace handling. Repositories with more than 100 files are partitioned into scoped subagent tasks to prevent context overflow and keep quality stable at scale.
- Automated review gates. After implementation and testing, a separate reviewer agent checks the result against the spec before it reaches human reviewers.
- Automatic building block extraction. During repository initialization, Rosetta identifies recurring codebase patterns, such as how to create a controller, a domain service, or a data grid, and turns them into reusable templates for the agent.
- Project knowledge datasets. Each project builds a structured knowledge base that covers architecture, tech stack, dependencies, and conventions. This enables cross project flows where the agent understands how services relate to each other and improves work across multiple repos.
- Skills, rules, commands, workflows, and subagents are separated. Each instruction type maps to native coding agent features such as Cursor rules or Claude Code commands. Agents use built-in capabilities instead of workarounds.
- OSS, Grid, and custom split. OSS provides the foundation. Grid adds advanced workflows. Organizations can layer their own customizations without forking the core.
- Requirements documentation authoring. A structured workflow produces testable, atomic requirements with traceability. Those requirements then drive planning, implementation, and validation.
- Prompt authoring. Teams that create and maintain AI agent instruction sets now have a dedicated workflow with specialized subagents for each phase.
- Debugging skill. The agent investigates root cause before attempting a fix, which makes debugging more systematic and less dependent on guesswork.
- Two-tier dangerous-actions hook. The
PreToolUsehook now classifies every pattern as eitherreconsider(dangerous but recoverable, AI may self-approve after blast-radius analysis) orhard-deny(catastrophic, human confirmation required).curl | shis hard-deny. Previously all denies were permanent HITL gates. - AI-autonomous retry via
# Rosetta-AI-reviewed. Forreconsider-tier patterns, the AI may append the marker token to a user-visible field and retry after reconsidering blast radius. The marker is validated by strict regex; legacy# Rosetta-reviewedis rejected. - Single-traversal pattern evaluation. Pattern matching and policy lookup now share one traversal (
detectDanger), eliminating the structural divergence risk where a hard-deny pattern could slip through if the two parallel scans returned different results. - Stateless hook design. Cooldown store and audit log removed. The hook is safe across worktrees, CI runners, and parallel sessions without shared state.
- Windsurf adapter deny feedback.
permissionDecisionReasonis surfaced asadditionalContextso Windsurf agents receive actionable denial explanations.
R3 advances Rosetta from governed assistance to deterministic, self-guarding execution. Where R2 made organization wide AI development consistent, R3 makes it reproducible and safe by default: a deterministic operation manager drives every workflow step, a cross IDE hooks runtime enforces guardrails and advisories at the moment of action, and the bootstrap that loads on every session is roughly half its former size. R3 is the served release; R2 remains supported with backported fixes.
- Deterministic execution: every workflow runs as a tracked, resumable plan driven by the operation manager
- Cross IDE hooks runtime with a self-reviewable dangerous-actions gate and advisory nudges
- GitNexus code graph integration for architecture aware navigation and automatic reindexing
- Roughly 57% smaller bootstrap through skill extraction and de-duplication
- Stays out of your way by default: a plain message no longer auto-triggers the full guided workflow; ask for it explicitly with
/rosetta(or any specific flow) when you want it - Easier to customize: skills, workflows, and rules are local files via plugins, so teams can write their own with the
coding-agents-prompt-authoringflow, something the MCP-only model never allowed - Public OSS MCP and RAGFlow deployment plus GitHub authentication
- IaC and automated QA / test generation workflows delivered; foundations laid for discovery and mobile
- Authorized security review workflow with a secret-first safety gate, bounded pre-production testing, and independent evidence review
- Operation manager. Plan creation, tracking, and step by step execution are handled by
rosettify— a local CLI and stdio MCP that stores execution plans as JSON. It replaces ad hoc planning with a deterministic, resumable, auditable loop (create → next → execute → update) with sequential phase gates and atomic writes. - Bootstrap integrated planning. Preparation steps, guardrails, HITL, documentation, and risk assessment are expressed as explicit plan phases and steps, so the agent commits to the process up front instead of improvising. Plan and act modes are supported directly.
- Graceful fallback. When the operation manager is unavailable, a fallback rule routes the agent to built in todo tracking, so execution discipline never depends on a single tool.
- Common input adapter. A single adapter normalizes the differing hook input schemas of Claude Code, Cursor, Copilot, Codex, and Windsurf into one canonical shape, so each hook is authored once and runs everywhere.
- Declarative hook framework. Hooks declare their activation (event, tool kind, file predicates) and the runtime gates, throttles, and debounces them. Each hook is bundled per IDE with isolation guarantees so a bundle carries only its own adapter code.
- dangerous-actions safety gate (PreToolUse). A deterministic, stateless last resort tripwire on destructive shell and MCP operations, safe across worktrees and parallel sessions. Every match is
reconsider— the agent may self-approve with aRosetta-AI-reviewedmarker in a user visible field after a blast radius check, so no pattern is an unconditional human-only block. Credential and key file overwrites get a separate non-blockingadvisetier, reasoned around irreversibility rather than secrecy. A single traversal detection avoids policy divergence bypasses, and Windsurf agents receive the denial reason as actionable context. - Advisory hooks.
md-file-advisorynudges on stray markdown placement,lint-format-advisoryprompts a syntax/type/lint/format step after code edits, andloose-filesflags.py/.jsfiles created without a module marker (on file creation events only). - GitNexus refresh hook. Detects a stale code graph index after source mutations and asks the agent to reindex, with trailing edge debouncing so only the last edit in a burst triggers work.
- Authoring skill. A
hooks-authoringskill documents entry rules, tool kind registration, and pitfalls for contributors adding new hooks.
- Code graph navigation. GitNexus is integrated as opt in skills (
gitnexus-setup,gitnexus-cli,gitnexus-tools) and wired into workspace initialization, giving the agent architecture aware navigation. It works in ad hoc mode with Claude Code and ships in the plugins.
- Roughly 57% smaller bootstrap. Bootstrap rules were refactored — JSON schemas pulled into skills and templates, duplicated orchestration rules merged, and HITL questioning moved entirely into the on demand
hitlskill. The per sessionbootstrap-*.mdpayload dropped from 31,711 to 13,510 bytes, a 57.4% reduction (the MCP modebootstrap.mdentry is excluded — still being optimized). - Strengthened, self-initializing prep. Preparation enforcement was tightened and workflow selection was folded into the orchestrator contract, so orchestrators and subagents self-initialize — load context, select the workflow, and commit to phases before acting.
- Explicit context loading.
load-project-contextmakes context loading and workflow selection explicit, reliable steps rather than implicit expectations.
- Rolling releases going forward. R3 is the last large, version-branch style release. From here Rosetta moves to a rolling model — changes ship continuously in small, incremental releases rather than long-lived branches and major cutovers like v3.
- Incremental workflow delivery. The v3 Workflows track has delivered an IaC workflow, SpecFlow integration, automated QA / test generation (ui-aqa-flow, api-aqa-flow, testgen-flow, with an
aqa-flowrouter kept for backward compatibility), and an authorized security review workflow (security-flow). The remaining workflows — discovery, mobile apps, and test harness engineering — will arrive through these smaller releases rather than a single shift.
- Public OSS deployment. A public Rosetta MCP and RAGFlow deployment supports OSS and demo environments.
- GitHub authentication. OAuth through GitHub is supported for MCP access.
- Analytics fix. PostHog now reports the correct user identity.
- Supply-chain and code scanning. CodeQL analysis runs on every push and PR to main plus a weekly scheduled scan, and each package has its own pre-merge CI pipeline.
Release scope: R3 is the live, served release. R2 is the previous release, receiving backports only. Other tags are release-agnostic: Tooling (plugin generator, rosettify), Server (MCP server, Helm), Hooks, CI, Docs.
When Rosetta runs on Gemini, it now uses a more capable model, Gemini 4 Argon, for the architect, planner, requirements-engineer, and prompt-engineer subagents (lightweight profile: architect only). These subagents make the decisions that shape everything built afterwards. Claude and GPT already ran them on Opus and Sol, while Gemini used Flash. On Claude, discovery and research moved to the cheaper Haiku 5.5.
Every model list also moved to new versions for each vendor. Work that ran on GPT-5.6 Terra now runs on GPT-6 Luna one reasoning step higher, which matches Terra in capability at about one eighth of the cost. Orchestration sizes work by expected code volume and context limits rather than mainly by file count, subagents report what they did not finish, and prompts are authored shorter.
Highlights
- Model versions updated for every vendor: Claude Opus 5.5, Sonnet 5.5, and Haiku 5.5 (were Opus 5, Sonnet 5, Haiku 4.5), GPT-6.1 Sol (was GPT-5.6 Sol), GPT-6 Luna (was GPT-5.6 Luna), Gemini 3.8 Flash (was 3.7), Grok 4.7 (was 4.6); Cursor Composer 2.5 is unchanged
- Gemini 4 Argon added. When Rosetta runs on Gemini, the architect, planner, requirements-engineer, and prompt-engineer subagents, which make the decisions that shape the rest of the work, now use Argon (lightweight profile: architect only). All other subagents keep Gemini 3.8 Flash, and Claude, GPT, and Grok runs are unaffected. Before, Gemini used Flash for these subagents too
- Lower cost on GPT: work that ran on GPT-5.6 Terra, the middle GPT tier, now runs on GPT-6 Luna, which matches Terra in capability at about one eighth of the cost (GPT-6 has no Terra model). In Codex model lists, reasoning effort is raised one step
- Lower cost on Claude: discoverer and researcher moved from Sonnet to Haiku 5.5, and so did the lightweight profile's engineer, reviewer, and validator
- Orchestration sizes a task as small, medium, or large from expected lines of code (under 200, under 2,000, more) and areas touched, with file count only a rough hint, and aims to keep each agent under 250K tokens of context (price doubles above 200K)
- Orchestrators pick a subagent's model and reasoning effort from a written ladder (Strategist, Tactician, Implementer), and the large-work playbook gains a "worker pull" tactic
- Subagent reports now state what was not done, fully or partly, so the orchestrator sees gaps before it accepts a result
- Prompts are authored shorter: drafts keep only key points and leave decisions to the agent that runs them;
rosettify-promptscompression follows the same rule - Workspace initialization is much faster and cheaper: it no longer extracts code patterns unless the user asks for it
- Reference files for each IDE (Claude Code, Cursor, Copilot, Codex, OpenCode, Windsurf) and the agent-launching skill list the new models in each tool's own id format; older entries stay listed
- Tooling and CI: Cursor and Copilot subagents no longer get a raw model id when a prompt names a Claude model with an effort suffix (for example
claude-sonnet-5-medium); therosettify-promptsquality judge works on Claude 5.5 models, which reject thethinking: disabledsetting it used to send; CI jobs use the new models (Codex jobs run GPT-6 Luna at one step higher effort) - Routine: maintainer-internal skills tightened (
documentation,update-change-log,compress-prompt,sync-web-site; the last two can now be invoked by the model, not only by name); weekly GitHub stats snapshot refreshed; last week's changelog entry landed
-
Change.
[R3]Every agent and workflow step lists the model to use for each vendor, and each coding agent takes the entry for its own vendor. All entries moved to new versions:- Claude: Opus 5 to Opus 5.5, Sonnet 5 to Sonnet 5.5, Haiku 4.5 to Haiku 5.5.
- OpenAI: GPT-5.6 Sol to GPT-6.1 Sol, GPT-5.6 Luna to GPT-6 Luna.
- OpenAI "Terra" (GPT-5.6 Terra, the middle tier): GPT-6 has no Terra model, so its work runs on GPT-6 Luna, which matches Terra in capability at about one eighth of the cost. In Codex model lists, reasoning effort is raised one step (low to medium, medium to high, high to xhigh).
- Google: Gemini 3.7 Flash to Gemini 3.8 Flash. xAI: Grok 4.6 to Grok 4.7. Cursor Composer 2.5 is unchanged.
The plugin generator translates these entries into each IDE's own model names and keeps older ids as inputs, so a prompt that still names an older model resolves to the current one. (Igor Solomatov, isolomatov-gd)
-
Why it helps. Agents run on current models without anyone editing prompts one by one. Work that ran on Terra costs about one eighth as much, with matching capability.
- Change.
[R3]On Claude, the discoverer and researcher subagents ran Sonnet. They now run Haiku 5.5, the cheaper model, at high effort (the researcher also gains Cursor Composer 2.5 as an option). In the lightweight profile, the engineer, reviewer, and validator moved from Sonnet to Haiku 5.5, and so did the matching steps of the lightweight coding workflow (implementation, review, tests, validation). The light engineer's reasoning effort rose from medium to high, and the light discoverer and researcher now run at medium effort. Architect, planner, requirements-engineer, prompt-engineer, and the full profile's engineer, reviewer, and validator keep their models. (Igor Solomatov, isolomatov-gd) - Why it helps. Searching, reading, and routine checks run on a cheaper model, so each run costs less. Roles that make design decisions keep the stronger models.
- Change.
[R3]Every subagent has a model list with one entry per vendor, and a coding agent takes the entry for its own vendor. Rosetta listed only Gemini Flash, so Gemini runs used Flash for every subagent, including the architect and planner. Gemini 4 Argon, Google's top-tier model in Rosetta's model ladder, is now listed before Gemini 3.8 Flash for the architect, planner, requirements-engineer, and prompt-engineer subagents (lightweight profile: the architect only), and for the workflow steps those subagents run (plus one research step and the workspace documentation step). These subagents make the decisions that shape the rest of the work, and Opus 5.5 and GPT-6.1 Sol already ran them on Claude and GPT. All other subagents keep Gemini 3.8 Flash, which stays in these lists as the next option. Claude, GPT, and Grok runs are unaffected. The plugin generator now maps Argon, and the older Gemini Pro ids, for Cursor and Copilot; before, those ids were dropped there. The agent-launching skill names Argon as Google's complex tier and, if the Gemini CLI rejects the id (Google's rollout is limited), drops the model flag and uses the CLI default. (Igor Solomatov, isolomatov-gd) - Why it helps. On Gemini, the decisions that shape the rest of the work now run on a more capable model, and the faster, cheaper Flash keeps the rest of the work. A rejected id does not stop a launch.
- Change.
[R3]The orchestration skill sized a request from a rough file count, which says little about how much an agent must hold in context. It now sizes by expected lines of code and areas touched: small is under 200 lines in one area, medium is under 2,000 lines in up to three areas, and large is anything bigger. Files stay as a rough hint (about 5, 20, 40 or more). The skill states the goal: keep every agent and subagent under 250K tokens of context, because price doubles above 200K, and treat efficiency as organizing and adapting work, not skipping steps. The team-manager playbook now applies to large requests (it applied to medium before), and the orchestrator reports how it will organize that work. A new section sets a model ladder: Strategist (Opus 5.5, GPT-6.1 Sol, Gemini 4 Argon), Tactician (Sonnet 5.5, Gemini 3.8 Flash, Grok 4.7), Implementer (Haiku 5.5, GPT-6 Luna, Gemini 3.8 Flash, Composer 2.5), with what each reasoning effort allows and a few exceptions, for example Luna at xhigh counts as Tactician. The models above Strategist (Fable, GPT Astra) are not used. The playbook also gains a "worker pull" tactic. (Igor Solomatov, isolomatov-gd) - Why it helps. Task size follows how much an agent must hold in context, so large work is meant to be split before its price doubles. An orchestrator picks a subagent's model by looking up a tier.
- Change.
[R3]When an orchestrator hands work to a subagent, the prompt asks for proof of each claim (links, line ranges, short quotes). It now also asks the subagent to state what it did not do, fully or partly. (Igor Solomatov, isolomatov-gd) - Why it helps. The orchestrator has the stated gaps in hand when it checks the result.
- Change.
[R3]A prompt that spelled out a decision in full duplicated reasoning the running agent redid anyway, padding every prompt without adding anything it needed to act correctly. Thecoding-agents-prompt-authoringskill's draft and hardening rules now call for compressing a prompt to key points and terse phrases, keeping only "thinking points" rather than decisions, shrinking direction text to one to three words per step without dropping any step, and leaving the decision to whichever agent runs the prompt later.rosettify-prompts's automated compression step and its "value lost" audit carry the same rule; the audit now restores only genuinely missing value, tersely, instead of re-adding verbose direction text. (Igor Solomatov, isolomatov-gd) - Why it helps. Shorter prompts cost less per call and leave the decision with the agent that has the actual context to make it.
A new docs/air/INTENT.md sets out Rosetta Air, a longer-term direction built on an atoms/molecules/organisms skill hierarchy and per-project "software factory" automation. It is a vision document, not a shipped change. The maintainer-internal checklist skill is split into two variants, run side by side to find out which produces better completion checks.
Three independent fixes landed in prompt-testing tooling: the dangerous-actions hook now only honors the Rosetta-AI-reviewed self-approval marker in a MultiEdit's actual written content, curiocity's command evaluator can no longer hang a benchmark run past a configured timeout, and rosettify-prompts rejects a config with duplicate suite IDs before it runs.
Highlights
docs/air/INTENT.mdadds a vision document for "Rosetta Air": skills organized as atoms, molecules, and organisms, with priorities (atoms first) and open directions (self-improvement, self-organization, per-project software factories) — a design intent, nothing shipped yetdangerous-actionshook (MultiEdit): theRosetta-AI-reviewedself-approval marker now counts only in an edit'snew_string, closing a bypass where it could sit inold_stringor an unrelated field (#339)curiocity'scommandevaluator gets atimeoutSec(default 60s) and kills the whole process tree on timeout instead of just the shell (#338)rosettify-promptsrejects a config with duplicatesuites[].idvalues before any run starts (#362)- The
checklistskill (maintainer-internal) is split into two variants run side by side —checklist-A, a flat itemized list, andchecklist-B, the prior fresh-eye-reviewed lifecycle — to compare which works better - Routine: two new lessons recorded in the
daily-ossskill (a fallback branch that silently dropped frontmatter tags, worktree test runs needingPYTHONPATHset) - Routine: weekly GitHub stats snapshot refreshed; one typo fixed in
docs/stories/articles-rules-of-power.md
- Change.
[Docs]A newdocs/air/INTENT.mdsets out a longer-term direction for Rosetta: skills organized as atoms (single-concern, reusable — implementation, testing, discovery), molecules (configurable workflows combining atoms for one use case — coding, API AQA), and organisms (opinionated, end-to-end automation of a business process; "one organism is one autonomous software factory"). It states priorities (atoms over molecules over organisms; self-improvement ships with organisms) and lists directions still to work out: self-improvement, self-organizing the knowledge base, per-project customization built from atom/molecule/organism templates, and distributing skills vianpx skillsinstead of plugins. Nothing in the current instructions, workflows, or plugins changes as a result — this is a design intent, not a release. (Igor Solomatov, isolomatov-gd) - Why it helps. A named hierarchy and an explicit priority order give future work a shared vocabulary before it starts: build small reusable pieces first, then automate on top of them, instead of designing each new skill from scratch.
- Change.
[Hooks]TheRosetta-AI-reviewedmarker, which lets the agent self-approve areconsider-tier dangerous action, now counts for aMultiEditcall only when it appears in an edit'snew_string. The hook previously scanned every field of every edit object, so the marker sitting inold_string(the file's existing content) or an unrelated field such asdescriptionwas enough to pass the check. (David Turner, atomicdjt) - Why it helps. The marker is supposed to mean "the agent reviewed what it's about to write." A marker in content the edit didn't produce, or in a field nobody reads, proved nothing — this closes that gap.
- Change.
[Tooling]curiocity'scommandevaluator gains atimeoutSecparam (positive number, default 60s). Past the deadline it kills the whole process tree, not just the top-level shell — SIGKILL on the process group on POSIX,taskkill /ton Windows — since Execa's owntimeoutoption only ended the shell while a nested child kept running. A timeout now reports as a failed (not errored) evaluator result. (David Turner, atomicdjt) - Why it helps. One evaluator with no way to end a wedged build or test command could hang an entire benchmark run indefinitely. A bounded, whole-tree kill guarantees every run finishes.
- Change.
[Tooling]rosettify-promptsnow rejects a config where twosuites[].idvalues match, failing at config-parse time before any run starts. (Shin, shin4141) - Why it helps. Reports group results by suite and variant ID; a silent duplicate would merge two suites' results together in the report. Catching it at parse time turns a confusing downstream mixup into an immediate, clear error.
GitHub Copilot's standalone install got simpler: it no longer asks users to hand-merge Rosetta's instructions into an existing .github/copilot-instructions.md, and JetBrains now follows the same steps as VS Code instead of a separate manual procedure.
Highlights
- Copilot standalone install drops the "merge contents into
.github/copilot-instructions.md" step fromINSTALLATION.md,PLUGINS.md, and their web mirrors - JetBrains Copilot testing collapses into the same procedure as VS Code, checking for
.github/instructions/plugin-files-mode.instructions.mdand.github/instructions/bootstrap-alwayson.instructions.md USAGE_GUIDE.mdandllms-full.txtupdated to match: Copilot's project-rules path is.github/instructions/*.instructions.md- Routine: a repeated typo ("faiures" → "failures") fixed across seven skill files
- Change.
[Docs]Copilot's standalone package now relies on its native.github/instructions/*.instructions.mdconvention instead of a single shared.github/copilot-instructions.md, removing the instruction to manually merge Rosetta content into a pre-existing file. The JetBrains-specific manual setup indocs/TESTING-PLUGINS.md(copy into.github, hand-append plugin-files-mode content) is replaced by the same two-step check used for VS Code.USAGE_GUIDE.md's rules table andllms-full.txtare updated to match. (Igor Solomatov, isolomatov-gd) - Why it helps. A manual merge step risked users losing their own
copilot-instructions.mdcontent, or skipping the merge and losing Rosetta's. JetBrains and VS Code Copilot users now follow one procedure instead of two that could drift apart.
The README's skill list is replaced with a full catalog: all 42 skills grouped into 11 task-shaped categories (decide what to build, build it, stay safe, recover when it goes wrong, extend, domain packs, and more), instead of two flat top-N lists that had drifted out of sync with what actually ships. Each skill's own README gained a matching one-line pitch, written from the reader's job to be done rather than paraphrased from its "Why it exists" section.
The public web site and llms-full.txt (the dense file an AI agent reads to learn Rosetta) caught up to match. A second pass closed several sections that had drifted out of sync long before this week: a dead anchor link, a missing FAQ answer, an Automated QA section absent from the web quickstart. llms-full.txt's own skill list, never updated since the file was created, named eight skills that don't exist and was missing twelve real ones; it now matches the actual instructions/r3/core/skills tree. Skill counts quoted across three different docs, which had drifted to 40/40/38, now read 42 everywhere; the same docs' workflow-type counts went from 13 to 17.
Highlights
- Root README's
## Skillssection replaced with a full catalog: 42 skills across 11 task-shaped groups, replacing two flat "Top Guardrails" / "Top Skills" lists - Every skill README gained a matching one-line pitch as its second paragraph, written from the reader's job to be done, not paraphrased from its "Why it exists" section
llms-full.txt's skill list, unedited since the file's creation, corrected: 8 named skills that don't exist in r3 removed, 12 missing real ones added, verified against the actualinstructions/r3/core/skillstreeorchestrator-contractrenamed toorchestrationin the three places that still used the old name; a phantomanalystagent removed- Skill counts, drifted to 40/40/38 across
docs/ARCHITECTURE.md, its web mirror, andllms-full.txt, now read 42 in all three; the same three docs' workflow-type counts went from 13 to 17 - Web site sync also closed older drift unrelated to this week's own changes: a dead anchor link on the usage-guide page, a missing quickstart Automated QA section, an architecture Versioning section, a developer-guide git pre-commit hook section, and a "why not just use IDE rules?" answer missing from the web FAQ
- Two lessons recorded for future sync runs: verify a handed-off file against the repo instead of trusting its author's summary (caught three more stale references this way), and never edit
docs/web/llms-full.txtdirectly, since CI overwrites it from the root copy on every build - The
checklistskill (maintainer-internal) now asks for a mix of general and request-specific items, not just archetypal ones - Routine: weekly GitHub stats snapshot refreshed
- Change.
[Docs]Root README's skill section, previously two flat top-N lists (guardrails, then skills) that had gone stale as new skills shipped, is replaced with a categorized catalog of all 42 skills, one line each, linked to its own README, grouped by the job it does (understand what exists, decide what to build, build it, delegate the work, stay safe, recover when it goes wrong, extend, domain packs, and more). Each skill's own README gained the same one-liner as a new second paragraph, mirroring the root list; a new lesson recorded inagents/MEMORY.mdrequires editing both together so the copies don't drift, and sets the bar for writing them: state what the skill is for, in the reader's terms, at its widest true scope, and never let a section name or a single example become the subject of the sentence. (Igor Solomatov, isolomatov-gd, with Claude Opus 5) - Why it helps. A flat "Top 8" list can't represent 42 skills without hiding most of them; a categorized catalog scales, and a reader can find the one skill for their actual job instead of scanning an arbitrary top list. The writing bar now exists once, in a place this and future skill READMEs can both reuse.
- Change.
[Docs]The web site's introduction and architecture pages, andllms-full.txt, are updated to match the new README skills catalog, then swept for older drift found independently: a dead#how-rosetta-protects-youanchor on the web usage-guide page, a missing quickstart Automated QA section, an architecture Versioning section, a developer-guide git pre-commit hook write-up, and a "why not just use IDE rules?" answer missing from the web FAQ (rootFAQ.mdgot the same entry, so the pair can't drift apart again).llms-full.txt's own skill list, unedited since the file was created, named eight skills that no longer exist in r3 and omitted twelve real ones; it's now verified against the actualinstructions/r3/core/skillstree, withorchestrator-contractrenamed toorchestrationand a phantomanalystagent removed. Skill counts quoted indocs/ARCHITECTURE.md, its web mirror, andllms-full.txthad drifted to 40/40/38; all three now read 42. The same three docs' workflow-type counts moved from 13 to 17; agent counts (10) were already consistent and untouched. (Igor Solomatov, isolomatov-gd, with Claude Opus 5) - Why it helps. Docs that quote a stale skill list or a wrong count actively mislead a reader trying to learn what Rosetta can do; catching drift that predates the week's own changes, not just the changes themselves, is the point of a sync pass. Two lessons recorded for the next one: a peer session's own summary of its diff is a claim to verify, not evidence to adopt (verifying one handoff here caught three more stale references), and the web copy of
llms-full.txtis a CI-generated artifact overwritten from the root file on every build, so it's never the one to edit.
A new harness skill formalizes how the AI builds the apparatus it needs to run, observe, and automate its own work — CLI/MCP actions, devcontainers, per-agent skill and hook authoring, unattended automations — covering eight coding agents (Claude Code, Codex, Cursor, Copilot, Windsurf, Antigravity, opencode, JetBrains Junie) with real captured session logs as evidence, not claims. The coding and testing skills now point at it directly instead of a narrow "CLI testing harness for libraries" line.
Repo automation (analysis, triage, planning, implementation, prompt validation) can now run on Codex as well as Claude Code, chosen per dispatch or a repo-wide default, now Codex. Getting there took real debugging: a mutation gate that reported verified GitHub work as "changed nothing" three times, a filesystem deny that instead broke DNS and git for the whole run, and a mystery ~60-minute runner death that a watchdog and resource sampler were built to diagnose before the real cause turned up — a leftover process, not a timeout. That diagnostic scaffolding is gone now that the fix is known.
Highlights
- A new harness skill designs, gates, and proves the tooling an agent needs to run, observe, and automate its own work, across eight coding agents (#330)
- coding and testing skills now recommend the harness skill directly when there's no way to run or observe a change locally
- CI pipelines (analysis, triage, planning, implementation, prompt validation) can run on Codex as well as Claude Code, chosen per dispatch or a repo-wide
ROSETTA_CI_AGENTvariable, defaulting to Codex - Codex and Claude runs use matched model/effort tiers, drawn from the same ladder the subagent instructions already declare
- The mutation gate's trace parser missed most of what Codex actually ran (JS-wrapped calls, template-literal commands, chained shell commands); fixed and verified against real runs that had been misreported as no-ops
- A filesystem deny ported from Claude's per-tool model instead broke DNS and git config for the whole Codex run; removed
- ~60-minute runner deaths traced to the Codex action leaving its process tree running after success, not a timeout; the watchdog and resource sampler built to chase it are deleted now that the real cause is fixed
- The Codex action is pinned to v1.11: v1.12 carries two upstream bugs behind the deaths, one of which kills the whole runner's DNS
repo-triage, the one pipeline any GitHub user can trigger, deliberately keeps its stricter sudo-revoking safety strategy while the maintainer-gated pipelines get an escape hatch- The backlog skill now works disjoint bounded stories in parallel instead of one story per run
- The lightweight coding workflow gained proper red/green TDD support
validate-promptsis back on pull requests and now publishes its execution trace like the other four pipelines
- Change.
[R3]A new model-invocableharnessskill designs the executable apparatus an agent needs to run its work, prove it, and stop repeating it by hand: CLI/MCP actions against a live service, devcontainers, per-agent skill and hook authoring, and unattended automations. It classifies the gap, writes a specification, gates it on HITL approval, hands implementation tocoding-flow, then requires proof by actual execution before recording a## Harnessentry inARCHITECTURE.md. It ships with hook-wiring reference guides for eight coding agents, each backed by real captured session logs. Thecodingandtestingskills' validation guidance now recommends it directly, replacing a line scoped only to "CLI testing harness for libraries/packages". (Igor Solomatov, isolomatov-gd) - Why it helps. The old guidance covered library CLIs only; one skill covering "cannot run, observe, or prove it" across five remedies means the AI reaches for the right one instead of improvising each time. Real logs per agent turn a hook-wiring claim into something checked against evidence.
- Change.
[CI]repo-analysis,repo-triage,repo-plan,repo-implement, andvalidate-promptsnow run on either Claude Code or Codex behind one variable, chosen per dispatch input or a repo-wideROSETTA_CI_AGENTdefault (now Codex). Both branches authenticate through the same Bifrost key on different routes — Anthropic base URL for Claude, the OpenAI Responses API for Codex. Codex model/effort pairs mirror the Claude ladder position-for-position from the subagent instructions (opus↔gpt-5.6-sol, sonnet↔gpt-5.6-terra, haiku↔gpt-5.6-luna). Codex has no per-tool allow-list, so three permission profiles stand in instead — read-only with network, workspace-write with no network, workspace-write with network — and each pipeline takes the least it needs. (Igor Solomatov, isolomatov-gd, with Claude Opus 5) - Why it helps. Running the same automation on a second model family is a real test of whether the instructions generalize past one vendor, and gives a fallback if either provider has an outage or a cost spike.
- Change.
[CI]The first smoke runs found a mutation gate that reported real, verified work — issue creation, project board edits — as "changed nothing", three separate times, because its trace parser understood only one of the three command shapes Codex's JS wrapper actually emits: bare JSON, quoted-but-bare keys, and backtick template literals. A fourth gap let chained commands (pwd && gh issue create ...) slip past a gate anchored to match only the first command in a line. All four are fixed and verified against the runs that had been misreported. Separately, a filesystem deny ported from Claude's tool-blocking model (Read(//etc/**)) instead removed/etcfrom the whole Codex process, taking out the TLS trust store and git config and breaking every network and git call; removed, since a Codex permission profile denies a path from the process, not a tool from the agent. (Igor Solomatov, isolomatov-gd, with Claude Opus 5) - Why it helps. A mutation gate that under-reports is the one failure mode a "did this run actually do anything" check can't afford — it would wave through a run that quietly did real work. A filesystem deny that breaks unrelated system function is worse than no deny at all.
- Change.
[CI]Long Codex runs were dying at 52–67 minutes with no logs, execution trace, or diagnosis. Two rounds of instrumentation — a resource sampler, then a step-level watchdog with a liveness check — chased it as memory starvation, then a network stall, then an Actions timeout later proven to be silently ignored on composite-action steps. The real cause:openai/codex-actionleaves its response proxy and exec process tree running after its step reports success, so the runner just waits on a still-open pipe until GitHub gives up on it around an hour in. Once found, the sampler and watchdog scaffolding built to chase it were deleted and replaced with one ordinary cleanup step, and the action is pinned to v1.11 — v1.12 carries the bug that caused this, plus a separate report of runs that never return. (Igor Solomatov, isolomatov-gd, with Claude Opus 5) - Why it helps. Root-causing it by reading what the failing runs actually had in common, instead of adding another timeout, turned a permanent diagnostic apparatus into one cleanup step. Pinning the action avoids a second upstream regression rather than working around it indefinitely.
- Change.
[R3][CI]The backlog skill now works disjoint bounded stories in parallel instead of one story per run. The lightweight coding workflow gained explicit red/green TDD support: when the context requests it, test authoring and review move ahead of implementation.validate-promptsis back on pull requests — paused earlier on cost grounds, but its path filter already bounds that cost — and now publishes its execution trace like the other four pipelines, closing the one pipeline that could be audited for its report but not its actual behavior. Two prompt gaps found on live planner and implementer runs are closed: the planner's own Bash allow-list blocked it from reading the CodeQL data a different section of the same prompt told it to handle, and the implementer's workspace-write profile pointed npm's cache and the GitHub step summary at read-only paths. (Igor Solomatov, isolomatov-gd) - Why it helps. A permission gate that contradicts the same prompt's stated job, or a pipeline no one can audit for behavior, undermines trust in the automation faster than it saves time.
A new backlog skill splits two jobs that used to live inside planning: grading whether a tracked story is actually ready for development (business and technical verdicts, each independent), and writing the human work breakdown once it is. The split let both get sharper: readiness grading gained a three-state severity scale (blocker, hold, advisory) instead of one binary flag, an idempotency key so a repeat run can't duplicate tracker items, and a hard limit on what it's allowed to write. Every subagent role also picked up an explicit effort setting and a color shown in Claude Code's UI, with the lightweight profile deliberately keeping architect on stronger models while moving other high-complexity roles to cheaper ones for the same effort.
On the server side, a dead team-authorization path that never actually scoped anything to a team is removed, and dataset name lookups stopped silently returning the wrong dataset on a name collision. The dangerous-actions hook's pattern matcher had a second quadratic-blowup bug, this time across thirteen matchers rather than just git branch delete, fixed the same way: check only the first candidate a lookahead window would ever match. A batch of twelve smaller fixes closed real gaps across the MCP server, CLI, plugin generator, and CI, and a documentation pass brought model IDs up to date and corrected a false claim that the dangerous-actions hook has a hard-deny tier (it doesn't; every match is advise or reconsider).
Highlights
- A new backlog skill validates story readiness (business and technical verdicts) before handing off a work breakdown, replacing planning's old bolt-on human-WBS mode (#307, #318)
- Readiness grading now has three severity levels, blocker/hold/advisory, instead of one pass/fail flag, and won't create duplicate tracker items on a re-run
- Every subagent role gained an explicit effort setting and a UI color; the lightweight profile deliberately keeps architect on stronger models while moving other high-complexity roles to cheaper ones, same effort, lower cost
- A dead RAGFlow team-authorization path that never actually scoped access to a team is removed from the MCP server, and dataset name lookups no longer silently return the wrong dataset on a name collision (#319)
- The dangerous-actions hook's quadratic pattern-matching bug is fixed across thirteen more matchers, not just git branch delete; adversarial input that used to take seconds now resolves in single-digit milliseconds (#320, #329)
- Docs corrected: newly released model IDs across the agent-farm skill, and the false claim that dangerous-actions has a hard-deny tier is gone (#328)
- A batch of twelve fixes closed real gaps: RAGFlow cleanup no longer sweeps up unmanaged docs, a migration lock can no longer be deleted out from under its next owner, and Codex TOML output no longer breaks on backslashes or repeated quotes (#323)
- CLI dataset-name resolution (explicit name, single prefix match, ambiguous match, fallback) is now regression-tested (#322)
- Rosetta's own daily GitHub-triage routing and self-improvement lessons-learned policy got tightened (maintainer-internal, high-confidence lessons only)
- Plugins 3.1.11 / rosettify 3.2.4 / rosettify-plugins 3.3.4 / rosetta-cli 3.0.6 / rosetta-mcp 3.0.5 carry all of the above
- Change.
[R3]A new backlog skill takes over two jobs that used to live inside planning: grading whether a tracked story is ready for development, and writing the human work breakdown once it clears. Readiness grading runs independent business and technical passes over the story and its tracker history, then derives two verdicts with three severity levels: a start blocker, a completion hold, or an advisory note that blocks nothing. A follow-up pass added an idempotency key so a repeat run can't create duplicate tracker items, a hard write-scope limit to the validated item and anything the run itself created, and an explicit rule that filing a follow-up ticket doesn't itself resolve the finding that triggered it. Work breakdown, unchanged in purpose, now sizes steps by shape (wide-shallow versus deep-narrow) instead of by which person or agent does them, and writes only to plan-folder artifacts, never the tracker. (Igor Solomatov, isolomatov-gd, with Claude Opus 5) - Why it helps. Planning previously mixed two different audiences, AI-executor session graphs and human work breakdowns, in one skill; splitting them let each get the depth it needs. The severity scale and idempotency guard close a real failure mode: one bad finding used to drag an otherwise-ready story to fully blocked, and a repeat validation run could double-file the same ticket.
- Change.
[R3][Tooling]Every subagent role now declares an explicit effort level instead of leaving it implied by a model-name suffix, and gained a color shown next to its name in Claude Code's UI. The lightweight profile, built to run cheaper without giving up result quality, moved four of its highest-complexity roles (architect, planner, prompt-engineer, requirements-engineer) to xhigh effort on cheaper models; architect alone was then deliberately kept on its stronger opus and sol models, since architecture decisions carry the highest blast radius even in a lightweight build. (isolomatov-gd) - Why it helps. An effort field that isn't tied to a specific model id survives the next model generation without a rewrite. The lightweight profile's whole point is running cheaper at the same quality; keeping architect on stronger models where blast radius is highest, while moving the rest to cheaper ones, is that trade-off applied deliberately rather than uniformly.
- Change.
[Server]The MCP server's RAGFlow team-authorization path, whose own membership check ignored which dataset was being accessed, is removed along with the RAGFlow team API client and theteamread policy value. Dataset name lookups are hardened separately: RAGFlow dataset names aren't unique across an API key's visible datasets, and a name collision used to overwrite the cached mapping with whichever dataset loaded last. A collision now marks the name ambiguous and returns nothing rather than guessing. (David Turner) - Why it helps. The team policy was unreachable dead code, so removing it costs nothing in practice, but the stale claim it left in docs and the README is now corrected too. A wrong-dataset guess on a name collision would have silently served the wrong content; failing safe is the right default here.
- Change.
[Hooks]Last week's fix closed a specific bypass in the git-branch-delete guard by widening its lookahead to catch flag variants like-fdand--delete --force. Those wider lookaheads turned out to re-scan overlapping windows on every candidate in a string, an O(n²) cost that matters on a matcher running before every Bash call. This week the same fix, checking only the first candidate a lookahead would ever match, is generalized across the other thirteen affected matchers:rm -rf, SQL DELETE/UPDATE without a WHERE clause, git force-push,aws s3 rm --recursive,kubectl deleteon production, dropdb/psql,ddof a device, curl-pipe-to-shell, and GPG private key handling. A new scaling test suite pins exact pre-change detection semantics across all of them and asserts a latency budget. (David Turner for the initial git-branch-delete fix, Igor Solomatov for the generalization) - Why it helps. An adversarial input of a few thousand near-miss candidates used to take the matcher from milliseconds to multiple seconds; on a hook gating every shell call, that's a stall the agent and the user both feel. The scaling tests mean a regression to the old pattern now fails on latency, not just correctness.
- Change.
[Docs]The coding-agents-farm skill's model-selection guidance is rewritten tier-first (workhorse, complex, fast) with the newly released model ids (Claude Opus 5, GPT-5.6 Terra/Sol/Luna, Gemini 3.7 Flash) as a dated snapshot rather than a fact to trust from memory, and gains a fallback: if the CLI rejects an id, drop the flag and take its default instead of substituting a remembered name. Architecture docs are corrected to match actual hook behavior: dangerous-actions has no hard-deny tier, every match is either a non-blocking advise notice or an overridable reconsider soft-deny, and the hook is registered on shell and MCP tool calls only (write/edit evaluation exists in code but isn't wired into any IDE's hooks.json yet, a deliberate release scoping). (Igor Solomatov, with Claude Opus 5) - Why it helps. A stale model id or an overclaimed safety tier in the AI's own instructions is worse than no claim at all, since the AI trusts it by default. Tier-first guidance survives the next model release; the old flat list didn't.
- Change.
[Server][CLI][Tooling][CI]Twelve low-risk fixes landed together: RAGFlow cleanup now only touches docs it actually manages, a Redis migration lock is now released with a per-run token so it can't delete a successor's lock after its own TTL expires,parsecollapses several RAGFlow list calls into one, and three PyPI publish workflows gained least-privilegecontents: readinstead of relying on repository defaults. The plugin generator's Codex TOML output now escapes backslashes and repeated quotes correctly, and a missing Gemini 3.5 Flash vocabulary entry for Copilot is filled in. Separately, CLI dataset-name resolution (explicit name, single prefix match, ambiguous match, fallback to default) gained regression tests. (Igor Solomatov, David Turner) - Why it helps. Each of these either corrupted state silently, blocked on an unbounded network call, or would have broken on the first instruction body containing a backslash; none needed a redesign, just a real fix backed by a test.
The planning skill got rebuilt around how Rosetta actually works: it now hands each execution session a self-contained "what to do and what to check" file instead of a human-style work breakdown, with the old format demoted to an explicit ask. A new arrange-workspace-flow turns workspace setup from an unenforced checklist into a tracked six-phase interview, and two new skills, discovery and design, add disciplined fact-finding and reversibility-weighted decisions you can trigger directly.
The plugin generator can now build a lighter, cheaper-model distribution alongside the standard one, and every model name Rosetta references moved forward a generation. A batch of small fixes closed real gaps: RAGFlow uploads without a release no longer land in a garbage dataset, the MCP server stops blocking on slow downloads, and a git branch force-delete guardrail bypass is closed. repo-triage runs for external contributors again, with its file-read tools scoped so a malicious PR can't read runner secrets.
Highlights
- The planning skill now hands each execution session a self-contained file, what to do and a checklist, with the old human-style work breakdown demoted to an explicit ask
- A new arrange-workspace-flow walks you through workspace setup in six tracked phases instead of a static checklist (#217)
- Two new skills, discovery and design, are ready to use: fact-only investigation, and decisions weighted by how hard they are to reverse
- The plugin generator can build a lightweight, cheaper-model plugin alongside the standard one (#310)
- Every model name Rosetta references moved forward a generation, and Cursor/Copilot stopped silently dropping tokens they had no mapping for
- repo-triage runs for external contributors again, with its file-read tools scoped to the checkout so a malicious PR can't read runner secrets
- Prompt-diff validation is paused on pull requests (manual dispatch only) while it moves onto the shared Claude Code action
- RAGFlow publishes without a release no longer land in a dataset literally named
aia-{release}, and RAGFlow HTTP timeouts are configurable instead of hardcoded - The MCP server no longer blocks other requests while one document downloads
- A
git branchforce-delete guardrail bypass (-fd,--delete --force) is closed - Package publish workflows can no longer race or double-publish
- Plugins 3.1.10 / rosettify 3.2.3 / rosettify-plugins 3.3.2 / rosetta-cli 3.0.5 / rosetta-mcp 3.0.4 carry all of the above
- Change.
[R3]The planning skill's default output changed from a human-oriented work breakdown (EARS requirements, a size-scaling table, 20-minute WBS steps) to a graph of self-contained session files, one per fresh coding-agent session that already shares the same environment and skills. Each file states only what to do and a final checklist, no process or methodology, and calls out project-specific traps (an asymmetry to preserve, ported code that must stay unchanged, hidden ordering) instead of restating docs it can reference by path. Sessions are ordered leaf-first with explicit file ownership so parallel sessions can't collide, and a new HANDOFF.md tracks cross-session status. The old EARS/WBS flow still runs, but only when you explicitly ask for a human work breakdown. (Igor Solomatov, with Claude Opus 5) - Why it helps. Plans were being read by AI subagents, not people, but the old format assumed a human reader and either over-specified process the executing agent didn't need or missed the traps that make ported code silently wrong.
- Change.
[R3]A new arrange-workspace-flow walks you through workspace setup in six phases: choose a layout, onboard reference source code, fill gaps in business and technical context, cover modernization facts if that's your goal, then get ecosystem recommendations. It replaces a static checklist you had to self-drive with a tracked interview: progress persists between phases, and only gaps get asked about, so nothing you already documented gets asked again. Anything the AI infers without your confirmation goes to docs/ASSUMPTIONS.md instead of straight into CONTEXT.md or ARCHITECTURE.md as fact. (Yevheniia Lementova) - Why it helps. A manual checklist enforced nothing and tracked nothing; you could skip a step silently, and the AI had no record of what it already covered.
- Change.
[New skill]discovery enforces fact-only investigation: everything you state must be cited, a path and line range or command output, "not examined" is called out separately from "examined and found absent," and a wrong existing solution gets flagged instead of silently worked around. design enforces proportional rigor: a one-way, high-blast-radius choice gets real alternatives and written reasoning, a reversible local one gets a sentence, and alternatives can't be invented after the fact to justify a favorite. design ships with 13 domain reference files, covering payments, regulated data, multi-tenancy, and more, each naming the traps specific to that domain. - Why it helps. Nothing previously forced a disciplined, evidence-only fact-finding pass distinct from opinion, or forced a decision's rigor to match how expensive it would be to reverse.
- Change.
[R3][Tooling]The plugin generator now supports build profiles: a lightweight profile ships alongside the standard build, steering each of the 10 subagent roles toward its own smaller model instead of moving every role the same way. It also gained a filename-directive validator, so a typo in a plugin source filename now fails the build instead of shipping a directive that silently did nothing. Every model name Rosetta references also moved forward a generation (Opus to claude-opus-5, GPT, Gemini, and Grok to their next tier), and Cursor and Copilot stopped silently dropping model tokens they had no mapping entry for. (Igor Solomatov, nightcityblade) - Why it helps. A single uniform model override suits a client pinned to one vendor, but a genuinely lighter build needs each role downgraded on its own terms. A guidance list that quietly loses entries for two of four target IDEs, or a plugin source file with a silently-ignored typo, undercuts the same goal: shipping instructions that say what they mean.
- Change.
[CI][Security]repo-triage now runs for pull requests, issues, and comments from non-collaborators, the exact audience it exists to greet, instead of failing outright on every one of them. That widening exposed a real gap: bare Read/Glob/Grep grants carry no implicit sandbox, so a prompt-injected instruction from an untrusted PR could read anywhere the CI runner can, including environment variables holding API keys. Both tools are now scoped to the checkout directory, with an explicit deny on /proc and /etc as a second layer. Separately, validate-prompts moved onto the same shared Claude Code action the other pipelines use, then had its pull-request trigger turned off pending further work, so prompt-diff validation currently runs on manual dispatch only. (Igor Solomatov) - Why it helps. Triage existed to help outside contributors but was failing on all of them; fixing that without scoping its tools first would have traded a broken feature for an exploitable one.
- Change.
[CLI][Server][Hooks]A publish without a configured release no longer lands in (or creates) a RAGFlow dataset literally namedaia-{release}. The MCP server no longer blocks other requests while one document downloads, and agit branchforce-delete guardrail bypass (-fd,--delete --forcein either order) is closed.loose-filesand lint advisories stopped skipping a real path just because it contains an excluded name as a substring, sorebuild/app.tsis no longer treated asbuild/. Package publish workflows gained concurrency locks, so consecutive commits to the same package can no longer race or double-publish. A handful of smaller fixes round out the batch: curiocity's max-turn limit is now configurable per trial, aREAD_ONCE_TTL=0no longer silently reverts to the default, RAGFlow HTTP timeouts are configurable instead of hardcoded, a partial API key excerpt is trimmed out of CLI logs, and a confirmed-dead validation function was removed from the MCP server. (fauad123, nightcityblade, Shin, joyheroes, David Turner, mikemikimike, Tech Guy, Igor Solomatov) - Why it helps. Each of these either silently corrupted state, stalled other requests, bypassed a safety guardrail, or leaked secret material; none needed a redesign, just a real fix.
The AI's specs command now writes requirements the way requirements-authoring already teaches it to: acceptance criteria as typed EARS objects, evidence and subsystem/component per requirement, one shared markup grammar for both writing and reading a unit. You also get two new guides this week — a day-to-day User Guide and a Modernization Guide — both published through a web build that now matches what you see locally.
The AI asks tighter questions now: 5-15 words, one topic, escalating at MEDIUM severity instead of waiting for CRITICAL or HIGH. Six CI papercuts got fixed too, including an actions/checkout guardrail change that had been failing every fork pull request outright.
Highlights
- The AI stores acceptance criteria as typed EARS objects instead of given/when/then triples (#250)
- You can author a complete requirement unit from the specs command's own
--help, no external template needed - The AI never reuses a purged requirement id, and
migrateskips anything outside the canonical shape rather than guessing at it - You get a new day-to-day User Guide: pick your scenario, follow one page start to finish (#251)
- The web site now builds with Rosetta's own Jekyll engine, so a local-only bug can't reach production silently
- You get Rosetta's first Modernization Guide: principles, red flags, process, and start prompts
- The AI's clarifying questions are now 5-15 words, one topic each, and it escalates at MEDIUM severity, not just CRITICAL/HIGH
- Fork pull requests build again after
actions/checkout's new guardrail, without exposing the base repo's token - Publish runs can't overlap, and the hooks CI job stopped building the package twice
rosetta-cli parsereports real skipped counts, and the MCP server's RAGFlow client honors its configured timeout- Plugins 3.1.9 / rosettify 3.2.1 carry all of the above
- Change.
[R3][Tooling]The AI now stores acceptance criteria as typed EARS objects — id, pattern, condition, responder, outcome — instead of a given/when/then triple, and can author a complete requirement unit from its own--helpwithout an external template. It scopes each requirements document to a system rather than a component, tracks evidence/subsystem/component per requirement, and never reuses a purged id. When you ask it to author or migrate a unit, it renders and reads one shared markup grammar, so it never reconstructs a unit's shape by inference — anything outside that shape it skips and tells you why. (Igor Solomatov, with Claude Opus 5) - Why it helps. Given/when/then paid for the same fact three times across a requirement; you now get strictly more specification for the same context, and each criterion is separately testable so a coverage gap shows as one missing row instead of a whole requirement. You can also ask it precise questions — which criteria touch a given subsystem, which lack evidence — instead of grepping raw markup.
- Change.
[Docs]You get a new day-to-day User Guide: what Rosetta is, how to install and initialize, then one page per real task — coding, modernization, requirements, security review, and more — each telling you what to do before it explains how it works. README, the Usage Guide, PLUGINS, and OVERVIEW all send you there first now. The AI also fixed the site's build pipeline: it now compiles with the project's own Jekyll 4.4 instead of GitHub's older bundled gem, so a page that worked locally can no longer silently fail only in CI. (abatyukgd, isolomatov-gd) - Why it helps. You previously had to reconstruct intent from reference docs written for a different audience; now you pick your scenario and follow it end to end. And the site you read now matches what ships locally, because both build with the same engine.
- Change.
[Docs]You get Rosetta's first migration methodology guide: principles, red flags, the process, and start-prompt templates, replacing a raw prompts file nobody was meant to read directly. The coding flow, the configuration doc, and the modernization workflow page all link to it now. (isolomatov-gd) - Why it helps. Migration work fails in specific, repeatable ways that a generic coding flow doesn't call out; you and the AI now start from the same playbook instead of relearning the same mistakes per project.
- Change.
[R3]The AI now asks you shorter, sharper questions: 5-15 words, one topic each, never two folded into one — and if it can't phrase a question that simply, it has to think harder before asking. It opens another questioning round on any MEDIUM-severity gap, not just CRITICAL or HIGH. Its answer options now include a safest pick, a by-the-book pick, the simplest option, and a genuinely different angle, on top of its usual recommendation. Rosetta's own repository also gainedAGENTS.mdandCLAUDE.md, so a contributor's coding agent picks up this project's context automatically instead of starting cold. (isolomatov-gd) - Why it helps. A wide open-ended question gets skipped; a narrow one gets answered, so you spend less time re-explaining what you meant. Catching ambiguity at MEDIUM severity means you resolve it before it becomes rework instead of after.
- Change.
[CI]Six papercuts got fixed this week. Fork pull requests stopped failing outright afteractions/checkout's new guardrail landed on every major tag; both affected workflows now opt in explicitly and stop writing the base repo's token into the checked-out fork tree (#242). Publish runs can no longer overlap (#248), and the hooks CI job stopped building the package twice (#249). Workflow actions are aligned to their current versions (#214).rosetta-cli parsenow reports real skipped counts instead of always zero (#213), and the MCP server's RAGFlow client honors its configured timeout instead of a hard-coded 30 seconds (#215). A copy-pastedcheck_state/check_modetag mismatch in the codegraph workflow doc is fixed (#236, #237). (Sebastian Legarraga, fauad123, breezeFur, 21cjyp-star, Igor Solomatov with Claude Opus 5) - Why it helps. Each of these either blocked a contribution outright, doubled a CI job's runtime, misreported status silently, or would trip a future lint pass; clearing them now means the next contributor doesn't inherit them.
The AI now writes requirements that say something different at every level. It used to state the rule as an EARS sentence, then restate it as Given/When/Then acceptance criteria, paying for the same fact three times on every turn. It now states the rule once, with the cases it covers and what it excludes, and spends the criteria on concrete, separately addressable cases. You get far more specification out of the same context, and your tests can claim coverage of exactly one criterion.
You can also take work from idea to merged pull request without opening an editor. You move a card to approve a plan, you answer comments, you review the pull request. The AI does everything in between. A full end-to-end implementation now runs from a phone.
Highlights
- The AI states a requirement rule once and spends acceptance criteria on distinct cases (#204)
- Your tests claim one criterion at a time, so a coverage gap shows up as a missing row
- The AI sweeps all nine ISO 25010 quality buckets and writes down why it leaves any of them out of scope
- The AI asks which feature flags exist before it designs, and writes code that holds in every flag state
- Your Rosetta docs survive a format pass now: workspace init keeps them out of Prettier's way
- The AI spends less on every session by not re-fetching its CLI helpers from the registry on each call
- You drive development from the board: approve a plan, answer comments, review the pull request
- The AI filed 18 issues across two runs on 05.08, and six reached merge the same day
- The AI finds your reference sources on case-sensitive filesystems, where a capitalized folder used to come back empty (#190)
- Anyone filing an issue gets a template that asks for what a maintainer needs (#202, from #201 by omaiesh)
- You can read how the automation is wired in the new
docs/AUTOMATION-ARCHITECTURE.md - Plugins 3.1.8 carries all of the above
- Change.
[R3]The AI no longer writes a requirement statement as an EARS sentence. It states the governing rule, the cases it reaches, and what it explicitly excludes. It then writes each acceptance criterion as a distinct, separately identified case carrying its own EARS pattern, so a test can claim exactly one of them. For non-functional work it sweeps all nine ISO 25010 quality buckets every time and records a decision when it leaves one out of scope. It tracks coverage per criterion rather than per requirement. (Igor Solomatov) - Why it helps. EARS carries one trigger and one response, so a statement written in it had nowhere to put scope or exclusions, and the criteria could only echo it back. You now get strictly more specification out of the same context. You can also ask questions of a whole requirements set: which criteria cover error paths, which requirements the AI inferred rather than you stating them, where the spec has drifted from the code.
- Change.
[CI][Docs]You now approve a plan by moving a card, and you review the result as a pull request. The AI files the issue, writes the plan into it, claims it, implements it, and opens the pull request, and it cannot promote its own work past either of your two decisions. When a run cannot finish, it leaves the card where nothing will pick it up again and tells you on the issue. It also holds back security-alert detail from public issues, referencing an alert by URL and severity only. You can read the whole design indocs/AUTOMATION-ARCHITECTURE.md. (Igor Solomatov) - Why it helps. You no longer need a checkout, an editor, or a laptop to get work merged. Two card moves and a few comment replies are the entire human interface, so an end-to-end implementation runs from a phone. The AI now also fails a run that produced nothing, so you learn about it the same day rather than after a week of green checkmarks.
- Change.
[CI][Server][R3]Six issues the AI filed on 05.08 went through planning, your approval, and merge the same day. It made CI cancel stale runs, taught the MCP pipelines to notice a dependency change, brought the last workflow onto the current Node action, covered the instruction cache with tests, fixed reference-source lookups on case-sensitive filesystems, and dropped a stale invariant pointing at a file nobody ships (#183, #184, #186, #188, #189, #190). (Igor Solomatov) - Why it helps. These are the fixes a repository accumulates and nobody schedules. Getting them merged with you approving each plan and each pull request is what makes the loop trustworthy for real work.
- Change.
[R3][Tooling]The AI asks which feature flags exist before it designs, and writes code that holds whether a flag is on or off. It keeps your Rosetta docs out of Prettier's way, so the headers it navigates by survive a format pass. It stops re-fetching its CLI helpers from the registry on every call. It finds your reference sources on case-sensitive filesystems. And when it authors instructions for other agents, it states the rule instead of describing it. All of this reaches you in plugins 3.1.8. (Igor Solomatov) - Why it helps. A flag your spec never named is a branch the implementation never covered, and you meet it in production instead of review. The registry lookup ran several times per step, so dropping it saves real time and money on every session.
- Change.
[Docs]Anyone landing on the repository gets one Quick Start instead of two competing ones, plus a second demo showing a frontend migration end to end. Copilot users on JetBrains can install from the Marketplace, with the standalone package presented as the fallback it is. Anyone filing an issue gets a template that asks for what a maintainer needs (#201 by omaiesh, #202). GitNexus licensing is stated plainly as paid. (Igor Solomatov) - Why it helps. The README answered "how do I install this?" twice, and the duplicate went stale first. JetBrains users were being sent down the harder path for no reason.
An external open-source review of Rosetta was published on 25.07. This week closed most of what it flagged: CodeQL analysis, PR CI for src/hooks (the one item the review called genuinely missing), per-package pipelines for rosetta-cli and rosetta-mcp, and 7 Dependabot alerts patched. The larger delivery is security-flow, a full security review workflow with eight mandatory-subagent phases, a filename-only secret gate that runs before any target content reaches a model, and active testing bounded to pre-production. Repo automation dropped Atlassian entirely for GitHub Projects v2. Every CI workflow now routes its model calls through the Bifrost gateway instead of a raw Anthropic key.
Highlights
- New
security-flowworkflow andsecurityskill (#163): 8 phase files, 18 activity assets, 7 output templates; the secret gate runs before source ingestion, production active testing is prohibited - Rosetta now covers 13 SDLC workflows, up from 12. README, FAQ, USAGE_GUIDE, and the website updated
- CodeQL Advanced analysis on every push and PR to main plus a weekly scan (actions, JavaScript/TypeScript, Python)
- New CI pipelines for
src/hooks,rosetta-cli, androsetta-mcp - All 7 Claude Code CI workflows route through the Bifrost gateway (#161); blanket
Bash(*)grants replaced with explicit read-only subcommand allowlists - Codex plugin emits workflows as invokable skills (#162, #164); the Antigravity-only transform became the shared
fileWorkflowToSkill - Repo automation (analysis, plan, implement, triage) moved off Jira and Confluence onto GitHub Projects v2 and the repo Wiki; the nightly analysis schedule is paused pending a reviewed manual run
- Guardrails tightened for higher environments:
dangerous-actionsstates higher environments are never allowed,risk-assessmentnames stage and pre-production explicitly and covers direct SQL/API server access load-project-contextreadsdocs/CONTEXT.mdanddocs/ARCHITECTURE.mdin full, and recognizes area-scopeddocs/<area>-CONTEXT.md/docs/<area>-ARCHITECTURE.md- LARGE orchestration reframed: delegate everything to subagents rather than always standing up the session EXECUTION_CONTROLLER
- Every workflow now declares an explicit state-file path,
agents/TEMP/<FEATURE>/<flow>-state.md - Versions: plugins 3.1.0 → 3.1.6, marketplace 3.0.0 → 3.1.6, rosettify and rosettify-plugins 3.1.0 → 3.2.0
- 7 Dependabot alerts patched in rosettify; roughly 53 MB of stale binaries dropped from
test-library/ - New
docs/prompts/modernization-prompts-raw.md, nine raw prompts for frontend replatforming - Product-owner dispositions published for all 98 rows of the external review
- Change.
[R3]Addedsecurity-flow: eight phases, each a mandatory subagent dispatch. Readiness, authorize, deterministic gates, model and select, inspect and test, normalize and triage, independent review, report and package. Every phase lives in its own file that only the assigned subagent may read. The orchestrator owns approvals, dispatch, and aggregation, and never loads a phase file. Behind it sits the newsecurityskill with 18 activity assets (code, API, architecture, cloud, containers, Kubernetes, IaC, packages, secrets, a secret-scan script, web DAST, network pentest, DNS recon, gateways, host compliance, exfiltration, LLM/AI, GUI-bot recommendation) and 7 output templates (run record, finding, evidence envelope, threat model, report, remediation task, task index). The secret gate runs before any agent or model ingests source and returns filenames only, never matches or values. Hits in DEV/QA need explicit approval after recommended exclusions. Hits above QA, or from an ambiguous environment, stop the run and cannot be overridden. Active testing is allowed only against explicitly approved pre-production targets. The capability never starts remediation; it emits concise inputs for a later user-invoked coding flow.[Docs]New website page and sidebar entry, a Security Review section inUSAGE_GUIDE.md, anddocs/SecurityOnePager.mdcovering the plugin-mode security posture. Workflow count moved from 12 to 13 across README, FAQ, and the website. (Igor Solomatov) - Why it helps. A security agent that reads source before checking for secrets has already leaked them into a model context nobody can recall. Ordering the gate first is the whole point, and making the above-QA stop non-overridable means no amount of prompting talks the agent past it. Keeping remediation out of scope is deliberate too: a reviewer that also fixes things stops being an independent reviewer.
- Change.
[Tooling]Codex used to receive workflows as flat documents under.agents/workflows/plus a workflows index, so they never surfaced as anything a user could invoke. Codex now emits.agents/skills/<workflow>/SKILL.mdwith owned phase files underphases/and frontmatter stripped, matching what Antigravity already did. The Antigravity-onlyfileAntigravityWorkflowToSkillprocessor became the sharedfileWorkflowToSkill, used by both targets. A newpluginReplaceLiteralsprocessor corrects the one glob string that folder rename-pairs structurally cannot reach, keyed on the long literal so an identical bare token elsewhere stays untouched. TheBOOTSTRAP_PREFIXconstant and theisLeadmanifest flag were deleted: every bootstrap entry now gets the same leading-newline strip. New e2e coverage for session-start bootstrap and Codex output, plus 89 lines of recorded requirement changes. (Igor Solomatov) - Why it helps. Codex users could not invoke a Rosetta workflow at all, only read one. Two targets needing the same transform is the signal the transform was never target-specific, and one shared processor is one place to fix a bug rather than two that drift.
- Change.
[CI]Added CodeQL Advanced analysis over actions, JavaScript/TypeScript, and Python, running on every push and PR to main plus a weekly scheduled scan. Added three pre-merge CI pipelines:ci-rosetta-hooks.yml(type-check, build, test on anysrc/hookschange),ci-rosetta-cli.yml, andci-rosetta-mcp.yml. Routed all 7 Claude Code CI workflows through the Bifrost gateway (#161), swappingANTHROPIC_API_KEYforBIFROST_API_KEYand settingANTHROPIC_BASE_URL,ENABLE_TOOL_SEARCH=true, andCLAUDE_CODE_DISABLE_AUTO_MEMORY=1. Replaced blanketBash(*)grants in the triage and prompt-validation workflows with explicit read-onlygitandghsubcommand allowlists. (Igor Solomatov) - Why it helps. The external review named PR CI for
src/hooksas the one genuinely missing piece; it now exists, alongside the two Python packages that also had no gate of their own. A gateway credential can be rotated and rate-limited centrally, which a per-repo provider key cannot. And an automation agent holdingBash(*)on apull_request_targettrigger is a much larger grant than any of these prompts actually use.
- Change.
[CI]Therepo-analysis,repo-plan,repo-implement, andrepo-triageworkflows no longer touch Jira or Confluence. Work items live on the Rosetta Automation Board (GitHub Projects v2), queried throughgh project item-list/field-list/viewinstead of JQL;load_stories.pywas rewritten accordingly. Plan and implement agents claim work by moving Status to In progress, and are never allowed to promote Backlog to Ready, so the human gate survives. Background knowledge and the run log moved to the repo Wiki, which the agent may write into its local checkout but never push; a dedicated workflow step does the commit and push. Triage'sghpermissions were restored after an earlier git-only narrowing had silently broken every triage run, since that prompt usesghand nevergit. Three automation prompts gained explicitsrc/versusinstructions/guidance so instruction files are not mistaken for ordinary documentation. The nightly analysis schedule is commented out until a manual run has been reviewed. Remaininginstructions/r2path references bumped to r3. (Igor Solomatov) - Why it helps. One issue tracker instead of two, in the same place as the code and the PRs, with no Atlassian credentials in CI. Splitting the wiki push out of the agent's tool grants means a misbehaving prompt cannot rewrite project history. The triage fix is the useful lesson: narrowing tool grants without checking what the prompt actually calls produces a workflow that fails silently rather than loudly.
- Change.
[R3]dangerous-actionsgained a rule directly under blast-radius assessment: never allowed to use or touch any higher environment. Its description now lists stage, pre-prod, and prod as activation triggers.risk-assessmentextended its trigger to any access to servers of higher environments, its first step to cover direct SQL and API servers rather than only MCPs, and its escalation step to spell out stage and pre-production alongside production.bootstrap-alwaysonhardened "avoid re-reading files by yourself" into "MUST NOT RE-READ files/websites/etc, unless content is lost". Changes propagated to all 7 plugin targets. (Igor Solomatov) - Why it helps. "Higher environments" was already in the text, but as a scoring input rather than a prohibition, and a model reading it that way will happily assess the risk of a stage database and then proceed. Naming stage and pre-production as separate words matters because agents treat "production" narrowly and treat everything else as fair game.
- Change.
[R3]The LARGE orchestration band no longer mandates the session EXECUTION_CONTROLLER. It now says the orchestrator's context will overload, so it must delegate everything to subagents and keep its own todo tasks at a higher level; the execution controller is available on direct request. Subagent prompts gained an optional Process Requirements field for batching and ordering constraints, andS.M.A.R.T.was dropped from the task line.subagent-directivesadded a rule requiring factory-style work to be split into groups: read one small set of files, produce, then read the next.load-project-contextnow readsdocs/CONTEXT.mdanddocs/ARCHITECTURE.mdentirely, greps headers across the remaining five docs, and recognizes area-scopeddocs/<area>-CONTEXT.mdanddocs/<area>-ARCHITECTURE.md.hitlretuned approval wording and resized the HITL bands to be cumulative (SMALL, then MEDIUM adds phase gates, then LARGE adds major decisions). Every workflow now declares its state file by full path,agents/TEMP/<FEATURE>/<flow>-state.md, and the workflow schema andcoding-agents-prompt-authoringreference were updated to require the prerequisite block verbatim.tech-specsadded a line requiring best practices across security, performance, reliability, maintainability, scalability, testability, observability, compliance, backward compatibility, and TCO. (Igor Solomatov) - Why it helps. Forcing a full execution controller on every 10-file task was overhead for the cases that only needed good delegation, and the real failure at that size is orchestrator context exhaustion, not missing plan structure. Batch-processing is the same problem one level down: a subagent told to write tests for 30 files reads all 30 first and then hallucinates. Ambiguous state-file references ("stored in FEATURE TEMP folder") produced a different path in every session.
- Change.
[Tooling]bump_versions.shnow treats the five plugin manifests and three marketplace files as one group, computes the target from the highest version observed across them, and bumps all eight together. Plugins and marketplace landed on 3.1.6, rosettify and rosettify-plugins on 3.2.0. rosettify writes logs under the user config directory instead of the working directory (#160). Patched 7 Dependabot alerts in rosettify:fast-uri3.1.2 to 3.1.4 (2 high),hono4.12.25 to 4.12.32 (3 moderate),@hono/node-server1.19.13 to 2.0.12,body-parser2.2.2 to 2.3.0, with the MCP SDK moved to 1.30.0 so the override lands inside its declared range.[Docs]README and the website gained Top Workflows, Top Guardrails, and Top Skills sections (#158, Yevheniia Lementova). Removed roughly 53 MB of stale binaries fromtest-library/archives. RenamedELEVATOR_SPEECH.mdtoELEVATOR_PITCH.md. Addeddocs/prompts/modernization-prompts-raw.md, nine raw prompts for frontend replatforming covering the mandate and identity rule, archetype mapping, test strategy, screenshots policy, and subagent batching. Publisheddocs/reviews/REVIEW-RESPONSE-2026-07.md, product-owner dispositions for all 98 rows of the external review, alongside the source magazine document. Refreshed the GitHub stats snapshot. (Igor Solomatov, Yevheniia Lementova) - Why it helps. Eight version files bumped by hand drift; computing from the highest observed value makes a partially-bumped tree self-correcting. Logs written into whatever directory the user happened to be in is the kind of thing nobody reports and everybody works around. And a 46 MB zip in a test fixture folder is paid for by every single clone.
The R3 publish week. The cutover batch that sat staged on on-v3-release merged as #130, and it carried more than what was staged: a whole new specs command in rosettify, per-package CI, and a help-flow workflow. R3 flipped from dormant to the live, served release, and R2 stepped back to support-only. Google Antigravity became the seventh supported target, with both a hook adapter and a plugin. The dangerous-actions hook matcher was narrowed to shell and MCP calls, and the generator's deterministic-hooks default flipped to false. Four rule files were deleted outright because the skills already covered them.
Highlights
- R3 published (#130): MCP cut to 3 read-only tools,
ims-mcp-serverrenamed torosetta-mcp-server/rosetta_mcp,rosetta-cliinternals renamedims_*→rosetta_*, plugins repositioned as the recommended install path, R1 retired and R2 moved to support-only - Server default release flipped to R3:
VERSION=r3, serving theaia-r3dataset;verify_mcp.pyretargeted to r3 - New
npx rosettify specscommand: requirements stored as AI-native JSON, 17 subcommands, machine-checked acyclic dependency graphs, guarded Draft → Approved status transitions - Google Antigravity support: hook adapter for Antigravity 2.0 / CLI / IDE (#143) and
core-antigravity, the seventh plugin target (#144) dangerous-actionsPreToolUse matcher narrowed to Bash and MCP calls across every IDE hook template; file writes and edits are no longer matched--deterministic-hooksnow defaults to false regardless of the release descriptor (FR-CLI-0012)- Four rule files deleted (420 lines): prompt, requirements, requirements-use, and coding-iac best-practices, all already covered by the matching skills
disable-model-invocationanduser-invocablefrontmatter flags dropped across every skill- New
help-flowworkflow replaces the deprecatedself-help-flow;adhoc-flowsimplified so the session execution controller is size-dependent instead of mandatory - Bootstrap: the todo-ledger rule promoted into core policies;
coding-flowdiscovery now triggers on ambiguity rather than task size - Per-package CI for rosettify, rosettify-plugins, rosettify-prompts, and curiocity;
run-tests.shandvalidate-types.shmoved undersrc/ - Package versions aligned on 3.x: rosetta-mcp-server 3.0.0, rosettify 3.1.0, rosettify-plugins 3.1.0
- New
collect-github-statsskill with the first repo snapshot; tech demo video back in the README; marketplace 2.0.17 renames thecoreplugin torosetta - A Rosetta security skill was proposed in
docs/stories/security-proposal.md— design only, nothing shipped - Versioning model: R3 is the final numbered release — changes now ship as incremental updates within
r3, not as new release folders
- Change.
[R3]Merged the release-cutover batch that had been staged onon-v3-release. The self-hosted MCP server dropped its five write/state tools (submit_feedback,query_project_context,store_project_context,discover_projects,plan_manager) and their whole dependency graph, leaving exactly 3 read-only tools (get_context_instructions,query_instructions,list_instructions) plus one resource reader. The primary Python package was renamedims-mcp-server/ims_mcp→rosetta-mcp-server/rosetta_mcp, withims-mcp-serverkept as a thin alias;rosetta-cliinternals followed (ims_auth→rosetta_auth,ims_config→rosetta_config, and so on).[Server]The server now defaults toVERSION=r3and serves theaia-r3dataset, withaia-r2retained for N-1 support;verify_mcp.pywas retargeted to r3 (VERSION=r2still runs when validating backports).[Docs]Documentation was restructured so plugins are the recommended, no-server install path and MCP is explicitly secondary — hosted MCP is marked evaluation-only, and MCP-specific content moved intodocs/MCP-ARCHITECTURE.md,docs/MCP-CONTEXT.md, and adocs/mcp/folder. R1 was retired and R2 moved to support-only across docs vocabulary. (Igor Solomatov) - Why it helps. A shared instructions server that can also be written to is a real risk; read-only removes it. Teams pulling instructions now get the R3 model by default — lean always-on bootstrap plus on-demand skills — while R2 consumers keep working during migration. Steering users to plugins first also keeps production traffic off a demo-only hosted endpoint.
- Change.
[Tooling]Addednpx rosettify specs, a new command that stores requirements as AI-native JSON instead of hand-edited markdown. One document per component, 17 subcommands (add,update,get,query,approve,deprecate,implemented,reopen,delete,restore,purge,graph,render,validate,migrate,rubric,info), each spec unit carrying structured given/when/then acceptance criteria, MoSCoW priority, verification method, and actor-stamped status history.depends_onedges are walked and kept acyclic;renderproduces the human-readable view on demand, so there is no markdown mirror to drift. Backed by an 826-line requirement spec (docs/requirements/rosettify/SPECS.md) and roughly 5,000 lines of tests. Shipped in rosettify 3.1.0. (Igor Solomatov) - Why it helps. The
requirements-authoringskill owns human judgment — intent capture, EARS phrasing, per-unit approval. What it lacked was a mechanical engine underneath: agents were hand-editing XML blocks in markdown, where duplicate identifiers, dangling dependencies, and incomplete acceptance criteria are invisible until someone reads carefully. Those are now machine-checkable, and batch edits stop being a text-surgery exercise.
- Change.
[Hooks]Added a Google Antigravity hook adapter covering all three surfaces — Antigravity 2.0, CLI, and IDE — with its own event mapping, IDE registry row, e2e suite, and captured session logs underdocs/hooks/(#143).[Tooling]Addedcore-antigravity, a single combined plugin serving all three surfaces (#144). Antigravity has no workflow concept, so the generator maps workflows to skills (phases underphases/, with phase references rewritten), reduces skill and agent frontmatter toname+description, setssubagent_required_modeltoinherit, and emits an Antigravity-schema-compliantplugin.json. The obsoleteconfigure/antigravity.mdwas rewritten from current vendor docs. (Igor Solomatov) - Why it helps. Antigravity users now get the same instruction set as Claude Code, Cursor, Copilot, and Codex users, instead of MCP-only integration. The other six plugin targets came out byte-identical apart from the shared hook-matcher change below, which is the evidence that the generator absorbed a new target without special-casing the existing ones.
- Change.
[Hooks]Thedangerous-actionsPreToolUse matcher went fromBash|Write|Edit|MultiEdit|mcp__.*toBash|mcp__.*across every IDE hook template, so the gate no longer fires on file writes and edits.[Tooling]--deterministic-hooksnow defaults to false regardless of what the release descriptor says (FR-CLI-0012). (Igor Solomatov) - Why it helps. The gate exists to catch destructive commands. Firing it on ordinary file edits was noise, which trains agents to stop reading the output.
- Change.
[R3]Deleted four rule files totalling 420 lines —prompt-best-practices,requirements-best-practices,requirements-use-best-practices, andcoding-iac-best-practices— whose content already lives in the corresponding skills. Dropped thedisable-model-invocationanduser-invocablefrontmatter flags from every skill. Addedhelp-flow, replacing the now-deprecatedself-help-flow. Simplifiedadhoc-flowso the session execution controller is engaged by task size rather than always. Promoted the todo-ledger rule from a separate<tasks>block intobootstrap-alwayson's core policies, and added a line requiring questions to lead with the main question. Retuned workflows from live testing:coding-flow's discovery phase now triggers on ambiguity instead of task size, its design phase became three explicit steps, and the AQA flows now say to answer from code or MCP before asking. (Igor Solomatov) - Why it helps. Four rules restating what a skill already says is four places to keep in sync and four chances for them to disagree. The frontmatter flags were carried per skill but never varied. Size-gated discovery was the wrong trigger — a one-line request can still be ambiguous, and a large one can be perfectly clear.
- Change.
[CI]Added per-package CI workflows for rosettify, rosettify-plugins, rosettify-prompts, and curiocity, and movedrun-tests.sh/validate-types.shundersrc/.[Tooling]Aligned package versions on 3.x: rosetta-mcp-server 3.0.0, rosettify 3.1.0, rosettify-plugins 3.1.0.[Docs]Added acollect-github-statsskill plus the first repo snapshot indocs/github-stats.json— the script append-merges, because GitHub's traffic API only keeps a 14-day rolling window and deleted history is unrecoverable. Trimmed the README, quickstart, and website introduction, restored the tech demo video in the README, and bumped the marketplace to 2.0.17, which renames the installed plugin fromcoretorosetta. Resyncedllms-full.txt, patterns, code map, tech stack, and definitions to R3-current. (Igor Solomatov) - Why it helps. Each package's tests now run on its own changes instead of riding one shared script. Aligned versions mean a reported version number identifies the release without a lookup table. The stats snapshot starts a history that the GitHub API itself will not keep, and the plugin rename matches what users actually call it.
A workflow-consolidation and hardening week. Test automation split into three dedicated R3 workflows backed by new QA reference knowledge (#129, #131). Live testing on Curiocity caught and fixed real correctness bugs: an approval-gate hang, a false-positive verification check, and truncated judge scoring. A stream of init-workspace and orchestration fixes tightened agent discipline based on real usage, and a new compress-prompt skill lets contributors shrink Rosetta's own instruction files without losing behavior. rosettify-prompts and rosettify-plugins both gained small but real usability upgrades, and dependency and documentation fixes rounded out the week. Separately, a large release-cutover batch was prepared (not merged) on a staging branch for the eventual v3 publish.
Highlights
- Test automation split into three R3 workflows (ui-aqa-flow, api-aqa-flow, testgen-flow) backed by new QA reference knowledge;
aqa-flowkept as a backward-compatible router (#129, #131) - Curiocity fixes from live testing: approval-gate hang on multi-step questions, false-positive manual-QA verification, judge-scoring truncation on long runs; adds a permanent results-history archive and an on-demand end-to-end comparison workflow
- New compress-prompt skill lets contributors shrink Rosetta's own skill/workflow/rule files while preserving every behavior-changing instruction
- Init-workspace and orchestration hardening from real usage: faster discovery, no orchestration overhead on trivial requests, enforced per-phase model/effort assignment, auto-mode no longer skips user-facing questions
- rosettify-prompts optimize gained interactive clarifying questions and readable colored terminal output; rosettify-plugins gained a per-run
--deterministic-hooksoverride (FR-CLI-0012) - New model tiers added across the canonical catalog and every R3 workflow phase (GPT-5.6 sol/terra/luna, Grok-4.5, Cursor Composer-2.5)
- R3's cumulative bootstrap and skill-compression work across recent weeks has cut total per-session context overhead to roughly 3.6K tokens, down from around 40K originally
- Dependency and doc fixes: esbuild and other Dependabot alerts closed (#134), a Traefik middleware namespace bug fixed (#124), broken links fixed across docs (#132), Antigravity/OpenCode docs corrected to say native hooks aren't supported yet, only MCP integration (#126)
- A large release-cutover batch is staged (not merged) on the
on-v3-releasebranch (draft PR #130): MCP's write-tool surface cut to read-only (3 tools left),ims-mcp-serverrenamed torosetta-mcp-server/rosetta_mcpas the primary package, plugins repositioned as the recommended install path with MCP framed as evaluation/self-hosted only, and the R2 → R3 default-release cutover prepared. Gated until v3 publish.
- Change.
[R3]Added QA reference knowledge to theqa-knowledgeskill: Given/When/Then spec format, synthesis and gap-analysis catalogs, implementation examples, TestRail export mapping, and a vendor-fork guide for other test-management tools (#129, Svetozar Lashin). Split the single, blendedaqa-flowworkflow into two dedicated ones,ui-aqa-flowandapi-aqa-flow, and rewrotetestgen-flowto lean on the sharedqa-knowledgematerial instead of duplicating logic inline.aqa-flow.mdnow just routes to whichever of the three applies, kept for backward compatibility (#131, plus follow-up fixes, Igor Solomatov). - Why it helps. The old blended workflow mixed UI and API test automation with no clear entry point and duplicated logic across flows. Separate flows plus one shared knowledge base cut that duplication; existing
/aqa-flowcalls keep working through the router.
- Change.
[Tooling]Fixed Curiocity only watching for the first approval question in a session, which froze any workflow with a second approval gate. Fixed manual-QA verification: escaped success text (e.g."status":"UP") in transcripts never matched, and the check wasn't scoped to the actual live response, so a run could pass even with a wrong result. Fixed the trajectory judge's 8,000-character cap silently dropping the end of longer runs; it's now 16,000 characters split between start and end. Added a git-trackedresults-historyarchive that snapshots each completed run for over-time comparison, and a manually-triggered end-to-end GitHub Actions workflow that runs Curiocity's suite against plain Claude Code, Claude Code with Rosetta plugins, and a full vanilla variant side by side. (Igor Solomatov) - Why it helps. These were real bugs caught by running the harness against live coding-agent sessions rather than trusting it blind: a frozen multi-step approval, a verification check that could rubber-stamp a wrong answer, and a judge that couldn't see whether a long run actually finished cleanly. The new archive and CI workflow make regressions in Curiocity or the plugins visible over time instead of anecdotal.
- Change.
[R3]Addedcompress-prompt, a contributor-facing skill that strips structural filler from Rosetta's own skill/workflow/rule files while preserving every instruction that changes agent behavior, gated by a HITL review and an independent verification pass. Fixed several init-workspace bugs found in real use: the large-workspace file counter was counting configs and assets instead of just source files, discovery was doing one-by-one directory listing instead of a single filtered scan, the shell-config phase was over-thinking a purely mechanical step, and auto-mode was letting agents skip the final wrap-up questions that are meant for the user directly regardless of mode. Orchestration no longer engages on trivial one-line requests, and orchestrators now explicitly enforce each phase's assigned subagent model and effort level instead of drifting to a default. (Igor Solomatov) - Why it helps. Contributors get a systematic way to shrink instruction files without guessing what's safe to cut. The init-workspace and orchestration fixes come straight from watching real runs: wrong thresholds, slow discovery, wasted process overhead on trivial work, and questions silently skipped are the kind of small drift that erodes reliability over time.
- Change.
[Tooling]rosettify-prompts'optimizecommand can now pause mid-pipeline to ask up to 3 clarifying questions when genuinely blocked (opt-in via--enable-questions), recorded in a new Q&A table in the run report; terminal output is now color-coded with whole-second durations and a running cost total instead of raw millisecond logs. rosettify-plugins gained a--deterministic-hooks true|falseper-run override (FR-CLI-0012) that flips a release's advisory-hooks default for a single build without defining a new release descriptor. (Igor Solomatov) - Why it helps. Clarifying questions stop the optimizer from guessing past a genuine ambiguity, and readable output makes a live run easier to follow. The hooks override lets an engineer test, say, r3 without its advisory hooks without forking a release definition just for that.
- Change.
[Server]Fixed a Traefik ingress bug where the rate-limit middleware name was missing its namespace prefix, which could point Traefik at the wrong middleware in multi-namespace clusters (#124, Konstantin Khristenko).[Tooling]Closed Dependabot alerts: esbuild's dev-server arbitrary-file-read on Windows across hooks, rosettify-plugins, and curiocity, and further runtime-dependency alerts in rosettify and rosettify-plugins (#134, Olha Maiesh).[Docs]Fixed broken links across docs and instructions: staledocs.claude.compaths, the moved goose docs, personal absolute paths, and a wrong PR reference (#132, Olha Maiesh). Corrected Antigravity/OpenCode documentation to state native hook support isn't currently tested or supported for them, only MCP integration is (#126, @ebbsanchez).[Tooling]Extendedrun-tests.sh/validate-types.shto also cover curiocity and rosettify-plugins/rosettify-prompts (previously only rosettify and hooks ran), and quieted structured logging to warnings/errors by default viaROSETTIFY_PLUGINS_LOG_LEVEL/CURIOCITY_LOG_LEVEL. (Igor Solomatov) - Why it helps. The middleware fix prevents cross-namespace Traefik misconfiguration. Closed Dependabot alerts keep the security backlog at zero. Fixed links mean docs actually resolve. The Antigravity correction stops the docs overclaiming hook parity across every IDE. Broader test/typecheck coverage and quieter logs make local validation runs faster to read and less likely to miss a tool's own regressions.
Staged for v3 publish: MCP read-only cutover, package rename, plugins-first docs (on-v3-release, PR #130, not yet merged)
- Change.
[R3 — staged, unmerged]On the drafton-v3-releasebranch (merges only at v3 publish), prepared a release-cutover batch: removed the 5 remaining write/state MCP tools (submit_feedback, query_project_context, store_project_context, discover_projects, plan_manager) and their full dependency graph, leaving the self-hosted MCP server with exactly 3 read-only tools (get_context_instructions, query_instructions, list_instructions) plus one resource reader; dropped the matching write_policy/allowed_scopes/invite_emails/plan_ttl_days config. Renamed the primary Python package fromims-mcp-server/ims_mcptorosetta-mcp-server/rosetta_mcp, keepingims-mcp-serveras a thin two-file alias. Restructured documentation so plugins are the recommended, no-server install path and MCP is explicitly secondary: hosted MCP is marked evaluation-only (with a warning against pointing production traffic at the public demo endpoint), and MCP-only content moved into newdocs/MCP-ARCHITECTURE.md,docs/MCP-CONTEXT.md, and adocs/mcp/folder. Flipped rosettify-plugins' default--releaseflag from r2 to r3, retired R1, and moved R2 to support-only across docs vocabulary. (Igor Solomatov) - Why it helps. None of this is live: main's plugin default is still r2 and the MCP server still carries the full tool surface, exactly as this CHANGELOG's own R2/R3 sections describe today. The batch exists so the actual v3 cutover, whenever the team publishes it, is a fast merge instead of weeks of rework. Read-only MCP removes a real risk (a shared instructions server that can also be written to), the package rename gives R3's primary transport a name that matches what it now is, and steering users to plugins first keeps production traffic off a demo-only hosted endpoint.
A refactor-and-tooling week. R3's always-on bootstrap shrank again and the core skill library was reorganized (#121): six bootstrap rule files collapsed into one always-on file plus a single mode file, several skills merged under clearer names, and ~35 skills gained short README routing files. rosettify-prompts' optimize command — flagged "not built yet" last week — shipped as a single-session pipeline of 7 intent-combined steps, alongside Bifrost gateway support and adaptive thinking effort. Curiocity gained perplexity and confidence scoring. Hooks got a strict Codex output schema and Windsurf fixes, and the README was rewritten for sharper positioning.
Highlights
- R3 bootstrap reduced again and core skills refactored: 6 bootstrap rule files → 1 always-on + 1 mode file, skills merged and renamed, ~35 skills gained README routing files (#121)
- rosettify-prompts
optimizecommand shipped: single-session, 7-step prompt/skill rewrite pipeline (was benchmarking-only last week) - Bifrost gateway support across rosettify-prompts and Curiocity
- Curiocity evaluation gained perplexity and confidence-level scoring
- New post-mortem skill and a tree-of-thoughts reasoning loop (R2 + R3)
- README rewritten: sharper positioning, architecture diagram, concrete quickstart (#123)
- Change.
[R3]Continued the bootstrap-shrinking work from a defense-system angle: safety rules stay always-on, rigor rules load on demand behind a user invitation. Six always-on bootstrap rule files (bootstrap.md,bootstrap-core-policy,bootstrap-execution-policy,bootstrap-guardrails,bootstrap-rosetta-files,todo-tasks-fallback) collapsed into onebootstrap-alwayson.mdplus exactly one mode file per session (local-/plugin-/newmcp-files-mode.md). Skills were merged and renamed:operation-manager+orchestrator-contract→orchestration(with the determinism engine as an EXECUTION_CONTROLLER asset),plan-manager→planning,subagent-contract→subagent-directives, andload-context-instructions+load-context+load-workflow→load-project-context. ~35 skills gained a shortREADME.mdrouting file for progressive disclosure (thin SKILL, load-on-demand assets). A validated token-compression pass trimmed the running-context files further. Removed content is archived verbatim indocs/stories/. (Yevheniia Lementova, Igor Solomatov) - Why it helps. Lean requests now carry near-zero always-on process context; rigor loads only when the work needs it. Clearer skill names and per-skill READMEs make the library easier for the agent to route through, and the mode-file split gives MCP its own alias mapping without bloating plugin context.
- Change.
[Tooling]Shipped theoptimizecommand: a single-session pipeline that walks a prompt/skill file through 7 intent-combined steps (inventory & intent; actors, boundaries & contracts; execution & delegation; review, validation & failure-hardening; patterns & simulation; compression; consistency & minimality), proposing changes rather than rewriting whole files and emittingtrace.json+report.md. Supports--dry-run, per-call output-token caps, and supporting/additional context injection. Added Bifrost gateway support, adaptive thinking-effort derivation (reasoning tokens scaled from output tokens), bench context injection, and a combined judge mode. (Igor Solomatov) - Why it helps. Last week rosettify-prompts could only benchmark prompt variants and rank them by cost and stability; the planned optimizer was explicitly not built. It now closes that loop — an author runs a file through the pipeline and gets traceable, reviewable change proposals instead of hand-editing on gut feel.
- Change.
[Tooling]Curiocity's evaluation gained perplexity and confidence-level signals in the LLM-judge and external evaluators, richer markdown reporting, and Bifrost gateway support. Fixed thenode-ptyinstall script to run under npm 12. (Igor Solomatov) - Why it helps. Confidence and perplexity make an automated pass/fail verdict auditable rather than a bare boolean, and the npm 12 fix unblocks fresh installs.
- Change.
[R2 + R3]Added apost-mortemskill and updatedself-learningto feed it (R2 + R3). Reworkedreasoninginto an explicit tree-of-thoughts loop (R2 + R3). Promotedqa-knowledge,qa-structure, anddata-collectionto canonical R3 skills with vendor-binding references and templates (#128, Svetozar Lashin). (post-mortem and reasoning: Igor Solomatov) - Why it helps. Post-mortems turn failures into reusable knowledge; tree-of-thoughts gives the agent a structured deliberation loop; the QA skills make the automated-QA workflow a first-class, documented path.
- Change.
[Hooks]Enforced a strict per-event output schema for Codex so each hook event returns exactly the shape Codex expects (Igor Solomatov). Fixed three Windsurf e2e tests (#127, Svetozar Lashin). Removed the agent-facingdangerous-actionsSKILL.md (8 copies) — the gate runs in the hook runtime, so the loadable skill was dead weight. (Igor Solomatov) - Why it helps. Codex silently drops malformed hook output; a strict schema keeps deny/advise decisions from vanishing. Deleting the orphaned skill removes a misleading duplicate of logic that actually lives in the hook.
- Change.
[R2]Rewordedbootstrap-core-policyso host models (notably Sonnet 5) stop flagging Rosetta's own system prompt as a prompt-injection attempt or complaining about it — softened imperative phrasing and reframed prompt priorities around AI-failure-mode prevention. (Igor Solomatov) - Why it helps. When the host model treats Rosetta's bootstrap as adversarial, it degrades or refuses. Neutral framing keeps the guardrails intact without tripping the model's own defenses. (These files were later removed from R3 by #121; the fix keeps R2 correct.)
- Change.
[Docs]Rewrote the README: sharper positioning, a Without/With comparison, a Mermaid architecture diagram, and a concrete "add rate limiting" quickstart example (#123, Eugene Steinberg).[CI]publish-instructions.ymlgained release-version tagging. Routine version bumps, doc/website sync, and new-skill doc references across the repo. (Igor Solomatov) - Why it helps. The README is the front door; the new version shows rather than tells. Release tagging makes published instruction datasets traceable.
A safety and tooling week. The dangerous-actions hook was reworked end to end — broader pattern coverage, no more unconditional blocks — backed by a new per-IDE end-to-end test suite that caught real adapter bugs. Two new internal tools shipped: Curiocity, which runs and grades live coding-agent sessions, and rosettify-prompts, which benchmarks prompt variants by cost and stability. Sonnet 5 became the default mid-tier model, plus Traefik ingress support, public GitHub links, and license fixes rounded out the week.
Highlights
- Dangerous-actions hook overhauled: wider pattern coverage, hard-deny tier retired for a self-reviewable model
- New end-to-end hook test suite (75 files) catches real Codex, Copilot, Cursor, and Windsurf adapter bugs
- New Curiocity harness runs and grades real Claude Code / Codex sessions automatically
- New rosettify-prompts tool benchmarks prompt variants for cost, speed, and stability
- Claude Sonnet 5 is now the default mid-tier model across instructions and plugins
- Change.
[Hooks]Broadened dangerous-pattern detection — SQLDELETE/UPDATEwithoutWHERE,DROP INDEX/DROP VIEW,ALTER TABLE ... DROP COLUMN; a stricterrm -rfdetector that catches split or reordered flags;git pushforce detection that also catches force-by-refspec (git push origin +main) while excluding the safe--force-with-lease. Removed thehard-denytier: every dangerous pattern is nowreconsider, self-approvable via theRosetta-AI-reviewedmarker after a blast-radius check. Credential and key file overwrites (SSH keys, cloud credentials,.netrc, GPG keys — plain.envwrites no longer flagged) moved to a new non-blockingadvisetier, reasoned around irreversibility rather than secrecy. Deny/advise messages now surface a fixed set of reasons instead of echoing back the offending command or file content. Also fixed shell-string evaluation so MCP tool calls get the same checks as direct bash calls. (Svetozar Lashin) - Why it helps. No pattern can trap a human-reviewed, legitimate action behind an unconditional block anymore, while genuinely irreversible actions still get flagged before they happen. Not echoing raw commands back in hook messages keeps sensitive content out of transcripts and logs.
- Change.
[Hooks]Added a full per-IDE end-to-end test suite (75 files, Claude Code/Codex/Copilot/Cursor/Windsurf) that drives real entrypoint binaries instead of only internal functions. Fixed bugs the suite and empirical log capture surfaced: Codex no longer misclassifies MCP tools it doesn't have; Copilot's two different event shapes are normalized under one path (fixing a double-fire on completed reads); Cursor gained a per-adapter exit-code override for its non-standard deny signal; Windsurf gained astderrMessagepath after discovering it never parses stdout JSON and only surfaces deny reasons via stderr. Documented each IDE's real hook wire format from scratch (docs/hooks/*.md,docs/hooks-verify*.md). (Igor Solomatov) - Why it helps. Adapter unit tests could pass while the real wired-up CLI misbehaved. End-to-end coverage against real entrypoints, backed by captured real traffic per IDE, catches silent bugs like double-counted reads or deny reasons that never reached the user.
- Change.
[Tooling]Introduced Curiocity, a new harness (published to npm) that drives real, interactive Claude Code or Codex sessions against test cases, answers the agent's genuine questions via an LLM guided by a written policy, and grades the outcome with file/test checks, trajectory checks, and an LLM judge against a rubric — producing a pass/fail verdict that can gate CI. Fixed a bug wherenpxusers'.envkey file was looked up inside npm's package cache instead of their own working directory. (Igor Solomatov) - Why it helps. Until now, proving a Rosetta skill, hook, or workflow behaves correctly inside a real agent session meant running it by hand and eyeballing the result. Curiocity automates that judgment call and can block a regression before it merges.
- Change.
[Tooling]Introduced rosettify-prompts (npx rosettify-prompts@latest), a CLI that runs multiple prompt or instruction variants against the Anthropic API in parallel and reports cost, latency, and stability per variant. Benchmarking only for now; a planned optimization command isn't built yet. (Igor Solomatov) - Why it helps. Prompt and instruction changes used to ship on gut feel. Authors now get real cost and consistency numbers before merging a change.
- Change.
[R2 + R3]Replaced Sonnet 4.6 with Claude Sonnet 5 as the canonical mid-tier model across R2 and R3 instructions, docs, and all IDE plugins. (Igor Solomatov) - Why it helps. Agents and subagents run on the current-generation mid-tier model by default instead of a stale one.
- Change.
[Server]MCP Helm chart gained Traefik ingress support — an ingress-class toggle and a generated rate-limitMiddlewareresource — plus unit tests and a split validate/publish CI pipeline (#120, Konstantin Khristenko).[R2 + R3]gain.json's SDLC references moved from internal Jira/Confluence links to public GitHub Issues and Wiki (#122, Olha Maiesh).[Tooling]Fixed two license files:ims-mcp-server's proprietary all-rights-reserved notice replaced with Apache 2.0, androsettify's corrupted Apache 2.0 text repaired. (Igor Solomatov) - Why it helps. Orgs standardized on Traefik (common on k3s) can deploy the MCP server without hand-patching the chart. Public GitHub links work for external OSS contributors who can't reach internal tools. Correct licenses keep the repo's OSS compliance story consistent.
A foundations week. The always-injected bootstrap is being collapsed into one minimal file, a new read-once hook stops agents re-reading the same file, and HITL questioning got a lot more thorough.
Highlights
- New
bootstrap-alwaysonrule will replace the separate bootstrap files with one minimal payload - New
read-oncehook stops agents from re-reading the same file - New user-invocable
rosettaskill routes a request to the right workflow (#117) - HITL now interviews you thoroughly before building, cutting wrong assumptions
- Hook runtime expanded with shared building blocks; Codex and Copilot hook specs documented
- Change.
[R3]Introduced a singlebootstrap-alwaysonrule, a minimal always-on payload meant to replace the separate bootstrap files (guardrails, core policy, and the rest). Shipped the first skill extracted under the reduce-bootstrap effort. (Igor Solomatov) - Why it helps. The bootstrap ships in every agent's context on every call. One small always-on file instead of several means lower token cost and less context pressure, with the same guarantees.
- Change.
[Hooks]Added aread-oncehook that prevents an agent from reading the same file twice, built on an expanded shared hook runtime (common normalization, logging, and reusable state/lock helpers) across Claude Code, Cursor, Copilot, and Codex. Documented the Codex and Copilot hook specs. Added debug coverage and unit tests for the lint-format advisory (#116, Maksym Kuznietsov). (Igor Solomatov) - Why it helps. Re-reading files burns calls and tokens for no new information. Shared building blocks mean a hook is authored once and runs on every IDE, instead of per-IDE one-offs.
- Change.
[R3]Added a user-invocablerosettaskill that identifies a request and routes it to the best-matching workflow, then hands off (no code or files before the handoff). (Yevheniia Lementova) - Why it helps. One entry point. Users invoke
rosettaand the right workflow runs, instead of guessing which flow to pick.
- Change.
[R3]HITL now interviews the user relentlessly after discovery and before implementation: walk the design tree, resolve decisions one by one, offer a recommended plus alternative enterprise-ready answer per question, and loop until no gaps remain. Added a recovery path for when the agent gets stuck, fixed a subagent misunderstanding, updated the compaction rule, and improved the reasoning skill. (Igor Solomatov) - Why it helps. Assumptions are the top cause of mistakes. Grilling the requirements up front catches them before code is written.
- Change.
[R3]Made sensitive-data handling more obvious in the instructions. (Igor Solomatov) - Why it helps. A clearer guardrail is a guardrail people actually follow.
- Change.
[Docs]Updated the FAQ, README, website, and Documentation Structure Plan (#106, ymakaruk-pixel with Yuri Makaruk). Aligned the reduce-bootstrap doc with the load-context-instructions dissolution decision (#119, Yevheniia Lementova). Added session transcripts and assorted doc fixes. (Igor Solomatov) - Why it helps. Front-door docs stay accurate as the bootstrap and skills change underneath them.
The week the plugin-generator rewrite went live. The old Python generator is gone, all source moved under src/, the command menu got cleaner, and a tech demo video shipped.
Highlights
- New plugin generator is now the only one; old Python generator deleted
- All source code moved under
src/for a cleaner repo layout - Internal skills hidden from the user command menu (#111)
gitnexusandgraphifymerged into onecodemapskill- Tech demo video published on the README and website
- Change.
[Tooling]Migrated fully to the new TypeScript plugin generator and deleted the old Python one (scripts/plugin_generator.py, ~1,270 lines, plus its tests). Moved all source (rosettify,rosettify-plugins,ims-mcp-server,rosetta-cli, hooks) under a singlesrc/directory, fixed schemas, and cleared the follow-up issues from the move. (Igor Solomatov) - Why it helps. One generator, no dead Python path to maintain. A standard
src/layout makes the repo easier to navigate and the cutover completes the three-week rewrite.
- Change.
[R2 + R3]Hid infra, guardrails, and phase skills from the user command menu via frontmatter flags (Claude Code). Mergedgitnexusandgraphifyinto onecodemapskill (the refresh hook becamecodemap-refresh). Inlined the init-workspace skills, refined questioning rules, added architect background guidance to the coding flow, and clarified licensing. (Artem Koziar) - Why it helps. Users see only the commands meant for them, not internal machinery. One
codemapskill replaces two overlapping ones, so there's less to learn and maintain.
- Change.
[Docs]Published a tech demo video and added it to the README and website. Added in-document navigation on the website, synced site information, and fixed layout, borders, and video sizing. (Igor Solomatov) - Why it helps. A short video explains Rosetta faster than a page of text. In-doc nav makes the site easier to read.
- Change.
[CI + R3]Made the prompt-validator CI output more condensed and focused, added automatic cleanup of old bot messages on PRs, fixed the coding-agents draft phase, and fixed a case where validation was skipped. (Igor Solomatov) - Why it helps. Reviewers get a tight, readable validation report instead of noise, and stale bot comments stop piling up on pull requests.
- Change.
[Docs]Updated Opus-class model references to GPT-5.5 inCONFIGURATION.md. (Igor Solomatov) - Why it helps. Configuration examples point at a current model.
- Change.
[Docs]Revised the Definition of Done and architecture docs for clarity, fixed deprecations, and cleaned up assorted docs. Fixed a development-server placeholder typo (#114, meichuanyi). (Igor Solomatov) - Why it helps. Clearer DoD and architecture docs mean fewer misreads for contributors.
A big week across reliability, model selection, and a new skill suite. Workspace init got more reliable and now writes a gain.json config file, model choice was made explicit everywhere, Solr support landed, and the instruction set got meaningfully cheaper to run.
Highlights
- Workspace init hardened, plus a new
gain.jsonas the single source of truth for SDLC tooling - Model selection made explicit: canonical model list per task, correct Claude IDs in plugins
- New Solr skill suite: query, schema, extending, semantic search
- Coding flow gained a file-based migration/modernization mode
- Leaner instructions (#109) cut per-call cost;
llms.txtnow published for the web
- Change.
[R2 + R3]Hardened the init-workspace flow, defined its subagents clearly, and added missing skills. Init now generates a repo-rootgain.jsonthat records SDLC tooling config collected from the user, treated as the single source of truth in conflicts. (Igor Solomatov) - Why it helps. Init misclassifying a workspace used to overwrite config or skip setup. Clearer subagents and one authoritative config file make setup repeatable and stop tools from disagreeing about project settings.
- Change.
[R3 + Tooling]Defined a canonical list of supported SOTA models by tier, and added a per-stepsubagent_required_modelso each workflow step states which model it needs. Fixed the plugin generator to emit full Claude model IDs (e.g.claude-opus-4-8) and to stop preferring Opus 4.6 over 4.8. Corrected the model mappings. (Igor Solomatov) - Why it helps. Agents now run on the intended model instead of a stale or wrong default. Right tier per task means better reliability without overpaying.
- Change.
[Tooling]Removed dead and forbiddenPluginSpecfields, applied clean-architecture fixes, and updated the spec to match. (Igor Solomatov) - Why it helps. Less dead surface area and a spec that matches reality, so the generator stays easy to extend (the goal of last week's rewrite).
- Change.
[R3]Added four Solr skills: query, schema, extending, and semantic search, each with deep reference material (edismax, block-join, JSON facets, kNN, relevancy, anti-patterns, and more). (Roman Kagan) - Why it helps. Agents working on Solr projects get expert, grounded guidance instead of guessing at query syntax and schema design.
- Change.
[R3]Added a file-based migration/modernization mode to the coding flow: tiny 1-3 file batches, mirror the source, no behavior change or new code, with per-file start/complete logging. Added a hint to run multiple implementation agents in parallel. (Igor Solomatov) - Why it helps. Large migrations stay accurate and auditable instead of drifting into rewrites, and parallel agents finish bulk work faster.
- Change.
[R2 + R3]Compressed frontmatter descriptions across the instruction set, foldedcoding-iacin, and tidied skills (prompt-adaptation became thepa-adaptreference). (Igor Solomatov) - Why it helps. Instructions ship in every agent's context on every call. Smaller payload means lower token cost and less context pressure.
- Change.
[Docs]Addedllms.txt/llms-full.txt, a dense machine-readable source of the whole project, and wired it to serve from the web via GitHub Pages. (Igor Solomatov) - Why it helps. AI agents (and people) can read the entire project from one URL instead of crawling the repo.
- Change.
[Server + Tooling]MCP Helm chart gained a PodDisruptionBudget and liveness/readiness probes (#105, Konstantin Khristenko). Fixed Operation Manager upsert behavior (#103, and #108 soupsert-with-templateproduces the phase for subagents) (Yevheniia Lementova). Fixed Rosetta initialization, cleaned up old MCP artifacts, and added a leadership elevator speech and config-instruction updates. (Igor Solomatov) - Why it helps. Safer rollouts and self-healing pods in Kubernetes. Plan execution no longer trips on upsert edge cases.
Tooling and reliability week. A new generator now builds every IDE plugin from one source, the hosted MCP server's intermittent freezes were tracked down and fixed, the requirements and code-analysis flows learned to turn existing code into specs, and the engineer-facing docs were rewritten.
Highlights
- New plugin generator (
npx -y rosettify-plugins@latest) builds all IDE distributions from one source - Fixed intermittent MCP server hangs (the 502-after-minutes bug) and added full request logging
- Code analysis can now reverse-engineer requirements from an existing codebase
- Rosettify builds a whole plan in one call: ~50% fewer calls
- Plugins, MCPs, and Quickstart docs rewritten for engineers
- Change.
[Tooling]One tool,npx -y rosettify-plugins@latest, builds every distribution (Claude Code, Cursor, Copilot, Codex, and the Cursor/Copilot standalones) from a single instruction source tree. Rewritten in TypeScript on a modular pipeline architecture, replacing the old single-file Python monolith, with a full reverse-engineered requirements spec and byte-for-byte parity against the previous output. Eight critical issues were fixed along the way. (Igor Solomatov) - Why it helps. Edit the instructions once and every plugin regenerates identically, so IDE variants can't drift apart. The modular architecture makes adding a new plugin practical, which was effectively impossible with the old monolith. No Python toolchain to install. The spec makes the build auditable.
- Change.
[Server]Fixed the intermittent freeze where the hosted server stopped replying and the gateway 502'd after tens of minutes. Root cause: synchronous, no-timeout RAGFlow calls ran directly on the async event loop, so one half-open socket froze the entire single worker, with nothing logged. The fix moves blocking work (RAGFlow, Redis, OAuth) off the loop with finite, tunable timeouts, and adds full request/response/SSE logging, an in-flight watchdog, clearer exception surfacing, an unauthenticated/healthzprobe, and a Docker healthcheck. (Igor Solomatov) - Why it helps. The server no longer silently locks up under a slow dependency. Every request now shows up in the logs (arrived, replied, or stalled), so operators can see and recover from problems instead of guessing. Timeouts are configurable via environment variables.
- Change.
[R2 + R3]The code-analysis flow can now extract requirements from an existing codebase, spawning one narrowly-scoped subagent per module, screen, or endpoint. Requirement identifiers now live in code comments only, never user-facing. Requirements authoring hands off directly to the coding flow, the review skills were merged into one, and type validation was fixed. (Igor Solomatov) - Why it helps. Turn legacy code into a real spec without hallucination (narrow scope per agent). Generated artifacts read cleanly for non-technical stakeholders. One straight path from requirements to code, with less duplicated skill logic.
- Change.
[Tooling]create-with-templateandupsert-with-templateaccept phase-steps as an argument, building an entire plan in one call instead of one call per step. (Igor Solomatov) - Why it helps. Roughly 50% fewer MCP calls. Faster plan setup, fewer round-trips, lower token cost.
- Change.
[Docs]Plugins, MCPs, and Quickstart docs rewritten for engineers: concrete install and verify steps, collapsible agent sections, Next Steps and Links blocks. Website home page, index, and collapsible sections fixed. Added a "Useful MCPs and CLIs" reference, an rtk CLI client-IP warning, and an MCP client-confirmation note. (Igor Solomatov, ymakaruk-pixel on #102) - Why it helps. Faster first-run success and fewer support questions. The two warnings surface real security and privacy footguns before users hit them.
- Change.
[CI]Fixed GitHub AI workflow handling for fork PRs and taught repo-triage to handle instructions. (Igor Solomatov) - Why it helps. Automated triage now works on external contributors' pull requests.