The work,
release by release.

AIWG 2026.10.1 makes Jev decision offload work from a token. Agents can send bounded decisions (yes/no gates, picking one of N options, 1-N scores) to the Jev decision classifier instead of reasoning them out in the frontier model.

What changed

• aiwg decision setup jev: pipe your Jev token in once and it is stored in a user-level 0600 credential file. --verify checks it with one live call.
• aiwg decision ask: one command sends one bounded decision to Jev and returns a typed answer with confidence. If Jev is not set up, abstains, errors, times out, or answers below --threshold (default 0.8), the result is fallback: "llm", and the agent decides as it would have anyway.
• Agents use it automatically: the decision-engine addon now ships a decision-offload rule and skill that tell agents to ask Jev first for bounded decisions. MCP clients get a decision-ask tool.
• The steward can set it up: ask it to "help me set up jev" or "use my jev token" and it walks you through installation, token setup, and verification.
• Fixes: valid Jev Score answers are no longer rejected for two-decimal rounding, and aiwg use decision-engine now keeps the addon's rule after deployment.

Try it

npm install -g [email protected]
aiwg use decision-engine
printf '%s' "$JEV_TOKEN" | aiwg decision setup jev --token-stdin --verify
aiwg decision ask --question "Is this test failure a timeout?" --yes-no --context-file out.log

Savings depend on your workload: the more small bounded decisions an agent makes, the more it offloads. The Jev quickstart covers fallback behavior, privacy (questions and context are sent to Jev), and troubleshooting.

The full change history is in the changelog.

AIWG 2026.10.0 promotes the Muse Code provider to stable, adds native Muse session discovery, fixes a Factory settings corruption bug, and ships more experimental, default-off gates and decision-study work.

What changed

• Muse Code is stable: --provider muse graduates from experimental, backed by a Linux walkthrough on Muse Code 1.4.2, a path security review, and release notes. aiwg use all --provider muse now installs the managed SessionStart hook and an opted-in --mcp profile, and aiwg doctor gains a Muse Code native extensions section.
• Muse session discovery: aiwg sessions discover --muse-root <path> imports Muse's own session logs for a workspace. It runs only for an explicitly authorized root and matches workspaces from facts recorded in the logs.
• Factory settings safety: Factory deploys no longer corrupt glob or URL values in ~/.factory/settings.json, and a hand-edited settings file is backed up before it is rewritten.
• Gates (experimental, default-off): gate-pack discovery and CLI, project gate floors in aiwg.config, and addon/extension bundle metric providers.
• Decision studies (experimental, default-off): D17 and D29 calibration and held-out study tooling, issue-triage, routing, and context-pruning pilots. Live qualification remains pending where each entry says so.

Try it

Update with npm install -g [email protected]. Muse users can deploy with aiwg use all --provider muse in a trusted workspace. The versioning guide describes the stable-channel policy.

The full change history is in the changelog.

AIWG 2026.9.24 is a corrective release that unblocks npmjs publication: the parallelism-cap test now holds saturated dispatch slots for the whole cap check.

What changed

