The work,
release by release.

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.6 completes the current Agentic Sandbox integration and lets an AIWG project use an existing artifact corpus outside its repository without moving or overwriting either tree.

What changed

• aiwg artifacts attach --to <path> validates an existing AIWG project, records the external artifact location, and refreshes indexing and sync state.
• Workspace status and build preflight follow .aiwg-location, so attached corpora behave the same way as repository-local artifacts.
• Cockpit exposes the qualified nine-tool Sandbox MCP fleet/activity surface with explicit authorization and completeness evidence.
• Exact Activity v1 schema mirrors and drift tests catch upstream contract changes before they reach Cockpit users.
• The credential-free qualification pins Agentic Sandbox v2026.8.3 and reports unavailable runtime tiers as insufficient evidence, never as a pass.
• All 39 repository-hosted Claude plugins and the marketplace catalog advance to 2026.8.6. The external training plugin remains independently versioned at 1.0.0.

The attach operation is intentionally non-destructive: it does not relocate the project, relocate the artifact corpus, or replace existing files in either location. A target without a valid aiwg.config is rejected.

Verification

The release candidate must pass version and marketplace lockstep validation, Claude plugin metadata/layout checks, TypeScript, the production CLI build, the full automated test suite, release metadata validation, Fortemi index checks, 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. That release does not include external artifact attachment, the nine-tool Sandbox MCP integration, or the exact Activity v1 schema-drift gate delivered here.

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-28 Channel: stable

AIWG 2026.7.22 makes threat assessment an explicit, inspectable project policy and closes the gap between shipping a component and being able to discover an operational driver for it. It also strengthens agentic installation, session history import, and release-publication integrity.

Highlights

• Project-owned threat posture - select off, audit, or enforce, start from documented built-in profiles, or compose project-local rule packs and per-surface overrides without patching framework code.
• One deterministic forge-content engine - issue text, pull-request metadata, diff summaries, review comments, outbound maintainer comments, release notes, and handoff artifacts share the same typed evidence and decision contract.
• Calibrated interruption - negative statements, quoted evidence, documentation, and explicit out-of-scope warnings are distinguished from requested behavior. The issue #1922 secret-storage warning is a passing regression while malicious credential and supply-chain variants remain detected.
• Complete discovery coverage - every shipped operational component must have an indexed driver or an explicit exemption. The LLM Wiki addon now has its missing driver, and CI prevents similar gaps from returning.
• Agentic setup flow - a versioned setup.aiwg.io/v1 contract can inspect, repair, install, deploy, regenerate, index, and verify AIWG across supported providers while preserving source-checkout development mode.
• Stronger release evidence - signed web manifests bind to the signed tag's exact commit, and release CI installs its SQLite test dependency without weakening dependency-age gates.

Configurable threat assessment

Threat assessment now lives under security.threatAssessment in the resolved workspace member's AIWG configuration. Existing projects retain the documented balanced enforcement default. Trusted local projects may deliberately turn off AIWG's classifier, audit-only projects can collect the same findings without policy-driven interruption, and high-assurance projects can require stricter authorization or rejection thresholds.

The engine records policy and profile versions, a stable policy hash, source provenance, matched rule and statement IDs, quoted evidence, severity, configured action, and audit-mode wouldAction. Invalid configuration, unknown rules, cyclic inheritance, unsafe shadowing, and unavailable packs fail closed. Turning AIWG assessment off does not disable provider, hosting-platform, repository-authorization, secret-scanning, or approval controls.

The design is informed by the local NIST AI RMF/control-baseline, OWASP agentic, AgentSpec, deterministic-gate, harness-engineering, trust-calibration, and indirect-prompt-injection research corpus. The documentation uses those sources as design input and does not claim standards conformance.

Capability discovery

The shipped-component inventory is now checked against the framework index. Frameworks, addons, extensions, plugins, and other operational bundles must resolve through an indexed skill, command, flow, rule, agent, or declared driver. The check emits a machine-readable coverage report and blocks CI when a new component has no route.

The LLM Wiki addon is covered by a canonical operational driver with setup, ingest, query, maintenance, and health guidance. This fixes the prior state where the bundle shipped but ordinary capability discovery could not lead an operator to it.

Installation and sessions

The new agentic setup contract gives providers a shared path for installation, repair, upgrade, deployment, indexing, context regeneration, and engagement verification. It diagnoses Node/npm and PATH state, preserves source checkouts unless migration is explicitly approved, and reports evidence instead of assuming a successful install.

Session history imports now retain origin timelines, lifecycle terminal states, and relocation evidence across the normalized session contract. Regression fixtures protect the behavior while keeping provider-owned source histories unchanged.

Package matrix

All three packages are prepared to publish in CalVer lockstep:

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

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

Upgrade

Full local-corpus distribution:

npm install --global [email protected]

Lightweight signed-web distribution:

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

Existing projects remain compatible. The new threat policy is explicit, versioned, and independently documented; provider and repository authorization controls remain in force regardless of the selected AIWG assessment mode.

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-04
Channel: stable (npm install -g aiwg)

This patch release ships the latest Cockpit merged-console work and makes open questions in issue-driven remediation easier to find and close.

Highlights

• Cockpit now includes the merged operator-console slice across Bridge mission projection, unified event snapshots, telemetry, memory, missions, and apps/web compatibility surfaces.
• The address-issues flow now applies a question label when an unresolved question is filed into issue comments, creating the label when needed.
• Once a question is answered to satisfaction, the same flow removes the question label so the tracker reflects only currently open questions.
• Cockpit smoke coverage now works with pathless Fortemi discover results by preserving result names and using the canonical release-flow skill path where a pathful clone check is required.

Upgrade

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

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 improves the agent-facing discovery flow. aiwg discover now fronts stable capability identifiers instead of filesystem paths, offers clear text and JSON formatting controls, and searches a smaller canonical capability index without provider/plugin mirror duplicates.

Highlights

• aiwg discover result objects now 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.
• Default text discovery output is now a readable numbered list with the follow-up aiwg show ... command for each result.
• 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.
• aiwg discover "test" --limit 20 returns distinct capability names from the canonical index instead of repeated mirror copies.

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-03 Channel: stable (npm install -g aiwg)

This release note tracks the Fortemi Core index/search migration. AIWG now uses the static Fortemi Core cache path as the default artifact search/traversal backend while preserving the existing .aiwg/.index local backend behind --backend local for the phase-out window.

What changed

v2 AIWG -> Fortemi export contract

aiwg index export --format fortemi still defaults to the v1 compatibility contract. The new --schema-version v2 option emits AIWG domain records for skills, agents, commands, rules, flows, project-local bundles, research REF/PROF records, KB pages, memory entries, issues, and project artifacts.

The v2 records include search projections, typed relationships with direction, privacy locality, source-body chunks, and embedding metadata slots for the shared Fortemi Core semantic path.

AIWG also keeps a tested v2-to-v1 projection for older Fortemi React consumers. The active @fortemi/[email protected] contract validates the v2 export directly, including v2 relationship fields, chunk metadata, SKOS metadata, and provenance-event metadata.

Default Fortemi Core static cache

aiwg index sync materializes a v2 static export and manifest under .aiwg/.index/fortemi-core/<graph>/. Artifact search, discovery, traversal, hybrid/static semantic query, and research source selection use this cache by default. Operators can pass --backend local to use the legacy local index during the deprecation window.

The npm release package now also carries a prebuilt framework graph cache under prebuilt/fortemi-core/framework/. If no compatible local framework cache exists, default discovery can use that packaged fallback. The packaged cache is a compact metadata/capability projection; local sync remains the source-body/fulltext path.