• Dispatch cap test: the cap assertion saturated slots with 250ms tasks while the 5th dispatch's own admission work can outlast them on loaded runners. Saturating tasks now hold for 8s so the check runs against genuinely saturated slots.
• Discovery framework cache: aiwg discover/show retain framework warnings, expose stale diagnostics with scoped repair, and refresh rebuilt Fortemi caches (#272).

Try it

Update with npm install -g [email protected]. The versioning guide describes the stable-channel policy.

The full change history is in the changelog.

AIWG 2026.9.21 ships the Jev decision platform runtime (disabled by default, experimental where noted), the effect ledger foundation, and the experimental Muse Code provider verified against Muse Code 1.4.0.

What changed

• Jev decision platform: the decision runtime with mandatory state projection for network egress, review lifecycle (D10/D11), trace recording, and telemetry runbooks. Several entries close offline gaps only; remaining live qualification is tracked in the follow-up issues named in each entry.
• Effect ledger foundation: experimental v1 contract with signed effect segments, keyring, checkpoints, exit codes, and shared protected-storage and signing primitives.
• Muse Code provider: experimental --provider muse integration — registry and capability entries, skill writer, discover-first AGENTS.md bridge, one managed SessionStart hook, opt-in --mcp profile, export-first session import, and a muse exec Ralph adapter, all verified against an installed Muse Code 1.4.0.

Try it

Update with npm install -g [email protected]. Muse users can deploy with aiwg use all --provider muse in a trusted workspace. The versioning guide describes the stable-channel policy.

The full change history is in the changelog.

AIWG 2026.9.20 is a corrective release for the stable-channel policy introduced after v2026.9.19. Stable releases now use latest; the legacy next alias is retired on npmjs.org and the Gitea package mirror.

What changed

• Stable channel: latest remains the stable install channel for aiwg, @aiwg/cli, and @aiwg/cockpit.
• Legacy alias retirement: Gitea publication removes next, and release verification requires the alias to be absent from both registries.
• Exact-source Socket evidence: Tag-bound npm publication passes the exact release version and source commit directly to the fail-closed Socket audit. The audit no longer depends on the public mirror's divergent default-branch history.

Try it

Update with npm install -g [email protected]. The versioning guide describes the stable-channel policy, and the Socket post-publish audit documents the exact-source evidence flow.

The full change history is in the changelog.

AIWG 2026.9.19 adds a structured decision runtime and two shared ways to prepare work for AI providers. It also makes stable npm releases keep latest and next on the same version.

What changed

• Decision backends: The opt-in decision-engine addon now accepts structured entries and interchangeable Jev or LLM-subagent evaluators through one contract. Receipt validation, retry handling, and rollback gates make evaluations easier to replay and inspect. Live Jev testing remains a separate, explicit smoke check.
• Bot handoffs: aiwg bot-handoff --provider <id> --input proposal.json drafts a routine, teammate, connector, or memory proposal for review. It reads the supplied proposal and prints Markdown; creating a provider object remains an operator action.
• Grok Bot adapters: Optional native adapter scaffolding now covers routines, teammates, connector install profiles, machine health, and memory references. The scaffolding guide describes the contract gates and current limits.
• Build readiness: aiwg build-verify --provider <id> checks AIWG deployment and discovery before a provider runs a build or CI task. Grok Build also checks its native grok inspect view. The CI system still runs deterministic tests and controls credentials.
• Release channels: The release flow now checks that latest and next resolve to the same stable version for aiwg, @aiwg/cli, and @aiwg/cockpit before completion.
• Post-publish evidence: The tag-bound publisher invoked the fail-closed Socket audit directly, but the v2026.9.19 run failed its exact-source binding because the caller supplied the annotated tag object rather than the peeled release commit. v2026.9.20 carries the corrected binding.

Try it

Update with npm install -g [email protected]. For provider handoff examples, see the bot handoff guide. For CI setup, see build verification and Grok Build CI. The versioning guide describes the stable dist-tag policy.

The full change history is in the changelog.

Release date: 2026-09-21

Channel: stable

Dataset Intelligence qualification now executes its adversarial and replay corpora and verifies migration from the exact contract shipped in v2026.9.17. The prior release fixture is bound to its tag, source commit, package version, and SHA-256 digest, so migration evidence cannot silently drift with current source.

Executable qualification

The local matrix reports 13 passing cells and two controlled, mode-dependent cells. Cross-repository qualification reports 14 passing cells and retains the live-server cell as pending; this release does not reinterpret package or mock coverage as live-runtime evidence.

JSONL discovery also rejects inputs beyond the configured nesting limit. The million-record reader check now measures retained memory after garbage collection in an isolated process, avoiding failures caused by unrelated test suite allocation pressure while preserving the record-count and memory bounds.

Try it

npm install -g [email protected]

Links

• Changelog

Release date: 2026-09-20

Channel: stable

AIWG's dataset runtime is now a supported public package entry. Consumers can import aiwg/dataset from a clean installation, and the package carries the pinned Fortemi capability contract needed to validate negotiation and wire behavior without reaching into a source checkout.

Contract qualification

The release package exercises 20 capability-version cases and 11 wire cases. Cross-repository CI is pinned to the final signed Fortemi React Lane B source, while live execution evidence remains explicitly bound to the released Fortemi server rather than being inferred from package tests.

The release also reconciles the experimental Grok Build provider across the public inventory, Agent Skills matrix, and generated-context expectations.

Try it

npm install -g [email protected]

Links

• Changelog

Release date: 2026-09-17

Channel: stable

Grok Bot is now a stable AIWG provider: skills deploy through a fail-closed skills root, the wizard and schemas know the harness, sessions can import via manual export, and a cloud-session global install path loads AIWG the same way other providers do.

What else ships

Session export can carry exact attachment and registered-output bytes as Fortemi BLAKE3 blob sidecars (--include-bytes), refuses silent overwrite or post-plan drift, and accepts current Hermes JSONL exports. Clean-install steward repairs close registry, providers-list, doctor, and backup-gitignore gaps for grokbot. Cockpit verifies browser-bound desktop delegation over mTLS.

Try it

npm install -g [email protected]
aiwg use sdlc --provider grokbot

Links

• Changelog

Release date: 2026-09-15

Channel: stable

This patch fixes a CI-only test timeout that blocked publishing 2026.9.14 to npm. It carries no functional changes beyond that fix and the version bump — see the 2026.9.14 announcement for what this release actually contains: native session export to Fortemi Knowledge Shards, Claude web/account export ingestion, and two testing-quality addon fixes.

The 2026.9.14 tag's own CI passed cleanly, but the npm-publish workflow's test run failed three times in a row on the same call: bin/aiwg.mjs use sdlc --provider codex, the one call in that test file that goes through the router's cold tsx compile path rather than invoking a helper script directly. Under CPU contention from adjacent heavy integration suites on the publish workflow's runner, 60 seconds was consistently too tight and produced a spawnSync ETIMEDOUT — not a code regression, since the identical commit's full suite passed on the project's own CI every time.

The test now allows 150 seconds for that call, with a 180-second outer test timeout to match.

AIWG 2026.9.12 completes the release-cut recovery with two workflow fixes found only after the signed 2026.9.11 tag exercised the production release path.

Independent release workflows

Gitea treated four workflows as one concurrency stream because each used the literal group name release. On a tag push, release creation and plugin packaging were canceled while the npm workflow ran. Each workflow now has a distinct group, and a regression test checks that required and release workflows cannot cancel one another.

A realistic npm processing window

npm accepted the root package but kept it in processing for longer than the first three-minute retry window. The two scoped packages were already queryable with provenance. The root-package provenance check now waits up to fifteen minutes, and the job has a forty-five-minute budget so the remaining signing, SBOM, checksum, installer, and release-asset steps can finish.

The wait remains bounded and preserves a package-specific failure diagnostic.

Release integrity

The tag is created through the dedicated AIWG release-signing key held in OpenBao. The release commit, version lockstep, full test suite, metadata, documentation, Fortemi index, and workflow pin gates are verified before the tag is pushed.

Release date: 2026-09-14

Channel: stable

This patch makes the release pipeline tolerate npm's normal package-processing delay without weakening its provenance gate.

The 2026.9.10 publish was accepted by npm and produced a Sigstore transparency log entry, but the large root package was still processing when the workflow queried it ten seconds later. That lookup exited immediately, so the workflow skipped the remaining dist-tag, cosign, SBOM, checksum, installer, and GitHub release-asset steps.

Publication now retries each package's provenance lookup for up to three minutes. A package must still become queryable with its attestation before the release continues. If it does not, the job reports the affected package after the bounded wait instead of disappearing at the first registry error.

The release-cut audit also found three floating action tags in the isolated OMP native conformance workflow. Checkout, Bun setup, and artifact upload are now pinned to immutable commits recorded in the CI pin manifest.

No application behavior or public API changes in this patch.

Release date: 2026-09-14

Channel: stable

Most of this release is one failure mode, found in six places: a check that cannot fire reads exactly like a check that passed. A lint target that excludes every rule reports PASS. A drift report lists artifacts that are byte-identical to their source. A deploy lands over a cap the same tool flags a moment later. A warning points at a command that re-emits the warning. None of these looked like bugs while they were happening, which is why they lasted.

If you run AIWG in a nested workspace, or lint a subdirectory, or deploy to Codex with bundles, this one is worth taking.

A lint run that applies no rules now says so

aiwg lint documentation/references --ruleset research reported 2,542 files and zero findings. aiwg lint . --ruleset research reported 34 findings in the same files with the same ruleset. The rule's glob is written from the project root (documentation/references/**/*.md) while the walk was rooted at the target, so narrowing the target to the directory you care about — the natural thing to do — silently matched nothing and printed PASS.

Globs now resolve the same way wherever the walk starts. And because a run that applies no rules should never be indistinguishable from a clean one, output now names how many of the selected rules applied, lists the ones that matched nothing, and says plainly that zero applied is not a clean result.

Two smaller things in the same area: files git ignores are skipped by default (--no-gitignore opts back in), so regenerated trees stop reporting findings about their own generated text; and a reference sitting beside an absence marker — "REF-2464 remains unallocated after deduplication" — is read as documentation of a deliberate gap rather than a dangling reference. Silencing that previously meant deleting accurate documentation or allocating a REF that is deliberately absent.

The recommended retraction convention works at any length

research/uncertainty-registered accepts "an outcome with a date". The retraction convention written for it supplies exactly that:

~~<original limitation>~~ **Done YYYY-MM-DD (<what closed it>).** <evidence>

It was accepted when the struck text was one sentence and rejected when it was two — the accepting window ended at the clause, before the **Done <date>** that closed it. A struck span followed by a dated outcome on the same line is now a completed retraction whatever its length, an explicit dated closure discharges an uncertainty outside struck spans too, and the fix hint names the retraction form instead of only listing obstacles.

Drift you can actually clear

aiwg doctor reported every project-local artifact as drifted immediately after a clean aiwg use, and re-running the deploy never cleared it. The entire difference was the managed marker the deployer writes itself. The check now judges "differs from source" against the source: a deployed file that equals its source plus the marker matches, whichever recorded hash the registry happens to hold. Real edits are still detected.

Codex deploys stay under the startup listing cap

A default deploy produced a skill set the same run then flagged as over Codex's 8,000-character startup listing cap, and the only remediation offered was --force — which replaces unmanaged files and does nothing for the budget.

The deployer now projects the listing and places overflow on the standard tier, largest entry first and never a kernel skill, naming what moved. Overflow skills stay indexed, so aiwg discover and aiwg show still return them. A plain redeploy re-places an over-cap deployment without --force. An explicit --copy-all still means what it says: everything in the listing. AIWG_CODEX_LISTING_CAP overrides the cap; 0 disables it.

--force guidance changed too. The unmanaged-file advisory lists up to ten files and points at a --force --dry-run preview, so the overwrite set is visible before anything is overwritten.

Rules are budgeted for subagent dispatch, not just the session

Dispatching aiwg-steward failed with Prompt is too long before its first tool call, in a project whose startup-context check read ~97K of 200K, ok. Two reasons: the check measured only the project's own rules, while Claude Code also inlines each ancestor directory's memory file and rules directory; and a subagent inherits that whole surface plus its own definition and still needs room to work.

Rule deployment now reconciles .claude/rules/ against a 64K-token inline budget after every deploy pass. HIGH rules beyond it move on demand — never CRITICAL, never the indexes — and are listed in RULES-ONDEMAND.md under their own heading with the aiwg show rule fetch hint. They remain binding. AIWG_RULES_INLINE_BUDGET_TOKENS sets the budget; 0 disables it. aiwg doctor gained a Subagent Dispatch check that fails when the inlined surface leaves no room, and names the ancestor contribution.

Recovery commands work while the installation is drifted

An installation identity mismatch blocked every command except installation, including status, doctor, runtime-info, version, and the documented discover --backend local fallback — the steward's whole recovery ladder. Those read-only commands now run under drift and print the drift first; version reports a same-root method mismatch, and status --probe --json carries an installation block with mutations_blocked. Everything that writes still fails closed. aiwg discover --backend local "<phrase>" also parses correctly when the flag comes before the phrase, which is how the fallback is documented.

Two warnings that had no exit

aiwg doctor's Permissions line pointed at steward permissions audit, which re-emitted the same warning, while migrate --dry-run reported "0 legacy sources" and never said it would write anything. A project with no legacy permissions now gets an informational line pointing at aiwg steward permissions migrate --apply, and migrate says it writes the initial default-deny block.

The Model Policy line flagged deployed agents carrying bare model aliases, which consuming projects could not fix because the source is here. Claude deploys now compile a bare alias to its pinned variant (sonnet → claude-sonnet-4-6, opus → claude-opus-4-7, haiku → claude-haiku-4-5), so a subagent dispatch never inherits a 1M-context parent. Source frontmatter stays provider-neutral; pinned ids, inherit, and [1m] opt-ins deploy unchanged.

Operator context stays in the load path

aiwg regenerate --existing-project moved a provider startup file's operator content to .aiwg/context/providers/<PROVIDER>.md and linked it from WORKSPACE.md. No bootstrap imports that file, and the next aiwg use dropped the link — so operator policy left the agent's context with nothing reporting it.

Provider startup files are bootstrap surfaces. Their operator content now ports into the WORKSPACE.md operator block, verbatim and attributed, which every provider bootstrap loads and which regeneration preserves. Tables, procedures and code blocks survive intact. Links to previously migrated files survive aiwg use, doctor reports such files as not auto-loaded, and identical directives shared by two files are reported once per pair rather than once per line.

Also in this release

• Fortemi dataset execution validates the advertised capability descriptor and binds negotiation to it, with shared SemVer and wire vectors rather than shared code (#2242).
• A control-API-backed Cockpit desktop panel and inventory entry, gated on the runtime advertising both the identity verifier and the desktop backend (#2547).
• A Keycloak (OIDC) verifier for the desktop identity boundary (#2545).
• llm-model-archivist, a media-curator agent that discovers, ranks and preserves open-weight models in original-precision weights (#2554).
• address-issues-threat-assess no longer flags an issue because of the orchestrator's own prior cycle comments (#2549).

Upgrading

npm install -g aiwg@latest
aiwg doctor

Projects on a prior version pick up the rule budget and the Codex listing budget on the next aiwg use. aiwg doctor reports the new Subagent Dispatch line and, on a nested workspace, the ancestor rule contribution it was previously blind to.

Release date: 2026-09-13

Channel: stable

Supersedes v2026.9.8, which was tagged but never published — its npm publish failed on a test that the release itself exposed, and the fix landed after the tag.

This release is about AIWG describing its own state accurately. Several commands reported a declaration where they should have reported reality — which version is running, what a migration will move, what a deploy left behind — and the gap was invisible precisely because every check looked green. If you have run AIWG in the same project across several versions, the pruning and context-budget work here is worth taking.

version reports the binary that ran

aiwg version read the canonical install rather than the executing one. On a host where an npm global shadowed a source checkout it confidently reported the source version and path — the first command anyone runs to answer "what am I on" was describing the install that was not running, while installation show correctly reported State: mismatch at the same moment.

path: is now always the executing root, and when the canonical install declares a different root the notice names it, its version, and points at aiwg installation show.

Drift has a stated remedy

installation switch and adopt write installation.json and nothing else. On a host where an npm global shadows a declared source checkout, switch is a no-op — the declaration is already what it would write — and adopt "resolves" the mismatch by capitulating to the copy the operator is trying to stop using. The command that actually fixes it, npm link, appeared nowhere in AIWG's output.

installation show now prints a Resolve block tailored to the direction of the drift, and says plainly that these commands are declaration-only. adopt refuses to abandon a declared install without --yes, showing both sides first.

Long-lived projects stop accumulating

Rules were never in scope for the target-provider prune, so a project deployed continuously since earlier versions kept every rule any past version ever wrote: 219 agents and 68 rules where a fresh deploy today writes none, putting the project 9% over its own startup-context budget with .claude/rules/*.md alone consuming ~117K of a 200K window. The budget warning described the symptom without naming the cause.

Refresh now prunes orphaned rules — gated on the managed marker, so operator-authored rules and project-local bundles are untouched — and refresh --dry-run lists what it would remove instead of printing only "Checking for stale deployments...". The context warnings name the cause and point at the dry run.

Session start stops costing context

The SessionStart hook invoked its script with no arguments, and with no arguments the script printed its usage block and exited 0 — so a help message for a command the agent never calls became the first content of every session transcript. It was also registered twice, because registration matched only on AIWG's own id and appended a managed entry beside an identical untagged one.

No-argument invocation is now silent, help moved behind help/--help, and registration adopts an untagged entry instead of duplicating it.

Migrations say what they are about to narrow

workspace-context migrate classifies a source by filename, which is right when the content is provider-specific and quietly wrong when a project used CLAUDE.md as its main context file — the normal path, since CLAUDE.md was the conventional home for project context long before WORKSPACE.md existed. Project-neutral methodology got narrowed to one provider with nothing erroring.

migrate --dry-run now reports, per source, how much operator content moves and to which scope, and flags a provider-named source carrying enough content to be a decision rather than a default.

Repositories can declare what they hold

A privacy-classification vocabulary already existed per artifact but never reached project scope, so the difference between a repo routinely excerpted for partners and one holding executed agreements was carried only by prose and a free-text note. project now accepts classification, pii, and handling flags, and doctor warns when a repo declared private has a secondary remote that pushes on release.

The access manifest gained the write path it was missing: aiwg repo-access add, remove, and audit, the last reporting git subdirectories that are formally denied because nobody registered them.

Rules answer the question you ask

Discovery ranking weights trigger phrases heavily, and rules have always supported them — 2 of 168 declared any. A skill usually has a distinctive name you might guess; a rule's name describes the policy, not the question. Nobody queries "delivery-policy", they query "should I open a pull request". So the artifacts that encode "you may not do this without authorization" were the ones least able to surface.

The 16 rules an agent most needs mid-task now declare triggers written as the question being asked:

"do I need permission for this"  -> human-authorization
"where do I put an api key"      -> token-security
"can I commit to main"           -> delivery-policy
"should I delete this test"      -> anti-laziness
"is this command destructive"    -> ops-safety

No indexer change was required. docs/development/rule-creation-guide.md documents the mechanism — there was a creation guide for every artifact type except rules — and npm run lint:rule-triggers reports coverage so the remaining rules close incrementally.

The phrases stay out of your context: deployed rules keep their frontmatter, so triggers are stripped at deploy. They exist for the index, not for the agent reading the rule.

The bibliography resolver extracts what it counts

The resolver shipped in the previous cycle counted correctly and extracted almost nothing. Against real e-prints it returned no title on 52 of 66 entries of an ACL paper, none on a biblatex one, and "ArXiv preprint" as a title three times — so Confirmed by could not be populated at all. Five parse gaps, each from a real shape it met: \href {url} {Title} with spaces, biblatex \field, bare abs/NNNN arXiv ids, style-dependent year placement, and brace-delimited .bib fields, which had never parsed and which the report did not name.

Unresolved entries now say so. A printed title that matches two corpus REFs — the corpus inducts some works twice — is resolved deterministically with the twins listed in ambiguous, instead of silently depending on file order. Measured against hand-resolved citation sidecars on four dialect cases: 57 of 60 edges, the remainder corpus-side duplicates.

Also in this release

• --help reaches real usage for installation, repo-access, and steward permissions.
• main-only-blocked is accepted as a deprecated force-push alias, naming the semantic narrowing instead of rejecting a config that was valid when written.
• workspace-context doctor stops flagging relative paths inside fenced code blocks.
• The stale-commands warning is emitted once per run and names the actual files.
• The framework-graph build error names the install root, so the documented repair is run where it works.
• Research: a bibliographic-services reference covering per-service failure modes and the OpenAlex citation-count trap, plus a shipped bibliography resolver and acquisition-obstacle recording.

Release date: 2026-09-12

Channel: stable

AIWG 2026.9.7 fixes a class of bugs where a deploy or refresh removed artifacts it had no basis for judging, and restores AIWG's rules to the top of the precedence order the bootstrap generates. If you run aiwg use or aiwg refresh against a workspace with more than one bundle or more than one provider, this release is worth taking.

Deploys account for what they touch

aiwg use all takes a kernel-only path: it deploys skills and nothing else. That path was still calling the flat-artifact prune with an empty desired set, so every AIWG-managed agent, command, and rule in the provider tree matched as stale.

The observed result: aiwg use sdlc followed by aiwg use all took .claude/agents from 139 to 0 and .claude/rules from 47 to 2 — and reported success. A run that deploys only skills has no basis for calling any flat artifact stale, and no longer tries.

The reporting that hid it is fixed too. Deployment counts came from reading the provider directory, not from what the run wrote, so a deploy that wrote nothing still printed whatever happened to be sitting there. A no-op deploy and a successful one looked identical. Counts now describe the artifacts the run actually accounts for.

Ask your assistant:

Deploy the SDLC framework, then deploy everything, and show me what each run actually wrote.

Refresh stays inside the tree it was asked to touch

A provider-scoped refresh walked every provider's agents directory and deleted AIWG-managed agents from older packages — including trees it was never asked to touch. Because commands and rules in those trees were never considered, aiwg refresh --provider claude could leave .codex/ with zero agents while its commands, rules, and AGENTS.md bridge stayed intact and advertised.

The cross-provider prune is opt-in behind --prune-other-providers, but when an operator passed it, the prune deleted git-tracked and gitignored files alike. In one reported workspace .claude/ was ignored and .codex/ was not, so the prune landed as 161 staged deletions in a working tree holding unrelated in-flight work — losable by anyone who commits without reading git status first.

Deleting a regenerable ignored artifact and deleting a committed file are different questions, and they now get different answers. --force keeps its own meaning: may I overwrite artifacts AIWG does not manage, scoped to files the run was going to write anyway. It does not authorise destroying tracked files in a tree the run was not asked to touch.

Skill-command wrappers now retire with their source skill, instead of surviving every deploy while advertising a command that resolves to nothing.

Your rules outrank the harness

The precedence block AIWG generates into every WORKSPACE.md ranked provider, system, and harness instructions above AIWG's own rules. That is backwards, and it had a concrete consequence: a session-level directive to add commit attribution trailers beat no-attribution — a rule marked CRITICAL whose exceptions section reads "None" — and an agent could cite the generated precedence as justification.

Deployed AIWG rules now bind over provider, harness, and session directives on any subject a rule covers, including directives that claim to supersede earlier guidance. Platform capability and safety constraints remain absolute; the distinction is capability versus preference. "This tool is unavailable" is a constraint. "Format commits this way" is a directive, and a project rule on commit content wins.

Run aiwg regenerate to pick up the corrected block. AIWG also detects a bootstrap whose precedence has drifted back and routes that finding to regenerate through the steward, so the fix does not silently come undone.

The optional sqlite backend is optional again

better-sqlite3 is an optional peer dependency, so a default npm install does not provide it. Suites that needed the backend were failing rather than skipping — 61 tests across 25 files, and only one of those failures named the cause. The rest surfaced as unrelated-looking symptoms, which made a normal contributor install look like a broken checkout.

Those suites now skip with a named remedy and warn once. A clean npm install && npm test is green. npm run features:sqlite installs the same pinned build CI uses, and the suites then run in full — the guards fire only on absence, so nothing is lost when the backend is present.

The README asks, rather than invokes

The README now leads with what you would say to your assistant instead of the command you would type. Tooling interactions throughout are prompt-driven, and the Mermaid diagrams render again. If you point new contributors at the README, the path they see first is the one AIWG is actually designed around.

Test hardening

This cycle carries a large pass over AIWG's own suite: source-bound audit oracles, fixture isolation for heavy lanes, statistical boundaries for NFR cases, mutation budgets, and runner-ownership registration. A filesystem watcher flake that had recurred four times is addressed at its contract rather than its timeout — WatchService.start() now resolves only once chokidar reports the watch armed, not merely that its initial scan finished, because a file created in that window was reported by neither and no caller-side wait could recover it.

Upgrading

npm install -g aiwg
aiwg refresh
aiwg regenerate

aiwg regenerate is what applies the corrected precedence block to your WORKSPACE.md. If you maintain multiple provider trees, run aiwg doctor afterwards to confirm each one still reports the surface you expect.

Release date: 2026-09-08

Channel: stable

AIWG 2026.9.6 expands the Testing Quality addon with a repeatable workflow for assessing an existing test suite, reviewing its evidence, and applying reversible normalization changes.

Review what your tests actually prove

Ask your assistant:

Assess this codebase's test conformance. Inventory its runners, collect execution evidence, review test oracles, and propose a normalization plan.

The addon includes conformance, oracle-review, and normalization agents; three new skills; YAML flows; and standard schemas and templates for protocols and outputs. The supporting aiwg test-conformance CLI provides twelve commands covering inventory, evidence collection, assessment, planning, changes, and rollback.

Assessment binds evidence to source and configuration. Runner discovery and execution receipts help reconcile declared tests with executed cases. Negative controls check whether specified tests fail when reviewed source behavior is deliberately changed, then restore the source and rerun the baseline. Missing evidence blocks a conformance claim; a green test run alone does not establish that the tests are adequate.

Normalize a suite with a reviewable plan

Platform templates support development and deployment planning. Apply and rollback record exact file contents and modes, detect conflicting edits, and guard path and symlink boundaries. Research guidance can search a configured local corpus and suggest platform testing tools through primary-source references.

Profiles cover Vitest, Jest, native Node, pytest, Go, Cargo, JUnit/Maven, VSTest, and generic runners. Real Vitest and pytest lifecycles were qualified for this release. The other profiles have adapter fixtures and research guidance; they still need validation against the target project's runner and reporting conventions.

See the conformance workflow and acceptance matrix for the evidence requirements and qualification limits.

AIWG uses the workflow on its own tests

The release audit restores omitted Vitest tests, separates mixed Node/Vitest contract lanes, makes validation setup fail closed, strengthens schema and fixture oracles, and adds multi-target negative controls. A real nested-suite Vitest report also exposed and fixed a suite-versus-file counting error in the conformance adapter.

AIWG now includes a runnable, source-bound conformance example. It collects real runner evidence, applies a reviewed source mutation, requires the named test to reject it, restores the source, and produces an assessment. Its review pins become stale when reviewed code changes. A separate measured library coverage gate proves that adding uncovered source fails the threshold even while behavior tests pass.

See AIWG's test conformance example for commands, scope, and the audit's before-and-after findings. Whole-repository semantic certification and live-platform qualification are outside this example.

Update and deploy

npm install -g [email protected]
aiwg use testing-quality --provider codex

Select your project's provider when deploying. The full aiwg package includes the addon corpus; @aiwg/cli provides the lightweight runtime. All three npm packages, including @aiwg/cockpit, share this release version.

Release date: 2026-09-07

Channel: stable

AIWG 2026.9.5 adds experimental DeepSeek Harness integration, makes shared project bundles usable from nested workspaces, and expands opt-in writing tools with explicit author control and fidelity review.

Use AIWG with DeepSeek Harness

The new deepseek-harness provider, also selected with dsh, connects AIWG to the official DeepSeek Harness CLI and SDK. It provides an AGENTS-first workspace bootstrap, native filesystem skills in .agents/skills/, and a managed Cordis overlay with workspace-write sandboxing and raw session recording. Existing operator configuration is preserved.

Preview the provider setup before deploying it:

aiwg use all --provider deepseek-harness --dry-run
aiwg use all --provider deepseek-harness
aiwg doctor --provider deepseek-harness

Headless execution and streaming SDK JSON-RPC support use bounded output, timeouts, and deterministic completion. AIWG waits for root and known child work to finish and drains output before reporting success. Sensitive model-route values stay out of the checked-in overlay.

Raw v2 JSONL histories can also join AIWG's session catalog through explicitly authorized session discovery and import. The importer preserves session topology and user/final-assistant text while redacting sensitive request, tool, reasoning, and unknown-plugin payloads.

This provider remains experimental and accepts only qualified Harness versions. AIWG hook wiring, MCP injection, structured question responses, daemon, and cron integration are not supported in this baseline. See the DeepSeek Harness provider guide and session import guide for exact versions, setup, and capability limits.

Share a bundle without copying it into every project

A member project can use projectLocal.searchPaths to point at a parent or external bundle root. Previously, deployment could write the native agent files but fail verification because the member index omitted their sources.

Validated external bundle payloads now enter the member index, default discovery, show, and managed quickrefs. Unrelated files beside the bundles stay outside the index, and links escaping an external payload are excluded. Rebuilding after removing a search root prunes its local index entries.

See sharing bundles with a nested project.

Start with the workflow you need

The onboarding and workflow guides now give more direct paths from a task to the relevant capability. Session exploration gains discoverable help, workflow recipes, and public source links. Provider guidance distinguishes indexed artifact access from native deployment when a provider cannot load an artifact natively.

Keep author control over writing changes

Opt-in writer profiles can carry approved samples and scoped preferences. Structured briefs, bounded examples, contextual diagnostics, and fidelity review help make proposed changes inspectable. Individual edit decisions, explicit learning proposals, receipts, and undo preserve the author's control. Selecting a profile alone does not intercept every provider response.

The release also packages the reviewed neutral-profile workflow and records voice-evaluation results and limits. These controls and fixture tests do not establish a general improvement in generated voice quality; broader human and model qualification remains open.

Additional capabilities and fixes

• The opt-in network-analysis addon supports bounded analysis of saved PCAP/PCAPNG captures, metadata-first evidence, stable citations, and optional local Termshark review.
• Artifact writes respect the configured external corpus. Fortemi dataset qualification independently verifies execution receipts and request digests.

Upgrade

Use the installation guide to select version 2026.9.5, then refresh an existing workspace with aiwg refresh --skip-update.

The synchronized package versions are [email protected], @aiwg/[email protected], and @aiwg/[email protected].

• Changelog
• Getting started
• Writing workflows

Release date: 2026-09-05

Channel: stable

AIWG 2026.9.4 gives lightweight CLI users a clear recovery path when they request bundled framework setup. The command now stops before changing the project and explains that the full aiwg package supplies the framework and addon sources required by aiwg use.

Recover from incomplete lightweight CLI setup

The lightweight @aiwg/cli package is intended for signed web-resource queries and external project-local bundles. It does not contain the full framework and addon corpus. Requests such as this previously started setup and then failed with a low-level missing-directory error:

aiwg use all --provider pi

The command now detects that package boundary before project initialization and prints the exact migration steps:

npm uninstall -g @aiwg/cli
npm install -g [email protected]
aiwg use all --provider pi

The same preflight applies to named bundled frameworks and dry runs. External project-local bundles remain available through the lightweight package.

Upgrade and references

npm install -g [email protected]
aiwg refresh --skip-update

The package versions are [email protected], @aiwg/[email protected], and @aiwg/[email protected].

• Lightweight CLI package guide
• Changelog
• Issue #2287

Release date: 2026-09-05

Channel: stable

AIWG 2026.9.3 adds experimental Oh My Pi and Google Antigravity integrations, promotes Hermes to stable, and fixes discovery of existing project-local skills when a Fortemi Core project cache is unavailable.

Find the workflows already in your project

An existing skill under .aiwg/extensions/, .aiwg/addons/, or another configured project-local bundle root now remains available to aiwg discover when the project cache is missing, stale, or corrupt. Discovery falls back to the local project index with a bounded warning; deployment, refresh, and upgrade also synchronize the project index after reconciling local bundles.

aiwg discover "your project workflow"
aiwg show skill your-project-skill

Portable workflows such as aiwg-guide, doc-consolidate, and the five semantic-memory skills now declare platforms: [all]. Their canonical and plugin copies no longer exclude newer providers through outdated allowlists.

Use OMP and Antigravity with explicit support boundaries

aiwg use sdlc --provider omp
aiwg use sdlc --provider antigravity

OMP has its own resource paths, profiles, MCP integration, model discovery, JSON/RPC execution, and native session imports. Its reviewed baseline is 18.1.10, with native conformance checks on Linux x64; other operating systems and newer releases remain unverified.

Antigravity supports project skills and agent projections, collision-safe MCP configuration, and bounded headless execution. Offline conformance is pinned to CLI 1.1.26. Authenticated model execution has not been qualified, global skill deployment remains unsupported, and agent projection is degraded.

Both integrations remain experimental. Hermes is now classified as stable. The published inventory covers 14 named providers plus a generic fallback.

Inspect Fortemi compatibility and recover from SQLite startup contention

Fortemi live storage qualification produces sanitized receipts recording the tested revision, server contract, complete operation inventory, mutation status, and resource bounds. Dataset workflows gain a live contract preflight and UAT plan. Fortemi MCP reads now accept nested content responses, and search can retrieve missing note metadata before filtering results to the subsystem.

Fortemi Server remains alpha and pre-certification. Live checks default to read-only and gate writes separately. These checks do not establish general persistence, recovery, migration, or load guarantees. The Fortemi Core cache used for capability discovery is separate and needs no live Server endpoint.

SQLite graph initialization now retries temporary journal-mode and schema locks within its configured busy timeout and closes failed connections. The fix includes a deterministic contention regression and regenerated benchmark evidence from the changed source.

Upgrade and references

npm install -g [email protected]
aiwg refresh --skip-update

This release also adopts Contributor Covenant 2.0 community standards. The package versions are [email protected], @aiwg/[email protected], and @aiwg/[email protected].

• OMP provider guide
• Antigravity provider guide
• Fortemi storage qualification
• Project capability discovery
• Changelog

Release date: 2026-09-04

Channel: stable

AIWG 2026.9.2 takes the experimental Pi Coding Agent integration from resource deployment into real runtime use. Pi can now participate in model discovery, headless External Ralph work, governed extension policy, and native session ingestion without losing its own backend/model identity.

What this changes for you

Run AIWG work through Pi

External Ralph now has a dedicated Pi adapter. You can select Pi as the coding harness, pass a Pi-native backend/model identifier, and carry thinking, tool, and session controls into a strict JSONL headless run:

node tools/ralph-external/index.mjs \
  "Implement the bounded change" \
  --completion "Tests pass" \
  --provider pi \
  --model openrouter/your-model \
  --thinking high \
  --tools read,bash

AIWG checks Pi's Node.js requirement before launch, keeps protocol output and diagnostics separate, sends an RPC abort before bounded process escalation, and treats agent_settled—not merely agent_end—as terminal settlement.

Discover the models Pi can actually use

AIWG reads Pi's non-interactive --list-models catalog and preserves the full backend/model identity. That matters with a routing harness such as Pi: “Pi” is the coding-agent provider, while openrouter/... identifies the LLM backend and model selected inside Pi.

Apply a reviewed extension policy

aiwg use all --provider pi now installs a receipted .pi/extensions/aiwg-bridge.ts. Once you trust the project in Pi, the bridge blocks destructive and package-mutating bash calls in headless sessions. In an interactive TUI it asks explicitly and defaults to denial. Operator extensions and Pi settings remain untouched.

aiwg use all --provider pi --dry-run
aiwg use all --provider pi

Import native Pi session trees

Pi v3 JSONL is now the thirteenth canonical AIWG session provider. The adapter discovers only authorized roots, preserves native entry and parent IDs, maps messages and lifecycle entries, retains future entry types opaquely, and redacts tool results and custom extension data before normalization.

Malformed, truncated, oversized, duplicate, unsupported-version, symlinked, and out-of-scope sources fail closed.

Verified boundary

The release was qualified with Pi Coding Agent 0.85.0 and OpenRouter in isolated temporary roots. Discovery, RPC state and abort, strict JSONL framing, live inference, and agent_settled all passed. No raw model output was persisted.

Pi remains experimental while its promotion gate is evaluated. AIWG does not install Pi itself, configure authentication, or add MCP packages, and Pi core does not provide a native MCP surface.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Learn more

• Pi quickstart
• Pi operational reference
• Pi session acquisition
• Changelog

Try Pi with the backend you already use, then tell us which model-routing and session-review workflows would benefit most from promotion to stable support.

Release date: 2026-09-04

Channel: stable

AIWG 2026.9.1 adds governed schema and dataset workflows, introduces Pi Coding Agent as the twelfth named provider integration, and strengthens live storage qualification. It also turns the public provider count into a tested contract so documentation cannot quietly drift from the implementation.

What this changes for you

Govern schemas and datasets as operational assets

Schema governance now provides a catalog, lifecycle policy, compatibility analysis, and validation commands. The Dataset Intelligence addon builds on that foundation with source-adapter contracts, standards profiles, canonical run ledgers, provenance, orchestration commands, migration guidance, and cross-runtime conformance checks.

Start by discovering the workflow that matches your task:

aiwg discover "govern schema compatibility"
aiwg discover "build a governed dataset pipeline"
aiwg discover "validate dataset provenance"

These capabilities make changes and evidence explicit. They do not certify an external dataset or replace operator review of source rights, quality, and fitness for purpose.

Use AIWG with Pi Coding Agent

Pi is now an experimental first-class provider for identity, detection, capability reporting, and native resource deployment:

aiwg use all --provider pi --dry-run
aiwg use all --provider pi
aiwg steward capabilities --provider pi

AIWG deploys provider-neutral startup context, portable Agent Skills, and Pi prompt templates while respecting project and relocated user scopes. Runtime extensions, model-catalog integration, and persisted-session ingestion remain future work.

The canonical inventory is now explicit: 12 named provider integrations plus a separate generic fallback adapter. Devin remains an alias for Windsurf rather than an additional provider.

Extend output behavior through supported APIs

The output-mode registry and protected transformation runtime are exported from the package API. New documentation covers selection, personal and project profiles, custom syntax, runtime integration, and troubleshooting.

Qualify storage against live implementations

Fortemi conformance now exercises published Core receipts against clean PGlite and live Fortemi paths. This provides concrete compatibility evidence rather than relying only on local unit-level substitutes.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Learn more

• Pi quickstart
• Provider inventory
• Dataset Intelligence overview
• Schema Governance overview
• Output modes
• Changelog

Useful feedback includes which provider you use, what kind of schema or dataset you govern, and whether the new validation evidence is clear enough to support your release decisions.

Release date: 2026-09-01

Channel: stable

AIWG 2026.9.0 introduces an opt-in Civic Action review kit for public-interest research and editorial preparation. It connects source provenance, public-records planning, meeting and vote reconciliation, public-technology research, local-resource profiles, correction planning, and publication QA without delegating consequential civic decisions to automation.

What this changes for you

Civic work starts from evidence, not a blank prompt

Install the addon and describe the civic artifact you need to prepare:

aiwg use civic-action
aiwg discover "plan a public records request"
aiwg discover "reconcile a public meeting transcript with minutes"
aiwg discover "publish cited local public information"

The addon supplies four bounded personas, eight focused skills, three FlowPlaybooks with resolvable AIWG capabilities, and structured contracts for source registries, request plans, vote ledgers, meeting reconciliation, public-technology reviews, local-resource indexes, publication packets, corrections, and gate results. The design and legal/ethics briefs shipped with the addon cite the primary standards and public-sector guidance that informed those contracts. A control-to-source matrix records which boundaries are executable and which remain declarative.

Selected local packet checks are executable

Three commands make the most important boundaries testable in local workflows and CI:

aiwg civic source-gate source-registry.json
aiwg civic meeting-gate vote-ledger.json reconciliation.json
aiwg civic publish-gate publication-packet.json

Each command validates its input against the shipped JSON Schema, then inspects selected declared fields and writes a structured JSON report. Exit 0 means the evaluator found no blocking condition among those fields, exit 1 means a declared condition blocked, and exit 2 means the input or invocation was invalid. Schema failures include bounded JSON-pointer diagnostics. A pass does not independently validate facts, determine legality, or authorize an action; warnings remain visible for a named human to disposition.

Meeting contracts preserve disagreement instead of smoothing it away

The meeting FlowPlaybook and contracts keep media/transcripts, agendas, vote ledgers, and minutes as distinct sources. The local meeting gate checks declared vote cues, conflicts, results, reconciliation decisions, minutes state, and named review. Speaker identity is never inferred from voice alone. Recording posture, jurisdiction, and source completeness remain mandatory human workflow decisions rather than conclusions made by the command.

Public records and procurement remain decision-support workflows

Public-records plans capture jurisdiction, authority, scope, exemptions, fee/format preferences, deadlines, and manual submission approval. Public- technology review contracts inventory record classes, evidence, risks, release states, and human questions, and prohibit an automated award recommendation.

These artifacts help a person research and prepare. They do not submit a request, contact an agency or vendor, give legal advice, select a supplier, or make a procurement decision.

Local public data stays portable

The local-resource contract supports vendor-neutral AIWG profiles for CAP, GTFS, and HSDS with provenance, freshness, selected vertical fields, citations, and declared validation state. These profiles are not standards-conformance or public-safety validators. Jurisdiction- and vendor-specific connectors remain separate adapters.

Consequential actions stay with named people

Civic Action performs no autonomous acquisition, recording, speaker identification, outreach, records submission, legal or procurement decision, correction approval, or publication. Its local commands enforce a bounded set of declared source, meeting, and publication packet checks. Records, procurement, local-resource, correction, and external-adapter actions remain decision-support workflows controlled by named people. A machine pass is review evidence—not legal advice, factual verification, standards certification, compliance, or authorization to act.

The release also isolates required CI workflow concurrency, makes Gitea release recovery and asset retries safer, binds GitHub signing identity to the release tag, and removes timestamp drift from prebuilt release indices.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Learn more

• Civic Action overview
• Civic Action quickstart
• Civic workflow standards and sources
• Legal and ethics guardrails and sources
• AIWG design-pattern mapping
• Control-to-source matrix
• Changelog

When you try the addon, useful feedback includes the jurisdiction and artifact type, which gate decision surprised you, and whether the report gave the human reviewer enough evidence to act without hiding uncertainty.

Release date: 2026-08-31

Channel: stable

AIWG 2026.8.28 makes operational evidence safer to publish and several runtime paths easier to recover. Ops workflows now have one classification, redaction, destination, and retention boundary; session storage can install its optional SQLite backend through the production feature path; A2A adapters preserve compatible routes during dual-version negotiation; and development-channel build drift produces a direct recovery message instead of a raw Node import error.

What this changes for you

Operational evidence crosses one explicit boundary

Operational output can contain sensitive values, internal topology, customer data, or more raw detail than a destination needs. The new governance API handles those concerns together before a payload reaches an agent response, file, repository, tracker, cross-repository transfer, export, or bundle.

The boundary minimizes evidence, redacts text and nested structures, compares artifact classification with the selected sink, and attaches retention or disposition metadata. When full publication is not allowed, it can emit a separately gated summary without copying sensitive source fields.

The command-line preparation path makes the same decision available to ops workflows:

aiwg ops evidence prepare \
  --input evidence.json \
  --policy governance-policy.yaml \
  --sink issue-comment

Projects can extend classification and retention policy while keeping secure defaults for raw audit output, identity audits, network inventories, disaster recovery evidence, and sanitized summaries.

Session SQLite support follows the feature boundary

Session commands can select the optional SQLite backend without treating it as a hidden base dependency. The feature workflow installs and verifies the backend for the scoped session path, while CI exercises the same package and runtime boundary used in production.

This keeps the default package smaller and makes the capability explicit: add the storage feature when a session workflow needs it, and diagnose its state through the normal session tooling.

A2A adapters remain compatible during version negotiation

Dual-version A2A clients and dispatchers now qualify negotiated endpoints without dropping the legacy interface base expected by compatible peers. Codec, client, and dispatch tests cover the route shapes so protocol upgrades do not silently strand an older integration.

A stale development checkout explains how to recover

Development mode can point a globally installed launcher at a local checkout. If that checkout contains dist/src/cli/router.js but not the compiled installation manager, AIWG now stops before dynamic import and prints both supported recovery paths:

Run: (cd /path/to/checkout && npm run build:cli)
Or switch back: aiwg --use-stable

Channel-switching commands are handled before the preflight, so recovery stays available even when the selected checkout is only partially built.

Discovered executable skills stay executable

Fortemi Core release indices now preserve skill script entrypoints and execution flags. A script-bearing skill discovered from the packaged corpus can therefore be run through aiwg run skill <name> with the same execution metadata it had at source.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Learn more

• Ops evidence governance
• Session CLI and storage behavior
• Changelog

If you use the new evidence boundary, the most useful feedback is concrete: which sink you publish to, which classification decision surprised you, and whether a sanitized summary carried enough information to act. For development channels, let us know whether the new recovery message gets you back to a working command without needing to inspect the launcher or user-level channel state.

Release date: 2026-08-28

Channel: stable

AIWG 2026.8.27 turns the shared-server storage path into an evidence-backed release surface. PostgreSQL and PostgREST now have executable qualification jobs and versioned reference results, storage migrations must prove semantic parity before cutover, and every artifact-index backend follows the same ordering and pagination contract. The release also restores the fully templated tracker response for address-issues cycles.

What this changes for you

Shared-server claims are tied to current evidence

Dedicated CI jobs obtain short-lived PostgreSQL and PostgREST runtime configuration from Vault, exercise the live server adapters, and produce reports that declare the environment and scope they actually tested. Published reference evidence lets reviewers reproduce the supported claims, while release gates reject stale or incomplete benchmark evidence.

This separates measured behavior from assumptions: local SQLite, direct PostgreSQL, and PostgREST results each identify their own qualification surface.

Migrations prove meaning, not only row movement

The migration protocol now checks logical identities, snapshot and replay integrity, tombstones, revisions, digests, parity, cutover approval, and rollback readiness. A copied record set is not sufficient when relationships, deletions, or revisions differ at the destination.

Index behavior is portable across backends

Graphology, JSON, and SQLite artifact indexes now use deterministic traversal ordering and common cursor semantics. Consumers can paginate without backend- specific ordering surprises, and the golden conformance corpus protects that contract.

Address-issues comments retain the complete cycle record

Native goal and resume paths now use one canonical AL CYCLE renderer and validator. Before a tracker comment is posted, the flow checks that the templated status, work details, evidence, verification results, and continuation state are present.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Run aiwg refresh to update through the installation method recorded for the current machine and redeploy installed frameworks. Keep all three managed packages on 2026.8.27. Source checkouts should update through their normal Git workflow, build, and then run aiwg refresh --skip-update.

Rollback

Pin aiwg, @aiwg/cli, and @aiwg/cockpit to 2026.8.26 with the same package manager used for installation, then run aiwg regenerate so deployed provider context matches the restored version. For a storage deployment, use the migration's recorded rollback plan and receipt; do not reverse a cutover by changing package versions alone.

Release boundaries

• Shared-server reference evidence covers only its declared PostgreSQL and PostgREST versions, configuration, topology, and workload. It is not a general performance guarantee for other environments.
• Migration cutover remains approval-bound and requires a deployment-specific rollback plan. Passing qualification does not authorize unattended production migration.
• Vault-backed CI validates runtime configuration and live qualification while keeping protected values outside the release artifacts.

Release date: 2026-08-26

Channel: stable

AIWG 2026.8.26 strengthens two connected security boundaries: the dependency graphs that enter a release and the evidence attached to alerts about those graphs. Root, Droid Bridge, evaluation, and Tauri XML dependencies move to patched releases, while exported findings become reproducible from an exact commit and lockfile rather than relying on a package name alone.

What this changes for you

Patched dependency graphs with boundary tests

The root package now resolves patched nanoid and esbuild releases. Droid Bridge upgrades its MCP and nested HTTP stack, with a real stdio initialization test proving the bridge still completes the protocol handshake. Evaluation tooling upgrades js-yaml and esbuild, with representative YAML parsing and unsafe-tag rejection tests.

The Tauri build graph also moves to quick-xml 0.41.0, clearing the two reported XML denial-of-service advisories. The desktop application does not accept XML or plist input at its own boundary, but the safe minimum is now documented and locked anyway.

Alerts identify the artifact that produced them

Dependency-alert exports now record the commit, workspace, manifest, lockfile and its SHA-256 digest, dependency path, ecosystem, direct/transitive status, and artifact-integrity evidence. The exporter rejects duplicate explicit alert identifiers, advisories without usable identifiers or URLs, and patched-version claims that do not match the affected dependency line.

That makes an alert answer the practical questions immediately: which artifact was scanned, how did the package enter it, and can another reviewer reproduce the result?

Obfuscation findings need behavioral evidence

Code that merely looks compressed or obfuscated is no longer enough for an actionable security finding. Behavioral alerts must include a file, symbol, rule identifier, confidence, artifact hash, and an excerpt or execution trace. Review suppressions are tied to that exact hash and require a rationale, so a changed artifact is reviewed again.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Run aiwg refresh to update through the installation method recorded for the current machine and redeploy installed frameworks. Keep all three managed packages on 2026.8.26. Source checkouts should update through their normal Git workflow, build, and then run aiwg refresh --skip-update.

Rollback

Pin aiwg, @aiwg/cli, and @aiwg/cockpit to 2026.8.25 with the same package manager used for installation, then run aiwg regenerate so deployed provider context matches the restored version.

Release boundaries

• The optional Tauri GTK3 source graph still contains glib 0.18.5, tracked by RUSTSEC-2024-0429 and roctinam/aiwg#2203. The issue is deferred until a compatible GTK4/Tauri release can be qualified; the advisory is not waived.
• This release does not qualify or publish Linux .deb, .rpm, or .AppImage desktop bundles. Cockpit remains available through its Bridge-hosted browser UI and VS Code shell, and the npm package continues to ship the desktop source.
• Exact-hash suppressions apply only to the reviewed artifact. Any content change produces a new hash and requires fresh review.

Release date: 2026-08-25 Channel: stable

AIWG 2026.8.25 tightens two everyday safety boundaries in the CLI: asking for help cannot accidentally run a state-changing command, and Windows package updates keep the exact quoting required by native manager wrappers. Refresh also reports a failed package update honestly even when it can continue with framework re-deployment.

What this changes for you

Command help is non-executing

The router now handles --help and -h before command hooks or normal handler execution. Commands with dedicated help keep their detailed output. Commands without it return a generic pointer to aiwg help without entering the command path.

This is especially important for maintenance commands such as refresh: asking what a command does is now structurally separate from doing it.

Windows global updates preserve wrapper quoting

On Windows, npm-compatible managers commonly resolve to .cmd or .bat wrappers, sometimes beneath paths containing spaces. AIWG now gives cmd.exe the already quoted wrapper payload verbatim instead of allowing Node to escape it a second time.

The same execution helper is used by install-aware update paths, so refresh and direct update operations share the corrected behavior.

Refresh reports partial recovery accurately

Refresh still attempts framework re-deployment after a package update failure, but its final result no longer looks like a clean update. Interactive output warns that AIWG may remain on the previous version, and quiet JSON uses the status refreshed-with-update-failure for automation.

Publication has realistic runner headroom

Stable and prerelease package jobs now allow 30 minutes for cold dependency installation, tests, signature checks, and publication of the complete package set. This changes the workflow timeout, not the release gates or trust policy.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

For managed npm and web installations, run aiwg refresh to update AIWG through the installation method already recorded for the current machine and re-deploy installed frameworks. Keep the three managed packages on the same version. Source checkouts should update and build through their project Git workflow, then run aiwg refresh --skip-update to re-deploy.

Rollback

If rollback is necessary, pin all three packages to 2026.8.20 with the same package manager used for installation, then run aiwg regenerate so provider context matches the restored version.

Release boundaries

• The Windows fix is covered with platform-specific command construction and execution tests; it does not claim qualification of every third-party package-manager wrapper.
• Refresh intentionally keeps its exit-0 recovery behavior when re-deployment succeeds after an update failure. Automation must inspect the documented quiet-mode status to distinguish that partial result.
• The longer publication timeout does not relax tests, signing, provenance, SBOM, checksum, or post-publication verification requirements.

Release date: 2026-08-24 Channel: stable

AIWG 2026.8.20 strengthens two boundaries that become important as projects grow beyond one process: how missions move between execution surfaces, and how storage moves between backends without losing identity or silently overstating capabilities. It also introduces an experimental Universal Harness Protocol client for portable harness operations and hardens SQLite as the supported same-host graph tier.

The common theme is evidence. A backend name no longer implies consistency or durability, a copied pathname is no longer enough to prove migration, and a mission payload cannot drift invisibly between CLI, Cockpit, Flow, and storage consumers.

What this changes for you

Missions have one explicit protocol boundary

The versioned Mission contract now has a generated inventory, schema baseline, consumer matrix, codecs, and migration tooling. This makes it possible to see which consumers accept a contract version and to migrate older payloads before they reach an execution boundary.

Mission backend routing is reversible and recorded. Operators can preview a migration, apply it, verify the result, switch routing, and roll back rather than changing a provider setting without durable evidence.

Use the focused gate while developing Mission consumers:

npm run test:mission-protocol

Experimental UHP clients can discover and run harnesses

The new UHP client implements the versioned 2026-08-11 transport for harness and model discovery, request/response and event-stream execution, cancellation, continuation, and file exchange. Configuration rejects unsafe remote transport defaults, structured errors preserve protocol detail, and Cockpit can project the normalized mission state.

Start with the offline conformance suite:

npm run test:uhp:offline

UHP remains experimental. A green fake-server suite proves the client contract; it does not certify an arbitrary third-party harness deployment.

Storage migrations are revision- and checksum-backed

The new scalable storage contract declares what each backend has actually demonstrated: read behavior, atomic batches, snapshots, cursors, tombstones, idempotency, query operations, durability, isolation, and maturity. Capability negotiation fails closed instead of inferring guarantees from a backend name.

The aiwg.storage-migration/v1 coordinator records source and destination identity, schema, snapshot/cursor, revisions, content digests, tombstones, destination receipts, and approval state. It supports bounded copy and replay, exact resume, parity negatives, digest-bound cutover, and rollback windows.

The currently shipped pathname-oriented aiwg storage migrate command remains the legacy offline path and is documented as such. The scalable coordinator is not yet wired into that CLI command, and local protocol tests do not constitute live Fortemi, PostgreSQL, or MySQL certification.

Run the common local correctness gate with:

npm run test:conformance:storage

SQLite is a stronger same-host graph tier

SQLite graph storage now verifies a safe WAL engine line, applies transactional schema migration, exposes typed query columns, uses native SQL set operations and bounded recursive traversal, reconciles stale nodes and edges atomically, and reports bounded lock exhaustion explicitly. Checkpoint metrics and online backup support operational qualification, while multi-process tests cover same-key races and committed WAL reopen behavior.

Run the reference-host benchmark before setting a local support envelope:

npm run benchmark:index:sqlite

The benchmark is evidence for the machine and workload that produced it, not a universal capacity claim.

Composition cycles fail closed

Composition graphs can now express guarded human-decision cycles only when progress strictly decreases and a hard iteration limit exists. Approval nodes pause and resume from checkpoints, and reports expose normalized scope, duplicate suppression, and branch/join resource evidence. Benchmark claims must survive a deliberately wrong negative-control policy.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Upgrade the package set together, regenerate provider context, and rebuild indexes whose backend configuration changed:

npm install --global [email protected]
npm install --global @aiwg/[email protected]
npm install --global @aiwg/[email protected]
aiwg regenerate
aiwg index build

Rollback

Roll all three packages back together to 2026.8.19, then run aiwg regenerate. Mission and UHP artifacts created under the new versioned contracts should be retained for diagnosis; use the supplied migration and contract-diff tooling before presenting them to an older consumer. SQLite indexes remain regenerable from canonical sources and can be rebuilt after a rollback.

Release boundaries

• Fortemi Server remains alpha until its updated server and shared-server qualification run are available.
• PostgreSQL and MySQL engine smoke tests are environment evidence only; their AIWG adapters remain unimplemented or deferred.
• The scalable migration coordinator is available as a library contract but is not yet the implementation behind the legacy storage migration CLI.

Release date: 2026-08-24 Channel: stable

AIWG 2026.8.19 tightens the artifact index around the way people actually write and inspect project context. Markdown links between indexed artifacts now show up as graph edges, global graphs declared in user configuration appear in aiwg index stats, and symlinked artifact directories are counted consistently by both build and coverage paths. Bulk provider installs are also compact by default: aiwg use all deploys the kernel skill set and leaves the broader catalog searchable instead of copying it into every provider surface.

This is a small release, but it removes a few blind spots that made the graph harder to trust. If the index says a graph has no edges, no global entries, or missing coverage, that result should reflect the project, not a scanner shortcut.

What this changes for you

aiwg use all is kernel-only by default

Every provider now receives the same compact default installation. Re-running the command also removes stale AIWG-managed agents, commands, and expanded rules from older full-copy installs while preserving operator-owned files.

Use the explicit compatibility switch when a fully materialized provider surface is required:

aiwg use all --provider codex --copy-all

Markdown links can show scoped relationships

Relative Markdown links between indexed artifacts now create typed markdown-link edges in the dependency graph. This lets normal reader-facing navigation contribute to graph traversal when the linked target is part of the same active graph.

The scope is intentionally narrow. External URLs, anchor-only links, image links, and paths that resolve outside the active graph do not create edges. @-mentions remain the durable syntax for traceability and provenance; Markdown-link edges represent local document navigation.

Inspect the result with:

aiwg index build
aiwg index graph --json
aiwg index stats

aiwg index stats now reports the Markdown-link edge count when the current index was built with this extractor version.

Global graph stats match default builds

Graphs declared in the user AIWG config and marked for default build now load before aiwg index stats reports aggregate or single-graph results. That means the stats output includes those global graphs instead of only project-local graphs.

Coverage uses the global graph's configured scan roots, so the reported indexed count and total file count are calculated over the same source set. Explicit-build user roots still stay out of default aggregate stats unless the operator builds or selects them intentionally.

Symlinked artifact directories are no longer invisible

Artifact discovery now follows symlinked and junctioned directories, while tracking real directories to avoid cycles. Broken links are skipped without failing the scan.

This matters for split-root and shared-corpus setups where a project links to a common artifact directory. Build and coverage now see the same linked files, and an unknown graph name fails explicitly instead of quietly falling back to the project graph.

Release reliability

The GitHub trusted-publishing workflow now preserves Git workspace trust after its isolated checkout step. This keeps follow-on npmjs.org release steps from failing because the working tree lost its safe-directory registration.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Upgrade the package set together, then regenerate provider context:

npm install --global [email protected]
npm install --global @aiwg/[email protected]
npm install --global @aiwg/[email protected]
aiwg regenerate

After upgrading, rebuild artifact indexes that should include Markdown-link edges:

aiwg index build

Rollback

Roll all three npm packages back together to 2026.8.18, then regenerate provider context. Indexes built with 2026.8.19 remain readable, but older extractors will not add new Markdown-link edge metadata until the index is rebuilt again on 2026.8.19 or later.

Discuss this release

Questions and field reports are welcome in the AIWG 2026.8.19 release discussion.

Release date: 2026-08-23 Channel: stable

AIWG 2026.8.18 makes two boundaries more dependable: the boundary between different agent protocol versions, and the boundary between a provider session and the AIWG installation it is allowed to maintain. It also turns the optional Flow graph profile into a usable execution surface with validation, replay, and operator visibility.

The common thread is continuity. An A2A peer can evolve its wire protocol without forcing the mission model to fork. A provider can start with a different PATH without moving the canonical AIWG installation. A graph run can cross agent, tool, Sandbox, and durable-code nodes without losing its identity or evidence trail.

What this changes for you

A2A peers can negotiate 1.0 without abandoning 0.3

The Bridge and A2A client now select compatible AgentCard interfaces and route through versioned codecs. Messages, tasks, artifacts, status changes, streaming events, and webhooks are normalized into the same internal mission model, so the rest of AIWG does not need parallel implementations for each wire version.

Selection is explicit and downgrade-resistant. If a peer advertises 1.0, AIWG uses the compatible 1.0 interface; if only 0.3 is available, the existing path continues to work. Golden fixtures and integration coverage keep both forms observable rather than relying on permissive parsing.

The compatibility guide describes the supported envelopes and negotiation behavior:

docs/a2a-protocol-compatibility.md

Every provider maintains the same AIWG installation

AIWG now persists a provider-neutral canonical installation record in the resolved user configuration directory. The record identifies the install method, canonical root, update strategy, absolute package-manager executable, release channel, and development mode.

This closes a subtle but costly failure mode on machines with more than one Node manager. A Codex session resolving Homebrew first and a Claude session resolving nvm first can no longer update different global prefixes merely because their process environments differ. Refresh and background maintenance use the recorded strategy. If the running CLI does not match the record, AIWG stops and explains how to inspect or deliberately change it.

Inspect the current identity with:

aiwg installation show
aiwg version --json
aiwg runtime-info

After intentionally moving an installation or changing Node-manager versions, use aiwg installation adopt for the current installation or aiwg installation switch with an explicit root and method. AIWG will not silently create a second installation as a repair shortcut.

The optional graph profile now has an execution surface

The graph-pattern addon extends the existing Flow model with validated graph playbooks and commands for scaffolding, explanation, dry runs, replay, and conformance checks. Its runtime dispatches agent, tool, Sandbox, and durable-code nodes through explicit adapters while preserving stable run and invocation identities.

The profile remains optional. A focused task still belongs in a direct agent call or bounded loop. Use the graph profile when conditional routes, guarded cycles, joins, reducers, or mixed runtimes need to be explicit and replayable.

Graph state also reaches Cockpit as a read-only projection, including active nodes, edges, checkpoints, degraded outcomes, and operator decisions. Mission and Flow remain the durable execution authorities; Cockpit presents their state without becoming another scheduler.

Security and reliability details

• Graph metadata records requested and realized capabilities separately and defines fail-closed, policy-degraded, and evidence-degraded outcomes.
• Sandbox graph nodes use a versioned event contract for dispatch, retry, checkpoint, resume, cancellation, and terminal lineage.
• The Flow static-site deployment guide now makes DNS, tunnel, Caddy, volume, workflow, and operator handoff boundaries explicit.
• The canonical installation record migrates existing channel and development settings while preserving startup-check state and release selection.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Upgrade the package set together, then regenerate provider context:

npm install --global [email protected]
npm install --global @aiwg/[email protected]
npm install --global @aiwg/[email protected]
aiwg regenerate

Existing installations migrate their legacy channel state on first canonical identity resolution. Run aiwg installation show after upgrading to confirm that the recorded and actual roots are aligned.

Rollback

Roll all three npm packages back together to 2026.8.17, then regenerate provider context. If 2026.8.18 has already written a canonical installation record, keep it and explicitly adopt or switch only if the rollback changes the actual installation root or package-manager executable. Preserve graph-run and A2A evidence so rollback does not erase completed mission history.

Release date: 2026-08-22 Channel: stable

AIWG 2026.8.17 makes graph-shaped agent work concrete without turning graphs into the answer to every orchestration problem. The composition runtime can now execute validated Flow graphs with typed state, bounded joins, retries, replay, and capability narrowing. The important part is not that a diagram exists. The important part is that the same graph can be validated, run, inspected, and replayed with evidence about what actually happened.

This release also changes how we talk about releases. The changelog remains the durable record, but stable releases now get a GitHub Announcements discussion that focuses on what the changes mean in practice and gives people a place to compare how they are using them.

What this changes for you

You can run graph compositions, not just describe them

aiwg composition run executes phased and multi-track FlowGraph definitions through an explicit adapter. Activation and invocation IDs are stable, joins are bounded, reducers are typed, retries are mutation-safe, and checkpoints can be replayed. Requested resources and realized resources are recorded separately so the trace shows what the runtime actually used.

This helps when dependencies, parallel branches, joins, or recovery paths need to be explicit. A loop is still usually the better tool for one focused task. Think of the graph as the road map between work units; the agents and loops are still the vehicles doing the work.

Start by validating a graph before running it:

aiwg composition validate path/to/flow-graph.yaml
aiwg composition run path/to/flow-graph.yaml

Composition policies can be compared with receipts

The new benchmark expands one fixed-task manifest across single-pass, Self-Refine, parallel-candidate, strict LCM, adaptive-convergence, and budget-partial policies. It reports success-conditioned resource use, injects known failure modes, and blocks quality or efficiency claims when the evidence does not support them.

If you are deciding whether another agent pass or another parallel branch is worth the cost, this gives you a repeatable comparison instead of a preference disguised as a benchmark.

The graph pattern now has a practical development map

The new gap audit separates what AIWG already has from what graph-oriented development still needs. AIWG already owns the Flow DAG, gates, fanout, capability routing, Mission durability, A2A dispatch, and audit substrate. The next work is narrower: conditional routes, guarded cycles, reducers, shared run identity, runtime adapters, graph conformance, and an operator view in Cockpit.

That distinction matters. Building a second graph DSL would create two systems that slowly disagree. Extending Flow keeps one execution and evidence model.

Release notes now have a conversation layer

For stable releases, publication verification now completes before the release flow opens a GitHub Announcements discussion. That discussion links back to the GitHub release, all published npm versions, these notes, and the exact CHANGELOG section. It highlights practical impact and asks concrete questions rather than copying every bullet.

The goal is simple: release records tell you what shipped; the discussion helps work out how to use it well.

Cockpit browser bootstrap is easier to recover

If a Cockpit Bridge is already running and its printed one-time browser URL has expired, the installation guide now provides a command to mint a fresh URL. It also explains source-checkout and SSH local-forward use without putting the reusable Bridge bearer into browser history or forwarded URLs.

Other improvements

• Static Flow site deployment now has a validated private-origin plan with explicit DNS, Caddy, volume, workflow, and operator handoff boundaries.
• Built-in codebase indexing recognizes conventional Python manifests, package roots, tests, and scripts while preserving JavaScript and TypeScript defaults.
• Provider transformation receipts now record unavailable evidence explicitly instead of implying evidence was collected when the provider could not expose it.
• Cockpit deployment diagnostics, session replay, Codex dangerous-launch handling, attestation transport conformance, and mutation-test native reloads received additional hardening.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Upgrade the package set together, then regenerate provider context:

npm install --global [email protected]
npm install --global @aiwg/[email protected]
npm install --global @aiwg/[email protected]
aiwg regenerate

Rollback

Roll all three npm packages back together to 2026.8.16, then regenerate provider context. Preserve graph-run checkpoints and release-verification evidence so the rollback does not erase the record of work already executed.

Release date: 2026-08-21 Channel: stable

AIWG 2026.8.16 completes the production path for locally verifiable public setup resources. The release callback now binds the exact setup digest into the site deployment contract, closing the final gap between signed package release, attested resource publication, and aiwg.io inspection.

What changed

• The post-publication callback includes the top-level SHA-256 digest of the release's exact setup.aiwg.yaml bytes required by aiwg.io's deployment verifier.
• The site deployment can verify the signed resource manifest, setup and agentic YAML descriptors, adjacent DSSE/in-toto attestations, publisher, validity window, and monotonic stable-channel freshness before activation.
• Public YAML responses advertise their adjacent attestations through Link: rel="describedby"; HTTP metadata and rendering remain non-authoritative.
• Failed rebuilds cannot overwrite immutable release bytes, and rollback keeps prior signed evidence and freshness state available for audit.
• Project index health now counts WORKSPACE.md, linked context, and .aiwg artifacts over one shared file set, keeping human and JSON coverage accurate and bounded at 100%.

Production verification

• Stable promotion to 2026.8.16 occurs only after the callback binds the release tag, manifest, and exact setup digest into the site deployment gate; the prior 2026.8.15 resources remain immutable and independently verifiable.
• The published setup and agentic YAML bytes match their signed descriptors and adjacent attestation descriptors exactly.
• aiwg.io exposes inline and full-page inspection, copy, and download flows with explicit rendered, unsigned, policy-exempt, and locally verified states.
• Anonymous or invalid paid-resource access remains fail-closed; the scoped production smoke path passes with the required entitlement.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Upgrade all AIWG packages together, then regenerate provider context:

npm install -g [email protected]
aiwg regenerate

Continue to use a local AIWG verifier with an explicit trust root and persisted freshness state before an agent consumes public setup or handoff resources.

Rollback

Roll all three npm packages back together to 2026.8.15, then regenerate provider context. Existing immutable release evidence and trusted freshness state should be retained during rollback.

Release date: 2026-08-21 Channel: stable

AIWG 2026.8.15 adds a reviewed agent handoff for the public setup path and connects signed release evidence to local inspection on aiwg.io. It also lets projects separate customer-facing issue intake from their internal engineering tracker.

What changed

• The repository now owns agentic.yaml, a provider-orchestrated handoff that requires local verification of the exact public setup.aiwg.yaml bytes and adjacent attestation before an agent may inspect or execute the setup plan.
• Release CI binds both YAML files to the verified signed tag and dispatches the private publisher on the stable channel. The publisher emits adjacent DSSE/in-toto provenance and commits digest, byte length, and media type in the signed web release manifest.
• aiwg.io verifies the pinned Ed25519 authority, signed manifest, exact artifact and sidecar bytes, publisher scope, validity window, and monotonic stable sequence before showing verified status. Rendering, copying, downloading, or HTTP cache metadata remains non-authoritative.
• Ordinary site deployments preserve previously published evidence, and a release rollback stops new emission without deleting sidecars, signed manifests, or trusted sequence state.
• Workspace configuration may independently identify customer-facing and internal issue trackers while retaining the configured delivery authority.
• Generated tracker-authority blocks compute their configuration link from the receiving document, keeping root and nested context entry points valid.
• Threat assessment distinguishes benign ML/NLP terminology from actual authentication-material handling while retaining strict exfiltration gates.

Verification

• The canonical handoff passes strict SetupManifest validation and contract coverage for exact-source release dispatch.
• Tracker-link generation and threat-assessment precision have focused regression coverage, including cross-surface false-positive and false-negative measurements.
• The aiwg.io verifier, staging pipeline, viewer, cache policy, and deployment workflow pass repository CI and deployment gates.
• Branch CI is required to pass before the signed release tag is created.
• The stable publication and public-path verification are completed by the signed-tag release workflow.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Upgrade all AIWG packages together, then regenerate provider context:

npm install -g [email protected]
aiwg regenerate

The public YAML viewer is an inspection surface. Use aiwg verify with an explicit trust root and persisted freshness state before agent-guided use.

Rollback

Roll all three npm packages back together to 2026.8.14, then regenerate provider context. Stop new attestation emission if necessary, but retain prior sidecars, signed manifests, and freshness state for audit and downgrade protection.

Release date: 2026-08-20 Channel: stable

AIWG 2026.8.14 gives projects explicit control over how generated material is presented. It adds composable runtime output modes while ensuring that optional provider-native surfaces cannot silently replace canonical AIWG artifacts.

What changed

• Output modes are now runtime-selectable and composable through a provider-neutral registry. The unchanged default is truly byte-preserving, and projects can combine built-in, project, user, and existing voice profiles in deterministic order.
• Two advisory examples are included: an ASD-STE-oriented technical-writing mode and a Wittgenstein-inspired clarity mode. Protected literal content is preserved, and mandatory validators can fail or fall back safely.
• aiwg output-mode supports invocation, session, and project selection, while aiwg run --output-mode passes the resolved stack to script and skill runtimes.
• The new artifact_outputs policy keeps the AIWG artifact store canonical and makes provider-native destinations explicit-only by default.
• Claude Design remains available when explicitly requested, but is treated as a derived presentation. Dual output records provenance back to the canonical artifact, and unknown provider destinations fail safe.

Verification

• TypeScript, CLI build, schema compilation, and project configuration validation passed.
• Focused output-mode and artifact-policy regression suites passed.
• The release candidate passed 9,196 unit/integration tests and 107 UAT tests, plus the 38-query release-discovery and 3,299-item package gates.
• Branch CI is required to pass before the signed release tag is created.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Upgrade all AIWG packages together, then regenerate provider context so the artifact destination policy is compiled into current provider bootstrap files:

npm install -g [email protected]
aiwg regenerate

Existing projects retain the safe compatibility behavior: canonical AIWG artifacts remain canonical and provider-native presentation is explicit-only.

Rollback

Roll all three npm packages back together to 2026.8.13, then regenerate provider context. Project configuration using artifact_outputs should be removed only if an older release rejects unknown configuration fields.

Release date: 2026-08-20 Channel: stable

AIWG 2026.8.13 aligns the Hermes provider with the runtime's active profile, native skill metadata, and first-match context behavior. It also makes the npm publication path less dependent on third-party setup actions and remote install scripts.

What changed

• Hermes deployments honor the process HERMES_HOME value, falling back to the platform-native Hermes home only when it is unset. Framework, kernel, managed-skill, user-scope, provider, and quickref paths now agree on that location.
• Deployed Hermes skills omit AIWG's provider-oriented platforms field, which Hermes otherwise interprets as an operating-system compatibility gate.
• Portable metadata.hermes-tags source values become native metadata.hermes.tags in deployed copies without weakening source-format validation.
• The generated .hermes.md bridge matches Hermes's first-found project context behavior and explicitly routes the agent to the shared AGENTS.md project context.
• Publication installs pinned Cosign and Syft binaries only after checking their repository-tracked SHA-256 digests, reducing exposure to action codeload and remote-installer outages.

Verification

• Hermes-focused unit and integration coverage exercises custom, relative, literal-tilde, and platform-default home resolution; native frontmatter transformation; managed skills; kernel deployment; and quickrefs.
• The complete local suite passed with 615 test files and 9,174 tests; the PR's metadata, documentation, strict skill-lint, Test, and Build workflows passed.
• Release validation checks synchronized package/plugin versions, TypeScript, production builds, generated documentation, metadata, Fortemi discovery parity, and the full CI suite.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Install all AIWG packages at version 2026.8.13. Operators using Hermes should redeploy with the same HERMES_HOME value used by the running Hermes profile:

HERMES_HOME=/path/to/profile aiwg use --provider hermes

Rollback

Roll all three npm packages back together to 2026.8.12, then redeploy the project's provider assets. Hermes profiles with a non-default HERMES_HOME should remain on 2026.8.13 or later to preserve profile-aware deployment.

Release date: 2026-08-17 Channel: stable

AIWG 2026.8.12 extends verification from individual packages to the full path an artifact travels: marketplace exchange, provider transformation, web-backed release delivery, and local consumption. It also ships six reproducible research and red-team addons, strengthens self-hosted Gitea configuration, and makes the Fortemi conformance path more portable across release runners.

What changed

• Artifact verification now has stable outcomes, trust-root and trust-state contracts, attestation emission, a public API, CLI handling, schemas, and adversarial conformance coverage.
• Marketplace v2 bundles can carry portable evidence, provider deployments can authenticate transformation receipts against source inventories, and signed web-release descriptors bridge provenance across release surfaces.
• Five research experiment addons cover century-readiness review, long-context retrieval benchmarking, natural-language evaluation, orchestration topology comparison, and premortem-v2 analysis.
• A synthetic monitorability red-team addon exercises unlabeled and monitor-constrained scenarios with reproducible fixtures and evidence.
• Project setup can designate Gitea explicitly for ambiguous self-hosted remotes, while legacy force-push policy values are normalized during repair.
• Doctor uses Git's effective ignore rules, including negations and local or global excludes, instead of relying only on textual .gitignore inspection.
• Fortemi shard conformance verifies host capabilities, provisions pinned Rust, and fetches receipt references atomically on the selected Gitea runner.

Verification

• Public artifact-trust schemas and every stable verifier outcome are covered by unit, integration, lightweight-CLI, and schema-lint tests.
• Provider transformation receipt tests cover source inventory authentication, expected first-use state, deployment verification, and web-mode packaging.
• Research addon fixtures and recorded evidence are exercised by integration tests, including monitorability threshold transitions.
• Release validation checks synchronized package/plugin versions, TypeScript, production builds, generated documentation, metadata, the full CI suite, and Fortemi discovery parity.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Install all AIWG packages at version 2026.8.12. After upgrading, refresh AIWG for each provider you use so provider outputs can be checked against the new transformation receipt and artifact-trust contracts.

Rollback

Roll all three npm packages back together to 2026.8.11, then redeploy the project's provider assets and regenerate its context files.

Release date: 2026-08-15 Channel: stable

AIWG 2026.8.11 restores two installation invariants: refreshing a project keeps every installed bundle intact, and deploying a framework leaves discovery ready to use. It also completes the Codex context-budget hardening and incorporates a community contribution that repairs Cockpit's nested test dependencies.

What changed

• aiwg refresh --all redeploys every selected installed bundle through the active package's verified deployment pipeline. It preserves desired provider artifacts and will not run cleanup after a deployment failure.
• Fresh and repeated aiwg use operations rebuild and synchronize the Fortemi Core framework cache. Default discover/show works immediately without a manual aiwg index sync repair.
• The packaged prebuilt index is validated at its real installed location, including manifest, schema, graph, backend, checksum, and item-count checks.
• Codex provider deployment retains bounded dispatch metadata that keeps the intended 25-skill kernel and quick-reference surface within provider context budgets.
• Cockpit's web package and both lockfiles now align with the repository's Vitest 4 dependency line, contributed through GitHub PR #140.
• Doctor and deployment integrations retain finite but load-aware timeout budgets, eliminating false release failures while preserving fail-closed discovery validation.
• Release-preview tests use isolated temporary provider state for deterministic local and hosted validation.

Verification

• A real four-bundle refresh retained sdlc, aiwg-utils, agent-loop, and rlm, along with all 124 deployed Claude agents.
• Fresh and repeated deployment discovery returned live results; the final release package contains a validated 3,257-item framework index.
• Packed-install policy, release discovery parity, package budgets, generated artifact lint, type checking, and canonical repository CI passed.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Install all AIWG packages at version 2026.8.11. After upgrading, ask your coding agent to refresh AIWG for the provider you use, then verify the provider reports the intended kernel and quick-reference skills.

Rollback

Roll all three npm packages back together to 2026.8.10, then redeploy the project's provider assets and regenerate its context files.

Release date: 2026-08-15 Channel: stable

AIWG 2026.8.10 is the immutable-tag recovery release for 2026.8.9. It contains the same provider deployment, split-root workflow, documentation, and setup improvements, plus a correction for clean-checkout npm publication tests.

What changed

• Clean release checkouts now generate the ignored Fortemi Core package index before building the lifecycle-script-free global-install test tarball.
• Packaging holds the shared prebuilt-directory lock while reading the generated index, preserving deterministic discovery and doctor checks when package tests run concurrently.
• Self-verifying provider deployment tests allow a bounded three-minute subprocess budget, avoiding false failures on loaded hosted runners.
• OpenClaw's cross-agent compatibility mirror honors the requested project target, so isolated deployments cannot mutate the AIWG source checkout.
• The intended default provider copy profile remains the 25 kernel and quick-reference skills. Full standards deployment remains explicit.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Install all AIWG packages at version 2026.8.10. After upgrading, ask your coding agent to deploy AIWG for the provider you use and verify that the project is engaged.

Rollback

Roll all three npm packages back together to 2026.8.8, then redeploy the project's provider assets and regenerate its context files. Version 2026.8.9 was tagged but its npm publication did not complete.

Release date: 2026-08-12 Channel: stable

AIWG 2026.8.8 gives projects a compact, automatically maintained way to expose their own extensions and addons to agents. It also makes context regeneration choose and explain the appropriate workflow from repository state, strengthens the CLI performance gate, and improves artifact-root and documentation-release reliability.

What changed

• Project-local extensions, addons, frameworks, plugins, and providers can now synthesize a project-only kernel quickref from discovered bundle manifests. This keeps custom capabilities visible without adding them to AIWG's base quickrefs or loading every project artifact into context.
• Operators can curate managed quickrefs with .aiwg/quickref.config.json, including exclusions and overrides. Existing .aiwg/quickref.json definitions continue to work as the legacy compatibility format.
• aiwg regenerate now selects workspace refresh or transactional project adoption when no branch flag is supplied. It reports whether the choice was explicit or inferred and lists the evidence used to make it.
• Artifact relocation preserves the repository-local control plane while discovery and synchronization follow the attached corpus.
• CI now enforces a reproducible CLI cold-start performance gate with documented local diagnostics.
• Scheduled documentation publication checks for releasable changes every six hours.

Verification

The release candidate must pass version and marketplace lockstep validation, plugin metadata and layout checks, TypeScript, the production CLI build, the full automated test suite, metadata and Fortemi-index validation, stable UAT, hosted CI, signed-tag verification, and post-publication checks for npm packages, installer checksums, release assets, SBOMs, and provenance.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

npm install --global [email protected]

For the lightweight signed-web distribution:

npm install --global @aiwg/[email protected]

After upgrading, run aiwg use all --provider <provider> and aiwg regenerate --provider <provider> in each project that should receive the updated kernel and context routing.

Rollback

Roll all three npm packages back together to 2026.8.7, then redeploy the project's provider assets and regenerate its context files.

Release date: 2026-08-05 Channel: stable

AIWG 2026.8.7 repairs the npm publication boundary for the Activity v1 conformance fixtures introduced in 2026.8.6. The fixtures were intentionally included in the package, but their new top-level test/ directory was omitted from the supply-chain allowlist. Both npm publication workflows correctly failed closed before publishing 2026.8.6.

What changed

• The audited tarball allowlist now records the intentional test/ package root used by the Activity v1 conformance fixtures.
• A regression test derives positive package roots from package.json#files and requires each one to be represented in the allowlist.
• All 39 repository-hosted Claude plugins and the marketplace catalog advance to 2026.8.7. The external training plugin remains independently versioned at 1.0.0.

The release does not weaken the publish gate. The real npm pack output must still match the reviewed top-level allowlist exactly, and unexpected roots continue to stop publication as a supply-chain incident signal.

Verification

The release candidate must pass version and marketplace lockstep validation, Claude plugin metadata/layout checks, TypeScript, the production build, the full automated test suite, the package-root regression test, the real tarball audit, release metadata validation, and hosted pull-request CI. Publication then requires the repository's signed tag gate and post-publication package, installer, checksum, and release-asset verification.

Package matrix

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

npm install --global [email protected]

For the lightweight signed-web distribution:

npm install --global @aiwg/[email protected]

Refresh Cockpit and Claude Code marketplace plugins after upgrading so cached plugin payloads and Cockpit contracts match this release.

Rollback

Roll all three npm packages back together to 2026.8.5. Version 2026.8.6 has signed source releases but was not published to npm because its tarball policy metadata was incomplete.

Release date: 2026-08-04 Channel: stable

AIWG 2026.8.5 makes sandbox activity and managed-Docker posture visible in Cockpit, adds verifiable web-resource revalidation, and repairs the versioning and self-containment contracts used by the complete Claude Code plugin catalog.

What changed

• Cockpit presents coverage before activity timelines, preserves explicit scope and completeness evidence, and exports signed activity manifests without exposing restricted event content.
• Managed-Docker instances expose a governed security posture and clear recreation guidance when legacy identity boundaries do not meet the secure default.
• Signed web-resource metadata uses payload-bound ETag or Last-Modified validators. A 304 response can reuse only previously verified bytes, while inconsistent cache evidence triggers an unconditional verified recovery.
• Session analytics and forensic views retain content-free operational facts, stable citations, and explicit authorization boundaries.
• Reviewed line-memory promotion and marketing theme-management workflows add durable memory and repeatable design operations.
• Every repository-hosted Claude plugin advances to 2026.8.5, uses a discoverable skill layout, and keeps its own runtime paths inside the cached plugin payload. The external training plugin retains its independent version.
• Cockpit preserves sandbox authentication and authorization failures across coverage, timeline, and export routes, and rejects incomplete activity summaries before browser rendering.
• Context-pack batch touches are serialized with other line-memory mutations.
• The credential-free live qualification gate pins Agentic Sandbox v2026.8.3 to commit 201221e5a26f7f0cc719ab584520ce3164065825, proves fleet restart re-adoption and governed activity behavior, and records unavailable runtime tiers without converting insufficient evidence into a pass.

Verification

The release candidate is required to pass marketplace/version lockstep, Claude-compatible plugin layout and isolated-path regression tests, Cockpit activity authorization and envelope tests, line-memory process-concurrency tests, TypeScript, the production build, the full test suite, release metadata validation, and Fortemi index validation. The signed release tag then gates forge releases, checksums, SBOM/provenance assets, npm publication, and installer verification.

The latest Sandbox compatibility evidence is the v2026.8.3 qualification. Earlier v2026.7.x Cockpit observations remain minimum-feature evidence.

Package matrix

All three npm packages publish in CalVer lockstep:

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Full local-corpus distribution:

npm install --global [email protected]

Lightweight signed-web distribution:

npm install --global @aiwg/[email protected]

Refresh Cockpit through the base CLI to keep it in lockstep:

aiwg use cockpit
aiwg cockpit

Claude Code users should update the AIWG marketplace and installed plugins so the new 2026.8.5 payloads replace older cached versions.

Rollback

Roll back all three npm packages together to 2026.8.4. That version does not contain the Cockpit activity/posture additions, web metadata revalidation, plugin cache-version repair, or the regression fixes described above.

Release date: 2026-08-03 Channel: stable

AIWG 2026.8.4 makes the complete Claude Code plugin catalog independently installable and strengthens the governance, recovery, and audit contracts used by durable multi-agent missions.

What changed

• The Claude Code marketplace now publishes all 40 packaged frameworks and addons. Cached plugins retain their complete runtime-relative dependency trees, so independently installed bundles remain self-contained.
• aiwg storage import-corpus now previews and ingests local research text through provider-neutral storage, while authenticated Fortemi HTTP/SSE connections resolve credentials from environment references without storing their values.
• Shared-host mission dispatch uses an explicit admission contract for resource, isolation, and policy requirements, with stable evidence for both admitted and denied workloads.
• Operator approvals, denials, overrides, and expirations share a canonical audit representation across HITL drivers and downstream consumers.
• Mission operators can pause, resume, cancel, retry, and recover durable work after conductor restarts. Cockpit projects those controls together with live mission, approval, capability, and audit views.
• Research corpus snapshots and queries preserve curated Fortemi retrieval evidence across package boundaries.
• Claude Code trace hooks now receive the required start and stop subcommands, and refresh repairs previously generated no-argument entries.
• Release mirroring verifies the commit behind signed annotated tags instead of comparing tag object IDs directly.

Verification

The release candidate is required to pass version lockstep, TypeScript, unit/integration tests, the production build, stable-channel UAT, and the configured Gitea CI workflows. Post-tag verification checks both forge release surfaces, checksums, package publication, and the installer fetched from the published GitHub release.

Package matrix

All three packages publish in CalVer lockstep:

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Full local-corpus distribution:

npm install --global [email protected]

Lightweight signed-web distribution:

npm install --global @aiwg/[email protected]

Install or refresh Cockpit through the base CLI to keep its version in lockstep:

aiwg use cockpit
aiwg cockpit

Rollback

Roll back all three packages together to 2026.8.3. That version does not contain the complete plugin marketplace, durable mission governance additions, Fortemi retrieval preservation, or trace-hook registration fix described above.

Release date: 2026-08-03 Channel: stable

AIWG 2026.8.3 fixes three lifecycle and publication regressions and moves the MCP server dependency graph onto the advisory-free Hono v2 line.

What changed

• Project-local removal records the provider-transformed bytes that were actually deployed. Freshly deployed skills are therefore removable as pristine, while later user edits remain protected.
• aiwg install-plugin --source handles local legacy manifests through the correct framework root and gives project-local wrappers actionable guidance to use .aiwg/plugins/ plus aiwg use.
• GitHub release creation waits for the operator-pushed signed annotated tag and verifies its expected commit before publishing a stable release.
• @modelcontextprotocol/sdk 1.30.0 allows the package graph to use @hono/node-server 2.0.11, removing the affected Windows static-serving dependency route.

Verification

The release candidate passed the main test/build workflow, documentation build and deployment workflows, and Fortemi shard conformance on the delivered dependency commit. The production dependency audit reports no MCP SDK or Hono finding and no moderate-severity findings.

Package matrix

All three packages publish in CalVer lockstep:

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Full local-corpus distribution:

npm install --global [email protected]

Lightweight signed-web distribution:

npm install --global @aiwg/[email protected]

Install or refresh Cockpit through the base CLI to keep its version in lockstep:

aiwg use cockpit
aiwg cockpit

Rollback

Roll back all three packages together to 2026.8.2. That version does not contain the plugin lifecycle fixes or the MCP SDK dependency update described above.

Released: 2026-08-03 Channel: stable

AIWG 2026.8.2 adds a decentralized package exchange and verification layer around ordinary Git repositories. Packages remain independently hosted while their source identity, publisher claims, transformations, validation evidence, and installation results become reproducible and locally auditable.

Immutable package identity

Every marketplace envelope binds the package name and version to a canonical Git remote, immutable commit, source-tree and artifact digests, file inventory, wrapper and profile versions, provider support, dependencies, license, and an optional SBOM.

Movable tags and branches may be used for discovery, but AIWG resolves them to an immutable commit before deployment. Commit-keyed caches and lockfiles detect tag movement, altered source, archive divergence, rollback attempts, and dependency substitution.

Signed provenance and Fortemi receipts

The versioned envelope maps package entities, activities, and agents to W3C PROV and round-trips through Fortemi Knowledge Shard 2.0 full-v1 without semantic loss. Publication, verification, installation, export, and import produce operation and conformance receipts.

Publisher trust uses Ed25519 roots with delegation, rotation, and revocation. Verification fails closed for unknown required fields, invalid signatures, digest mismatches, lossy conversion, or incomplete portable bundles.

Federated catalogs and direct Git parity

Multiple independently hosted signed catalogs can index the same package. Catalog inclusion is presented as an observation, not a safety endorsement, and removing a catalog does not invalidate an existing immutable lock.

Direct Git and catalog-mediated installation resolve to the same content and lock identity:

aiwg install https://host/owner/plugin.git --ref v1.0.0
aiwg marketplace install namespace/plugin --ref v1.0.0 --verify

Both project-local and global installation scopes maintain their corresponding package and Fortemi indices. Standalone .aiwg/plugins/* repositories deploy their complete agents, skills, and rules to the selected provider.

Offline verification and portable recovery

Once the source objects, package content, trust roots, and receipts are cached, verification works without network access. Portable export preserves normalized content, immutable coordinates, signatures, provenance, and prior receipts; import into a clean project reproduces the same lock identity before deployment.

The release gate exercised this flow against the BT6 plugin fixture, including Claude and Codex deployment, offline verification, export, clean-project import, and post-import verification.

Package matrix

All three packages publish in CalVer lockstep:

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Follow the installation guide and select 2026.8.2 for the full local-corpus package or lightweight signed-web CLI. Existing project and global package indices remain compatible.

Rollback

Roll back all three packages together to 2026.8.1. Existing immutable package caches, locks, trust roots, and receipts remain on disk and can still be verified by the version that created them.

Released: 2026-08-02 Channel: stable

AIWG 2026.8.1 introduces a complete persistent-memory cycle, expands governed sandbox work from one target to durable fleets, and adds authenticated access to paid resource channels. It also makes Codex deployment safer and more predictable across project workspaces.

Compound memory

The new compound-memory addon combines line-memory and llm-wiki without forking either storage model:

aiwg use compound-memory --provider codex
aiwg compound-memory ingest notes.md
aiwg compound-memory context "current project decisions"
aiwg compound-memory review

Raw inputs remain immutable. Knowledge and short facts require reviewed promotion, context packs enforce hard budgets and carry source citations, and generated outputs remain derived evidence until accepted. Canonical project context uses exact-preview confirmation, idempotent receipts, lifecycle metadata, conflict visibility, and provider-neutral storage.

Review and maintenance expose stale facts, contradictions, orphaned wiki pages, unlinked outputs, and due canonical context before mutation. A deterministic three-session fixture verifies continuity, retrieval quality, latency, provenance, restart safety, and portable activation without rewriting existing line-memory or wiki data.

Governed sandbox fleets

The fleet workload contract and mission conductor extend Cockpit's sandbox controls to multiple targets. Stable parent and child identities, admission checks, retries, restart reconciliation, and durable cross-product evidence make fleet progress observable without hiding partial failures.

The conformance suite exercises a three-target recovery path and fails closed on malformed or unavailable inventory. Cockpit now projects parent/child mission state while preserving the daemon health contract.

Paid resource access

aiwg auth login, status, and logout manage paid-resource account access using protected platform storage with a permission-restricted file fallback. Authorization is scoped to the configured HTTPS API origin and access material never participates in URLs, cache keys, lockfiles, or routine diagnostics.

Signed manifests, digest checks, bounded downloads, and offline cache behavior remain unchanged for authenticated channels.

Codex and reliability improvements

• aiwg use ... --provider codex preserves native kernel skills across addon sweeps and writes Codex UI metadata under agents/openai.yaml.
• Setup guidance uses $aiwg-regenerate and tells operators to reopen Codex at the target project root.
• Generated .codex/ and .agents/ trees are added to .gitignore; existing tracked files stay tracked and dry-run remains non-mutating.
• Development launchers load notifier and logging modules from the active checkout, and stale cache entries from another installed version are ignored.
• The lightweight CLI can package external standalone plugins and install valid wrappers either into the current project or globally for the user. Each mode refreshes its matching artifact and Fortemi indices.

Package matrix

All three packages publish in CalVer lockstep:

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Follow the installation guide and select 2026.8.1 for the full local-corpus package or lightweight signed-web CLI. Cockpit remains installable and refreshable through the base CLI.

Rollback

Roll back all three packages together to 2026.8.0. Existing memory stores and fleet evidence remain on disk; disabling the new addon or conductor does not delete retained data.

Released: 2026-08-01 Channel: stable

AIWG 2026.8.0 opens the August release line with a durable, auditable way to run bounded provider jobs from external schedulers. It also expands session intelligence, promotes Fortemi full-v1 interoperability, adds reusable design theme operations, and hardens Cockpit and dependency boundaries.

External-trigger single-shot jobs

The new aiwg job surface lets cron, systemd timers, or Gitea Actions own time while AIWG owns the reviewed execution contract:

aiwg job validate path/to/job.yaml
aiwg job render-cron path/to/job.yaml --format systemd
aiwg job run path/to/job.yaml --once

The jobs.aiwg.io/v1 contract describes the provider executor, Gitea work source, approval policy, and required completion evidence. Codex execution receives its prompt on stdin and writes a structured result. Stable idempotency keys, host locks, cross-host claim election, approval rechecks, and completion markers prevent duplicate external actions.

Runtime records are private, bounded, and redacted. External targets require exact allowed origins and accounts, and attachment paths must resolve beneath approved canonical roots. Publication remains approval-gated by default.

Session and artifact intelligence

• Session import and reindex maintain one versioned, content-free analytics index with stable citations for authorized forensic views.
• sessions analytics provides filtered operational facts, while explicitly authorized sessions forensics emits sanitized timelines without executing or exporting historical provider payloads.
• Fortemi shard export now defaults to the full-v1 receipt contract and binds producer, converter, and consumer evidence. Legacy core-only output remains available through an explicit compatibility mode.

Design and automation clarity

• The media-marketing framework adds a theme manager, schemas, candidate and comparison templates, cross-channel adaptation guidance, and design QA workflows.
• Provider capability reporting and automation documentation now distinguish external scheduling from AIWG orchestration. AIWG generates or validates the bounded job; the external scheduler owns the clock.

Security and reliability

• Cockpit no longer places reusable launch material in URLs and keeps scoped handoff state out of history, referrer, UI, and routine logging surfaces.
• Cockpit live acceptance waits for runtime re-adoption, observes the expected transient disconnect, and records the executor-reported version.
• The static server uses the fixed Hono node-server v2 line and rejects encoded Windows backslashes before filesystem resolution.
• Production dependency floors advance across Hono, MCP SDK, js-yaml, ws, yaml, glob/minimatch, and routed validator dependencies while retaining the minimum-release-age supply-chain policy.

Package matrix

All three packages publish in CalVer lockstep:

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Full local-corpus distribution:

npm install --global [email protected]

Lightweight signed-web distribution:

npm install --global @aiwg/[email protected]

Install or refresh Cockpit through the base CLI:

aiwg use cockpit
aiwg cockpit

Rollback

Roll back all three packages together to 2026.7.25. Existing external-job flow files are inert unless an external scheduler invokes them, so disable the corresponding cron, timer, or workflow before rolling back a deployed job.

Released: 2026-07-31 Channel: stable

AIWG 2026.7.25 makes Cockpit-launched provider sessions start in the working directory selected by the managed target. Host sessions use the host runtime's resolved workspace, while container and VM sessions use the executor-reported directory with /home/agent as the compatibility fallback.

What changed

• Cockpit Bridge now forwards normalized launch_context.cwd to provider processes for host, container, Docker, and VM targets.
• Older container and VM inventory without cwd metadata falls back to /home/agent instead of a root-owned directory.
• The protected daily gate asserts the cwd invariant on the candidate phase while retaining immutable previous-stable and rollback validation.
• The bounded Codex live probe supports gate-owned workspaces that are not Git checkouts without relaxing its read-only sandbox.

Cockpit and sandbox compatibility

Agentic Sandbox v2026.7.18 supplies the target-native cwd field and gives its non-root container image a matching HOME and WORKDIR. Older sandbox versions remain usable through Cockpit's compatibility fallback, but do not provide the same executor-bound cwd evidence.

Package matrix

All three packages publish in CalVer lockstep:

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Full local-corpus distribution:

npm install --global [email protected]

Lightweight signed-web distribution:

npm install --global @aiwg/[email protected]

Install or refresh Cockpit through the base CLI so it remains version-locked to the installed AIWG release:

aiwg use cockpit
aiwg cockpit

Upgrade Agentic Sandbox to v2026.7.18 to receive executor-bound cwd metadata and the corrected non-root container home.

Rollback

Roll back all three packages together to 2026.7.24. Cockpit will again use its older local cwd selection, so verify host and container startup directories after rollback.

Released: 2026-07-29 Channel: stable

AIWG 2026.7.24 aligns Cockpit with the current agentic-sandbox runtime contract and exposes the setup manifest workflow as first-class CLI commands. The release keeps Cockpit opt-in and version-locked while broadening the runtime signals it can safely render for host, container, Docker, and VM targets.

What changed

• Cockpit Inventory now gates VM fast-start controls by advertised provider capability. Cloud Hypervisor rows can expose snapshot, restore, fork, and warm-pool actions; libvirt rows can expose checkpoint, restore, and warm-pool actions when the executor advertises them.
• Restore, fork, and warm-pool requests now use the sandbox runtime_options launch intent and poll the async operation resource through terminal state.
• Cockpit surfaces sandbox MCP discovery, GPU/VFIO posture, Apple Silicon runtime posture, local container fallback availability, and mTLS readiness as capability-driven status rather than fixed assumptions.
• MCP proxy calls through Cockpit now require a separately scoped MCP bearer file, while discovery remains display-safe metadata.
• Local Docker lifecycle fallback is now explicit opt-in for development, and non-Linux libvirt reconnect fallback requires explicit operator opt-in.
• Codex project-local addon skills now deploy to .agents/skills/, matching the native Codex project skill loader while keeping indexed generated artifacts separate.
• aiwg setup-generate, aiwg setup-validate, and aiwg setup-run provide the CLI entry points for authoring, validating, and dry-running setup.aiwg.io/v1 manifests.

Cockpit and sandbox compatibility

The new Cockpit runtime controls are intentionally capability-gated. Older agentic-sandbox builds still render inventory and sessions, but unavailable provider actions stay disabled with the executor-provided reason. This keeps the UI usable during mixed-version upgrades while making the newer fast-start VM and transport readiness paths visible when the sandbox supports them.

The Apple Silicon validation baseline is the unsigned, unnotarized agentic-sandbox v2026.7.14 developer package. Runtime-option delegation, MCP discovery, bootstrap readiness, and degraded-libvirt gating require a sandbox build from main after v2026.7.14 until those commits are covered by a newer sandbox tag.

Package matrix

All three packages publish in CalVer lockstep:

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Full local-corpus distribution:

npm install --global [email protected]

Lightweight signed-web distribution:

npm install --global @aiwg/[email protected]

Install or refresh Cockpit through the base CLI so it remains version-locked to the installed AIWG release:

aiwg use cockpit
aiwg cockpit

Released: 2026-07-28 Channel: stable

AIWG 2026.7.23 publishes the feature set prepared in 2026.7.22 after the tarball supply-chain gate stopped both registry workflows before publication. The gate found three new package-root entries and required an explicit review before they could ship.

What changed

The reviewed roots are intentional parts of the public package contract:

• schemas/ supplies the security configuration schemas introduced with the configurable threat-assessment policy.
• setup.aiwg.yaml supplies the versioned setup.aiwg.io/v1 agentic install, repair, and upgrade contract.
• vscode-extension/ supplies the editor-facing AIWG configuration schema.

The package allowlist now names those roots explicitly. The check remains fail-closed for any other unexpected top-level entry.

Included release

This patch carries the complete 2026.7.22 feature set:

• project-owned threat-assessment modes, profiles, and surface overrides;
• deterministic forge-content assessment with attributable evidence;
• complete shipped-component discovery coverage and an LLM Wiki driver;
• the agentic setup flow for installation, repair, upgrade, and verification;
• normalized session lifecycle and relocation evidence;
• stronger signed-release manifest binding and publish-test dependencies.

Package matrix

All three packages publish in CalVer lockstep:

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Upgrade

Full local-corpus distribution:

npm install --global [email protected]

Lightweight signed-web distribution:

npm install --global @aiwg/[email protected]

The signed release tag drives both registry publishers, provenance generation, release assets, checksums, and the stable GitHub mirror release.

Released: 2026-07-27
Channel: stable

AIWG 2026.7.21 adds secure portable Agent Skills and an evidence-preserving session catalog across supported providers, while making the first-run experience substantially clearer for people who should not need to operate the framework from a command reference.

Highlights

• Portable Agent Skills - validate and safely import a local directory or a pinned Git source, bind activation to reviewed content, deploy compatible projections across providers, inspect drift, and export strict portable bundles without executing imported scripts.
• Cross-provider session catalog - import normalized, redacted evidence from Claude Code, Codex, Copilot, Cursor, Factory, Hermes, OpenCode, OpenClaw, OpenHuman, Warp, Devin Desktop/Windsurf, or the declared generic interchange. Search is authorized by workspace and provider before matching or snippet generation.
• Review before memory - extraction produces cited candidates. Nothing becomes durable project memory until a reviewer accepts the exact candidate, acknowledges any security warning, previews the destination, and confirms promotion.
• Bounded Line Memory - the new addon offers a small, inspectable, recency-retained facts file for projects that do not need a wiki, graph, or semantic store.
• Clearer first-run guidance - public documentation now leads with installation, aiwg use all --provider <provider>, reopening the provider, invoking aiwg-regenerate, and verifying the project connection. Detailed flags, automation, JSON contracts, and recovery procedures live in a stable agent/operator corpus.
• Stronger release evidence - SQLite session suites, provider conformance, and production-path performance checks are blocking CI gates with preserved machine-readable results.

Agent Skills

The managed lifecycle includes validation, dry-run import, digest-bound trust, activation, provider deployment, update, uninstall, doctor diagnostics, and strict export. AIWG preserves scripts, references, assets, licenses, and other accepted files as data; validation and deployment do not execute them.

Unpinned Git revisions, credential-bearing URLs, traversal, symlinks, special files, unsafe collisions, and unreviewed content changes fail closed. Provider projections report loss or unsupported behavior instead of silently discarding source meaning.

Session intelligence

The new aiwg sessions namespace manages a project-local catalog. SQLite/FTS5 is the reference local backend and requires the optional better-sqlite3@^12.8.0 peer dependency. Without it, the rest of AIWG remains available and aiwg sessions doctor --json reports that the catalog backend is unavailable.

Imports never modify provider-owned logs. Search requires an explicit workspace, applies authorization before matching, and returns stable evidence citations. Deletion previews by default: tombstone is reversible, while purge requires confirmation, actor/reason classifications, and an explicit disposition for promoted dependents.

Candidate extraction treats transcript text as inert input. Review and promotion are separate operations, and promotion writes only through a confirmation-bound gateway with lineage receipts. Semantic retrieval remains optional and preview-gated; local lexical retrieval is the standalone default.

Documentation and onboarding

People beginning with AIWG now get a single respectful journey that defines the terminal, project root, and provider; explains where each action happens; and states what changes, when approval is required, what success looks like, and how to recover.

The complete CLI and provider references were not deleted. They moved to docs/agents/, where agents and advanced operators receive exact commands, preconditions, structured output, diagnostics, and failure handling. The corpus ships inside the npm package and the signed release reference.tar.zst bundle, but is excluded from docs.aiwg.io navigation, search, sitemap, and rendered pages.

Reliability and fixes

• Citation sidecar tables with recognized shifted or variant columns now normalize correctly, and graph statistics distinguish declarations from canonical edges.
• The nlp-prod addon again includes its declared executable command modules and doctor coverage.
• Codex uses the shared .agents/skills/ projection, preventing duplicate skill installations from consuming its context budget.
• AIWG now pins @fortemi/[email protected] and carries shard lifecycle and state transfer semantics through current producer/consumer receipts.

Package matrix

All three packages are prepared to publish in CalVer lockstep:

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

The signed release tag will publish the npm packages with provenance, create Gitea release assets and checksums, package the agent reference corpus, and mirror the stable release to GitHub. This document prepares that release; it does not itself publish or promote any package or channel.

Upgrade

Full local-corpus distribution:

npm install --global [email protected]

Lightweight signed-web distribution:

npm install --global @aiwg/[email protected]

Existing local-corpus workflows remain compatible. The session catalog is opt-in and requires the optional SQLite peer described above.

Released: 2026-07-26
Channel: stable

AIWG 2026.7.20 makes project-local operation more portable and makes discovery quality measurable. Artifact-root handling now reaches the remaining context, storage, configuration, Smith, update, and extension lifecycle paths, while a checked-in relevance benchmark records why lexical discovery remains the production default.

Highlights

• Portable artifact roots - context generation, storage, configuration, MCPsmith, Toolsmith, update services, and project-local bundles consistently honor the shared project artifact resolver and AIWG_ARTIFACTS_PATH.
• Discovery evaluation - aiwg index eval-discovery runs an 80-query, eight-capability benchmark and reports ranking, hard-negative, latency, index-size, and memory evidence for the production paths and experimental candidates.
• Provider-aware orchestration guidance - generated bootstrap context chooses bounded worker roles and explains each provider's actual execution model without transferring integration responsibility away from the primary agent.
• Kernel surface conformance - provider deployment now has integration coverage that proves each supported platform receives the same 24-skill kernel inventory and no standard skills, with unit coverage for project quickref destinations.
• Project-local lifecycle hardening - packaging, promotion, removal, discovery, and updates now agree on validated standalone plugin contracts and artifact locations.
• Local media adapters - media-curator transcription and diarization skills include local adapter scripts and synchronized framework/plugin guidance.
• Code-to-docs reconciliation - managed addon and framework documentation was regenerated from authoritative component sources before release.

Package matrix

All three packages publish in CalVer lockstep:

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

The signed release tag publishes the npm packages with provenance, creates the Gitea release assets and checksums, and mirrors the stable release to GitHub.

Upgrade

Full local-corpus distribution:

npm install --global aiwg@latest
aiwg discover "project-local plugin lifecycle"

Lightweight signed-web distribution:

npm install --global @aiwg/cli@latest
aiwg discover "project-local plugin lifecycle"

Existing installations and explicit resource-source selections remain compatible.

Released: 2026-07-23 Channel: stable

AIWG 2026.7.19 completes the npm presentation and verification work for the web-backed CLI distribution. The lightweight package now presents a full, package-specific guide on npm, and release regressions prevent any AIWG package from falling back to stub-level documentation.

Highlights

• Full @aiwg/cli guide — the package README covers distribution choice, zero-configuration signed web resources, discovery and lookup, per-call version selection, caching, offline operation, the JavaScript API, security, migration, troubleshooting, and package scope.
• README quality contract — all three published package sources must remain substantial, self-contained, package-specific documents. The packed CLI integration test also verifies that npm receives the exact dedicated README.
• Safer mirror verification — Gitea package checks install AIWG tarballs by direct URL while resolving third-party dependencies from npmjs.org, matching the supported operator workflow.
• Bootstrap tag retirement — the one-time package reservation remains in npm history, while the deprecated bootstrap dist-tag is removed through a narrowly scoped authenticated maintenance workflow.

Package matrix

All three packages publish in CalVer lockstep:

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

The signed release tag publishes all three packages to npmjs.org through GitHub OIDC trusted publishing with provenance and mirrors them to Gitea.

Use the full local-corpus distribution:

npm install --global aiwg@latest
aiwg discover "architecture evolution"

Use the lightweight signed-web distribution:

npm install --global @aiwg/cli@latest
aiwg discover "architecture evolution"
aiwg show skill architecture-evolution

No project configuration is required for @aiwg/cli web discovery. Operators can pin resources for one call with --aiwg-version <version> or choose a source explicitly with --resource-source local|web|auto.

Upgrade

npm install --global aiwg@latest
# or
npm install --global @aiwg/cli@latest

Existing local installations, project deployments, and explicit web-mode invocations continue to work without migration.

Released: 2026-07-23 Channel: stable

AIWG 2026.7.18 is a corrective package release for the lightweight web-backed CLI and Cockpit distributions introduced in 2026.7.17. It makes the documented no-configuration install path match the behavior of the packages users receive from npm.

Highlights

• Web resources by default in @aiwg/cli — install the lightweight package and run aiwg discover or aiwg show without project configuration or resource flags. Both the binary and exported CLI API select the signed stable channel.
• Legacy local behavior preserved — the full aiwg package still defaults to its bundled local corpus, so existing installations can opt into web mode per call without changing project deployments.
• Deployable Cockpit tarball — @aiwg/cockpit now includes its compiled production web UI and license, launches through npm's global binary symlink, and remains available when the optional executor is not installed.
• Package-level regression coverage — clean-install tests verify the real package entry points, default configuration, resource resolution, served Cockpit UI, licenses, and allowlists.

Package matrix

All three packages publish in CalVer lockstep:

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

The signed tag published all three packages to npmjs.org through GitHub OIDC trusted publishing with SLSA provenance. The same versions are mirrored in Gitea. Because Gitea's bundled npm registry is not an npmjs proxy, install a Gitea mirror tarball by URL rather than using a process-wide Gitea --registry override:

npm install --global \
  https://git.integrolabs.net/api/packages/roctinam/npm/aiwg/-/2026.7.18/aiwg-2026.7.18.tgz

Release validation clean-installed every package from npmjs.org and from its Gitea tarball, exercised both aiwg binaries without configuration, and confirmed the installed Cockpit binary serves its health endpoint and compiled UI.

Use the full local-corpus distribution:

npm install --global aiwg@latest
aiwg discover "architecture evolution"

Use the lightweight signed-web distribution:

npm install --global @aiwg/cli@latest
aiwg discover "architecture evolution"
aiwg show skill architecture-evolution

Operators can pin resources for one call with --aiwg-version <version> or override source selection with --resource-source local|web|auto.

Upgrade

npm install --global aiwg@latest
# or
npm install --global @aiwg/cli@latest

No project migration is required. Existing local configurations and explicit web-mode invocations continue to work.

Released: 2026-07-22 Channel: stable (npm install -g aiwg)

AIWG 2026.7.17 introduces signed web-backed resource discovery, a lightweight CLI distribution, relocatable project artifacts, and user-global framework bootstrap. Operators can now choose local or versioned web resources per call without changing the agent-facing discover and show workflow.

Highlights

• Signed web-backed resources — aiwg discover and aiwg show accept --resource-source, --aiwg-version, and --offline, verify signed release manifests and raw resources, and query the downloaded precomputed framework index through Fortemi Core.
• Lightweight @aiwg/cli distribution — the new package contains the CLI and supported API runtime without bundling the framework corpus. It publishes at the same CalVer as aiwg and @aiwg/cockpit.
• Relocatable .aiwg artifacts — .aiwg-location, AIWG_ARTIFACTS_PATH, and aiwg artifacts move --to <path> let projects move or rename their artifact root while preserving bindings and rebuilding indexes.
• Custom project-local search paths — configuration and environment overrides can add external addon, extension, framework, plugin, and provider roots without moving the main project corpus.
• User-global bootstrap — aiwg use <framework> --provider <name> --global installs framework and kernel assets into supported provider user paths and leaves only lightweight project bootstrap files.
• Installed-package API — package consumers can invoke the CLI router and signed resource helpers through supported aiwg exports, with packed-install conformance coverage for legacy local and web-backed modes.

Package matrix

All three packages publish in CalVer lockstep:

[email protected]
@aiwg/[email protected]
@aiwg/[email protected]

Use the full distribution when you want the bundled corpus:

npm install --global aiwg@latest

Use the lightweight CLI when resources should resolve from the signed release host:

npm install --global @aiwg/cli@latest
aiwg discover "architecture evolution" \
  --resource-source web \
  --aiwg-version stable

The initial web slice supports the framework graph through the Fortemi Core backend. Project and codebase graphs remain local because they describe the operator's workspace.

Upgrade

npm install --global aiwg@latest
aiwg doctor

Existing project-local installations and legacy local resource configuration remain supported. Web source selection is per call and does not require moving or redeploying an existing project corpus.

Released: 2026-07-21 Channel: stable (npm install -g aiwg)

AIWG 2026.7.16 makes project context portable across providers, tightens model-aware orchestration, and expands discovery for operational workflows. It also separates durable testing guidance from generated execution evidence.

Highlights

• Canonical workspace context — new and existing projects can maintain a protected WORKSPACE.md context graph with provider-specific adapters, conflict-aware migration, credential checks, rollback, and doctor support.
• Explicit regeneration modes — aiwg regenerate --workspace maintains the canonical graph, --existing-project extracts bounded project context, and --full-inject retains the legacy compatibility path.
• Provider-aware orchestration — Steward now emits capability-bound launch envelopes, validates model-wrapper capabilities, and applies dynamic provider catalogs and cheap-first role/tier policy consistently.
• Operational discovery — procedural Markdown and declarative runbooks are indexed as first-class assets with structured actions, verification, rollback, inventory, targets, and step metadata.
• Testing evidence hygiene — generated reports, logs, and dashboard state now live under ignored .aiwg/testing/outputs/; durable plans, protocols, and deterministic fixtures remain tracked.
• Research incorporation portfolio — three routed model wrappers audited 1,901 local research records and identified 155 evidence-graded candidates for future architecture and implementation work.

Reliability fixes

This release also hardens SDLC skill-first routing, Steward option parsing, workspace regeneration limits, deployment verification, characterization-test isolation, flow namespace matching, provider deployment cleanup, and release discovery coverage.

Upgrade

npm install -g aiwg@latest
cd your-project
aiwg regenerate --workspace --provider codex
aiwg use all --provider codex --verbose

Replace codex with the target provider configured for the project. The regenerate command refreshes WORKSPACE.md, AIWG.md, and the provider's startup adapter. The use all command redeploys frameworks, kernel skills, agents, and the three model-aware subagent wrappers for that provider.

For providers with native agent definitions, a successful verbose deployment prints:

Model wrappers verified: aiwg-model-reasoning-worker, aiwg-model-coding-worker, aiwg-model-efficiency-worker

That verification is part of aiwg use: missing, empty, stale, or incorrectly pinned wrappers fail an unfiltered deployment. Providers without a native per-agent model surface report the applicable inherited, global, or informational policy instead of claiming an exact pin. Restart the provider session after deployment so it reloads the refreshed kernel and agent files.

Existing projects can preview bounded context extraction with aiwg regenerate --existing-project --dry-run before applying it. Projects that need the previous inline behavior can continue using aiwg regenerate --full-inject.

Released: 2026-07-20
Channel: stable (npm install -g aiwg)

AIWG 2026.7.15 fixes two Windows path-handling defects reported against native Claude Code and the shared artifact graph index. The changes are narrow and backward compatible; no provider sessions or migrations are required.

Highlights

• Shell-safe Claude Code hooks (#133) — generated hook commands now use forward-slash script paths on every platform. Redeploying also repairs existing AIWG-managed hook commands containing Windows backslashes, preventing Claude Code from collapsing them into invalid module paths.
• Cross-platform shared index home (#132) — when XDG_DATA_HOME is absent, AIWG now resolves the user's home directory with Node's platform API instead of interpolating an unset HOME variable. This prevents creation of a literal undefined/.local/share directory in Windows projects.

Upgrade

npm install -g aiwg@latest
cd your-project
aiwg use all

Running aiwg use all refreshes existing AIWG-managed Claude Code hooks with the corrected command paths. Projects that only use artifact indexing receive the corrected shared-index location automatically. No breaking changes.

Released: 2026-07-20
Channel: stable (npm install -g aiwg)

AIWG 2026.7.14 delivers provider-aware model policy and worker routing across the supported provider set, while keeping provider installation—not a hard-coded model inventory—as the stable deployment boundary. It also promotes Fortemi Knowledge Shard portability from source-level compatibility to a profile-scoped, immutable conformance receipt exercised by both the pinned Core library and the Fortemi server.

Highlights

• Provider-first runtime inventory (#1812, #1813) — aiwg runtime-info --providers distinguishes configured, deployed, detected, available, and active providers. Dynamic model sources retain provenance and freshness without making live discovery a deployment dependency.
• Safe model policy and worker wrappers (#1802–#1807, #1814) — canonical role/tier/effort intent compiles to native provider controls where supported and explicit degraded or unsupported results everywhere else. Cross-provider wrappers are validated from generated output without launching paid sessions.
• Observed Codex routing (#1185) — bounded CLI probes establish gpt-5.5 and gpt-5.4-mini mappings plus semantic reasoning-effort defaults; invalid or unavailable pins fail without silent fallback.
• Fortemi core-v1 conformance (#1797) — the exact @fortemi/[email protected] converter output is digest-pinned and verified through clean PGlite and server import/re-export paths, with explicit capability/loss reporting and atomic rejection cases. Claims remain limited to the named core-v1 profile.
• Project-local deployment controls (#1788) — committed quickrefs, provider-aware refresh, ownership-safe pruning, and project-local doctor checks make full and quick-reference deployment testable from output files.
• Dedicated repository authority — ordinary commits, signed release tags, Gitea tracker actions, and SSH transport now have separate project identities and fail-closed OpenBao-backed routing.

Upgrade

npm install -g aiwg@latest
cd your-project
aiwg regenerate

Run aiwg use all (or your selected framework/addon deploy commands) to refresh provider payloads and project-local quickrefs. No breaking changes.

Released: 2026-07-15
Channel: stable (npm install -g aiwg)

AIWG 2026.7.13 closes two subtle provider-deployment gaps: aggregated on-demand rule indexes now cover the complete installed corpus after every framework, addon, and extension pass, and OpenHuman once again receives its project-root AGENTS.md bridge. The release also completes generic vault routing for CI and release signing and synchronizes the onboarding docs with the deployed behavior.

Highlights

• Complete on-demand indexes (#1784) — provider deployment resolves the installed AIWG root before enumerating MEDIUM/LOW rules, so later addon or extension passes cannot truncate the index.
• OpenHuman project context restored (#1785) — full deployment renders the provider template into AGENTS.md, including commands and the complete on-demand rule section. Native TOML harness agents remain opt-in.
• Generic vault release path — the tag wrapper and migration verifier now use the same VAULT_CI_* bootstrap and routed-secret contract as CI.
• Onboarding wire-in — existing projects are consistently directed through aiwg regenerate; provider quickstarts explain when regeneration is required.
• Documentation fixes — Pagenary entity-safe inline markdown, a compact Fortemi control popover, corrected OpenHuman deployment paths, and repaired slugged research citations (#1787).

Upgrade

npm install -g aiwg@latest
cd your-project
aiwg regenerate

Re-run aiwg use all (or your selected framework/addon deploy commands) if you want provider payloads refreshed before regeneration. No breaking changes.

Released: 2026-07-13
Channel: stable (npm install -g aiwg)

The next stable release after v2026.7.11. It extends Cockpit stale-agent recovery to VM runtimes, ships a dedicated Cockpit documentation section, adds a native corpus-snapshot command, moves CI secrets and release signing to OpenBao, and lands the repaired LFD control surface for external agent loops.

Highlights

• Cockpit Reconnect for stale agents — now including VMs (#1778). Inventory and Sessions keep a running Docker/container/VM instance visible when its agent registration is stale, label it agent unreachable, and expose Reconnect. The Bridge recovers containers via docker exec <container> agent-reconnect and VMs via the libvirt qemu-guest-agent channel (virsh qemu-agent-command <domain> guest-exec pkill -HUP -x agent-client), after trying executor-owned reconnect endpoints first.
• Dedicated Cockpit documentation section at docs/cockpit/ — ten pages (overview, installation, architecture, surfaces, sessions, Bridge API, trust & security, recovery, development, releases) derived code-to-docs from the actual Bridge, web UI, and companion components, and wired into the docsite.
• aiwg corpus snapshot (#1647) — a deterministic native command producing corpus-snapshot metrics as markdown, terminal summary, or JSON, backed by a declarative Flow playbook.
• CI secrets and release signing on OpenBao — release workflows fetch migrated secrets and the GPG release key from an OpenBao vault at CI time via a least-privilege AppRole; the signing identity is unchanged for verifiers.
• Cockpit fixes: the VS Code shell now consumes shell-core and gains a working Windows keychain backend (#1783); qemu/kvm instances correctly count as VM runtime coverage (#1782).
• LFD remediation batch for external Ralph/agent-loop controls: resumed budgets, unknown-vs-zero usage semantics, completion-vs-budget stop policy, declared exploration quota, stall rule, hypothesis records, holdout-isolated mode, eval harness, VOID runtime, and CI coverage — plus a bounded manual provider test runbook.

Companion upstream work. This release's Cockpit VM recovery was validated against agentic-sandbox 2026.7.7+, which fixed the VM control-channel idle drop (#633) and made agent reconnect state-preserving (#634). On those agents all session types survive a reconnect; the Bridge's reconnect message and docs/cockpit/recovery.md state the version condition.

Upgrade

npm install -g aiwg@latest
aiwg --version
aiwg use cockpit
aiwg cockpit

For a real local Cockpit stack with host-runtime coverage:

AIWG_COCKPIT_START_HOST_DAEMON=1 npm run cockpit:up

Verification

The Cockpit stack was brought up for this release against the latest agentic-sandbox build with the host-runtime daemon (AIWG_COCKPIT_START_HOST_DAEMON=1 npm run cockpit:up): Bridge and executor healthy, a host instance provisioned and its agent registered over mTLS with a managed tmux backend, a session created with a live attach URL, the WebSocket data plane streaming, and the full-system e2e:cockpit-dev control-plane chain green.

Released: 2026-07-06
Channel: stable (npm install -g aiwg)

This patch release supersedes v2026.7.10 so the stable release tag includes the Cockpit session-management and CI corrections that landed after the npm tarball recovery release.

Highlights

• Stabilizes Cockpit session startup and attach behavior across host, Docker, and QEMU runtimes.
• Collapses duplicate fallback session rows and preserves control when replaying attached sessions.
• Bounds Cockpit session-start waits and docsite deploy SSH/rsync timeouts.
• Backfills the August through November 2025 AIWG report posts into the docs blog corpus.
• Updates the Cockpit bridge integration test contract for host session working directories.

Upgrade

npm install -g aiwg@latest
aiwg --version

Released: 2026-07-04
Channel: stable (npm install -g aiwg)

This patch release supersedes v2026.7.9, whose npmjs.org metadata and provenance were accepted while the base aiwg tarball URL initially returned 404 during install checks.

Highlights

• Reissues the v2026.7.9 release payload with a fresh immutable npm version.
• Keeps the Cockpit merged-console, issue-question label tracking, and release manifest publish-gate fixes from the previous release.
• Gives npm install -g aiwg a newly published latest target that can be verified directly against the registry tarball.

Upgrade

npm install -g aiwg@latest
aiwg --version

Released: 2026-07-04
Channel: stable (npm install -g aiwg)

This patch release supersedes v2026.7.8, whose GitHub npmjs.org publish workflow stopped in the full test gate before publishing either aiwg or @aiwg/cockpit to npmjs.org.

Highlights

• Keeps the v2026.7.8 Cockpit merged-console and issue-question label changes.
• Fixes a stale release-manifest test that assumed v2026.7.1-announcement would remain the first release entry forever.
• Leaves the release manifest ordered newest-first while still protecting the Fortemi preview announcement's presence and content.

Upgrade

npm install -g aiwg@latest
aiwg --version

Released: 2026-07-03
Channel: stable (npm install -g aiwg)

This patch release supersedes v2026.7.6, whose npm publish workflow stopped before publishing at the Fortemi Core prebuilt package gate. It keeps the pathless discovery improvements and canonical capability index from v2026.7.6 and updates the release gate to validate the new metadata contract.

Highlights

• aiwg discover result objects expose stable id values and omit paths by default, reducing context noise for agents.
• aiwg show metadata <id-or-name-or-path> exposes Fortemi metadata, resolved absolute paths, indexed paths, and provenance when diagnostics require them.
• aiwg discover --format json|text, --pretty, and --compact make output selection explicit while keeping --json as a compatibility alias.
• The framework capability graph no longer indexes provider/plugin mirror copies under agentic/code/plugins; Fortemi caches and discovery results use the canonical framework/addon/extension source set once.
• The Fortemi prebuilt package gate now follows the same pathless workflow as users: discover by id, then resolve detailed paths through show metadata.

Upgrade

npm install -g aiwg@latest
aiwg --version
aiwg discover "test" --limit 20
aiwg discover "release flow" --format json --pretty

Released: 2026-07-03
Channel: stable (npm install -g aiwg)

This patch release fixes global npm installs where aiwg discover could fail with Cannot find package '@fortemi/core' after the default discovery path moved onto Fortemi Core.

Highlights

• @fortemi/core is now a runtime dependency of the aiwg package, so global installs include the Fortemi-backed discovery engine by default.
• The prebuilt package gate now installs the packed tarball with development dependencies omitted and runs aiwg discover "test" from that production install.
• The release keeps the agent-led project setup messaging from main: agents and skills remain the front door, with CLI setup used as an enhancement path when it helps establish repo behavior, policy, and issue storage.

Upgrade

npm install -g aiwg@latest
aiwg --version
aiwg discover "test"

Released: 2026-07-03
Channel: stable (npm install -g aiwg)

This patch release supersedes 2026.7.3 as the artifact-aligned stable release for the Fortemi capability discovery parity fix.

2026.7.3 was published during the first tag push before main was rebased onto the latest remote documentation commit. Because npm package versions are immutable, 2026.7.4 carries the same discovery fix from the corrected main lineage so the package, tag, and repository history line up again.

Highlights

• Fortemi-backed capability discovery uses the merged capability-default graph surface instead of project-only lookup.
• Bare aiwg show skill doc-sync and aiwg show skill flow-release resolve canonical framework skills instead of ambiguity lists from plugin mirrors.
• The release-flow skill declares release flow, flow release, and related trigger phrases.
• Real-corpus parity tests compare Fortemi default discovery against local framework discovery over the AIWG corpus.
• Project-local custom skill discovery/show is covered by unit, integration, and live UAT checks.

Upgrade

npm install -g aiwg@latest
aiwg --version

Released: 2026-07-03
Channel: stable (npm install -g aiwg)

This patch release restores the default AIWG capability discovery contract after the Fortemi Core static-cache backend became the default search path.

aiwg discover and aiwg show now search the merged capability surface by default: framework capabilities plus project-local .aiwg capabilities. Common framework skills such as doc-sync and flow-release resolve without requiring --graph framework or --backend local, and project-local custom skills under .aiwg/skills/ are discoverable once the project graph is built and synced.

Highlights

• Fortemi-backed capability discovery now uses the capability-default graph surface instead of project-only lookup.
• Bare aiwg show skill doc-sync and aiwg show skill flow-release resolve canonical framework skills instead of ambiguity lists from plugin mirrors.
• The release-flow skill now declares release flow, flow release, and related trigger phrases.
• Real-corpus parity tests now compare Fortemi default discovery against local framework discovery over the AIWG corpus, using ordered result paths.
• Project-local custom skill discovery/show is covered by unit, integration, and live UAT checks.

Follow-up

Project-local customization is covered in this release. User/global custom skills under ~/.aiwg still need a first-class sidecar index so personal capabilities can follow the operator across projects without mutating the packaged framework cache. That design is tracked in #1709.

Released: 2026-07-03 Channel: stable (npm install -g aiwg)

This patch release supersedes the failed v2026.7.1 publish attempt. The Fortemi Core migration preview payload is unchanged from 2026.7.1; this release fixes the publish workflow gate that verifies .aiwg/ is excluded from the npm package.

The previous gate scanned the text output from npm pack --dry-run. That output includes lifecycle logs from prepack, including the local generated cache path .aiwg/.index/framework/, so the workflow stopped even though the structured npm file list did not include .aiwg/.

GitHub and Gitea publish workflows now validate .aiwg/ exclusion against npm pack --dry-run --json, and the integration test uses the same structured file-list check.

Released: 2026-07-01 Channel: stable (npm install -g aiwg)

This release adds a native human-in-the-loop path for MCP clients. AIWG now ships an ask-user MCP interaction tool that emits protocol-native elicitation requests when the connected client supports them, and falls back to a markdown prompt when it does not. That gives operators a consistent interaction surface without forcing every provider or MCP host to expose the same UI capability on day one.

It also records interactive-question support in the provider capability matrix, so AIWG can route prompts through the best available native UX. Codex guidance now documents its mode-gated request_user_input path, and Cockpit's merged console topology ADR is accepted for the next stage of session UX work.

What changed

MCP ask-user interaction tool

The MCP server now exposes an ask-user interaction tool backed by a shared elicitation helper. When a client advertises elicitation support, AIWG sends a structured request with schema-backed choices. When that support is unavailable, the same request is rendered as a markdown fallback so the session can continue through ordinary text.

The behavior is covered by unit tests for protocol-native elicitation, markdown fallbacks, and response normalization.

Native interaction routing

The provider capability matrix now includes native interactive-question support. That lets AIWG distinguish providers that can ask structured questions through their own UX from providers that need a text fallback. The bundled Codex rule documents the request_user_input mechanism and the mode gating around it.

Cockpit console topology

AIWG accepted the Cockpit merged console topology ADR, capturing the direction for a session UX that unifies operator console work without losing provider native behavior.

June 2026 report

The June 2026 AIWG progress report is published under the docs blog and the docs manifests were refreshed.

Upgrade

npm install -g aiwg
aiwg refresh

No breaking changes.

Released: 2026-06-30 Channel: stable (npm install -g aiwg)

This release makes AIWG's rule corpus pay for itself. Rules now declare a canonical enforcement level, and deployment splits them into two tiers: the CRITICAL/HIGH rules that must prime every session are inlined into each provider's always-on context, while the MEDIUM/LOW tier becomes on-demand — reachable through aiwg show rule <name> and a generated RULES-ONDEMAND.md index. Pair that with a careful compression pass over the largest always-on rule bodies, and a full aiwg use all Claude startup drops from ~193K to ~110K tokens — back under the 120K working-headroom target on a standard Sonnet window, with every normative directive intact.

The same release extends the Cockpit session workspace with a read-only observe terminal and persistent instance/session navigation, and hardens executor enrollment so Docker and VM agents register reliably.

What changed

Enforcement-tiered rule deployment (#1673)

Every rule now carries a canonical enforcement: frontmatter level. The two shared deploy enumerators (getAddonRuleFiles, collectFrameworkArtifacts) inline only the always-on CRITICAL/HIGH tier into a provider's rule directory; MEDIUM/LOW rules are pruned from the always-on set and left on-demand. Index files and any un-triaged rule default to always-on, so nothing is ever silently dropped. A CI guard (test/unit/providers/rule-tier-deployment.test.ts) asserts the enumerators never leak a MEDIUM/LOW rule into the always-on set.

The architecture decision is recorded at .aiwg/architecture/adr-rule-deployment-context-budget.md.

On-demand rule index across every provider (#1675)

The MEDIUM/LOW tier stays discoverable everywhere. File-based providers write a compact RULES-ONDEMAND.md into their rule directory after deploying the always-on rules:

.codex/rules/RULES-ONDEMAND.md
.factory/rules/RULES-ONDEMAND.md
.cursor/rules/RULES-ONDEMAND.md
.github/instructions/RULES-ONDEMAND.md
.opencode/rule/RULES-ONDEMAND.md
.windsurf/rules/RULES-ONDEMAND.md
~/.openclaw/rules/RULES-ONDEMAND.md

Each entry is one line with its fetch hint:

- `mention-wiring` — `aiwg show rule mention-wiring`

Aggregated providers note the tier in their single bridge file instead of a discrete file — warp appends an ## On-Demand Rules section to WARP.md (excluding rules already inlined verbatim), and hermes/openhuman render it into AGENTS.md (openhuman via a new {{ON_DEMAND_RULES}} template token). A shared renderOnDemandRuleSection helper keeps the file index and the bridge sections in lock-step.

Compressed always-on rule bodies (#1674)

The largest always-on rules — anti-laziness, skill-discovery, subagent-scoping, rlm-context-management, cli-secondary, citation-policy, auto-compact-continue, provenance-tracking, failure-mitigation, agent-fallback, agent-friendly-code, agent-generation-guardrails, hitl-gates, executable-feedback, tao-loop — were compressed per-rule, removing non-normative illustration (research-quote blocks, metrics dashboards, integration YAML, prompt-reinforcement galleries, ASCII diagrams) while preserving every FORBIDDEN/REQUIRED directive, rule statement, and enforcement level. Component RULES-INDEX.md summaries were tightened to one line each. The full detail of any rule remains one aiwg show rule <name> away.

Net effect on a full aiwg use all Claude startup:

Startup-context budget in aiwg doctor (#1672)

aiwg doctor now reports the aggregate context Claude Code inlines at session start versus the standard Sonnet window, with an OK/WARN/OVER verdict — so the budget is visible without guesswork. The same measurement is enforced in CI:

npm run lint:claude-context -- --startup --strict

Cockpit: observe terminal + persistent navigation

The Cockpit session workspace gains a read-only observe terminal (auto- observing the selected session's output) and a persistent instances + sessions navigation pane that refreshes on an interval. Executor enrollment was hardened across the board (#1669, #1670, #1671): the executor binds to 0.0.0.0 in cockpit-up so Docker agents enroll, the vsock CID registry auto-heals before executor start, attach retries through the PTY-readiness window, session lists de-duplicate by id, and stale stopped-Docker rows are destroyable.

Upgrade

npm install -g aiwg            # stable
aiwg refresh                  # re-deploy frameworks to pick up the tiered rules

aiwg refresh re-deploys with the tiered model: your provider rule directories keep the always-on CRITICAL/HIGH rules plus a RULES-ONDEMAND.md index for the rest. Nothing is lost — every MEDIUM/LOW rule is fetchable via aiwg show rule <name>. No action is required for the Cockpit changes.

No breaking changes.

Correction (2026-07-15, #1784/#1785): OpenHuman's default project artifact is an AGENTS.md context bridge, not copied markdown personas. Its on-demand section must cover the complete installed framework, addon, and extension corpus. AIWG 2026.7.13 corrects both the documentation and the multi-pass index generation.

Released: 2026-06-28 Channel: stable (npm install -g aiwg)

This release closes the loop on Cockpit's VM session path. The agentic-sandbox vsock transport line (v2026.6.31–v2026.6.34) fixed VM agent enrollment upstream; this release re-validates that path end to end from the Cockpit side, adds a one-command launcher for the full stack, and hardens stale-instance handling.

What changed

Cockpit live VM sessions validated over vsock (#561, #1659)

Before the vsock transport landed, a Cockpit-driven VM session would provision a qemu guest that could never enroll — the agent dialed management over a loopback-unreachable network path and the session hung at bootstrap-pending. agentic-sandbox v2026.6.31+ replaced that with an AF_VSOCK transport: the guest enrolls over its hypervisor-assigned CID instead of a routed network path.

This release re-ran the Cockpit live matrix against v2026.6.34 and the VM target now completes the full lifecycle:

provision → vsock enroll (CID registered, session reconcile)
→ boot-ready → provider workload (AIWG_COCKPIT_LIVE_OK) → clean destroy

The local run wrote evidence to .aiwg/testing/outputs/cockpit-vm-vsock-2026-06-27.md and its JSON sibling. The container matrix was re-validated against the same release.

cockpit-up launcher (#1657)

Bringing the Cockpit up previously meant starting the agentic-sandbox executor and the Cockpit Bridge/web separately and hoping they lined up. The new launcher does both:

npm run cockpit:up
# or: apps/cockpit/scripts/cockpit-up.sh [--rebuild]

It health-checks the executor, starts the latest agentic-sandbox via its management/dev.sh if it is down (resolving a sibling checkout or ~/dev/agentic-sandbox), then brings up the Bridge and web UI. --rebuild forces a fresh web build.

Graceful stale-instance destroy (#1660)

Destroying an instance the executor has already reaped no longer surfaces a raw 404. The Bridge maps the stale lookup to an already_gone result and refreshes inventory, so the operator sees the instance disappear instead of an error.

Artifact-index fixes

• Canonical agents over persona mirrors — index builds resolve the canonical agent definition rather than a persona mirror when both exist, preventing duplicate or incorrect agent records.
• Missing-graph tolerance — a missing graph no longer aborts an all-graph aiwg index build.

acquire → induct-media handoff (media-curator, research)

The media-curator acquisition flow now emits an explicit, validated handoff to the research induct-media step, so acquired media flows into the research corpus without a manual bridge. The transcribe-media skill also gained explicit aiwg discover triggers.

Upgrade

npm install -g aiwg            # stable
aiwg refresh                   # update + redeploy in place

No migration steps. The Cockpit VM session path requires agentic-sandbox v2026.6.31 or newer (vsock transport); v2026.6.34 is the validated build.

Released: 2026-06-23 Channel: stable (npm install -g aiwg)

This release shrinks the context an agent loads at startup. Generated provider bridges now route to capabilities through a tiered model instead of inlining a long deployed-artifact index, so default context stays small while the full detail stays one aiwg discover away.

What changed

Tiered provider-context bridge (#1651, #1652)

AGENTS.md and its provider twins are the always-loaded bridge an agent reads first. They previously rendered every deployed capability as a long-form index, which grew with the installation. They now render a Tier 2 quickref capability map: per-section purpose, when-to-use, curated aiwg discover phrases, and a aiwg show deep-load target. Full Tier 3 bodies (skills, rules, agents, behaviors) are reached on demand, not carried by default.

On a 1,000-artifact fixture the rendered bridge drops from 106 KiB to 7.4 KiB (93% smaller) with no loss of reachability — aiwg discover + aiwg show resolve any artifact the long index used to inline.

A new size guard keeps it that way:

npm run lint:context-sizes
# Context bridge ceiling: 8.0 KiB.
#   - AGENTS.md: 7.3 KiB (ok)
#   - WARP.md: 3.9 KiB (ok)
#   - .hermes.md: 0.4 KiB (ok)
#   - .github/copilot-instructions.md: 3.9 KiB (ok)

See docs/context-tier-model.md and docs/context-tier-pilot-report.md for the model and measurements.

Cockpit live-VM Bridge validation (#1658)

The Cockpit live UAT matrix had been posting VM provision requests straight to the executor, bypassing the Bridge's SSH-key injection for qemu launches — so the VM target failed with No SSH public key found. Provisioning now routes through the Bridge, which validated the agentic-sandbox v2 ssh_key passthrough end to end: the VM target now provisions and boots against a current executor. (apps/cockpit is excluded from the published npm package; this is development and validation work.)

Docsite Docs Map

Override styling for the pagenary-rendered Docs Map — SVG sizing and on-hover node labels.

Upgrade

npm install -g aiwg     # 2026.6.11
aiwg version            # -> 2026.6.11 [stable]

No migration required. The tiered bridge is regenerated by aiwg use / aiwg regenerate; existing deployments pick it up on the next refresh.

Links

• Changelog: CHANGELOG.md
• Context tier model: docs/context-tier-model.md
• Pilot report: docs/context-tier-pilot-report.md

Released: 2026-06-22 Channel: stable (npm install -g aiwg)

This is the clean publish for the media/research release line. It carries the type-flexible Media Curator work, Research Complete media REF induction, and the docsite-link repair in one signed release.

What changed

2026.6.9 reached the Gitea npm registry before the release tag correction could complete. Because npm package versions are immutable, this patch release publishes the corrected commit as 2026.6.10.

The functional feature set is the same as 2026.6.9:

• Media Curator starts unknown and mixed collections with assess-and-plan.
• Research Complete can induct time-based media as REF artifacts.
• Timestamp citations can point to transcript-backed media segments.
• Release doc-sync treats skills and agents under agentic/code/** as code.

This cut also fixes strict docsite links in the Agent Loop and LLM Wiki docs.

Upgrade

npm install -g aiwg     # 2026.6.10
aiwg version            # -> 2026.6.10 [stable]

Prefer this version over 2026.6.9.

Links

• Changelog: CHANGELOG.md
• Media handoff guide: docs/integrations/media-curator-to-research-handoff.md

Released: 2026-06-22 Channel: stable (npm install -g aiwg)

This release broadens AIWG's media path beyond music-first archives. Media Curator now starts unknown or mixed collections with a generic assess-and-plan route, while Research Complete can induct time-based media into citable REF artifacts with transcript-backed timestamp citations.

What changed

Media Curator is now explicit about the first decision: inspect the collection, then choose the right route. Music and discography workflows still work, but they are selected when the evidence shows a music-centered archive. Other media can move through acquisition, transcription, metadata tagging, export, or research handoff without pretending to be an album collection.

Research Complete now has a media REF contract for videos, lectures, podcasts, interviews, talks, and similar time-based sources. The new media induction path records storage policy, source URL, transcript sidecars, timestamp citations, and source-type metadata in the research corpus.

The media-curator to research handoff guide now covers the complete path:

/acquire --url "https://example.invalid/watch?v=lecture" --format video
/transcribe-media acquired-media.mp4 --source-url "https://example.invalid/watch?v=lecture"
/induct-media metadata.json --transcript media.transcript.json --storage hash-only

Highlights

Upgrade

npm install -g aiwg     # 2026.6.9
aiwg version            # -> 2026.6.9 [stable]

No action required. Redeploy media-curator or research-complete in any workspace where you want the new media guidance:

aiwg use media-curator
aiwg use research-complete

Links

• Changelog: CHANGELOG.md
• Media handoff guide: docs/integrations/media-curator-to-research-handoff.md

Released: 2026-06-21 Channel: stable (npm install -g aiwg)

Maintenance cut to refresh the @aiwg/cockpit npm package page now that the trusted-publishing path is validated.

What changed

The Cockpit README now starts like the main AIWG README: product framing first, then install commands, badges, quick links, and short operator-facing sections before the deeper architecture and validation runbook.

The recommended install path is explicit:

npm i -g aiwg
aiwg use cockpit
aiwg cockpit

That path installs @aiwg/cockpit outside the base package footprint under ~/.aiwg/cockpit/package and keeps it version-locked to the base aiwg CLI. Direct package installation remains documented for package testing:

npm i -g @aiwg/cockpit
aiwg-cockpit

Upgrade

npm install -g aiwg     # 2026.6.8
aiwg version            # -> 2026.6.8 [stable]

No action required. Documentation/package-page release; no CLI behavior changes.

Links

• Changelog: CHANGELOG.md
• Cockpit package: @aiwg/cockpit

Released: 2026-06-21 Channel: stable (npm install -g aiwg)

Maintenance cut to validate the new @aiwg/cockpit npm trusted-publishing leg. The previous 2026.6.6 run generated a Sigstore provenance bundle for github.com/jmagly/aiwg, but npm rejected the cockpit publish because the packed apps/cockpit/package.json had no repository.url.

Fix

@aiwg/cockpit now declares repository metadata that matches the GitHub Actions provenance identity:

{
  "repository": {
    "type": "git",
    "url": "https://github.com/jmagly/aiwg",
    "directory": "apps/cockpit"
  }
}

The npm scope is @aiwg, but the provenance source repository is still the GitHub mirror that runs the publish workflow. The directory field points npm users and registry metadata at the subpackage inside the monorepo.

The cockpit publishability smoke test now asserts this metadata so an empty or missing repository.url fails locally before a release tag is cut.

Upgrade

npm install -g aiwg     # 2026.6.7
aiwg version            # -> 2026.6.7 [stable]

No action required. Release-pipeline/package-metadata validation cut; no CLI behavior changes.

Links

• Changelog: CHANGELOG.md
• Release process: docs/contributing/versioning.md

Released: 2026-06-21 Channel: stable (npm install -g aiwg)

Follow-on hardening surfaced while validating 2026.6.5's GitHub-mirror fix. No CLI or API changes.

Fixes

GitHub mirror tag-push is idempotent

After 2026.6.5 corrected the mirror's secret name, the mirror job started actually running — and exposed that its tag-push to the GitHub mirror was not idempotent: if the tag already existed (a re-run, or a manual push that raced the workflow), git push failed with "tag already exists" and the job aborted before creating the GitHub Release.

github-mirror.yml now tolerates an already-present tag (the same || echo guard the main-push already had) and proceeds to Release creation. The Release step itself was already idempotent (it checks for an existing release first).

Docsite strict-link build

The v2026.6.4 and v2026.6.5 announcements linked the CHANGELOG with a relative ../../CHANGELOG.md path that resolves outside the published docs tree, which failed the docsite's strict-link check. They now use the absolute GitHub URL, matching every prior announcement.

Release runbook

CLAUDE.md / AIWG.md step 8 no longer instructs a manual git push github. The Gitea tag push (step 7) triggers github-mirror.yml, which pushes main + the tag to the GitHub mirror and creates the GitHub Release itself. The manual push raced the workflow's own tag push; the runbook now says not to do it.

Upgrade

npm install -g aiwg     # 2026.6.6
aiwg version            # → 2026.6.6 [stable]

No action required. Tooling/release-process release.

Links

• Changelog: CHANGELOG.md
• Release process: docs/contributing/versioning.md

Released: 2026-06-21 Channel: stable (npm install -g aiwg)

A maintenance cut that closes two release-pipeline gaps surfaced while cutting 2026.6.4. No API or CLI surface changes.

Highlights

Fixes

cut-tag.sh now verifies package-lock.json lockstep

Cutting 2026.6.4 bumped package.json, .claude-plugin/marketplace.json, and apps/cockpit/package.json — but not package-lock.json. CI's check:versions / npm ci reject a lockfile whose version drifts from package.json, so the build gate failed after the tag was already pushed and the npm publish never ran. The wrapper's lockstep checks didn't cover the lockfile.

tools/release/cut-tag.sh now runs a package-lock.json lockstep check (new pre-tag step 5/12) so a stale lockfile fails fast, locally, before tagging:

FAIL: package-lock.json version is '2026.6.4', expected '2026.6.5'.
       Run: npm install --package-lock-only
       (then commit package-lock.json) so CI's check:versions / npm ci pass.

GitHub mirror creates Release pages again

github-mirror.yml checked secrets.GH_TOKEN, but the configured Gitea Actions secret is named GH_ACCESS_TOKEN. The mismatch meant the "Check token availability" step always saw an empty value and skipped the GitHub tag push + Release creation — while still reporting the job as successful (the graceful fork-mode path). As a result, v2026.6.2, v2026.6.3, and v2026.6.4 never got an auto-created GitHub Release.

The workflow now reads GH_ACCESS_TOKEN (the GH_TOKEN env var that gh and the push URL consume is unchanged), so stable tags get their GitHub Release created automatically. This release is the validation that the path works end-to-end.

Upgrade

npm install -g aiwg     # 2026.6.5
aiwg version            # → 2026.6.5 [stable]

No action required. Maintenance release.

Links

• Changelog: CHANGELOG.md
• Release process: docs/contributing/versioning.md

Released: 2026-06-21 Channel: stable (npm install -g aiwg)

A correctness cut. Project-local extension/addon bundles now deploy to every provider the same way they always did for Claude; aiwg remove fails cleanly instead of crashing; and the kernel-skill prune can no longer wipe your skills directory when it can't locate the AIWG root. The npm-publish pipeline is also hardened so a single failing step no longer strands the @next channel.

No change to the base footprint — npm i -g aiwg installs the same surface.

Highlights

Fixes

Project-local bundles deploy on Factory and Codex (#124)

tools/agents/providers/claude.mjs has long detected when --source points at a project-local bundle (agents/, commands/, skills/, or rules/ directly under the source root) and deployed those artifacts. factory.mjs and codex.mjs lacked that isAddonSource short-circuit, so project-local extension/addon bundles silently deployed 0 agents and 0 rules to Factory and Codex — they only scanned the agentic/code/{frameworks,addons} tree, which doesn't exist inside a project-local bundle.

Both providers now carry the same check:

mkdir -p .aiwg/extensions/my-bundle/agents .aiwg/extensions/my-bundle/rules
# … add an agent + a rule + a manifest …
aiwg use my-bundle
# Before: Factory/Codex → "Deploying 0 agents…", "Deploying 0 rules…"
# After:  agent → .factory/droids/, .codex/agents/
#         rule  → .factory/rules/,  .codex/rules/

(Codex resolves commands and skills from srcRoot inside their own deploy steps, so only agents and rules needed the explicit handling there.)

Kernel-skill prune is null-safe (#123)

Deploying a project-local agent-shadowing bundle without AIWG_ROOT set could empty the provider's kernel skill directory (e.g. .claude/skills/). computeAllKernelNames walked up from the bundle path, found no agentic/code/{frameworks,addons} tree, returned an empty desired set, and pruneStaleAiwgSkills deleted every AIWG-managed kernel skill.

Two-part fix:

1. The use CLI now injects AIWG_ROOT (the resolved install root) into the project-local deploy subprocess, so the desired-kernel set resolves correctly even though --source is the bundle path.
2. computeAllKernelNames now validates AIWG_ROOT and returns null when no AIWG tree is locatable; pruneStaleAiwgSkills skips on null — mirroring the computeAllArtifactBasenames contract (#1627). hermes.mjs guards the null before spreading.

Setting AIWG_ROOT is still honored, but is no longer required for project-local agent bundles.

aiwg remove no longer crashes (#118)

aiwg remove all --provider factory (and aiwg remove <unknown-id>) crashed with Error: The "path" argument must be of type string. Received an instance of Object before doing any work. The plugin-uninstaller CLI was calling new PluginUninstaller({ dryRun, force, keepData }), but the constructor takes (aiwgRoot: string) — so path.join(<options-object>, 'registry.json') threw immediately. The collected options were also never forwarded to uninstall(), and the result handler read fields that don't exist.

The CLI now:

• constructs via createUninstaller() (resolves the AIWG root correctly);
• forwards { force, dryRun, keepProjects } to uninstall();
• reports from result.errors / result.stats;
• rejects unknown flags (including --provider) with a clear message + exit 2.

Behavior now:

aiwg remove all --provider factory   # → clear "--provider only for project-local/user-scope" error (handled at the TS layer, #1610)
aiwg uninstall-plugin all --provider # → "Error: unknown flag --provider" (exit 2)
aiwg remove all                      # → "Plugin 'all' is not installed" (exit 1) — no TypeError

CI / release pipeline

• @next advances even when an earlier publish step fails, so a partial failure no longer strands the prerelease channel.
• @aiwg/cockpit publishes from ./apps/cockpit rather than via npm --prefix.
• The Gitea publish workflow is scoped to the Gitea npm registry only.

Upgrade

npm install -g aiwg     # 2026.6.4
aiwg version            # → 2026.6.4 [stable]

No action required. If you previously set AIWG_ROOT solely to protect your kernel skills directory when deploying project-local agent bundles, that workaround is no longer necessary.

Links

• Changelog: CHANGELOG.md
• Project-local bundles: docs/customization/project-local-quickstart.md
• CLI reference (aiwg remove): docs/cli-reference.md

Released 2026-06-20

June's closing cut turns the AIWG Cockpit from beta substrate into a control plane an operator can actually drive against a real agentic-sandbox. The running board is derived from real A2A tasks, starting a session is a single explicit picker, the attach view renders a true terminal, and the whole stack comes up with one command. None of this changes the base npm i -g aiwg footprint — Cockpit remains the opt-in @aiwg/cockpit package.

Install or upgrade:

npm install -g aiwg
aiwg refresh

Why this matters to users

What Changed

Added

• Cockpit running board from real A2A tasks (#1639) — the board is derived from the executor's real task surface, not a mock.
• Session-start picker modal (#1640, #1641) — instance/runtime/loadout/backend/posture, the single home for both start paths; clobber guard + inline errors.
• Bridge /api/loadouts passthrough (#1641) — proxies the executor loadout catalog (/api/v1/loadouts, v2 /loadouts), normalized to {id,label,description,runtimes}, so the picker offers the full set rather than echoing the instance's own loadout.
• One-command dev bring-up harness — replaces the /tmp rigs; plus a dev-stage full-system e2e harness with documented test stages and a mock↔real contract guard.

Changed

• Running vs Sessions made legible (#1644) — each panel opens with a one-line purpose statement (Running = fleet overview board; Sessions = attached workspace) and names the relationship.
• Release pattern + config-defaults gate formalized for @aiwg/cockpit (sane tested defaults, packaging discipline).

Fixed

• Cockpit attach renders via xterm.js, not raw bytes — escape sequences are interpreted (colors, tmux redraws, titles, bracketed paste).
• Cockpit Home degrades gracefully against real v2 executors instead of collapsing to "No stack connected" (#1638); running/approvals panes degrade independently.
• Bridge port hygiene — defaults off the executor port range and refuses reserved-port collisions.
• Capability injection uses the plain skill name, not a / prefix (#1642).
• /api/show resolves by discovered path; ambiguous same-named artifacts return a 4xx with disambiguation text instead of a 502 (#1643, bridge half — the persona-vs-agent indexing dedup is tracked separately).
• Deploy-adjacent tests hardened against /tmp and untracked scratch.

Docs

• ADR: Cockpit chat-style agent view + output-parsing model (#1645) — a per-session Terminal↔Chat toggle over the existing observer-default attach, a normalized ChatEvent contract, structured-stream-preferred / PTY-parser-fallback sourcing, first-in-scope Claude Code.
• LFD control-patterns research spike (#1585) captured under research-planning.

Docsite

• Upgraded to Pagenary 6.13 — @pagenary/publisher now self-minifies (roctinam/pagenary#14), so the separate terser devDependency was dropped; 3 broken doc links were fixed so the strict-link validation build passes.
• Docs Map — docs.aiwg.io gains Pagenary's concept-derived relationship graph (444 nodes / 1,683 edges) as a navigable view.
• Refreshed welcome copy — accurate counts: 200+ agents, 8 frameworks, 29 addons, 11 platforms.

Verified Proof

On 2026-06-20, a real Docker agentic-sandbox instance provisioned a host agent and ran the Cockpit provision-host UAT under Codex; the local run wrote evidence to .aiwg/testing/outputs/cockpit-provision-host-codex-2026-06-20.{json,md}. This release's running board, session picker, and attach terminal were exercised against that real v2 executor rather than the mock.

Upgrade Notes

• No action required. Cockpit is the opt-in @aiwg/cockpit package; the base CLI footprint is unchanged.

Links

• Changelog: CHANGELOG.md
• June month-in-review: 2026-06-june-monthly-announcement.md
• Previous release: 2026.6.2

Released 2026-06-18

This patch release tightens the AIWG Cockpit live UAT gate so it proves a real agentic framework can start inside an agentic-sandbox session and use AIWG discovery from there.

Install or upgrade:

npm install -g aiwg
aiwg refresh

What Changed

• Cockpit live matrix workloads now require both AIWG_COCKPIT_LIVE_OK and an expected AIWG discovery result (issue-audit by default), instead of accepting a shell-only marker.
• The default provider workload asks the running agent to use AIWG discovery to choose the capability for auditing open issue state and release blockers.
• The Codex live workload command now uses the supported codex exec -s read-only syntax.
• Cockpit docs describe the host/container/VM matrix gate and the AIWG_COCKPIT_LIVE_DISCOVERY_EXPECT override.

Verified Host Proof

On 2026-06-18, a patched agentic-sandbox host runtime provisioned a host agent, registered it over mTLS, opened a managed tmux session, and launched Codex inside that session. Codex used AIWG discovery and selected issue-audit, returning the required AIWG_COCKPIT_LIVE_OK marker.

Claude also launched in the same session, but did not inherit usable auth state and reported that login was required. That remains a provider auth-state injection follow-up, not a Cockpit discovery-gate pass.

Upgrade Notes

• No migration is required.
• Operators using uat:cockpit-live:matrix should point AIWG_COCKPIT_EXECUTOR_URL at a real executor and leave mock-only success out of release evidence.

Links

• Changelog: CHANGELOG.md
• Previous release: 2026.6.1

Released 2026-06-15

A consolidation release on top of 2026.6.0. It lands the foundation of the AIWG Cockpit (a UX-first control plane) as beta groundwork, completes the declarative-Flow and cross-stack-Mission work previewed in June, brings every agent definition under the dispatch ceiling, and reconciles the documentation against source.

Install or upgrade:

npm install -g aiwg          # fresh install (stable)
aiwg refresh                 # update an existing install + redeploy

AIWG Cockpit — beta groundwork

The AIWG Cockpit is a UX-first control plane that sits on top of the AIWG CLI and the per-provider agentic stacks — letting you manage an install, deployed agents, and live multi-stack sessions from one surface, without ever replacing or nerfing the CLI underneath. This release ships the groundwork, not the finished UX.

What's in place (epic #1588):

• A data-driven core bound to the extension / aiwg discover / artifact-index registry — capabilities are derived from the registry, not hardcoded.
• Instance control normalized on the agentic-sandbox interface (a live session view + running-agents board).
• Two shells over one shared core — a Tauri (Rust) desktop app and a VS Code extension (#1594).
• A declarative UI contribution model — extensions contribute screens, actions, workflows, and event-hooks (#1591).
• Strong local control-surface auth — 127.0.0.1 + Origin + CSRF + per-launch token + OS-keychain handshake (#1595).
• Lean base, opt-in heavy — Cockpit ships as a separate opt-in @aiwg/cockpit package with a base-footprint CI guard (#1593); the base npm i -g aiwg footprint is unchanged.

The full operator UX is still in construction — install @aiwg/cockpit only if you want to follow the foundation. The complete experience lands in a later release.

# opt-in; not installed by the base CLI
npm install -g @aiwg/cockpit

Declarative Flows + cross-stack Missions are complete

The bulk migration of flow-* skills to flow.aiwg.io/v1 Flows (#1539) and the cross-stack Mission conductor with per-stack executor adapters (#1546) — previewed in 2026.6.0 — are now fully landed. One Mission conductor fans heterogeneous workers across stacks (for example, a Claude session dispatching Codex subagents) over the runtime:<name> executor convention. Flows are discoverable via aiwg discover and runnable as orchestration.

Leaner agents — every definition under the dispatch ceiling

Oversized agent definitions were silently failing subagent dispatch with Prompt is too long at 0 tokens — before the agent did any work. A repo-wide debloat (#1587, #1600) fixes this:

• Worked examples and restated protocol boilerplate are externalized out of agent definitions into the discoverable example catalog (few-shot coverage preserved via an inline anchor + referenced catalog).
• A hard 16 KB size ceiling is enforced by aiwg doctor, with a locked regression test.
• aiwg-steward was reconciled across its dual sources; rlm-agent and several SDLC, forensics, marketing, and media-curator agents were trimmed under the ceiling.

Docs match the code

A doc-sync code-to-docs pass reconciled every skill/agent count in the documentation against on-disk source:

• Kernel skills 16/19 → 20 (the self-maintenance ops set grew to 10: aiwg-issue, aiwg-pr, aiwg-mission joined).
• Addons 27/28 → 29; addon skill surface ~270 → ~214.
• Per-framework counts corrected — research 20 → 39 skills, security-engineering 7 → 27 skills, sdlc 90/220 → 93 agents.
• Three doc-to-doc contradictions (the same fact carried as three different stale values) resolved.
• Hermes's top-level kernel documented as the global 20-skill set (the generator deploys the global kernel, not a 9-skill subset).

Release announcements and dated blog posts were left untouched as immutable historical records.

Other changes

• release-publication-verify skill (#1599) — a post-tag verifier that confirms a tag actually published (npm dist-tag + Gitea/GitHub release artifacts).
• aiwg-steward "Built With AIWG" badge (#1596) — opt-in README attribution badge on request.
• aiwg regenerate additively installs the @AIWG.md hook into operator-owned provider files without clobbering them (#1597, #1579); aiwg doctor flags drift on non-managed twin files.
• package-all-plugins scoped to plugin packaging so native-release discovery routes correctly (#1598).
• Docs site reflects all 11 providers; README gains a hero masthead + badges; OpenCode --help assertion covers stderr; docsite deploy ~-resolver fixed; stray WARP.md backups removed.

Upgrade notes

• No action required. All changes are additive or self-healing on the next aiwg refresh / aiwg use.
• AIWG Cockpit is beta groundwork — @aiwg/cockpit is opt-in and not installed by the base CLI; the base footprint is unchanged. The control-plane UX is still in construction (#1588).

Links

• Changelog: CHANGELOG.md
• Cockpit epic: #1588
• Previous release: 2026.6.0

Released 2026-06-12

The June release covers a wide surface area, introducing a new deployment provider, a declarative orchestration layer, and a research framework capable of analyzing an entire corpus rather than just storing papers. Alongside routine cross-provider hardening, the discovery layer now handles natural user queries more reliably. Note that highly complex requests still demand precise terminology.

Install or upgrade:

npm install -g aiwg          # fresh install (stable)
aiwg refresh                 # update an existing install + redeploy

OpenHuman is AIWG's 11th provider

OpenHuman (tinyhumansai) is an open-source personal-AI runtime. It pairs a Rust core with a Tauri desktop shell, and can drive claude_code and factory as inference backends. As of 2026.6.0, AIWG supports it as a first-class deployment target:

aiwg use sdlc --provider openhuman

The deploy is a hybrid that matches OpenHuman's own conventions:

• Kernel skills install globally to ~/.openhuman/skills/<name>/SKILL.md — the ungated user-scope root OpenHuman scans unconditionally, and the exact path OpenHuman's own "Install from URL" writes to. The full standard set stays discover-reachable under ~/.openhuman/.aiwg/skills/.
• Personas stay workspace-scoped at .agents/agents/ for the external coding hosts OpenHuman drives.
• Commands and rules aggregate into an AGENTS.md discover-first bridge.

This is verified live, not theoretical: deploy AIWG and OpenHuman's agent harness scans the SKILL.md bundles at startup and event-bus-wires the triggered ones (aiwg steward, capability discovery, aiwg pr, ops runbook, …). Your AIWG skills are loaded and usable by OpenHuman's agents the moment you deploy.

One honest caveat: OpenHuman's BETA "Skills Explorer → Installed" tab reads ~/.openhuman/workflows/, not skills/, so deployed skills don't render in that particular panel yet — an upstream OpenHuman limitation that affects its own catalog installs too, not an AIWG deploy issue. The skills work regardless; the panel will catch up.

See the OpenHuman quickstart.

Releases and orchestration run on declarative Flows

AIWG's orchestration is now declarative. flow-release and flow-architecture-evolution are YAML Flows (flow.aiwg.io/v1) rather than prose runbooks:

• Discoverable directly — aiwg discover "cut a release" surfaces the Flow; YAML Flow docs are a first-class discoverable type.
• Config-driven gates — the release gate sequence lives in .aiwg/release.config, so the same skill body works for a CalVer + npm project (like AIWG) and a SemVer + container-only one. Only the config differs.
• Intra-step multi-agent panels — Flows can fan out a step across an agent panel and synthesize the results, via a documented executor fan-out contract.

Cross-stack Missions

A Mission is a single conductor fanning heterogeneous workers across stacks — a Claude session dispatching Codex subagents, for instance — over the runtime:<name> executor convention. /aiwg-mission ships AIWG-owned on Codex with no plugin dependency, so the orchestration surface is the same wherever you run it.

The research corpus learned to think

The research framework picked up the tooling that turns a pile of PDFs into a navigable, auditable knowledge base:

• Semantic + lexical search — aiwg index query --semantic (embeddings: similar, dedup-report) and --fulltext (BM25 body search).
• Citation intelligence — aiwg corpus extract-crossrefs and citation-backfill densify the citation graph; profile-graph edges link sources by embedding similarity.
• Integrity + quality — aiwg corpus integrity-scan (submission-risk), sidecar-lint/repair for metadata, per-type induction depth audits with frontmatter backfill.
• Vision — provider-neutral scanned-page extraction pulls structured content out of image-only PDFs.
• Extensibility — an open source-type registry with by-source-type views.

Discovery matches how you ask

The discover layer got materially better at natural language:

• Full questions ("help me choose the right AIWG framework or skill") normalize to keyword phrases and match.
• Single-content-token queries no longer dead-end.
• discover is now the exclusive agentic-capability surface, auto-builds the framework index from $AIWG_ROOT so deployed commands are findable from any project, and induces discover-first on new directives, not just when an agent is about to decline.

Cross-provider hardening

• Cursor — rules emit as native .mdc (not .md), and cleanup preserves operator-authored .mdc.
• OpenClaw — Steward identity injected into SOUL.md; commands correctly aggregated; discover-first bridge + scope defaults.
• Warp — WARP.md regenerated as a lean discover-first managed bridge (down from a 17.5k-line aggregate).
• OpenCode — loads AIWG.md directive classification via instructions[] and wires deployed rules into opencode.json.
• Codex — AIWG-owned /aiwg-mission, AIWG.md via instructions[], address-issues/issue-audit as commands.

Housekeeping you'll notice

User-facing CLI output — the aiwg use version stamp, the aiwg diagnose bug-report link, the entrypoint packaging-bug message — now reads github.com/jmagly/aiwg, sourced from package.json rather than the internal build origin. And the agentic-sandbox project now publishes its docs as a tenant at docs.aiwg.io/agentic-sandbox, cross-linked from the serve and daemon guides.

Links

• Changelog: CHANGELOG.md
• OpenHuman quickstart: docs/integrations/openhuman-quickstart.md
• Website: aiwg.io · Docs: docs.aiwg.io · Repo: github.com/jmagly/aiwg

npm install -g aiwg

Tag: v2026.5.13 · Released: 2026-05-29 · npm: npm install -g [email protected]

Two deploy-path regressions in the 2026.5.x stable line: every aiwg use was scaffolding a duplicated workspace layout that immediately tripped the legacy detector, and every upgrade from a pre-be3ee551 install left stale .js hook command paths in .claude/settings.json that crashed Claude Code's SessionStart hook with MODULE_NOT_FOUND. Both fixed here. Also picks up the @pagenary/publisher 2026.5.4 adoption that was queued in Unreleased.

What's fixed

Fresh aiwg use no longer reports migration: partial (Closes #1516)

Every fresh aiwg use was creating two parallel workspace trees under different parents — the intended scoped layout at .aiwg/frameworks/<id>/... (per PR #54) and a legacy top-level layout at .aiwg/<name>/... driven by each framework's memory.creates manifest schema. Because the SDLC legacy-dir detector treats top-level dirs like intake/, requirements/, architecture/ as legacy markers, every newly-deployed workspace immediately reported migration.status: "partial" (legacy AND scoped both present) and migrate-workspace could not fully resolve it.

The six non-SDLC framework manifests (forensics-complete, knowledge-base, media-curator, media-marketing-kit, research-complete, security-engineering) now declare their memory.creates scaffolding under the scoped .aiwg/frameworks/<id>/... location, so both scaffolding passes converge on one directory tree. SDLC's documented top-level artifact dirs are unchanged — they remain the canonical user-facing layout per CLAUDE.md.

The two divergent legacy detectors in workspace-status.mjs and framework-detector.ts are unified on a single definition:

• SDLC canonical top-level dirs alongside .aiwg/frameworks/ = the intended SDLC layout, not "partial migration".
• Orphan non-SDLC top-level dirs left over from pre-#1516 installs (forensics/, kb/, media/, marketing/, security-engineering/) still register as a migration signal, so users on affected workspaces continue to see the prompt until they migrate.

Stale .js hook paths refreshed on aiwg refresh (regression on Claude Code 2.1.157)

Pre-be3ee551 installs (May 10) registered hook scripts as .js in .claude/settings.json. The package declares "type": "module", so .js was loaded as ESM where require() is undefined — every hook invocation failed with ReferenceError. That fix renamed the scripts to .cjs so Node would always load them as CommonJS.

The hooks installer's idempotency check matched existing entries by _aiwg_id only (extension-stripped), so once a stale aiwg-session.js entry was present in settings.json, the upgrade pass on every subsequent aiwg refresh saw "already present" and skipped it — leaving the stale .js command path behind. Claude Code 2.1.157 invokes that path on every session start, the file no longer exists on disk, and the user sees:

SessionStart:startup hook error
Failed with non-blocking status code: node:internal/modules/cjs/loader:1459

(MODULE_NOT_FOUND for the missing .js script.)

The installer now rewrites the command, type, and _aiwg_managed fields on existing AIWG-managed entries when they're out of date, surfacing the rewrite in result.warnings so refresh CLI users see what changed. Regression test added.

@pagenary/publisher bumped to ^2026.5.4

Picks up the page-renderer frontmatter strip (pagenary#19) — collection blog posts no longer render their YAML frontmatter as visible text above the title on docs.aiwg.io. The collection manifest is unchanged. Adopted via the documented npm install --min-release-age=0 first-party override per docs/contributing/versioning.md. docs/contributing/publishing-blog-posts.md updated to drop the now-stale frontmatter-leak caveat.

User impact

• Projects that already have stale .js paths in .claude/settings.json heal automatically on the next aiwg refresh / aiwg use. No manual edit required.
• Projects with the duplicated workspace layout from the pre-#1516 deploy bug (any of .aiwg/{forensics,kb,media,marketing,research,security-engineering}/ present alongside .aiwg/frameworks/) will still show as flagged by aiwg status until the orphan top-level dirs are moved or pruned. The template stubs (forensics/chain-of-custody.md, kb/index.md) carry the only content and can be relocated under .aiwg/frameworks/<id>/.
• Documentation blog readers on docs.aiwg.io no longer see raw YAML frontmatter rendered above blog-post titles.

Verification

npm run check:versions
npm run typecheck
npm run build
npx vitest run test/unit/plugin/framework-detector.test.ts
npx vitest run test/integration/forensics-complete.test.ts
npx vitest run test/unit/extensions/claude-hooks-installer.test.ts
npm run uat

Tag: v2026.5.12 · Released: 2026-05-27 · npm: npm install -g [email protected]

This release lands the bulk of AIWG's research-corpus tooling merge from section9/research-papers into the native research-complete framework — radar/freshness, profile generation, funder analytics, discovery logging, and a configurable corpus root with a shared parser foundation — and launches the AIWG engineering blog as a single-source-of-truth markdown collection rendered by pagenary 2026.5.3. The Gitea release workflows now state what they actually do (Gitea owns its own registry mirror; npmjs.org publishes from GitHub Actions via OIDC) — closing #1481 once the operator rotated the underlying token.

What's new

The research-corpus tooling merge is the largest piece. AIWG's research-complete framework absorbed the radar/freshness subsystem (radar-init, radar-status, radar-report plus matching skills and a template), profile generation (profile-generate, profile-status, --fm variant), entity-profile graph analytics (centrality, communities, temporal), funder-network analytics, and discovery-logging with PROF-S curator tooling. A shared parser foundation backs all of it, and the corpus root is now configurable instead of hardcoded — what was 26 path-bound scripts in a separate repo is now one native subsystem you reach through aiwg corpus and aiwg index. Epic #1496 is roughly two-thirds done; the remaining sidecar lint, induction-quality, citation-graph, and integrity-scan clusters carry through to the next release.

aiwg index build renders corpus markdown views natively in-process — by-year, by-topic, by-venue, by-authors, by-method, by-model-size, by-training-pipeline, citation-network, and the new radar/discovery/funder views — replacing the separate regenerate_indices.py step.

Index configuration consolidated into aiwg.config under a validated schema (index.graphs); .aiwg/.index/ is gitignored by default and aiwg doctor surfaces its freshness.

The AIWG engineering blog is now a single-source-of-truth markdown collection. Write docs/blog/<slug>.md, push to main, and pagenary 2026.5.3 auto-generates docs.aiwg.io/blog/index.json (envelope schema {title, route, count, generated, posts[]}) plus a companion feed.xml from each post's frontmatter — no hand-authored HTML, no hand-maintained manifest. The first post, "How AIWG builds your customized system prompt," is live; four reviewed companions (A10–A13) are queued. Publishing conventions, frontmatter spec, image placement (docs/.public/blog/ → /assets/blog/), and the publish flow are documented at docs/contributing/publishing-blog-posts.md.

Doc-site CI now installs @pagenary/publisher as a devDependency and runs npx pagenary build:tenants aiwg-docs, replacing the previous git clone roctinam/pagenary.git → /tmp/pagenary step. The clone path is retired, GT_ACCESS_TOKEN is no longer referenced by any workflow, and the secret can be revoked after one clean deploy on the npm path. @pagenary/publisher itself advanced from 2026.5.1 (exact) to ^2026.5.3 (caret) to pick up the collection-support feature that drives the blog manifest. The bump used the documented --min-release-age=0 override since pagenary is first-party (roctinam/pagenary).

The Gitea release workflows had their topology drift cleaned up. npm-publish.yml's header and dry-run text still claimed it published to "both Gitea and npmjs.org," contradicting the fact that the npmjs.org legs were disabled back in #1283 (May 2026). The text now says Gitea-registry-only, names GitHub Actions as the npmjs.org publishing authority via OIDC, and marks NPMJS_TOKEN as referenced only by the disabled legs (revokable). Both npm-publish.yml and gitea-release.yml already documented NPM_TOKEN as a Gitea API token; the operator rotated the underlying token to one with both repository:write and package:write scopes, which closes #1481. The next signed-tag push exercises both Gitea jobs through valid auth.

A small dev-experience fix landed: the CLI's dist/src/update/notifier.mjs import path failed on a checkout where dist/ had been cleaned, because the .mjs/JSON/YAML files are copied into dist/src/ by build:copy-mjs (separate from tsc). Rebuilding via npm run build:cli restores it; #1513 tracks an aiwg doctor guard so a missing build fails loud and actionable next time instead of a raw MODULE_NOT_FOUND.

Documentation updates

• Added this release announcement and the 2026.5.12 changelog section.
• Added docs/blog/ (with the first post) and docs/contributing/publishing-blog-posts.md (publishing-process contract).
• Registered the Blog section in docs/_manifest.json + docs/contributing/_manifest.json.
• Rewrote the publishing doc to the real collection mechanism: envelope schema, derived-vs-verbatim fields, no-status-filter (drafts stay out of docs/blog/), docs/.public/blog/ image convention.
• Clarified .gitea/workflows/npm-publish.yml header + dry-run text and the NPMJS_TOKEN note.

User impact

• Research operators get the section9 tooling natively in AIWG: radar dashboards, profile generation, funder graphs, and discovery logs run through aiwg corpus / aiwg index with one configurable corpus root.
• Anyone touching the docs site benefits from a faster, secret-free CI clone path (no more /tmp/pagenary clone).
• Blog publishing is now write-markdown-and-merge — no HTML, no manifest editing.
• Release operators see a Gitea release pipeline that finally matches the real topology, and the next release proves the rotated token end-to-end.
• Developers who hit the dist/notifier.mjs import error from a clean/fresh checkout now have a clear path (npm run build:cli) and an upcoming doctor guard tracking under #1513.

Known follow-up

• pagenary#19 — page renderer still shows YAML frontmatter as visible text on the rendered docs.aiwg.io page (the generated manifest is unaffected). Clean page rendering arrives when pagenary lands the render-side strip and ages past the supply-chain release-age gate.
• #1486 — fix 53 pre-existing broken internal doc links and re-enable the strictLinks: true gate on docsite-build.
• Epic #1496 remaining clusters — sidecar lint & metadata repair (#1503), induction quality (#1504), citation-graph densification (#1505), integrity / submission-risk scan (#1506), and the needs-infrastructure items: scanned-page vision extraction (#1507) and Fortemi import (#1508, deferred). Entity-profile graph analytics (#1501) is partial.
• #1513 — aiwg doctor should detect a missing/incomplete dist/ and emit an actionable error.
• Provider field-validation cluster (#1405 / #1407–1415) remains correctly blocked:field-validation pending per-provider field reports.

Verification

Release-readiness checks for this line:

npm run check:versions
npm run typecheck
npm run build:cli
npm test
npm run uat

Tag: v2026.5.11 · Released: 2026-05-25 · npm: npm install -g [email protected]

This patch release prepares AIWG for the next stable cut by tightening provider selection, documenting local issue synchronization, and running a broad code-to-docs audit over the actual AIWG capability corpus: all of agentic/code/ plus repository Markdown.

It also ships the first concrete time-based media primitive, transcribe-media, while keeping the larger research-media handoff explicit as follow-up work instead of overstating the release scope.

What's new

Codex-aware provider detection now prefers active runtime/process evidence in mixed workspaces. Refresh, regenerate, steward, channel sync, and related tests cover the cases where Claude and Codex files coexist but the current session should target Codex output.

Local issue workflows now have documented import/export and live sync paths. Projects can follow the local issue migration guidance, preserve backups, and use the configured issue-tracker topology rather than guessing where issue state belongs.

Media-curator now exposes transcribe-media for acquired audio/video. The workflow records source metadata, media and transcript hashes, timestamped segments, optional speaker labels, and explicit degraded plans when local transcription tooling is unavailable.

Security-engineering gained additional scaffolding for banned APIs, sanitizer/fuzzing CI emitters, DFIR readiness routing, and supply-chain audit provenance.

Documentation updates

• Added this release announcement and the 2026.5.11 changelog section.
• Updated release configuration so doc-sync covers all of agentic/code/ plus all repository Markdown files.
• Updated release configuration to route release tags through tools/release/cut-tag.sh, preserving the regular-commit and release-tag signing-key split.
• Updated the system-wide cli-secondary rule: raw CLI commands augment skills, while skills own orchestration, final formatting, presentation, synthesis, gates, and recovery.
• Refreshed media-curator docs and README references for transcript sidecars and research handoff preparation.
• Recorded a 2026-05-25 doc-sync report under .aiwg/reports/ with the audit scope, evidence, fixes, and remaining follow-up issues.

User impact

• Codex users in mixed-provider workspaces get more predictable generated guidance and provider refresh behavior.
• Teams using local issues have a clearer migration and live-sync path.
• Media archive workflows can now produce transcript sidecars suitable for downstream review and future research induction.
• Release operators have a stronger documented gate for the true AIWG capability corpus and a safer tag-signing path.

Known follow-up

The full media-curator to research-complete bridge remains open: REF templates, timestamp citation policy, citation sidecars, induct-media, and quickref/generated-guidance discoverability are tracked separately. Cargo/Rust supply-chain audit discovery also remains open because Cargo queries still route to npm-specific guidance first. The skill-first CLI augmentation audit is tracked as #1480.

Verification

Release-readiness checks for this line:

npm run check:versions
npm run typecheck
npm run build:cli
npm test
npm run uat

Tag: v2026.5.10 · Released: 2026-05-19 · npm: npm install -g [email protected]

This patch release makes the first-run path easier to understand and safer to execute. It adds a real guided onboarding flow, tightens status reporting around local project engagement, and refreshes beginner-facing docs so new users can move from install to a verified workspace without reading internal implementation history.

It also restores the literal meaning of aiwg use all: the command now deploys every framework, addon, and deployable extension by default. Workspace-aware filtering remains available through explicit profile-driven deployment and preview commands, but it no longer shadows the full install path.

What's new

aiwg wizard now walks users through provider choice, profile selection, execution mode, and verification. JSON output stays plan-only for automation, while unattended execution requires --non-interactive so scripts do not accidentally mutate a workspace.

aiwg status --probe --json now reports a deterministic engagement status for the current workspace. When local AIWG config is malformed, the status path keeps returning actionable repair guidance instead of leaving users with a raw parse failure.

aiwg use all now stays on the full deployment path. Use aiwg use --workspace-signals to preview a workspace-aware plan or aiwg use --profile <name> to deploy a filtered profile.

The full deployment summary now distinguishes platform-native skills from the larger aiwg discover corpus by printing a separate discoverable-skill count after the capability index build.

The shared context finalization path now includes engagement verification guidance without adding generated attribution footers to project docs.

Documentation updates

• Added beginner docs for provider handoff, scope and recovery, onboarding validation, share/demo workflows, and current onboarding research.
• Updated the skills/commands unification guide to describe provider-specific command mirroring without exposing internal tracker references.
• Updated release navigation so the current and immediately previous patch releases appear in the docs manifest.

User impact

• New users have a guided path from aiwg wizard to a verified provider workspace.
• Automation can inspect wizard plans without side effects and must opt in explicitly before executing deployment.
• aiwg use all installs the complete AIWG surface again instead of only the workspace-aware subset.
• Status output is more useful for support and onboarding because it distinguishes configured, partially configured, and repair-needed project states.

Verification

Release-readiness checks for this line:

node tools/cli/validate-writing.mjs docs/beginner-provider-handoff.md docs/beginner-scope-and-recovery.md docs/beginner-onboarding-validation.md docs/beginner-share-demo-assets.md docs/beginner-research-refresh-2026.md docs/beginner-first-success.md
npx vitest run --config config/vitest.config.js test/unit/cli/wizard.test.ts
npx vitest run --config config/vitest.config.js test/unit/cli/handlers/use-workspace-filter.test.ts
npm run typecheck
npm run build:cli
npm test

Tag: v2026.5.9 · Released: 2026-05-18 · npm: npm install -g [email protected]

This patch release fixes the workspace-aware aiwg use all deployment path introduced in the 2026.5 line and restores command-surface compatibility for operator workflows after the skills-first pivot.

What's fixed and improved

aiwg use all now computes the workspace-aware framework/addon/extension plan once, then deploys each selected source directory directly. This prevents the full framework post-deploy flow from running repeatedly for every selected framework, which previously produced repeated capability-index builds, repeated session-reload messages, and duplicate hook backup lines.

The legacy full deployment remains available:

aiwg use all --no-workspace-signals

Operator workflow skills are now mirrored into provider command surfaces where providers support commands, and into the closest reasonable provider location where they do not. This keeps workflows such as aiwg-setup-project, aiwg-update-claude, and aiwg-update-agents-md locatable through command/slash-command patterns while skills remain the canonical source artifact.

Also included

• aiwg use --workspace-signals --dry-run now reports the workspace-aware subset as the behavior that aiwg use all will deploy by default.
• Full deployment coverage tests now exercise the legacy path explicitly with --no-workspace-signals.
• Doctor/listing guidance now points users toward workspace-aware deployment when deployed skill counts exceed provider listing budgets.
• OpenCode and Warp provider definitions now declare command directories for mirrored operator workflows.
• Deployment completeness coverage now asserts command mirrors for Codex, OpenCode, Copilot, Warp, and Windsurf.

User impact

• aiwg use all no longer appears to run the same deployment repeatedly in workspace-aware mode.
• aiwg-setup-project remains discoverable as a skill and is also copied to command surfaces for providers that expose commands.
• Providers continue receiving all relevant assets; when a provider does not explicitly support an artifact class, AIWG places the asset in the closest reasonable location.

Verification

Release-readiness checks for this line:

npm run check:versions
npm run typecheck
npm run build:cli
npx vitest run --config config/vitest.config.js test/integration/deployment-completeness.test.ts
npx vitest run --config config/vitest.config.js test/integration/use-all-deployment.test.ts
npm test

Tag: v2026.5.8 · Released: 2026-05-18 · npm: npm install -g [email protected]

This release is the post-2026.5.7 hardening line. It focuses on fleet operations for small API plans, provider-aware behavior deployment, explicit repo-access checks, model-tier routing primitives, serve/daemon reliability, context parallelism controls, and default-install hygiene.

TL;DR

# Install
npm install -g [email protected]

# Inspect a machine/workspace for cockpit ingestion
aiwg status --export json

# Deploy fleet behavior policy where supported
aiwg use aiwg-fleet --provider openclaw

# Check repository read-scope assumptions before an agent relies on paths
aiwg repo-access

What's in the box

1. Fleet behavior and discipline

The new aiwg-fleet addon ships quiet-bot and quiet-business-bot behavior bundles. These capture mention-only / business-domain response policies for budget-sensitive bots and deploy natively where provider behavior artifacts are supported.

aiwg-utils also adds prompt-level discipline rules for the same fleet problem space:

• escalation-discipline — summarize and justify before moving above the default model tier; Tier 3 requires confirmation.
• tool-quota — stop retry/tool-call loops instead of spending through a small plan.
• quiet-mode — portable mention-only / low-noise behavior where native behavior support is unavailable.
• respect-repo-access-manifest — do not assume repository paths are readable until checked.

2. Status export for cockpits

aiwg status can now emit structured fleet payloads for external dashboards:

aiwg status --export json
aiwg status --export ndjson

The schema is documented in docs/fleet/status-export-schema.md and includes version, installed frameworks, provider deployments, recent activity, long-running operations, and health flags. The model stays pull-based and loopback/private-network friendly.

3. Repo-access preflight

aiwg repo-access makes read-scope assumptions explicit before an agent tries to follow paths that the active platform may not be able to read. The companion docs in docs/security/repo-access-manifest.md define the manifest contract and the safety model.

4. Model-tier routing primitive

The new model router types and helper support Tier 0-3 policy decisions with rationale and confirmation requirements. This is a primitive, not full deployment-time provider integration yet; #1185 remains open for workspace-level tier config, aiwg use integration, and the ADR-level taxonomy.

5. Context parallelism caps

Provider-scoped max parallel subagent caps can now be declared in .aiwg/aiwg.config. Generated AIWG.md / AGENTS.md surfaces the cap, and RLM parallel defaults respect it. This keeps fan-out behavior visible and bounded in provider contexts where parallel subagents are expensive.

6. Serve and daemon reliability

The execution stack gained A2A terminal task-state observation, sandbox transport fixtures, PTY bridge resilience coverage, and daemon/serve gap-fill tests. These harden the mission-control and serve paths without making default CI depend on a live sandbox host.

7. Install hygiene

better-sqlite3 and @xenova/transformers are now optional peers rather than default install dependencies. This removes deprecated native prebuild plumbing from the default install tree. The SQLite backend implementation suite now skips cleanly when better-sqlite3 is absent, while factory/error-path coverage still runs.

8. Release-doc and docsite checks

The docsite release workflows now fail loudly on silent notify/deploy problems and verify the generated SPA section file for a release announcement instead of grepping the shell HTML. That makes missing release docs visible before publish promotion.

Verification

Release-readiness checks for this line:

npm run check:versions
npx tsc --noEmit
npm run test:ci

The latest post-fix Gitea CI run on main passed both Test and Build (actions/runs/2333, commit 530cf535).

Compatibility

No breaking changes for normal CLI use. Optional native backends/features that directly need better-sqlite3 or @xenova/transformers now require explicit installation by users who enable those paths.

Open tracker note: the only open bug-labelled issue at release time is #1379, an audit/epic for companion CLI workflow language. The first enforcement slice has landed; the remaining work is full inventory/remediation, so it does not block this patch release.

Tag: v2026.5.7 · Released: 2026-05-15 · npm: npm install -g [email protected]

This release closes the RLM search gaps found while auditing loop-structure documentation and updates the agent-loop skill so the default path is the current in-session loop. External daemon loops remain available, but they are now an explicit choice instead of the default interpretation.

TL;DR

# Install
npm install -g [email protected]

# Search large docs or repos; --max-parallel is now parsed correctly
aiwg rlm-search "find all references to loop structures" \
  --source docs \
  --depth 2 \
  --max-parallel 4 \
  --budget 200000

# Normal loop requests stay in-session
agent-loop "fix the failing tests"

# External/crash-resilient loop remains explicit
agent-loop-ext "run the overnight migration" --completion "all migration tests pass"

What's in the box

1. RLM search option parsing

rlm-search now recognizes --max-parallel as a first-class alias for concurrency. Before this patch, a command like:

aiwg rlm-search "find all references to loop structures" --source docs --max-parallel 4

could preserve the flag in the parsed argument list and then accidentally treat 4 as the query. The parser now consumes --max-parallel correctly and rejects unknown flags instead of letting a later positional value overwrite the user's natural-language query.

2. Single-chunk source coverage

rlm-prep now writes a manifest and chunk-0000.txt even when a source file fits in one chunk. That matters for docs trees and small source files: they are now included in the prep index and downstream rlm-search plan instead of being silently skipped.

Existing prep directories are coverage-checked before reuse. If a prep index does not cover the expected source files, manifests, and chunks, AIWG rebuilds it automatically before search.

3. Agent-loop routing clarity

The agent-loop skill source now prefers the internal/in-session loop first. Use the external daemon path only when the user explicitly asks for external, daemon-backed, crash-resilient, detached, or overnight execution.

This matches the operational expectation from recent sessions: agent-loop should be an internal loop construct by default, with agent-loop-ext / external Ralph used intentionally.

4. External loop observability

The external loop patch line also surfaces captured session logs through status paths when the daemon route is intentionally used. That makes external runs less opaque without changing the default routing decision.

5. Build-time version lockstep

npm run build:cli now runs a release-version guard before compiling. The check fails if any of these version surfaces drift:

• package.json
• package-lock.json top-level version
• package-lock.json root package packages[""].version
• .claude-plugin/marketplace.json metadata.version

This catches stale lockfiles during normal build verification instead of waiting until tag creation or publish prep.

6. Agent release-signing keyring note

The release docs now call out an operational detail from this release: agent runtimes may set HOME to an isolated role directory, which makes gpg use a different keyring than the operator's /home/<user>/.gnupg. If cut-tag.sh cannot see the AIWG release key but the key is present in the operator keyring, run:

GNUPGHOME=/home/<user>/.gnupg tools/release/cut-tag.sh 2026.X.Y

tools/release/cut-tag.sh now prints this diagnostic when the configured release key is not found.

Verification

Focused local checks for this release line:

npm run check:versions
npm run test -- test/unit/workspace/check-marketplace-version.test.ts
npm run uat -- test/uat/rlm-cli.uat.ts
npm run build:cli

The RLM UAT suite includes regressions for:

• single-chunk manifest/chunk creation
• single-chunk files appearing in the prep index
• rlm-search --max-parallel 4 preserving the full query text
• package/lockfile/marketplace release-version drift detection

Compatibility

No breaking changes. rlm-search --parallel N continues to work. --max-parallel N now works in the CLI as documented by the RLM search skill. Existing agent-loop commands keep working; only the default routing preference changed.

Tag: v2026.5.6 · Released: 2026-05-14 · npm: npm install -g [email protected]

Two behavioral upgrades that make iterative and long-running work survive context pressure and reach measurable completion without operator hand-holding. Plus a CI workflow ordering fix that closes the v2026.5.5 stable-publish regression mode.

TL;DR

# Install
npm install -g [email protected]

# Try the new completion inference (no --completion needed)
agent-loop "fix the failing auth tests"
# → derives `npm test` (or whatever the project actually uses) from
#   CLAUDE.md, package.json scripts, CI config, .aiwg artifacts,
#   confirms once, then iterates against the inferred gate

# CI-style auto-adopt
agent-loop "fix all type errors" --auto-criteria

# Force the old behavior (require explicit --completion)
agent-loop "task" --no-infer-completion

If you've ever had an agent stop mid-task to ask "should I keep working?": the new auto-compact-continue rule (HIGH, deployed via aiwg-utils) says the answer is always yes unless the task's measurable completion criteria are met or a real authorization gate has appeared. The rule codifies what to do instead: write a progress file at .aiwg/working/<task>-progress.md, let auto-compact run, recover from the durable substrate (activity log, progress file, git, AIWG memory, CLAUDE.md/AGENTS.md/AIWG.md).

If you run iterative loops without thinking too hard about completion criteria: the new infer-completion-criteria skill walks 5 evidence layers and proposes a measurable verification command grounded in your project's actual config — not a generic guess.

What's in the box

1. infer-completion-criteria skill

A new skill in the agent-loop addon (agentic/code/addons/agent-loop/skills/infer-completion-criteria/). Invoked automatically by agent-loop, ralph (legacy executor name), and agent-loop-ext when the user starts a loop without --completion.

The pipeline is a deterministic walk through five evidence layers, plus a synthesis step that validates against the vague-discretion rule:

The synthesis step produces a structured YAML proposal:

proposed_completion:
  criterion: "npm test passes AND npx tsc --noEmit exits 0"
  verification_command: "npm test && npx tsc --noEmit"
  rationale:
    - "Task verb 'refactor' triggers regression gate (Layer 1)"
    - "package.json scripts.test = 'jest --coverage' (Layer 3)"
    - "CLAUDE.md Development section references both checks (Layer 2)"
    - ".github/workflows/ci.yml runs both as required checks (Layer 4)"
  confidence: high
  alternatives_considered:
    - criterion: "npm run lint exits 0"
      rejected_because: "Lint is not in CI required checks for this repo"
  max_iterations_suggestion: 10
  needs_human_confirmation: false

The confirm-or-edit flow uses the platform's native interaction tool (AskUserQuestion on Claude Code, formatted text elsewhere per native-ux-tools). Headless / CI runs adopt high-confidence proposals automatically with --auto-criteria, or fail fast with the proposal printed as a diagnostic so the user can re-launch with --completion explicit.

The refusal case is named explicitly: if the task is genuinely vague ("make the code better") and no measurable criterion can be derived, the skill refuses and prints concrete rephrasing suggestions. A loop with no measurable gate runs forever or exits prematurely, which is the failure mode vague-discretion exists to prevent.

Edge cases the skill handles:

• Multi-language monorepos (workspace config detection)
• Projects with broken test suites (the criterion IS getting from red to green)
• Projects with no tests at all (surfaces this as a finding; the criterion becomes "tests exist for new code AND pass")
• Conflict between layers (prefer CLAUDE.md over CI over manifest)
• Multiple test commands (test:unit / test:integration / test:e2e) — picks based on task scope
• Use-case ID in the task → pulls acceptance criteria verbatim from .aiwg/requirements/UC-XXX.md

2. auto-compact-continue rule (HIGH)

A new rule deployed to every provider via aiwg-utils (core, autoInstall). The single load-bearing statement:

The answer to "should I keep working?" is always YES — until the task's stated completion criteria are met or the user has redirected. Context pressure is not a scope question. Long tool output is not a scope question. Crossing iteration N is not a scope question. The right response to all of them is: compact, checkpoint to durable storage, and continue.

Named exceptions:

1. Authorization gates (per human-authorization rule) — destructive or out-of-scope action discovered; ask about that action, not about continuation
2. Three-attempts-failed escalation (per anti-laziness Rule 6) — with full context
3. Explicit user redirect
4. Genuinely ambiguous new-directive classification (per skill-discovery Rule 0)

The rule then provides the operational pattern that makes "always continue" safe:

• Durable substrate table — what survives compaction (CLAUDE.md / AGENTS.md / AIWG.md, activity log, AIWG memory, progress file, git history, .aiwg/working/) vs what's at risk (raw tool outputs, exploratory reasoning, earlier turns)
• Progress file template — .aiwg/working/<task-slug>-progress.md with required sections: task contract, current status, completed steps, failed approaches (do not retry), open questions, state references. Per REF-909 (Anthropic), the "failed approaches" section is the single most underrated artifact — without it post-compaction agents re-discover known dead ends
• Trust auto-compact — let the platform run it; preserve state on disk before context fills, not after
• Compact Instructions block — a ## Compact Instructions section in your CLAUDE.md / AGENTS.md / AIWG.md biases the summarizer toward preserving completion criteria, last successful step, failed approaches, authorization questions
• Aggressive in-session compression — REF-122 (Verma, 2026): passive prompting yields ~6% savings, aggressive every-10–15-tool-calls discipline yields ~22.7%. The rule prescribes the aggressive variant
• Recovery protocol after compaction — read progress file first, then recent activity log, then git status, reconcile, skip failed approaches, resume from "Next action"

Cross-references to every interacting rule (vague-discretion, anti-laziness, human-authorization, instruction-comprehension, skill-discovery, activity-log, context-budget, subagent-scoping, context-bloat).

The rule body landed in v2026.5.5's incident-fix commit (the rule file and the v2026.5.5 release work happened in the same overnight session); it's surfaced in this release because the user-facing impact is felt now that the agent-loop changes pair with it.

3. CI workflow ordering fix

.gitea/workflows/npm-publish.yml — the Build step now runs before Run tests, matching ci.yml. Several tests assert on dist/ output (e.g. test/unit/cli/validate-metadata-import.test.ts asserts the import path resolves to dist/src/plugin/metadata-validator.js — regression test for #1001). The v2026.5.5 stable publish hit this exact ordering bug.

Inline comment in the workflow file cites the v2026.5.5 incident so future contributors understand the ordering constraint isn't accidental.

How to use the new completion inference

The default path — let inference run:

agent-loop "fix the failing auth tests"

# Output:
# Inferring completion criteria...
#   Layer 1 verb: "fix tests" → test-pass class
#   Layer 2 CLAUDE.md: "npm test" is the canonical test command
#   Layer 3 package.json: scripts.test = "jest"
#   Layer 4 CI: .github/workflows/ci.yml runs `npm test`
#   Layer 5: no related use case found
#
# Proposed criterion: npm test passes (exit 0)
# Verification: `npm test`
# Confidence: high
#
# Proceed? [Y/n/edit]

Auto-adopt for CI / scripted use:

agent-loop "fix all TypeScript errors" --auto-criteria

Explicit-required (old behavior):

agent-loop "task" --no-infer-completion
# → fails fast with: "Error: --completion is required. To enable inference, omit --no-infer-completion."

With a use case ID — inference picks up acceptance criteria:

agent-loop "implement UC-AUTH-001"

# Output:
# Inferring completion criteria...
#   Layer 5: found .aiwg/requirements/UC-AUTH-001-user-login.md
#
# Using acceptance criteria from UC-AUTH-001:
#   - [ ] User can log in with valid email/password
#   - [ ] Invalid credentials show clear error message
#   - [ ] Account locks after 5 failed attempts
#   - [ ] Login completes within 2 seconds
#
# Proposed criterion: All acceptance criteria from UC-AUTH-001 verified by tests,
#                     AND `npm test -- --testPathPattern=auth` passes
# Confidence: high (acceptance criteria are explicit)

Refusal case — vague task:

agent-loop "make the code better"

# Output:
# Cannot infer measurable criteria for this task.
#
# "Make the code better" is vague (per AIWG vague-discretion rule).
# A loop with no measurable gate runs forever or exits prematurely.
#
# Please supply --completion with a concrete check, e.g.:
#   --completion "npm test passes AND npm run lint exits 0"
#   --completion "all functions in src/utils/ have JSDoc"
#   --completion "complexity score from eslint < 10 for all files"
#
# Or rephrase the task with a concrete intent:
#   agent-loop "reduce cyclomatic complexity in src/utils/"
#   agent-loop "add JSDoc to all exported functions in src/api/"

How auto-compact-continue changes behavior

In practical terms: agents that previously stopped to ask "should I keep working?" mid-task will now compact and continue against the same measurable gate, recording state to disk so the loop survives platform auto-compact.

The rule is deployed via aiwg-utils (core, autoInstall) — you don't need to do anything to get it. After npm install -g [email protected], run aiwg refresh to redeploy the rule to your installed providers.

To opt into the strongest version of the discipline, add a ## Compact Instructions section to your project's CLAUDE.md / AGENTS.md / AIWG.md. A minimum-viable block:

## Compact Instructions

When summarizing this conversation for compaction, preserve:
1. The current task's completion criteria verbatim.
2. The last successful step and any verification command that proved it.
3. Failed approaches and the reason each failed (do not let them be re-attempted).
4. References to `.aiwg/working/*-progress.md`, `.aiwg/activity.log`,
   and any in-flight commits.
5. Pending authorization questions that were raised but not answered.
6. Open scope boundaries (what is in/out of scope for this task).

Discard:
- Exploratory reasoning traces leading to already-known conclusions.
- Tool outputs that were superseded by later, more authoritative reads.
- Greetings, status banners, and other non-load-bearing prose.

This block survives compaction because system-prompt-scope content (CLAUDE.md and equivalents) is what the auto-compact mechanism guarantees to keep.

Research foundation

Two new references added to the AIWG companion research-papers corpus:

• REF-909 — Anthropic Applied AI Team. Effective Harnesses for Long-Running Agents. Anthropic Engineering Blog, Nov 2025. link

  • Initializer-agent / coding-agent pattern
  • claude-progress.txt as the load-bearing artifact across context resets
  • "Failed approaches" section as the single most underrated component
  • Companion reference implementation at github.com/anthropics/cwc-long-running-agents

• REF-910 — Anthropic. Compaction. Claude API Documentation, 2026. link

  • Auto-compact mechanics: triggers, summarization, continuation
  • ## Compact Instructions for biasing what survives
  • What survives compaction vs what's at risk
  • The v2.1.96 regression where system-prompt inflation collapsed the auto-compact budget — documents that the trigger threshold is sensitive to context costs the user doesn't control

Both refs are GRADE LOW (vendor documentation) but authoritative for Claude-specific patterns and reflect production experience.

The empirical basis for aggressive in-session compression discipline is REF-122 (Verma, Active Context Compression: Autonomous Memory Management in LLM Agents, arXiv:2501.09067, 2026) — already in corpus. Focus Agent on N=5 SWE-bench Lite instances using Claude Haiku 4.5: 22.7% token reduction with aggressive compression every 10–15 tool calls, vs 6% with passive prompting, identical accuracy.

Files of interest

What this doesn't do (yet)

The JS launcher at tools/ralph-external/session-launcher.mjs does not yet call infer-completion-criteria before spawning the external loop process. The skills above document the contract; the launcher integration is a follow-up that touches stable working code and deserves a dedicated change. The in-session ralph skill works as documented because it's an in-context Skill invocation, not a launcher subprocess.

If you depend on the external loop's automatic completion inference, pin to explicit --completion for now and watch for the follow-up.

Upgrade

npm install -g [email protected]
aiwg refresh                # redeploy rules + agent-loop skill set
aiwg doctor                 # confirm clean state

No config changes required. The new behavior activates only when --completion is omitted from a loop invocation.

Links

• Tag: v2026.5.6 on Gitea
• Mirror: github.com/jmagly/aiwg
• npm: npm install -g [email protected]
• CHANGELOG entry: CHANGELOG.md
• New rule: auto-compact-continue.md
• New skill: infer-completion-criteria/SKILL.md

Tag: v2026.5.5 · Released: 2026-05-14 · npm: npm install -g [email protected]

Two user-facing changes plus the deployment-pipeline fix that brings the skill-discovery rule (the discover-first protocol) to all 10 supported providers on every fresh aiwg use invocation. Companion artifact: the Novice-User Adoption study lands as a baselined research deliverable under .aiwg/studies/novice-user-adoption/.

TL;DR

# Install
npm install -g [email protected]

# Redeploy AIWG so the now-cross-provider rule reaches your platform
aiwg refresh

# First-time-user safety: try running `aiwg use sdlc` from $HOME
cd ~
aiwg use sdlc          # ← warns about deploy target, 3-second cancellable delay
AIWG_GLOBAL_INSTALL=1 aiwg use sdlc   # ← suppresses warning, deploys silently

If you're a first-time user: aiwg use from your home directory or /tmp will no longer silently dump 200+ agent files into a place you didn't expect. You get a 3-second warning naming what's about to happen and how to cancel.

If you're a multi-provider user: the discover-first protocol — the rule that mandates aiwg discover before declining a request or improvising from training data — now reaches every provider's rules surface. Codex, Copilot, Cursor, Factory, OpenCode, Windsurf, OpenClaw via filesystem deploy; Warp via WARP.md aggregation; Hermes via AGENTS.md priming + MCP rule-show. Previously only Claude Code and Cursor had it.

If you're an AIWG contributor: the study under .aiwg/studies/novice-user-adoption/ documents the discovery audit (Workstream A), read-access audit (E), wizard design + Cognitive Walkthrough (C), engagement-surface design with Lee & See trust calibration (F), 3 empirical-question instruments (G), and the global-install ADR comms drafts (D). The evidence-type taxonomy gains a deployment-scripted level between static-flagged and scripted.

What's in the box

1. Project-isolation warning for aiwg use

When you run aiwg use sdlc (or any framework) from a directory that has no project signals — no .git, package.json, pyproject.toml, Cargo.toml, go.mod, pom.xml, Gemfile, build.gradle, or *.csproj up to 3 parent directories — AND your cwd is $HOME, /, or /tmp, AIWG now emits:

No project detected here. AIWG will deploy to the current directory. To associate AIWG with a specific project, run this from your project root. Continuing in 3 seconds — press Ctrl-C to cancel.

Three seconds, cancellable with Ctrl-C. Non-cancelled emissions write warn:no-project-signal to .aiwg/activity.log. The stat-only walk completes in <50ms (CI-enforced via a perf-test gate).

Opt out: AIWG_GLOBAL_INSTALL=1 aiwg use sdlc emits a one-line info message ("AIWG_GLOBAL_INSTALL=1 set — deploying to current directory without project check.") and skips the delay.

Source: src/cli/project-isolation/ (new module). 29 unit tests covering per-signal positive cases, walk-depth boundary (MAX_PARENT_DEPTH = 3), Ctrl-C cancellation, env-var suppression, activity-log integration, performance gate. Module is guarded against the per-framework / per-provider iteration loops so it fires once per CLI process.

Why this matters: novice users who run aiwg use from a fresh terminal often land in $HOME and don't realize they're deploying 200+ files into a place they'll later have to clean up. The warning surfaces the trade-off at the moment it's most actionable, without breaking the power-user workflow (which is aiwg use sdlc from a project root — invisible because project signals are present).

2. Cross-provider discover-first protocol parity

The skill-discovery rule encodes the discover-first protocol: before declining a user request as "outside AIWG's scope" or improvising a workflow from training data, the agent MUST run aiwg discover against the user's need. Most AIWG skills (~385 of ~400) are not in any provider's loaded context — they reach the agent only via aiwg discover + aiwg show.

Before this release, the rule was deployed to 2 of 10 providers (Claude Code and Cursor — and even those were stale copies that had drifted from the source-of-truth). After this release: 10 of 10 providers have the rule via their native rule-delivery channel.

Root cause: agentic/code/addons/aiwg-utils/manifest.json had consolidation.deployIndexOnly: true, which caused getAddonRuleFiles() in tools/agents/providers/base.mjs to skip the addon's individual rule files. Only the consolidated RULES-INDEX.md was deployed; its links pointed at source paths under $AIWG_ROOT/agentic/code/addons/aiwg-utils/, which only Claude Code and Cursor could reach reliably.

Fix: deployIndexOnly is now false. Both the index AND individual rule files deploy together to every provider. Per saved-memory feedback_parity_no_removal: always-deploy + adapt — no writer was removed; the deploy set was extended to match the architectural intent.

Warp aggregation (tools/warp/setup-warp.mjs): new transformRuleToSection() and collectAiwgRulePaths() helpers plus a "## AIWG Rules" aggregation block in generateAIWGContent(). skill-discovery sorted first; remaining aiwg-utils rules alphabetical. Regenerated WARP.md jumps from 0 → 101 references to aiwg discover / aiwg show / skill-discovery. The regenerated file is not shipped in this commit (would balloon the diff by ~1.5MB); operators regenerate locally via node tools/warp/setup-warp.mjs after aiwg use sdlc --provider warp.

Hermes priming (tools/agents/providers/hermes.mjs): CRITICAL_RULE_DIRECTIVES extended from Top-6 to Top-7. skill-discovery added as the first directive (governs how the agent interacts with AIWG architecturally). ~1KB compressed, well within Hermes's 19KB AGENTS.md hard cap.

3. Scope-model documentation

docs/cli-reference.md and README.md now document the project-scope (default) vs user-scope (global install) trade-off side-by-side:

• Project scope (recommended): aiwg use sdlc from a project root → ./.claude/agents/, ./.claude/skills/. One project's agent set never bleeds into another's session.
• User scope (global): aiwg use sdlc --scope user → ~/.claude/agents/, ~/.claude/skills/. Same set loads into every session. Canonical mode for OpenClaw and Hermes (whose primary discovery is user-scope).

Trade-off cited inline: REF-720 (Lost in Multi-Turn Conversation, MSR/Salesforce 2025) measured a 39% capability drop when context bleeds across unrelated tasks. The new project-isolation warning surfaces this at deploy time.

ADR-NUA-001 formalizes global install as a first-class supported flow with project-scope as the recommended default. The 5-day Discord/Telegram comms window for the ADR transition is still pending (tracked in #1338 — open by design).

What's NOT in the box

• AIWG.md generator wiring for the new 02b-discover-first.md template fragment. The fragment is committed and registered in the aiwg-sections manifest. But the current src/smiths/context-pipeline/aiwg-md.ts copies CLAUDE.md verbatim and doesn't consume the fragment manifest — that wiring appears to have been orphaned during a prior refactor. Tracked in #1344 (open).
• Field-validated behavioral verification per provider. The deployment is verifiable (rule file appears in the right path); whether each provider's agent actually loads and acts on the rule requires a session per provider. Field-validation sprint is residual work on #1336 (open).
• OpenClaw skills-count anomaly investigation. ~/.openclaw/skills/ deploys only 1 file where other providers deploy 15-20+. Tracked in #1345 (open).

Migration

Nothing to migrate. This is additive across the board. Existing aiwg use invocations continue working unchanged. The first time you run aiwg use after upgrading, you may see the project-isolation warning if your cwd is $HOME, /, or /tmp — that's the new behavior, intentional, and Ctrl-C-cancellable.

If your previous .claude/rules/skill-discovery.md or .cursor/rules/skill-discovery.md was a stale leftover (md5 different from agentic/code/addons/aiwg-utils/rules/skill-discovery.md), the next aiwg use overwrites it with current source.

Companion artifact: Novice-User Adoption study

Under .aiwg/studies/novice-user-adoption/:

• Workstream A — hookup-matrix.md (10-provider × 5-channel matrix; deployment-scripted across all cells; field-validation gap documented)
• Workstream B — requirements/UC-NUA-002-runs-aiwg-use-first-time.md + project-isolation code shipped in this release
• Workstream C — working/wizard-design.md + wizard-survey.md (4-tool pattern survey, full Cognitive Walkthrough record under NFR-USE-02's ≤2-friction-per-step budget)
• Workstream D — architecture/adr-global-install.md (PROPOSED) + working/comms-drafts-adr-global-install.md + working/global-install-rough-edges.md (18-entry per-provider inventory)
• Workstream E — working/provider-read-audit.md (CLI-mediated read-access reframing)
• Workstream F — working/engagement-surface.md (3-surface design + Lee & See trust calibration + anti-pollution checklist)
• Workstream G — working/empirical-G{1,2,3}.md (3 survey/questionnaire instruments + N=1 directional data)

The study introduces deployment-scripted as an intermediate evidence type in the SAD §5.2.2 taxonomy: between static-flagged (file:line reference only) and scripted (CI-verifiable behavior). It captures the layer where on-disk verification confirms the deployment delivers right files to right paths, but doesn't yet verify the agent on the provider reads and acts on them.

CI changes

• New perf-test gate: test/unit/cli/project-isolation/perf.test.ts asserts median detection completes in <50ms across 50 iterations (NFR-PERF-01).
• test/unit/consolidated-rules.test.ts — 2 tests rewritten to verify the new positive contract (includes aiwg-utils + returns skill-discovery rule). 53/53 pass.
• .claude-plugin/marketplace.json metadata.version brought back into lockstep with package.json (was 2026.5.2; the PUW-038 #1139 check caught the drift on commit 9c054f03 — now 2026.5.5).

Issue activity

Closed in this release: #1335, #1337, #1339, #1340, #1341, #1343, #1346, #1347

Open by design (next-cycle work):

• #1336 — Workstream A hookup audit (partial-pass; field-validation sprint required)
• #1338 — Workstream D global-install ADR (awaiting 5-day comms window)
• #1342 — Citation-validate sweep (dormant)
• #1344 — Inline discover-first protocol into AIWG.md / WARP.md / copilot-instructions.md
• #1345 — Investigate OpenClaw skills-count anomaly

Upgrade

# Stable channel
npm install -g [email protected]
# Or refresh existing install
aiwg refresh
# Verify
aiwg version    # → 2026.5.5
aiwg doctor     # ensure healthy

If you're tracking next for pre-release validation, that channel won't move from this release — 2026.5.5 ships as latest.

Acknowledgments

The discovery audit that surfaced the cross-provider deployment gap exists because of the feedback_no_platform_generalization discipline: static analysis flags candidates, only field reports conclude breakage. The audit upgraded the entire matrix from static-flagged to deployment-scripted in a single cycle, then surfaced the rule-deployment gap as a concrete actionable finding. Without that discipline, the parity gap would have stayed hypothesized rather than measured.

References

• Parent epic: #1334 (Novice-User Adoption study)
• Commit chain: ac7a2d88 (Workstream B), f6ae3e85 (C/D/E/F/A/G partial deliverables), c32b7e26 (cycle 2 audit), 9c054f03 (cross-provider parity via deployIndexOnly), e49342cc (Warp + Hermes parity completion)
• Saved-memory rules honored: feedback_parity_no_removal, feedback_no_platform_generalization, feedback_aiwg_branding_restraint, feedback_no_skill_copying, feedback_discovery_multi_hook, feedback_aiwg_engagement_state, feedback_calver_full_versions
• Research evidence cited: REF-720 (Lost in Multi-Turn Conversation, MSR/Salesforce 2025) for the project-scope cross-bleed trade-off; Lee & See (2004) for the engagement-surface trust-calibration framework

Tag: v2026.5.4 · Released: 2026-05-13 · npm: npm install -g [email protected]

29 issues (5 epics + 18 stories + 1 hotfix + 5 use cases) closing the Hermes integration gap. Before this release, Hermes Agent users could reach only a fraction of AIWG via MCP — five tools, one of which was a non-executing stub. After this release, Hermes users have feature parity with every other AIWG-supported provider.

TL;DR

# Install
npm install -g [email protected]

# Redeploy AIWG into your Hermes setup
aiwg refresh --provider hermes

# Confirm in Hermes
hermes chat "What AIWG tools are available?"
# Should list ~12 core tools by default
# Enable more via env: AIWG_MCP_TOOLSETS=memory,kb,ralph aiwg mcp serve

If you're a Hermes user: this is the release you've been waiting for. The 385 standard skills, the rules surface, the CLI command bridge — all reachable now. See the refreshed quickstart.

If you're a non-Hermes AIWG user: no breaking changes. The MCP server you connect from Claude Desktop / Cursor / Factory has gained 20+ new tools by default (discover, list/show pairs, command-run) and a clean opt-in toolset model. Your existing 4 working tools (artifact-read, artifact-write, template-render, agent-list) are unchanged. workflow-run is marked deprecated but still registered.

If you're an AIWG contributor: the MCP server is now modular. New tools go in src/mcp/tools/*.mjs, registered from server.mjs. Subsystem toolsets are template-driven via STORAGE_SUBSYSTEMS in subsystems.mjs.

Why this release exists

The post-#1212 discoverability refactor moved ~385 AIWG skills out of per-project deploy and into an index-driven model accessed via aiwg discover and aiwg show CLI commands. But the MCP server pre-dated that work and exposed only 5 tools (workflow-run — a stub; artifact-read, artifact-write, template-render, agent-list — the working four). Hermes users had no path to the post-#1212 surface.

Vendor research confirmed three breaking issues:

1. Hermes was at v0.13.0; our quickstart still targeted v0.4.0 with hundreds of lines of drifted file:line citations.
2. Generated AGENTS.md instructed users to call delegate_task(skip_context_files=True, skip_memory=True) — kwargs that don't exist on Hermes's actual signature. Every user since the integration shipped was running broken example code.
3. Standard skills (~385) were deployed to ~/.hermes/.aiwg/skills/ — a sibling of Hermes's scanned root, invisible to its os.walk(). The intended discovery never happened.

Plus an architectural gap: AIWG ships full feature parity for skills, agents, commands, rules, and templates across nine providers. For Hermes — purely MCP-driven — those surfaces had no path. This release establishes the three-layer parity model (native deploy + MCP exposure + AGENTS.md priming) for Hermes.

What ships

Layer 1 — Native deploy (Hermes scans the filesystem)

The new ~/.hermes/skills/.aiwg/ path replaces the unreachable ~/.hermes/.aiwg/skills/ from earlier versions. migrateLegacySkillPath() cleans up the legacy path on next refresh — idempotent, hash-matches before removal so user-authored files are never touched.

Layer 2 — MCP exposure (Hermes calls tools)

Default core toolset (~12 tools, always on, ~2.5K tokens schema):

• Discovery: discover, skill-list/-show, command-list/-show, rule-list/-show, agent-list/-show, template-list/-render/-show
• Execution: command-run (allow-listed against definitions.ts; destructive ops gated)
• Artifacts: artifact-read, artifact-write

Opt-in toolsets via AIWG_MCP_TOOLSETS=<csv> env var or aiwg mcp serve --toolsets=<csv> CLI flag:

All write operations marked destructiveHint: true where appropriate; destructive subcommands require confirmed: true flag (elicitation fallback for clients without MCP elicitation support).

Layer 3 — AGENTS.md priming (Hermes loads context on every turn)

The 6 highest-enforcement AIWG rules are inlined into the generated AGENTS.md as a compressed directives block (~3K chars):

1. no-attribution — no AI tool branding in commits/PRs/code
2. anti-laziness — never delete tests, suppress CI, or workaround
3. citation-policy — never fabricate citations, DOIs, or page numbers
4. token-security — never hard-code or echo secrets
5. versioning — CalVer format, no leading zeros
6. ops-safety — gate destructive operations, never cross host boundaries

The remaining 23 rules are reachable on demand via mcp_aiwg_rule_show <name>. AGENTS.md hard-fails generation if it exceeds 19,000 chars (Hermes's 20K context cap with 1K headroom).

Hotfixes

Broken delegate_task API: tools/agents/providers/hermes.mjs:117 was shipping delegate_task(skip_context_files=True, skip_memory=True) to every Hermes user. Those parameters don't exist — the behavior is hardcoded internally. Replaced with the correct delegate_task(goal="...", context="...") form. If you've been confused why delegate_task calls from AIWG examples didn't work, this is why.

.hermes.md emission: Our CHANGELOG has referenced .hermes.md emission since #1239, but the deployer never actually wrote the file. Now it does — thin pointer at project root, ~450 chars, loaded with priority over AGENTS.md.

Curator protection: Hermes v0.12.0+ ships an autonomous Curator that archives stale skills on a 7-day cycle. AIWG kernel skills now register in ~/.hermes/skills/.bundled_manifest so the Curator excludes them. Standard skills under .aiwg/ are already protected by the dot-prefix rule (Curator skips paths starting with .).

Documentation

• Hermes quickstart refreshed against v0.13.0. All file:line refs verified against commit 942adf6.
• Hermes skill fields documents the Curator protection mechanism.
• CLI reference documents --toolsets flag and the new core tool surface.
• CI drift verifier: tools/verify-hermes-citations.mjs walks every Hermes citation in AIWG docs and validates against the pinned version. Runs on every PR touching Hermes docs. Pin: HERMES_VERIFIED_VERSION = '0.13.0'. Update the pin (and re-run the verifier) when AIWG is verified against a new Hermes minor release.

Migration notes

For Hermes users on AIWG 2026.5.3 or earlier:

# Update AIWG
npm install -g [email protected]

# Re-deploy — the migration helper cleans up legacy paths automatically
aiwg refresh --provider hermes

# Reload MCP in active Hermes chats
/reload-mcp

The deployer will:

1. Migrate skills from ~/.hermes/.aiwg/skills/ → ~/.hermes/skills/.aiwg/ (idempotent; hash-matched)
2. Write/update .bundled_manifest for Curator protection
3. Regenerate AGENTS.md with rule priming (~4K chars, well under 20K cap)
4. Emit .hermes.md thin pointer

The MCP server itself doesn't need restart unless you also want to enable opt-in toolsets via the env var.

For non-Hermes users: No action required. New MCP tools become available next time you start aiwg mcp serve.

Issues closed (29)

Hotfix: #1305 (H1 — broken delegate_task API)

Epics: #1306 (E1 MCP CLI bridge), #1307 (E2 skill path fix), #1308 (E3 AGENTS.md re-arch), #1309 (E4 subsystem toolsets), #1310 (E5 docs refresh)

Stories: #1311 (S20 scope split), #1312 (S1 command-run), #1313 (S2 discover + list/show pairs), #1314 (S4 path fix), #1315 (S3 workflow-run deprecation), #1316 (S5 migration helper), #1317 (S6 Curator manifest), #1318 (S7 rule priming), #1319 (S8 .hermes.md emission), #1320 (S9 rule-list/show), #1321 (S21 quickstart refresh), #1322-#1328 (S10-S17 subsystem toolsets), #1329 (S22 skill-fields docs), #1330 (S23 drift verifier), #1331 (S16 mc toolset), #1332 (S18 toolset dispatch), #1333 (S19 list_changed — deferred).

What's next

The Hermes integration now ships at parity with every other AIWG provider. Future iterations on this surface (track for the next epic if needed):

• Refresh .aiwg/research/parity/hermes/assessment.md — the drift verifier flagged 4 stale citations in that older doc. Not blocking; informational.
• Hot toolset re-enable + notifications/tools/list_changed — currently the toolset surface is static at server startup. A future iteration could allow runtime toggling with proper change notification. Deferred from S19 (#1333) with rationale.
• MCP elicitation support — verify when Hermes adds the 2025-06-18 spec elicitation handler. Currently we fall back to isError: true + requires_confirmation: true for destructive ops.
• Hermes minor-version verification harness — bump HERMES_VERIFIED_VERSION and re-run the citation verifier on each Hermes minor release.

Thanks to upstream Hermes Agent (NousResearch) for the stable MCP integration surface. This release pinned to commit 942adf6 (v0.13.0, 2026-05).

Tag: v2026.5.3 · Released: 2026-05-13 · npm: npm install -g [email protected]

This is the first AIWG release published through the fully hardened supply-chain pipeline. Every signed-release control modeled in the Mini Shai-Hulud response plan (#1278) is now live, exercised against a real release cycle, and verifiable end-to-end.

TL;DR

# Install
npm install -g [email protected]

# Verify provenance (optional but recommended)
npm view [email protected] --json | jq .dist.attestations
# Should return a non-empty attestation object or array

# Full verification suite
# See docs/releases/verifying.md for cosign tarball verification + SBOM scan

If you're an AIWG consumer: nothing breaks. Node 20+ still works for the CLI. You now get cryptographic provenance for free; verifying it is optional.

If you're an AIWG contributor: bump your local npm to 11.5+ so the release-age gate fires on your npm install/npm update. The gate is what prevents a freshly-pushed malicious dep from entering the lockfile.

If you're a downstream package author who wants the same pattern for your own npm package: the new skills described below walk you through it.

Context — why this release exists

In early May 2026, the npm ecosystem absorbed the Mini Shai-Hulud worm campaign — a supply-chain attack chain where compromised maintainer accounts pushed malicious versions of dozens of popular packages. AIWG was not directly affected, but the campaign exposed gaps in our publish pipeline: no provenance attestation on npmjs.org, no signed-tag gate, no registry-independent signature on the tarball, no SBOM.

The response was a 9-wave hardening plan tracked in #1278. Track A — the publish-pipeline controls — landed across this release. Track B — user-facing capabilities for downstream adopters — ships in this release and continues in v2026.5.4+.

What's verifiable now

The full verification walkthrough and chain-of-trust analysis are at docs/releases/verifying.md. The user-side hardening guide is at docs/security/supply-chain-hardening.md.

Six signed assets per release

Both the GitHub release and the Gitea release carry:

1. aiwg-2026.5.3.tgz — the published tarball
2. aiwg-2026.5.3.tgz.sigstore — cosign keyless signature bundle
3. release-manifest.json — version, tag SHA, commit SHA, workflow run URL, tarball SHA-256
4. release-manifest.json.sigstore — cosign keyless signature bundle for the manifest
5. aiwg-2026.5.3.cdx.json — CycloneDX SBOM
6. aiwg-2026.5.3.cdx.json.sigstore — cosign keyless signature bundle for the SBOM

Same six on both registries. Verification works identically against either source.

Maintainer signing key

Published in SECURITY.md and .gitea/keys/maintainers.asc.

• Principal: AIWG Release Signing <[email protected]>
• Fingerprint: FE9272F0BC5781E1DE77FAAA719AB63879E84CE8
• Algorithm: ed25519
• Created: 2026-05-12
• Expires: 2031-05-11

The key signs annotated release tags only. Commits to main are signed with the maintainer's separate personal key (already registered with GitHub against the maintainer's GitHub identity) so the GitHub "Verified" badge appears on commits without exposing the release-only key to a wider surface. CI's tools/ci/verify-signed-tag.sh gate (#1299) fails any publish whose tag does not verify against a key in .gitea/keys/maintainers.asc or .gitea/allowed_signers. Release procedure: explicitly select the release key on tag creation with git tag -s -u FE9272F0BC5781E1DE77FAAA719AB63879E84CE8 -m "..." vX.Y.Z.

Adopt the pattern for your own packages

Four focused skills land in the security-engineering framework for users who want to apply the same hardening to their own npm packages:

Long-form walkthrough at docs/security/supply-chain-hardening.md. Release-publisher requirement: npm trusted publishing requires npm 11.5.1+ and Node 22.14+; AIWG uses Node 24 in the publish workflow.

What changed in CI

For the curious: the publish pipeline now pins every container and action.

• Containers: node:24@sha256:050bf2b... (publishing leg) and node:20@sha256:8f693ea... (everything else). Manifest in ci/digests.txt.
• Actions: 40-char commit SHA pins on actions/checkout, actions/setup-node, actions/upload-artifact, sigstore/cosign-installer.
• Tools: cosign v2.6.1, syft v1.18.0.

The pin manifest is the source of truth. Diff it to audit any bump. The update procedure is documented at the bottom of ci/digests.txt.

Requirements summary

Risk closure

9 of 10 supply-chain risks modeled in the Mini Shai-Hulud planning doc are now fully closed. The remaining one (S9, AI-runtime-boundary attacks) is intentionally out of scope for this campaign and tracked separately in the threat-model backlog.

Full risk-closure table and the corresponding control map are in .aiwg/security/supply-chain-postmortem-2026-05.md.

Upgrade

npm install -g [email protected]
aiwg doctor

No breaking changes. If you previously pinned to a 2026.5.3-rc.* pre-release, switch to the stable version — the pre-releases were internal pipeline checkpoints and one (rc.0) shipped without provenance.

References

• #1278 — Mini Shai-Hulud response plan + Track A close-out
• CHANGELOG.md — full release detail
• docs/releases/verifying.md — verification walkthrough
• docs/security/supply-chain-hardening.md — apply the pattern to your own package
• SECURITY.md — maintainer key fingerprint, vulnerability disclosure
• ci/digests.txt — CI pin manifest

Released: 2026-05-11 Channel: stable (npm install -g aiwg) Previous: v2026.5.1 Pipeline: this release is the first to dogfood the new flow-release skill — driven mechanically by .aiwg/release.config rather than by hand-walking the prose checklist.

What's in it

This release lands a multi-commit fix sweep driven by an external tester report (sebuh-infsol on jmagly/aiwg#108–#112), plus the infrastructure changes that came out of taking that report seriously: kernel skills for filing issues and PRs, a config-driven release flow, and a doctor gate that catches discovery-surface degradation before it confuses an agent.

If you only read one line: every bug sebuh-infsol reported on May 11 is fixed, the release process is now an executable spec, and filing high-quality issues/PRs is now a kernel skill instead of a wiki page.

Headline changes

aiwg steward works end-to-end

Two stacked bugs blocked aiwg steward capabilities for any user not in a dev-mode source checkout:

1. Path resolution — the handler walked a fixed number of .. segments from its compiled location, landing inside dist/ instead of the package root where agentic/ ships.
2. Schema mismatch — the handler read a schema (provider.capabilities[id].native_tool, matrix.baseline, etc.) that didn't exist in the YAML.

Both fixed. The canonical types in src/providers/capability-matrix.ts are now the single source of truth, and feature names accept both hyphenated (agent-teams) and underscored (agent_teams) forms.

$ aiwg steward capabilities --provider claude-code
  Provider: Claude Code (claude-code)
  Status:   stable
  Daemon:   native (+ pty-adapter)
  ─────────────────────────────────
  cron — ✓ native
    Scheduled task execution (recurring triggers)
  ...

Slash invocations on Claude finally deterministic

Pre-release, /aiwg-refresh --dry-run in a Claude Code session would invoke the instructional skill, which asked for Bash permissions repeatedly and churned. Two fixes converge:

• .claude/commands/aiwg-refresh.md (and aiwg-doctor, aiwg-status, aiwg-help, aiwg-regenerate, aiwg-issue, aiwg-pr) deploy automatically with aiwg use. Slash invocations route to the deterministic CLI.
• The kernel skills now carry script: frontmatter pointing at run.sh entrypoints, so aiwg run skill aiwg-refresh -- <flags> works on every platform.

aiwg regenerate is a real CLI command

Context-only regen of AIWG.md + AGENTS.md without redeploying frameworks. Faster than aiwg refresh when context drift is the only thing you need to fix.

$ aiwg regenerate --dry-run
◆ aiwg regenerate  (dry run)
  Provider: claude
  Target:   /your/project

  Would regenerate:
    - /your/project/AIWG.md
    - /your/project/AGENTS.md

  Dry run complete — no changes made

Kernel skills for filing issues and PRs

Two new always-loaded kernel skills put the filing-guidance in your agent's context, no docs lookup required:

• aiwg-issue — template selection, environment capture, duplicate detection, the cross-tracker import flow.
• aiwg-pr — delivery-policy compliance (direct vs feature-branch vs pr-required), the no-attribution rule, the verification gate, CI-green-before-done.

Companion steward-prep-delivery skill bundles a duplicate-detection helper that searches both aiwg discover and the configured Gitea tracker before you file.

For humans, the same guidance is at docs/contributing/filing-issues.md and docs/contributing/filing-pull-requests.md. Templates at .gitea/ISSUE_TEMPLATE/ and .github/ISSUE_TEMPLATE/.

Config-driven release flow

The flow-release skill is a portable gate-runner. What gates exist, in what order, hard-stop or warn-only — all declared in .aiwg/release.config rather than hardcoded.

AIWG's own config declares 7 gates:

1. local-build-test — typecheck, unit tests, build, UAT (stable only)
2. ci-green — poll Gitea actions on the release commit
3. doc-sync — invoke doc-sync skill with code-to-docs direction, guidance scoped to agentic/**/*.md + docs/**/*.md
4. changelog-and-announcement — CHANGELOG.md section + announcement doc must exist (stable only)
5. readme-freshness — diff-against-latest-stable prompt (soft gate)
6. release — tag, push origin, push GitHub mirror, npm dist-tag
7. post-release — close imported issues with thanks; create release entries

Any project can author its own .aiwg/release.config from the schema at agentic/code/frameworks/sdlc-complete/schemas/flows/release-config.yaml.

Doctor surfaces discovery degradation

aiwg doctor now smoke-probes four discovery-kernel commands:

✓ Discovery: aiwg discover: `aiwg discover doctor --json --limit 1` succeeded
✓ Discovery: aiwg show: `aiwg show skill aiwg-doctor` succeeded
⚠ Discovery: aiwg index: aiwg index pipeline unavailable — project-local artifact index may be missing
✓ Discovery: aiwg runtime-info: `aiwg runtime-info --check aiwg` succeeded

Each is a warning (not a hard fail), because doctor must work even on a partially installed system. But a degraded discovery surface is now legible before an agent tries to use it.

Six other CLI fixes

• aiwg runtime-info --discover — mkdir -p parent dir before write (no more ENOENT on a fresh project)
• aiwg new <name> --help — no longer scaffolds a project as a side effect
• aiwg catalog list/search — JSON data files now ship in dist/
• Three import-path fixes (workspace-migrate.mjs, optimize-prompt.mjs, diversify-content.mjs) — all corrected to dist/src/... per the tsc rootDir=. layout
• Doctor no longer recommends the unimplemented aiwg install-skill-seekers (the integration is intact via doc-intelligence + skill-factory addons)

Installation

# Stable
npm install -g aiwg

# Verify
aiwg version           # 2026.5.2 [stable]
aiwg doctor            # workspace health check
aiwg discover release  # finds flow-release

If you're upgrading from 2026.5.1, just aiwg refresh to redeploy with the new kernel skills and command stubs.

Try the new skills

# Filing issues
aiwg show skill aiwg-issue
aiwg run skill steward-prep-delivery -- "your search terms"

# Filing PRs
aiwg show skill aiwg-pr

# Running a release (in your own project)
aiwg show skill flow-release
# (writes .aiwg/release.config from the schema if absent)

# Regenerating context files only
aiwg regenerate --dry-run

Migration notes

• aiwg install-skill-seekers was never an actual CLI command. The skill-authoring surface is the skill-factory addon — aiwg use skill-factory.
• The Release Checklist in CLAUDE.md is preserved for browsability but is now annotated as "mechanically driven by flow-release."
• The kernel-skill count grew from 6 → 9 (added aiwg-regenerate, aiwg-issue, aiwg-pr); the aiwg-utils-quickref and CLAUDE.md self-maintenance sections reflect the new total.

Acknowledgements

This release exists because @sebuh-infsol filed five high-quality issues with full reproductions and suggested fixes on the GitHub mirror (jmagly/aiwg#108–#112). Every one of those reports turned into a discrete fix landing in this version. The import flow you can see in docs/contributing/filing-issues.md was codified directly from how those reports were handled.

Thank you.

Links

• Compare: v2026.5.1 → v2026.5.2
• CHANGELOG: CHANGELOG.md
• Closed issues (Gitea): #1261, #1262, #1263, #1264, #1265, #1266, #1267, #1268, #1269, #1270
• Closed mirrors (GitHub): jmagly/aiwg#108, #109, #110, #111, #112
• New kernel skills: aiwg-issue, aiwg-pr, aiwg-regenerate (run aiwg discover "<topic>")
• New CLI command: aiwg regenerate
• New SDLC skill: flow-release (owned by Deployment Manager)

Released: 2026-05-11 Type: Major release (41 rc iterations folded in) Previous stable release: v2026.3.3 (2026.4.0 was never cut — the rc series rolled forward into 2026.5.0)

v2026.5.0 is two complementary stories landing in one stable cut:

1. Project-local artifacts — a complete operator surface for customizing AIWG per-project without forking, with a graduation path to upstream or a private corpus that's a hash-verified copy with zero rewrite. Epic #1033 delivered eight ADRs / design docs and four implementation phases.
2. Kernel-pivot maturity — the kernel-vs-standard skill split (introduced in 2026.5.0-rc.10) became the load-bearing model AIWG actually operates under. The late-rc work hardened the discover-first protocol, fixed the publish pipeline, audited the Hermes integration against upstream source, and shipped visual docs that finally make the mental model accessible without prose-only walls.

Highlights

What's new in detail

Project-local artifact lifecycle (epic #1033)

The epic shipped in dependency order, child by child. Each phase produced a usable feature on its own; the complete operator surface lit up in #1037.

Discovery + manifest validation (#1034)

Read-only scan of .aiwg/{extensions,addons,frameworks,plugins}/<name>/manifest.json:

• Unified BundleManifestSchema (Zod) — discriminated nested config (addonConfig, frameworkConfig, extensionConfig, pluginConfig)
• Strict validation rejects unknown top-level keys, enforces DoS limits (64 KB manifest, 200 bundles, 50 keywords, 20 overrides), supports safety-critical and overrides fields
• Symlinked bundle dirs refused unless --allow-symlinks (per threat model #1042)
• Case-insensitive id collisions within a type are refused
• Surfaced in aiwg list with [project] source label; aiwg list --project-local filters with per-type counts

Deploy via aiwg use (#1035)

aiwg use sdlc now deploys project-local bundles automatically alongside the upstream framework. aiwg use <bundle-name> deploys a single bundle. --no-project-local skips discovery entirely. Registry tracks source: 'project-local' with localPath, localType, manifestVersion, and (new in #1037) artifactHashes.

Override / shadow policy + safety-critical denylist (#1036)

Seven verdicts from ADR #1041:

1. No collision → deploy
2. Non-safety shadow → deploy + warn
3. Safety-critical + explicit overrides: → deploy + prominent warn
4. Safety-critical without overrides: → refuse (--force does not bypass)
5. Phantom override → refuse
6. Two project-local bundles export same artifact → refuse both
7. Git-installed (cache) shadow → same path as cases 2/3/4 against the cache

Remove + doctor + promote + activity log (#1037)

Implemented in five phases following the design contracts:

Scaffolding (#1050)

aiwg new-bundle <name> [--type {extension|addon|framework|plugin}] [--starter {skill|rule|agent|minimal}] creates a complete bundle in one command. Aliases (new-extension, new-addon, etc.) infer the type from invocation. Output validates against BundleManifestSchema out of the box.

Activity log

Every lifecycle event writes a single line to .aiwg/activity.log:

## [2026-05-02 19:45] deploy | deploy: my-bundle:extension | claude: agents=0 commands=0 skills=1 rules=1
## [2026-05-02 19:46] delete | remove: my-bundle:extension | claude=2 reverted
## [2026-05-02 19:47] promote | promote: my-bundle:extension | agentic/code/addons/my-bundle

12 design events: discover, deploy, deploy-failed, conflict, shadow-acknowledged, shadow-refused, remove, remove-mutated, remove-conflict, remove-force, promote, promote-failed. Writes are non-blocking (failures emit a stderr warning, never break the underlying op). Discover events deduplicate by (name, type) against the recent log tail.

Identical-form portability (ADR #1038)

The load-bearing design invariant: a project-local bundle is byte-identical in shape to its upstream form. This makes aiwg promote a hash-verified copy — no rewrite, no migration, no schema gymnastics. The same manifest shape works at:

• .aiwg/extensions/<name>/ (project-local)
• agentic/code/addons/<name>/ (upstream)
• <corpus-path>/<name>/ (private corpus)
• A marketplace-packaged plugin payload

Moving between any of these is cp -r + SHA-256 verify.

Customization paths (Path A / B / C)

The customization guide restructured around three paths. Pick by what you're customizing and how you want to share it:

The three paths compose. A project on Path A can later promote to Path B or Path C; a fork (Path B) can deploy alongside Path A bundles cleanly; a corpus (Path C) is just another source in the registry.

See docs/customization/README.md for the full decision tree.

Documentation

A comprehensive doc refresh shipped alongside the implementation:

The old docs/project-local/ directory (which documented a superseded .aiwg/.project/ design) was replaced with redirect stubs pointing at the canonical docs above.

Architecture decisions

The epic produced eight new ADRs / design docs in .aiwg/architecture/:

Test coverage

The 2026.5.0 work added 33 new unit tests across 4 new test files for the project-local lifecycle, plus integration and UAT coverage:

Plus the full test matrix mapping in .aiwg/testing/test-strategy-project-local.md.

Migration notes

From v2026.4.x

No breaking changes. Existing aiwg use and aiwg remove invocations work unchanged — project-local awareness is additive.

The two surfaces that gained behavior:

1. aiwg use now auto-discovers .aiwg/{extensions,addons,frameworks,plugins}/<name>/ bundles after the upstream deploy. Pass --no-project-local to skip.
2. aiwg remove <name> now routes to a project-local handler when <name> matches a project-local entry in aiwg.config.installed. Otherwise falls through to the existing plugin-uninstaller.

Upgrading an existing project to take advantage

npm install -g [email protected]
aiwg refresh         # re-deploy with project-local discovery enabled
aiwg new-bundle my-team-rules --type extension --starter rule
# edit the bundle, then:
aiwg use my-team-rules
aiwg doctor --project-local

Operators currently maintaining a fork

See docs/customization/from-fork-to-project-local.md for the per-category migration guide. Common case: rules / skills / agents move to project-local; AIWG core changes stay in the fork.

Late-cycle additions

Two user-reported issues landed in the rc.10 cut and ship in 2026.5.0:

• #107 — Claude settings.json hooks field shape. The hook installer (and the CLI extension hook auto-registration from #480) wrote hooks as an array of {matcher, hooks} objects. Claude Code requires an object keyed by event name with matcher-group arrays as values, and /doctor was flagging the array shape: "hooks" must be an object mapping event names to matcher arrays; received array. This field was ignored. Both writers (src/extensions/claude-hooks-installer.ts, src/cli/cli-extension-loader.ts) now emit the correct shape, and existing array-shaped settings are migrated in place on next aiwg refresh. Operator-authored entries are preserved.
• #105 — PROF-* node IDs in citation-sidecar parser. src/artifacts/citation-parser.ts accepts PROF-[POFG]-[a-z0-9-]+ (people / orgs / funders / groups) alongside REF-\d+ at all three call sites. Unblocks research-corpus projects building entity-profile graphs whose profile→REF edges are now natively traversable via aiwg index neighbors. Purely additive — both ID spaces are unambiguous and prefixed.

Second story: kernel-pivot maturity (rc.20 → rc.41)

The project-local story was the headline. The 21-rc rc.20 → rc.41 trail was the second story: hardening the kernel-pivot model that rc.10 introduced, until it became the load-bearing way AIWG actually operates.

Discover-first protocol — driven by real droid-user feedback (#1249)

A Factory droid user reported using Grep to search .factory/rules/ for an AIWG-keyword query, hitting rlm-agent.md by literal-string match, and missing eight other RLM-related artifacts that aiwg discover would have ranked. Their honest analysis: "No hard trigger mandating aiwg discover as the first action for AIWG-related queries. The discovery skills are advertised as available, but not as required."

The fix:

• New Rule 1.5 in skill-discovery.md: aiwg discover MUST be the first information-gathering tool call for any query mentioning AIWG, a framework name, or a capability keyword (skill / agent / rule / command / addon / workflow / template). Filesystem Grep/Glob/Read against any provider artifact directory (.claude/, .codex/, .factory/, .warp/, .cursor/, .windsurf/, .opencode/, .github/, ~/.hermes/, ~/.openclaw/, agentic/code/) is forbidden until discover has been consulted at least once in the session.
• Top-banner Discover-First Protocol on the deployed RULES-INDEX.md. Factory's consolidatedSdlcRules: true deploy path doesn't inline aiwg-utils content — only references it via @$AIWG_ROOT link. Promoting the protocol to a banner on sdlc-complete's RULES-INDEX makes it visible at the top of the file on every provider that deploys SDLC rules.
• All 9 framework quickref descriptions rewritten with explicit AUTO-INVOKE when user mentions: <trigger list> phrasing. System-prompt routing on most platforms gives auto-invoke language more weight than passive availability statements.
• aiwg-finder subagent documented as the preferred routing when subagent delegation is available (Claude Code's Task, Hermes's delegate_task, Factory's droid spawn). Keeps the discover transcript out of the parent context.

Hermes integration audit — source-verified against v0.4.0+ (#1239, #1241, #1242, #1243, #1244)

The Hermes integration was the first AIWG provider where our docs needed to be source-verified against the upstream code, not just based on the README/changelog. After fast-forwarding the local Hermes checkout 5,390 commits and reading agent/prompt_builder.py, hermes_cli/mcp_config.py, hermes_cli/commands.py, and tools/delegate_tool.py, five claims were corrected:

Concrete deliverables shipped:

• AGENTS.md is now a 579-byte thin pointer (was 30 KB+ on a typical SDLC deploy) referencing AIWG.md and aiwg discover / aiwg show. Eliminates four warning classes across all 10 AGENTS.md providers (auto-split, spillover, approaches-cap, per-entry sanitizer-rejection).
• .hermes.md twin file diverges from AGENTS.md with a Hermes-MCP-specific suffix pointing readers at artifact-read, aiwg discover/show, and delegate_task instead of the dead-end AIWG.md link (Hermes doesn't auto-load AIWG.md).
• aiwg-orchestrate skill auto-installs to ~/.hermes/skills/ on first deploy. Idempotent on rerun — operator edits preserved. Provides ~95% per-workflow context reduction via delegate_task.
• Hermes Capabilities Reference in the quickstart catalogs 10 capabilities (/kanban, /handoff, ACP adapter, /agents, /goal, /cron, /snapshot, /background, gateway platforms, plugin system) with file:line citations and AIWG composition notes.
• Steward agent gained a "Hermes Composition Reference" routing table for operator-level integration questions.

Per-platform session reload notice (#1240)

Every aiwg use now ends with a "Session reload required:" section that names the action, rationale, and consequence per provider — covering all 10 platforms (claude, codex, copilot, cursor, warp, windsurf, factory, opencode, hermes, openclaw). The notice diagnoses the "Agent type 'X' not found" symptom that occurs when a running session predates the most recent deploy.

The Steward agent's Post-Deploy Session Reload table makes this triage rule explicit: when a user reports "Agent type not found" for an agent that exists on disk, the first move is to check whether their session predates the most recent aiwg use and instruct them to reload accordingly.

aiwg-regenerate promoted to kernel skill (#1245)

The kernel set grew from 9 to 10 self-maintenance ops (steward, aiwg-doctor, aiwg-refresh, aiwg-status, aiwg-help, use, plus the new aiwg-regenerate). Natural-language invocation works for "regenerate my CLAUDE.md" without an aiwg discover round-trip. Per-provider variants (aiwg-regenerate-claude, aiwg-regenerate-codex, etc.) stay non-kernel — the umbrella delegates to them.

Publish pipeline fixes (#1246, #1247)

After rc.27, Gitea Release objects stopped being auto-created and public npmjs.org publishes stopped landing — but CI reported green. Two silent-failure bugs:

• .gitea/workflows/gitea-release.yml: doubly-escaped inline JSON body returned "[]: json: string unexpected end of JSON input" from Gitea, swallowed by || echo "Release may already exist". Rewritten with jq -n JSON construction + explicit HTTP-code handling (201/200 = created, 409 = already exists, anything else = exit 1).
• .gitea/workflows/npm-publish.yml: npm publish ... 2>&1 | tee ... returned tee's exit code (always 0) without set -o pipefail. Added defaults.run.shell: bash at the job level, set -o pipefail to all four publish steps, and refined error-pattern allowlist (drops spurious 403 match).

NPMJS_TOKEN rotation by the operator closed the loop. Every rc tag from rc.38 forward actually creates a Gitea Release and publishes to public npmjs.org.

Architecture overview docs (#1248)

A new canonical docs/architecture-overview.md lands with 8 mermaid diagrams giving the visual mental model:

1. AIWG is a deploy-time tool — runtime-invisible
2. Two-tier skill model — kernel vs standard
3. Discover → show flow (the optional layer)
4. What's optional — Minimal vs Standard vs Full
5. The .aiwg/ lifecycle
6. Hermes context-file priority (first-match-wins)
7. Multi-platform deploy — one source, ten targets
8. Session reload after aiwg use

Cross-linked from docs/how-it-works.md, docs/discovery-and-kernel-skills.md, docs/integrations/hermes-quickstart.md, and the README. Image placeholders at docs/architecture-overview/images/ ready for polished Gemini-generated illustrations — three prompt-set aesthetics (illustrated computing iconography, monospace/terminal, editorial) catalogued on issue #1248 for whatever channel needs them.

Acknowledgements

The 2026.5.0 work was scoped in epic #1033 with companion issues #1034–#1037 (implementation), #1038–#1044 (decisions), #1045–#1052 (parallel design / docs / test). All children resolved.

Late-cycle bug reports from @sebuh-infsol (#107) and the research-papers downstream consumer audit (#105).

Install

# Pre-release (current)
npm install -g aiwg@next         # latest 2026.5.0-rc.X

# Stable (when cut)
npm install -g aiwg              # latest stable

Or use the Claude Code plugin:

/plugin marketplace add jmagly/ai-writing-guide
/plugin install sdlc@aiwg

Reference

• Customization README — Path A / B / C
• Project-local quickstart
• CLI reference
• CHANGELOG entry
• Epic #1033 — full child issue list

Released: 2026-03-25 Type: Major feature release

This release ships across four capability areas: first-class agent identity (SOUL.md), an operational control layer for background orchestration (Mission Control + AIWG self-maintenance), a fully operational autonomous daemon, and a new reactive artifact type (Behaviors). It also promotes Hermes and OpenClaw to first-class deployment targets — OpenClaw being the first platform with native behaviors support. A comprehensive 15-article getting-started guide series rounds out the release.

Highlights

ops-complete Framework

A new framework purpose-built for operational infrastructure — the base layer for sysops, itops, devops, and streamops workflows in AIWG.

Deploy

# Base framework only
aiwg use ops

# With extensions
aiwg use ops --ext sys          # + per-host fleet ops
aiwg use ops --ext sys,it,dev   # Classic trio
aiwg use ops --ext sys,it,dev,stream  # Full stack

YAML-Native Design

ops-complete is the first AIWG framework built natively on the YAML metalanguage. Every ops artifact is a schema-validated YAML document using a Kubernetes-inspired envelope:

apiVersion: ops.aiwg.io/v1
kind: OpsPlaybook
metadata:
  name: deploy-auth-stack
  namespace: production
spec:
  # Desired state (kind-specific)
status:
  # Observed state (executor-written only)

The spec:/status: split is intentional: agents write desired state, executors write observed state. The two never mix.

Kind Vocabulary