A synced Fortemi Core cache with zero items is valid, not stale. Queries return empty result sets, aiwg discover reports a Fortemi static-cache no-match hint, and aiwg show does not fall back to the local AIWG corpus unless operators explicitly select --backend local.

Supported Fortemi-backed commands in this preview include:

• aiwg discover / aiwg show
• aiwg index query, including static semantic and filtered hybrid query modes
• aiwg index deps
• aiwg index neighbors
• aiwg index set
• aiwg research-query source selection

Boundary clarifications

Two existing Fortemi-adjacent surfaces remain separate from the Fortemi Core static index/search backend:

• The fortemi storage backend in .aiwg/storage.config is the Fortemi MCP persistence adapter. It can route KB or memory storage through Fortemi MCP tools, but it does not switch AIWG discovery, query, graph traversal, or research-query away from the Fortemi Core static cache.
• Local issue search remains served by the local issue provider and .aiwg/issues/index/issues.index.json. The v2 export can include aiwg.issue records, but aiwg issue list --search does not require or use the Fortemi Core cache in this preview.

Related tracker item #1551 was subsequently completed and closed: source-body chunks and body-level embedding metadata now share the accepted Fortemi v2 contract. #1508 remains deferred and reopens only when both the provider-neutral storage/index boundary is stable and an operator-approved target environment and credential path exists (or a Fortemi/memory-store endpoint is reachable from CI or documented local development). Any implementation must use AIWG storage/MCP. Direct Fortemi REST import and hardcoded-token patterns remain out of scope.

No-regression parity fixtures

The migration includes static parity fixtures that compare the current local backend against the Fortemi static cache for discovery, show, metadata query, fulltext query, static semantic/hybrid query, graph traversal, research REF/PROF retrieval, KB traversal, and v1/v2 export behavior. The research-query executable wrapper now makes source-selection parity testable with the Fortemi Core default while leaving GRADE-aware answer synthesis in the research-query skill workflow.

The suite intentionally keeps equal-score ordering tolerances explicit: exact where behavior is deterministic, membership-only where the current scorer produces equivalent ties.

The release gate also runs npm run ci:fortemi-index, which exercises the discovery matrix against local and Fortemi Core backends, invokes npm pack through prepack, verifies the prebuilt files, manifest checksum, and size ceiling inside the tarball, and proves packaged fallback discovery from an empty local cache.

Fallback

If a Fortemi-backed command reports a missing or stale cache, run aiwg index sync to refresh it, or use --backend local for the legacy fallback:

aiwg index query "retrieval"
aiwg index query "retrieval architecture" --hybrid --type adr --tags search --json
aiwg index query "retrieval" --backend local

To reset the cache:

rm -rf .aiwg/.index/fortemi-core
aiwg index sync --graph project

Do not remove .aiwg/.index/<graph>/; it remains the rollback source.

Fortemi Core 2026.7.1 baseline

@fortemi/[email protected] is now published with the @fortemi/core/aiwg-index subpath, direct v2 AIWG export validation, relationship traversal APIs, chunked-index helpers, and static semantic/hybrid helper contracts. AIWG can use it as the released baseline for the next migration slice.

The Fortemi v2 package-adoption gate is satisfied for the current static export contract. AIWG still keeps package-independent static semantic/hybrid fixtures over the v2 cache so required CI does not depend on optional embedding packages.

Still Gated

Removing the legacy local backend remains gated until the deprecation window closes and rollback evidence is reviewed. Live Fortemi integration tests remain optional and must skip cleanly without credentials.

The legacy fortemi MCP storage adapter remains available for persistence migrations but is deprecated for discovery/search routing. Search callers should use the Fortemi Core default and reserve --backend local for legacy fallback.

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-04-01 Type: Major release Previous stable release: v2026.3.2

This is the first major version milestone since the framework's foundations were laid. v2026.4.0 ships five capability areas simultaneously: a new corpus architecture that turns skills into thin, self-navigating context maps; a full autonomous operations layer (daemon, Mission Control, provider-watcher, behaviors); first-class agent identity (SOUL.md); a remote install system; and a complete platform overhaul covering 10 providers. More than 150 commits since v2026.3.2 went into this release.

Highlights

Specification-Complete Layer

The SDLC framework previously jumped from architecture (Layer 2) to code (Layer 5), forcing agents into design-mode during construction. This release fills the gap with two new layers:

Layer 3 — Behavioral Specifications

Six new templates bridge architecture and implementation:

Layer 4 — Pseudo-Code Specifications

Language-neutral pseudo-code using a fixed keyword set (SET, FUNCTION, FOR EACH, IF, VALIDATE, ON FAILURE) that domain experts can read and verify. One spec per method. Error handling is first-class — every VALIDATE block requires an ON FAILURE handler.

Use Case Realization Orchestration

New /flow-use-case-realization command orchestrates multi-agent spec generation:

Architecture Designer → Realize UC (sequence diagram + contracts)
                     → Parallel reviewers (Security, Test, Domain, Requirements)
                     → Synthesizer → Pseudo-code generation
                     → Traceability matrix

Supports --layer 3|4|both, --guidance, --interactive. Natural language: "realize UC-003", "generate behavioral specs".

Deepened Gate Criteria

• Elaboration gate (ABM) gains section 3a: behavioral specs required for ≥80% of architecturally significant use cases
• Construction entry gains section 8a: pseudo-code specs required for first iteration scope
• check-traceability rewritten for 6-layer enforcement (UC ↔ BS ↔ IC ↔ PC ↔ code ↔ tests) with orphan detection and --fix auto-remediation

Why This Matters

The AIWG thesis is that the final code generation step should be primarily language extraction — translating detailed specifications into a target language — rather than creative problem-solving. Detailed specs enable cheaper execution (smaller models can translate), higher reliability (less reasoning = fewer hallucinations), and deterministic verification (each code artifact traces to a spec that serves as its acceptance criterion).

References: #740–#746

VS Code Extension

vscode-extension/ ships the first two phases of the AIWG VS Code Extension (#623):

Phase 1 — Scaffold + Basic Activation

• Full VS Code manifest (chatParticipants, commands, viewsContainers, views, jsonValidation, configuration)
• Workspace detection and "Initialize AIWG?" prompt on first open
• CLI auto-detect from setting or PATH; run() (silent) and runAsTask() (terminal-visible) invocation modes
• Status bar: installed frameworks + active provider
• Sidebar tree views: Status, Frameworks, and Scripts

Phase 2 — MCP Auto-Config

• Idempotent .vscode/mcp.json writer — respects existing servers
• Wired to aiwg.mcp.autoStart setting and AIWG: Configure MCP command

Also included:

• @aiwg Copilot chat participant with /deploy, /status, /skill, /pipeline, /eval, /productionize routing; LM API path (no CLI required) + CLI fallback
• schemas/aiwg.config.v1.json — bundled JSON Schema for aiwg.config.json (autocomplete + inline validation in editor)
• Smoke tests for activation, commands, and MCP auto-config idempotency
• Brand assets: favicon, logo, 128×128 marketplace icon, activity bar icon

Corpus Architecture

@$AIWG_ROOT/ token system

Every AIWG skill and agent can now reference corpus files using @$AIWG_ROOT/<path>. The token resolves to the repo root in development, $(npm root -g)/aiwg for npm installs, and $AIWG_ROOT for custom installs. This replaces bare @agentic/code/, @src/, @docs/ refs that silently failed in user projects.

Token system supports any environment variable: @$TOKEN/path. Tokens declared in .env at project root.

1,099 bare refs across the entire corpus were migrated. 318 deployment-target .claude/ refs were updated to their corpus equivalents.

Composite skills

A skill can now be a thin collection of links with minimal framing — the corpus documents contain the logic:

## References

- @$AIWG_ROOT/agentic/code/addons/ralph/skills/ralph/SKILL.md — Loop engine
- @$AIWG_ROOT/agentic/code/frameworks/sdlc-complete/skills/issue-list/SKILL.md — Fetch issues
- @$AIWG_ROOT/agentic/code/addons/aiwg-utils/rules/context-budget.md — Parallel limits

The agent follows whichever refs are relevant to the current step. Rules live once, in one place, referenced by many skills. See docs/development/corpus-navigation-guide.md.

.aiwg/ reference contract

Distributable skills may only reference .aiwg/ paths declared in a framework manifest's memory.creates field. Repo-local paths silently fail in user projects. Tier 1 (always present) and Tier 2 (framework-specific) paths are fully documented and enforced by validate-component and dev-doctor.

No-escape rule

There is no backtick or code-block escape for @ references. Every @<path> in a deployed skill is processed as a context-load directive regardless of surrounding markup.

aiwg-dev addon

Developer toolkit for building and validating AIWG extensions:

• validate-component — full PASS/WARN/FAIL link classification per file
• dev-doctor — Section 4 subchecks: .aiwg/ refs, bare legacy refs, .claude/ refs
• link-check — standalone corpus validator with --fix, --report, --fail-on-warn (CI mode)
• devkit-* — scaffolding skills: create-addon, create-framework, create-skill, create-agent, create-command, create-extension

Autonomous Operations

Daemon

aiwg daemon-init scaffolds a YAML profile. aiwg daemon start launches the persistent background process.

• Web UI at localhost:7474 — single-page dashboard, no build step
• YAML profiles — manager default profile; composable configuration
• Scheduled task runner — cron expressions bridge to the supervisor task queue
• Multi-room messaging — Telegram multi-chat with room-scoped routing and task binding
• Autonomous engine — configurable thinking_interval_minutes, max_daily_tasks, budget_cap_usd, require_approval, allowed_actions, blocked_actions
• Cross-session memory — agent memory persists across daemon restarts; episodic + semantic + working memory tiers
• Docker — workspace-as-volume, env var pass-through, web UI from container

Mission Control

Background orchestration for parallel agent loops:

aiwg mc start --name "Sprint 4"
aiwg mc dispatch <id> "Fix auth module" --completion "tests pass"
aiwg mc watch          # live status stream
aiwg mc status         # JSON-ready aggregate
aiwg mc stop <id>      # drain or abort

JSONL event log per session. Persistent at .aiwg/ralph-external/mc/sessions/.

Provider-watcher

Daemon add-on that runs on a schedule: detects provider updates, executes configured tasks, and opens PRs automatically when new versions are detected. Configurable schedules per provider.

Daemon Platform Tiers

Platforms are now classified into three daemon tiers:

Tiers are declared in capability-matrix.yaml (daemon_tier, daemon_pty_adapter) and exposed via getDaemonTier() / daemonCapableProviders() TypeScript helpers.

PTY Adapter

tools/daemon/pty-adapter.mjs bridges any Tier 1 platform TUI over a pseudo-terminal, enabling human, script, or agent driving of interactive sessions:

aiwg daemon pty start claude-code   # spawn Claude Code under PTY
aiwg daemon pty list                # enumerate active sessions
aiwg daemon pty stop <session-id>   # stop a session

• node-pty is an optional dependency — install separately if needed (npm install node-pty)
• Session state persisted to .aiwg/daemon/pty/<sessionId>.json with PID verification
• Stale sessions auto-cleaned on list()
• SIGWINCH forwarded to the PTY on terminal resize

Reconnect note: full session reattach after detach requires the gRPC transport path (tracked in #657, depends on agentic-sandbox#131). Local PTY sessions do not survive detach.

aiwg serve and Web Dashboard

A local HTTP server scaffold for the AIWG web dashboard:

aiwg serve          # start dashboard at localhost (default port)

• WebSocket PTY stream bridge — pipes live terminal output from daemon sessions into the browser
• React app with xterm.js terminal viewer — full terminal emulation in-browser; stream any PTY session without a separate SSH connection
• Mission Control UI — telemetry dashboard with real-time mission status; fortemi-react panel for agent loop monitoring

The server is the foundation layer for browser-based orchestration. Further panels (cost telemetry, artifact explorer, health check) are tracked in follow-on issues.

Behaviors

The fifth AIWG artifact type:

# BEHAVIOR.md
hooks:
  - event: file.write
    pattern: "**/*.ts"
  - event: schedule
    cron: "0 */6 * * *"

Behaviors subscribe to system events and react without user invocation. Framework manifests include behaviors/ source directories. OpenClaw is the first platform to deploy them (~/.openclaw/behaviors/). aiwg add-behavior scaffolds new behaviors.

Platform restriction: Behaviors deploy only to Tier 1 daemon platforms ([claude-code, opencode, warp, openclaw, codex]). All six built-in BEHAVIOR.md files enforce this list. cursor was removed from concierge behavior (Tier 3).

Agent Identity

SOUL.md

Agent soul files encode persistent character — beliefs, reasoning style, opinions — alongside the existing voice profiles (communication style).

aiwg soul-create test-engineer --template sdlc-reviewer
aiwg soul-enable test-engineer
aiwg soul-blend test-engineer security-auditor --output composite

Four pre-built souls ship with sdlc-complete: test-engineer, security-auditor, architecture-designer, requirements-analyst. Soul files deploy as .soul.md companions alongside agent definitions.

Skills as Canonical Extension Type

SKILL.md is now the source format for all AIWG extensions. Commands are generated at deploy time for providers that require them (Factory, OpenCode, Warp, Windsurf, Copilot, Codex, OpenClaw). Claude Code and Cursor receive skills directly.

• aiwg add-command is deprecated — use aiwg add-skill
• userInvocable: false skips command generation for internal skills
• Skills carry triggerPhrases for NL matching and commandHint for command generation
• 56 command definitions converted to skills with full metadata

Install & Configuration

Remote install

Install frameworks, addons, and extensions directly — no repo clone required:

npm install -g aiwg
aiwg use sdlc                    # installs from registry
aiwg use sdlc --provider copilot

Project-level aiwg.config

# aiwg.config
provider: claude-code
frameworks:
  - sdlc
  - research
run:
  dev: aiwg use sdlc --dry-run
  deploy: aiwg use sdlc

Provider registry, deployment manifest, and aiwg run scripts per project. Resolution: AIWG_CONFIG env var → --config-dir flag → ~/.aiwg → ~/.config/aiwg.

aiwg sync

One-command installation sync:

aiwg sync                 # detect → update → re-deploy → health check
aiwg sync --dry-run       # preview changes
aiwg sync --provider warp # target a specific provider

Platform Updates

VS Code Extension (new)

AIWG's first IDE extension deploys as a VS Code marketplace package. See the VS Code Extension section above for full details.

[all] platforms token

Agent .md files can now declare platforms: [all] instead of listing every provider explicitly. The deployer replaces it with the target platform at deploy time:

---
platforms: [all]    # → [claude-code] when deploying to Claude Code
                    # → [codex] when deploying to Codex, etc.
---

Five grounding and diversifier agents were converted. injectPlatform: true option in the base deployer handles replacement.

OpenClaw (new)

10th deployment platform. First with native behaviors support. All artifact types deploy to ~/.openclaw/. ClawHub package publication documented.

aiwg use sdlc --provider openclaw

Hermes (first-class)

Graduates from MCP sidecar to full deployment target. aiwg use sdlc --provider hermes deploys 96 skills, agents, rules, and templates. Token-optimized AGENTS.md template. 5-tool MCP whitelist (~3,000 tokens vs 12,000+ full surface).

GitHub Copilot

• Agents deploy as .agent.md (Markdown body + YAML frontmatter) in .github/agents/
• Commands deploy as .prompt.md in .github/prompts/
• Rules deploy as .instructions.md with applyTo globs in .github/instructions/
• aiwg mcp install copilot generates .vscode/mcp.json

Windsurf

• Rules migrate from .windsurfrules to .windsurf/rules/ with trigger: always_on frontmatter
• Skills deploy to both .windsurf/skills/ and .agents/skills/ for cross-agent compatibility
• .windsurfrules retained as deprecated stub

Skill Namespace Strategy

Skill names collide across 10 platforms with overlapping ecosystems. v2026.4.0 introduces an ADR-driven, four-layer namespace system to eliminate ambiguity without requiring per-project configuration. (#695–#704)

Four layers

Layers 1–3 are always applied. Layer 4 is off by default to avoid introducing the collision surface that layers 1–3 are designed to prevent.

Per-platform deployment adapters

Platforms are grouped by how deeply they support recursive skill directories:

Collision detection

Collision checking is now wired into three CLI entry points:

• aiwg use — detects conflicts before deploying any skill
• aiwg doctor — reports stale or conflicting skill files in health check output
• aiwg validate-metadata — validates namespace fields in SKILL.md frontmatter

CLI command blocklist

A command blocklist prevents AI-generated skill names from shadowing built-in CLI commands. The canonical example: aiwg-sync (a hypothetical skill) vs aiwg sync (the CLI command). Blocked names are checked at aiwg add-skill time and caught by validate-metadata.

SDLC Enhancements

ops-complete framework

Operational infrastructure framework with YAML-native artifact design:

aiwg use ops                              # base framework
aiwg use ops --ext sys                    # fleet/hardware management
aiwg use ops --ext it                     # CMDB, DR, service deployments
aiwg use ops --ext dev                    # CI/CD pipelines
aiwg use ops --ext sys,it,dev,stream      # all extensions

Kubernetes-inspired envelope (apiVersion: ops.aiwg.io/v1). 6 JSON Schema kind definitions. Structured from: references replace template syntax.

RLM enhancements

nodes:
  - id: review
    agent: quality-reviewer
    preferred_model: opus
    quality_gate:
      min_score: 0.8
      max_iterations: 3
    chunking_strategy: semantic-boundary
    batch_size: 25

New examples: rlm-self-refine, rlm-divide-conquer, rlm-filter-recurse. Six AIWG-specific antipatterns documented.

Composable RULES-INDEX hierarchy

Each component owns its own rules/RULES-INDEX.md. The CLI assembles them at aiwg use time. aiwg-utils ships 7 rules; sdlc-complete ships 33. Addon authors contribute rules without editing shared files.

New Skills

issue-planner (sdlc-complete)

Research-grounded SDLC issue planning. Given an objective, issue-planner:

1. Dispatches parallel research agents (best practices, current research, vendor docs)
2. Generates the full SDLC doc corpus with gate checks
3. Produces a prioritized, dependency-ordered issue backlog
4. Requires explicit human approval before filing
5. Outputs the exact address-issues invocation to execute the backlog

Pair with --induct-research to route all references discovered during research into the induct-research skill automatically.

induct-research (research-complete)

The research analogue of address-issues. Accepts any target — file path, directory, URI, named MCP service, or issue reference — then:

• Classifies and analyzes sources in parallel
• Routes filing to Gitea MCP, GitHub CLI, Jira REST, or Codehound based on config
• Supports AIWG_RESEARCH_REPO env var for target repo override

Contract syntax for skills

All SKILL.md files now support formal contract fields:

requires:
  - "Issue list with reproduction steps"
  - "Target codebase read access"
ensures:
  - "Each issue has a committed fix or documented blocker"
errors:
  - "Tests still failing after 3 attempts → escalate to human"
invariants:
  - "Never delete tests to make them pass"

contract-manifest generates a human-readable chain manifest showing data-flow wiring (exact/semantic/unresolved) and an optional Mermaid diagram. contract-validate gives a pass/fail verdict on a skill chain at wiring time — catching missing dependencies before runtime.

prose-integration addon complete

The full prose-integration addon now ships with 7 skills:

All skills share a centralized Step 0 detection via prose-detect. prose-resolution rule enforces the canonical detection protocol. See docs/integration-guide.md for quick-start.

New Rules (aiwg-utils)

human-authorization (HIGH)

Agents must seek explicit human authorization before irreversible or high-stakes actions, especially when those actions are implied by findings rather than explicitly requested.

The five rules:

1. Recommendation ≠ authorization — identifying a problem is not permission to fix it
2. High-stakes categories require confirmation (code deletion, infra changes, public posts, permission changes, mass operations)
3. Task scope is the authorization boundary — don't expand on your own
4. Ask one specific question with concrete options
5. Agents own the gate check — don't rely on system friction to stop you

OpenProse antipatterns (5 new rules)

Derived from the OpenProse research corpus (#617, #648):

aiwg-utils now ships 14 rules (was 7).

no-time-estimates (HIGH)

Wall-clock time estimates are unreliable in AI-assisted development contexts. Human+AI velocity is non-linear and varies with operator skill, model quality, task decomposability, and centaur configuration. The rule bans time-denominated estimates entirely and replaces them with agent-oriented units:

• Scope count — number of atomic deliverables
• Agent count and roles — who is doing what
• Parallelism map — which batches are parallel vs sequential
• Pass estimate — expected iterations to quality gate

Prohibited phrases include "N days/hours/weeks", "expected duration", and "this should be quick". Apply in planning, sprint estimation, phase planning, and in response to "how long will this take?" questions.

Agentic Installer Addon

agentic/code/addons/agentic-installer/ ships the setup.aiwg.io/v1 SetupManifest language — a Kubernetes-style YAML RFC for cross-platform, script-first software installation. (#663–#667) See docs/configuration/setup-manifest.md for the permanent field reference.

Design philosophy

Scripts are the primary artifact. The type: agentic step exists only for exception handling and adaptive recovery — not as a substitute for scripting known installation sequences. A well-written SetupManifest produces shell scripts that run standalone, without AI tooling.

SetupManifest schema

apiVersion: setup.aiwg.io/v1
kind: SetupManifest
metadata:
  name: myapp
  version: 1.0.0

platform:
  os: [linux, macos]
  distros: [ubuntu, debian, fedora]
  arch: [x86_64, arm64]
  shell: [bash, zsh]

params:
  - name: INSTALL_DIR
    type: path
    required: true

prerequisites:
  - detect: "command -v git"
    version_min: "2.30"
    install_hint: "Install git: https://git-scm.com"

steps:
  - id: clone
    type: script
    script: installer/scripts/clone.sh
    verify: "test -d ${INSTALL_DIR}/.git"
  - id: configure
    type: script
    script: installer/scripts/configure.sh
    depends_on: [clone]

recovery_procedures:
  - id: full-reset
    triggers: [clone]
    script: installer/scripts/reset.sh

7 step types

What ships

• JSON Schema — full validation for all step types, platform matrix, params, prerequisites, recovery
• 11 script templates — clone.sh/ps1, install-deps for ubuntu/fedora/macos/windows, configure.sh/ps1, verify.sh, reset.sh, hub-chain.sh
• Lib helpers — detect.sh, params.sh, verify.sh, detect.ps1 sourced by all templates
• setup-generate — discover project artifacts, assemble manifest + script stubs
• setup-run — 6-phase execution with platform detection, dry-run, recovery confirmation gate
• setup-validate — schema + reference checks + agentic-step audit + --fix
• installer-agent — specialized persona for manifest generation, validation, and execution
• installer-safety (HIGH) — 7 mandatory behaviors: show before run, confirm destructive ops, validate before execute, agentic-steps-as-exceptions, params-before-steps, no inline secrets, platform mismatch = skip
• installer-authoring (HIGH) — 5 authoring rules: script-first, always source libs, manifests describe while scripts act, one manifest per unit, every manifest needs recovery

# Generate from project
"generate a setup manifest for this project"

# Validate
aiwg setup-validate setup.manifest.yaml

# Dry run
aiwg setup-run --dry-run

# Execute
aiwg setup-run

Artifact Index Enhancements

aiwg index gains three capabilities that unlock richer cross-artifact analysis. (#723)

Typed edges

Edge extraction is now configurable per-pattern. Edge type metadata flows through the graph so queries can filter and traverse by relationship kind (e.g., depends-on, implements, tests, cites):

aiwg index build --verbose     # shows typed edge extraction progress
aiwg index deps UC-001.md      # traverses typed dependency edges

Citation sidecar parser

Nodes can now be enriched from a companion sidecar file rather than having citations embedded in the primary artifact. The parser reads frontmatter from {filename}.citations.md (or a configured pattern) and merges declared fields into the node:

# UC-001.citations.md
sources:
  - id: NIST-800-53
    url: https://csrc.nist.gov/...
  - id: RFC-9110

This keeps primary artifacts clean while preserving full citation provenance in the graph.

Cross-graph set queries

The query engine now supports set operations across multiple graphs or result sets:

aiwg index query "authentication" --json | aiwg index query --union "authorization"
aiwg index query --intersection "security" "tested"
aiwg index query --difference "requirements" "implemented"

Useful for gap analysis — e.g., requirements not yet covered by tests.

filename-metadata node strategy

A new node ingestion strategy derives metadata from filename patterns without reading file content. Useful for large corpora where content reads are expensive:

strategy: filename-metadata
pattern: "UC-(?P<id>\\d+)-(?P<title>.+)\\.md"
fields: [id, title]

MetadataSupplementConfig

A new config block for merging fields from sidecar frontmatter into existing nodes without replacing them. Supports merge strategies (merge, overwrite, skip-existing) per field.

New Rules (aiwg-dev)

aiwg-ci-safety (HIGH)

New rule added to the aiwg-dev addon to prevent a class of misunderstanding unique to AIWG's dogfooding context: AIWG both builds the framework AND uses it, which creates confusion between AIWG's own CI and CI templates that ship to users.

The two things that look similar but are not:

The rule forbids agents from modifying .gitea/workflows/ without explicit human authorization, and documents that CI templates for target projects live in framework ci/ subdirectories. skill-placement.md and addon-boundaries.md in aiwg-dev were also updated with explicit CI template disambiguation sections.

Semantic Memory Kernel

A new core addon at agentic/code/addons/semantic-memory/ factors the topology-agnostic operations (ingest, lint, cross-reference, contradiction detection, event logging) out of four domain-scoped frameworks and into a shared kernel. Any consumer that declares a memory.topology contract in its manifest.json gets durable ingest, lint, query-capture, and event logging for free.

This was the architectural refactor identified by ADR-021: five of nine semantic-memory primitives were already generic (the artifact index, @-mentions, W3C PROV), three were domain-tinted but liftable, and one — query-to-artifact capture — was genuinely missing. The kernel ships as core: true, autoInstall: true, so every project picks it up on first install.

Kernel skills (5)

• memory-ingest — source → summarized pages written per consumer's pageTemplate; contradiction detection flags inline; cross-references written per declared crossRefStyle
• memory-lint — 8 composed checks: broken mentions, orphan pages, stale claims, missing cross-references, index drift, log integrity, provenance coverage, domain-specific rules
• memory-query-capture — turns query synthesis (comparisons, analyses, gap-findings) into durable pages so explorations compound instead of evaporating into chat history. Three invocation modes: ambient, explicit, skill-chain.
• memory-log-append — writes structured JSON Lines events to .log.jsonl; 10 op types documented (5 kernel: ingest, lint, query-capture, log-render, index-rebuild; 5 training-specific added by aiwg-training)
• memory-log-render — generates a greppable Markdown view (## [YYYY-MM-DD] <op> | <subject> line prefix) from the JSONL stream

The MemoryTopology contract

Each consumer declares a memory.topology block in its manifest.json:

{
  "memory": {
    "topology": {
      "namespace": ".aiwg/research",
      "rawSources": ".aiwg/research/sources",
      "derivedPages": {
        "summary": ".aiwg/research/findings",
        "entity": ".aiwg/research/knowledge/entities",
        "concept": ".aiwg/research/knowledge/concepts",
        "synthesis": ".aiwg/research/synthesis"
      },
      "index": ".aiwg/research/index.md",
      "log": ".aiwg/research/.log.jsonl",
      "crossRefStyle": "at-mention",
      "pageTemplate": "templates/research-page.md",
      "ingestRequires": ["provenance", "grade-quality"],
      "lintRules": ["citation-guard", "link-check", "mention-lint"]
    }
  }
}

Four crossRefStyle values ship: at-mention (AIWG default), wikilink (Obsidian-native, used by llm-wiki), markdown-link (standard), yaml-ref (Dataview-friendly). All four core frameworks now declare topologies.

Backward compatibility

Five existing skills keep their public names and UX but delegate to the kernel under the hood per ADR-021 D5:

• induct-research → memory-ingest --consumer research-complete (GRADE + citation layers stay in the wrapper)
• intake-from-codebase → memory-ingest --consumer sdlc-complete
• workspace-health → memory-lint for every installed framework
• corpus-health → memory-lint --consumer research-complete + GRADE coverage
• cleanup-audit → memory-lint + existing dead-code checks

No workflows break. Existing .aiwg/ artifacts stay valid — opt in to the kernel path per release.

Topology validation

aiwg doctor (and validate-metadata) now runs validateMemoryTopology() against every declared contract. Catches missing required fields, invalid crossRefStyle values, bad namespace (anything not starting with .aiwg/), empty derivedPages, and wrong array types for lintRules/ingestRequires. Runs as a warning pass — agents surface issues without blocking deploy.

LLM Wiki Addon

The LLM Wiki pattern — an LLM-maintained Markdown wiki that compounds as sources are ingested — ships as the first thin-topology addon on top of the semantic memory kernel. No custom mechanics; the addon's value is schema + page templates for domains that don't fit a pre-packaged framework.

Install and pick a profile

/plugin install llm-wiki@aiwg
# or
aiwg use llm-wiki

On install, an interactive prompt offers five topology profiles:

1. book-companion — characters, themes, plot threads, quotes (reading-log style)
2. personal — goals, projects, journal entries, insights
3. research-deep-dive — evolving thesis, evidence map (supporting/contradicting/ambiguous), revision history
4. business-team — meeting notes, decisions, action items, project state
5. generic — minimal default with title, summary, cross-references

Non-interactive: aiwg use llm-wiki --profile book-companion. The selection writes to .aiwg/wiki/config.json so subsequent ingests pick the right template.

Obsidian-native

crossRefStyle: "wikilink" means cross-references render as [[Page Name]] — directly consumable by Obsidian. The addon ships docs/obsidian-integration.md covering Web Clipper for raw source ingestion, Graph View for topology visualization, Dataview for dynamic tables from page frontmatter, and Marp for slide generation.

End-to-end flow

aiwg use llm-wiki --profile personal

# In chat:
# "ingest this article"            → memory-ingest --consumer llm-wiki
# "what do I know about X?"        → aiwg index query ...
# "save this as a page"            → memory-query-capture
# "health check the wiki"          → memory-lint --consumer llm-wiki

Training Framework → Standalone Marketplace Plugin

The training-complete framework — a corpus-to-dataset pipeline for AI training data curation — moved from agentic/code/frameworks/training-complete/ into its own repository at jmagly/aiwg-training. Main aiwg shrinks by ~20K lines; users who don't need training-data workflows get smaller installs.

Install

/plugin install training@aiwg     # Claude Code plugin install
aiwg use training                  # via AIWG CLI

Dual-stack architecture

aiwg-training ships as a marketplace plugin with both layers:

• Agentic surface (15 SKILL.md files, 7 agents) — works out of the box in any AIWG install. AI agents read specs and execute in-context.
• Optional Python runtime (aiwg-training CLI, 14K lines Python, 144 tests) — installed on demand during aiwg use training when the post-install.js hook detects Python 3.10+. The pre-skill.js hook exposes AIWG_TRAINING_BIN so skills can conditionally delegate batch work to the CLI.

Skills degrade gracefully: agent-only mode when Python isn't installed, CLI-delegated mode when it is.

What's in the training framework

15 skills covering the full pipeline: acquire-training-source, example-quality-assess, license-check, example-synthesizer (Self-Instruct, Evol-Instruct, SQuAD, STaR), preference-generator (DPO/KTO/ORPO/SimPO in 3 modes), synthetic-data-generator (Orca, Phi, PersonaHub, STaR, ReST with Model Collapse guard), 5 format adapters (Alpaca, ShareGPT, ChatML, JSONL, Parquet), decontamination-check (against MMLU/GSM8K/HumanEval/HELM/MT-Bench/AlpacaEval), dataset-version, dataset-reproduce, dataset-docs (auto-populated Datasheets/Model Cards/Data Statements), and the flow-dataset-build orchestrator.

Grounded in 485 research REFs; see the training repo README for the full research foundations section.

Architectural decisions

Locked in ADR-022 (10 decisions — framework name, topology, storage model, example granularity, preference pairs, dataset versioning, canonical format, decontamination gate, provenance, synthetic recursion). Published under MIT; dual-hosted privately with public mirror on GitHub.

Eval delegation

aiwg-training detects contamination; actual evaluation execution (running benchmarks against trained models) is delegated to the separate matric-eval project. See docs/matric-eval-integration.md in the training repo.

Bug Fixes

• aiwg use all rule count — reported 1 rule installed regardless of actual count; countDeployedArtifacts was counting .md files on disk; with deployIndexOnly: true only one file (RULES-INDEX.md) exists; fixed with countRules() that parses (N rules — ...) section headers from RULES-INDEX files
• new-project in skills catalog — was not registered in skills.manifest.json; now correctly discoverable via aiwg skills list
• sdlc-accelerate handler — "No handler found" error on aiwg use sdlc completion fixed
• External agent loop startup crash — SemanticMemory/MemoryPromotion constructors received objects instead of path strings; loops appeared to start but were always dead on arrival
• --dangerous flag position — was appended after the prompt string; moved before so it is treated as a CLI flag
• Codex model IDs — gpt-5.3-codex aliases now map to gpt-5.4 canonical IDs; previously caused 404 errors
• OpenCode 1.0.x adapter — event-stream parsing updated for opencode run protocol change; silent output drop on all 1.0.x installs fixed
• Factory command injection — $ARGUMENTS now injected at deploy time; static-only execution silently dropped user input before
• aiwg doctor AIWG_ROOT resolution — resolved from script location instead of hardcoded legacy path; failed on non-standard installs before
• OpenCode deployment writing to non-existent directories — deployment now creates missing directories before writing; previously silently dropped artifacts (#705)
• Windsurf skill deployment — now uses native skill deployment path; experimental label removed (#703)
• Factory, Warp, Copilot recursion depth — corrected to deep-recursion (Group A) per source-confirmed platform research; were previously categorized as one-level (#702, #704)
• CI test coverage — widened to run all non-inference tests; removed redundant Full Test Visibility job that was duplicating results
• 41 skills migrated from commands[] to skills[] — manifests that incorrectly listed skills under commands now use the correct skills key; affected discoverability via aiwg catalog (#706, #707)
• Agent-loop addon — renamed from ralph/ to canonical agent-loop/ path; 5 missing skills registered; aliases added so existing aiwg ralph-* invocations continue to work (#705)

Migration Notes

aiwg.config replaces manual provider config

Previous projects using manual provider configuration should run aiwg migrate-workspace to generate an aiwg.config.

Commands deprecated

aiwg add-command now emits a deprecation warning. Replace with aiwg add-skill — skills generate commands automatically for providers that require them.

AIWG.md hook file

Projects using CLAUDE.md for AIWG context injection should run aiwg migrate-hook to decouple context into a toggleable AIWG.md. CLAUDE.md becomes a 12-line wrapper.

@$AIWG_ROOT/ in custom skills

Any custom skills referencing AIWG corpus files via bare paths (@agentic/code/..., @docs/..., @src/...) should be updated to use the @$AIWG_ROOT/ prefix. Run /link-check to detect all affected refs.

Install / Upgrade

npm install -g aiwg          # fresh install
npm update -g aiwg           # upgrade from v2026.3.x
aiwg sync                    # re-deploy frameworks after upgrade
aiwg doctor                  # verify installation health

What's Next

• PTY adapter gRPC transport (#657) — PTYAdapter.fromSandbox() for container/VM execution modes; depends on agentic-sandbox#131
• VS Code extension Phase 3+ (#623) — Marketplace publishing, inline skill runner, deeper Copilot integration
• Full corpus audit against the new reference contract and thin-skill principle (#639)
• Agentic smithing improvements — AgentSmith and SkillSmith enhancements
• Voice framework v2

Released: 2026-03-27 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

No Template Syntax

ops-complete uses structured from: references rather than {{ }} template syntax. Every artifact is always valid YAML — no parser, no pre-processor.

inputs:
  - name: version
    from: vars.deploy_version
  - name: prev_version
    from: steps.health-check.outputs.current-version

Variable Resolution: 3-Level Maximum

1. Framework defaults — from OpsCapability defaults: section
2. Inventory/group — from OpsInventory group vars:
3. Instance — from OpsPlaybook vars: or OpsTarget host vars:

No deeper nesting. The 21-level Ansible precedence problem does not exist here.

Rules

Extensions

Extensions depend on ops-complete and cannot run standalone. They declare requires: ["ops-complete"] in their manifest.

sys — Per-Host Fleet Operations

Covers hardware, OS, boot chains, fleet documentation. Key rules: sys-hardware-safety (CRITICAL), sys-interactive-gate (HIGH), sys-host-independence (HIGH). Templates: system-spec, canned-process, host-standup. Skills: sys-fleet-inventory, sys-host-audit.

it — Asset Management, CMDB, DR

Covers service deployments, DR runbooks, network state, provisioning. Key rules: it-dr-validation (HIGH), it-service-health (MEDIUM). Skills: it-provision, it-dr-test, it-network-state, it-deployment-lifecycle.

dev — CI/CD Pipelines and Build Automation

Covers fleet-wide tooling, CI builder patterns. Key rules: dev-pipeline-safety (CRITICAL, references CI signal suppression #490), dev-ci-self-contained (HIGH). Skills: dev-ci-builder, dev-pipeline-audit.

stream — Streaming Infrastructure

Covers transcoders, platform integrations, key safety. Key rule: stream-safety (CRITICAL). Skills: stream-health.

Creating Custom Extensions

A valid ops extension requires only an ADDON.yaml manifest:

apiVersion: ops.aiwg.io/v1
kind: OpsExtension
metadata:
  name: netops
spec:
  extends: ops-complete
  description: "Network operations — switch configs, VLAN management, firewall rules"
  version: "1.0.0"
  capabilities: auto-discover

Drop it in agentic/code/extensions/netops/ with any templates, rules, or skills needed. Auto-discovery handles the rest.

AIWG Self-Maintenance

AIWG now maintains itself using its own CLI. Two new commands — aiwg sync and aiwg mc — and a dedicated maintenance agent make routine upkeep automatic.

aiwg sync — One-Command Session Sync

Brings the installation current in a single operation: update package → re-deploy all frameworks → health check.

# Full sync (update + redeploy + verify)
aiwg sync

# Check what would change without making changes
aiwg sync --dry-run

# Sync to a specific provider
aiwg sync --provider copilot

# Re-deploy only, skip the package update
aiwg sync --skip-update --frameworks sdlc

# Machine-readable output for orchestration agents
aiwg sync --quiet

When to run:

• Start of a long orchestration session → aiwg sync --dry-run
• User asks "is AIWG up to date?" → report + offer sync
• aiwg doctor shows errors → aiwg sync
• Deploying to a new provider → aiwg use <framework> --provider <p>

Mission Control (aiwg mc) — Background Orchestration Dashboard

Spawn multiple long-running agent loops, monitor all simultaneously, and react to completions or failures without blocking the primary session.

# Start a named session
aiwg mc start --name "Construction Sprint 4"

# Dispatch missions
aiwg mc dispatch mc-abc "Fix auth service" --completion "tests pass" --priority high
aiwg mc dispatch mc-abc "Add pagination" --completion "paginated responses"
aiwg mc dispatch mc-abc "Write integration tests" --completion "coverage > 80%"

# Monitor
aiwg mc status
aiwg mc watch

# Lifecycle control
aiwg mc pause mc-abc
aiwg mc resume mc-abc
aiwg mc stop mc-abc --drain   # let running missions finish, cancel queued
aiwg mc list

Status dashboard:

◆ MISSION CONTROL — Construction Sprint 4  [mc-abc]
──────────────────────────────────────────────────────
  #    Mission                   Status       Loop   Started
──────────────────────────────────────────────────────
  1    Fix auth service          ✓ DONE       4/10   14:22
  2    Add pagination            ⏳ RUNNING   3/10   14:25
  3    Write integration tests   ⏺ QUEUED     —      —
──────────────────────────────────────────────────────
  3 missions | 1 done | 1 running | 1 queued | 0 failed

Session state persists to .aiwg/ralph-external/mc/sessions/ and survives context resets. --json output is machine-readable for programmatic orchestration polling.

AIWG Steward Agent

The @aiwg-steward agent handles complex maintenance tasks: full health check + repair, cross-provider deployment, version sync. Invoke directly when aiwg doctor identifies issues that need multi-step resolution.

@aiwg-steward: run full health check
@aiwg-steward: deploy all frameworks to copilot
@aiwg-steward: ensure latest version deployed

MC Conductor Agent

The @mc-conductor agent orchestrates inside a Mission Control session — dispatches missions from work items, monitors completions, handles failures, and reports aggregate status. The right companion for large parallel construction phases.

Hermes — First-Class Platform

Hermes graduates from an integration experiment to a full deployment target on equal footing with the other 8 platforms.

Deploy to Hermes

aiwg use sdlc --provider hermes
aiwg use rlm --provider hermes

Architecture

Hermes Agent (host)
  ├── Conversation, memory, sessions
  ├── Built-in tools (40+)
  ├── Skills (~/.hermes/skills/)
  └── MCP connection
        └── AIWG MCP Server (sidecar)
              └── .aiwg/ artifacts, workflows, templates

Hermes owns conversation flow and persistent memory. AIWG owns workflow execution and artifact output. MCP is the seam.

Platform Coverage

• 96 skills declare platforms: [claude-code, hermes]
• 17 Claude-specific skills (Task tool, .claude/ paths) correctly declare platforms: [claude-code]
• Hermes-specific templates at agentic/code/frameworks/sdlc-complete/templates/hermes/

Token-Optimized Setup

A 5-tool MCP whitelist keeps AIWG's context footprint to ~3,000 tokens (vs. 12,000+ with the full surface). On a 12GB VRAM model with 32K context, this is the difference between 81% and 54% of context available for actual work.

# ~/.hermes/config.yaml
mcp_servers:
  aiwg:
    command: "aiwg"
    args: ["mcp", "serve"]
    tools:
      include: [workflow-run, artifact-read, artifact-write, template-render, agent-list]

Two-Model Strategy

Qwen 3.5 9B has the best tool-call accuracy of any open-weight model at this scale. Use delegate_task(model="ollama/qwen3.5:9b") to route coding tasks while keeping conversation on hermes3.

delegate_task Skill

The aiwg-orchestrate skill reduces parent context overhead by 95% vs direct MCP calls (~200 tokens vs 3,000–8,000).

See docs/integrations/hermes-quickstart.md for the full setup guide.

CLI UI Modernization

All CLI commands now use a shared display module (src/cli/ui.ts) built on chalk, ora, and cli-table3.

What changed

• Brand mark ◆ in AIWG indigo — consistent identity in terminal output
• Spinner-based progress indicators during async operations
• Structured table output for status and list commands
• Quiet mode (--quiet) on any command that supports it — emits clean JSON for orchestration agents and CI
• TTY/CI detection — graceful degradation when color is unavailable
• rule(), success(), info(), warn(), error(), dim() — consistent semantic output across all 49 commands

SOUL.md — Agent Identity Files

SOUL.md files give agents persistent identity: worldview, opinions, character traits, calibration examples. Unlike voice profiles (tone and style), SOUL.md encodes what an agent believes and how it reasons.

Commands

/soul-enable architecture-designer    # Create .soul.md companion
/soul-status                          # Check status across deployed agents
/soul-validate <path>                 # Validate completeness
/soul-disable architecture-designer  # Disable without deleting

Skills

soul-enhance architecture-designer.soul.md           # Enhance incomplete soul
soul-apply --agent security-auditor --content draft.md  # Apply identity to generation
soul-blend test-engineer.soul.md security-auditor.soul.md --strategy weighted
/voice-to-soul voices/technical-authority.md         # Generate soul from voice profile
/soul-to-voice architecture-designer.soul.md         # Extract voice from soul

Pre-built souls

Four SDLC agents ship with authored soul files:

• test-engineer — skeptical, integration-first, distrusts mocks
• security-auditor — assume breach, defense in depth, never trust inputs
• architecture-designer — systems thinker, monolith-first, explicit trade-offs
• requirements-analyst — assumption surfacer, always asks why, documents what's deferred

AIWG.md Hook File Architecture

AIWG context is decoupled from your provider config file into a dedicated AIWG.md loaded via an @-link directive. CLAUDE.md shrinks from 488+ lines to a 12-line wrapper.

/hook-enable      # Add @AIWG.md directive to your config file
/hook-disable     # Remove directive without deleting AIWG.md
/hook-status      # Show hook state across all 8 providers
/hook-regenerate  # Rebuild AIWG.md from installed framework fragments
/migrate-hook     # Migrate existing full-inject installation

AIWG.md is assembled from contextContributions.hookFragment entries in each installed framework's manifest. Install SDLC, run hook-regenerate, and AIWG.md updates automatically.

Agent Intelligence

Constraint Learning from Feedback (#146)

Agents accumulate domain constraints from structured reviewer feedback. FeedbackCollector records per-agent feedback, clusters recurring errors, and proposes versioned constraints at .aiwg/feedback/{agent}/. Constraints are proposed automatically when a pattern appears 3+ times.

Domain Grounding Agents (#184)

Four pre-built agents inject verified domain knowledge into reasoning chains:

40% domain accuracy improvement on specialized claims.

Quality and Metrics Infrastructure

Four new TypeScript modules with full unit test coverage:

Model Evaluation Suite (#433)

Evaluate any Ollama or cloud model for AIWG compatibility before deploying agents.

npx tsx tools/eval/src/index.ts qwen3.5:9b --backend ollama --verbose
npx tsx tools/eval/src/index.ts claude-haiku-4-5-20251001

6 dimensions, scored pass/fail thresholds: tool-use, instruction-following, coding, structured-output, reasoning, context-handling.

YAML Metalanguage Schemas (#447)

JSON Schema definitions for declarative AIWG definitions. Foundation for 40–60% token reduction when fully adopted.

agentic/code/frameworks/sdlc-complete/schemas/metalanguage/
├── flow.schema.json
├── agent.schema.json
├── rule.schema.json
└── skill.schema.json

Hybrid Artifact Addressing (#187)

Artifacts in .aiwg/ can now be referenced by file path or semantic URN from the same query interface.

@.aiwg/requirements/UC-001.md    # explicit path
@?"authentication flow"          # semantic search
@#security                       # tag filter
@elaboration:sad                 # phase:type filter

Sub-100ms query performance via in-memory index built from frontmatter.

Other Additions

• Verbalized sampling addon (aiwg use verbalized-sampling) — content-diversifier agent, 3 prompt strategies, diversity-awareness rule (#20)
• native-ux-tools rule — agents prefer platform-native interaction tools; platform capability matrix; fallback to formatted markdown (#448)
• Local/Ollama as first-class provider — Ollama on equal footing with cloud providers; local model support documented (#434)
• aiwg index enhancements — flexible graph types, deploy next-steps, verbose mode (#426)
• Community model testing guide — contribution guide for community model testing (#435)
• Skills CLI subsystem (src/skills/) — aiwg skills list|search|install|info; adapters for local, clawhub, and openclaw registries; SkillResult and SkillInstallResult types; full unit tests (#539)
• User-level config (src/config/) — aiwg config get|set|list|validate|reset|path; resolution order: AIWG_CONFIG env var → --config-dir flag → ~/.aiwg → ~/.config/aiwg; unit tests (#545)
• Ops workspace registry (src/ops/) — aiwg ops list|add|remove|switch|status; manages ops.yaml for workspace definitions and cross-repo wiring; unit tests (#544)
• MCP registry (src/mcp/registry.{ts,mjs}) — MCP server registry with install/list/remove and multi-provider resolution; unit tests
• ADR: skills as canonical extension type — decision record at .aiwg/architecture/adr-skills-canonical-extension-type.md

Fixes

• Factory provider — $ARGUMENTS and argument-hint now injected at deploy time; static-only execution silently dropped user input before (#454)
• commit-and-push — oversized prompt trimmed; local model docs added (#436)
• aiwg index stats without --graph — no longer crashes when graph flag is omitted (#425)
• SnapshotManager API mismatch — fatal crash on External agent loop execution resolved (#424)

RC5 Changes

Three fixes and two features found during RC4 testing.

External agent loop silently dying on startup

aiwg ralph "..." appeared to work — it printed a PID and loop ID — but aiwg ralph-status immediately showed no running loops and no output was ever produced.

Root cause: SemanticMemory, MemoryPromotion, and MemoryRetrieval constructors each take a string path as their first argument. orchestrator.mjs was calling them with { storagePath: path } objects instead. path.join() threw "path argument must be of type string", crashing the background process within seconds of startup. Because the PID was already written to the launcher registry before the crash, status checks saw the dead process, marked it failed, and the default status filter (running only) hid the entry entirely.

Fix: pass the path string directly to all three constructors.

--dangerous flag was passed after the prompt

buildAgentArgs() was appending the provider's dangerous flag (--dangerously-skip-permissions, --full-auto) after the prompt string. This meant the binary received:

claude "<prompt>" --dangerously-skip-permissions

instead of:

claude --dangerously-skip-permissions "<prompt>"

The flag was silently ignored because most CLIs stop flag parsing once a positional argument is seen. Fixed: dangerous flag is always inserted before the prompt.

Incorrect provider configs for Hermes and OpenCode

Hermes was registered with binary: 'hermes', implying a spawnable CLI that does not exist. Hermes is a model series accessible via ollama run hermes3 or through an MCP sidecar — not a standalone CLI. Updated to binary: null with a guidance message pointing to those paths.

OpenCode's promptPrefix was missing ['run'], so invocations were sending opencode "<prompt>" instead of opencode run "<prompt>". Fixed.

MCP sidecar integration for all 8 providers (#503–#510)

Full integration guides, config templates, and install targets added for every provider:

Docs at docs/integrations/{provider}-mcp-sidecar.md. Minimal + full config templates in agentic/code/frameworks/sdlc-complete/templates/{cursor,opencode,warp,windsurf}/.

aiwg ralph --attach and aiwg ralph-attach

Agent loops now support an attached watch mode:

# Launch and stay attached — output streams to your terminal
aiwg ralph "Fix all failing tests" --completion "npm test passes" --attach

# Re-attach to a running loop from any terminal session
aiwg ralph-attach
aiwg ralph-attach --loop-id ralph-fix-all-failing-tests-abc123

# Detach without stopping the loop
# Press Ctrl+C — loop keeps running in background

Output is read from the loop's daemon-output.log and polled every 250 ms. Ctrl+C detaches cleanly and prints the status/re-attach/abort commands.

RC4 Changes

• README homepage overhauled: SEO improvements, six-component deep dive, full 90+ research citation list with GRADE-sorted ordering, fixed nav anchors, external platform links
• Welcome page platform table aligned: Hermes and Local/Ollama entries simplified to match other entries; all 10 platforms linked to vendor sites

RC2/RC3 Critical Fixes

Four issues surfaced during RC2 and RC3 testing that would have made the release effectively unusable for new installs. All resolved before the stable tag.

aiwg sdlc-accelerate had no handler

The first command new users are directed to after aiwg use sdlc returned "No handler found for command: sdlc-accelerate". The CLI entry existed in every help screen but the dispatch table had no matching handler.

SdlcAccelerateHandler is now implemented in src/cli/handlers/sdlc-accelerate.ts. It spawns Claude Code with the /sdlc-accelerate skill interactively, forwarding any arguments the user passes.

aiwg use sdlc --provider hermes exited with "Unknown provider"

Hermes graduated to first-class platform in this release, but the deploy script (deploy-agents.mjs) and the use command handler (use.ts) still had no knowledge of it. Running aiwg use sdlc --provider hermes exited immediately with an error.