v2026.4.0 — Autonomous Systems

Major release: corpus architecture, daemon, Mission Control, behaviors, SOUL.md, OpenClaw, Hermes, ops-complete, and more.

AIWG v2026.4.0 — "Autonomous Systems"

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

What changedWhy you care
Corpus architecture & link validationSkills are now thin context maps — they link into the corpus rather than restating it. `@$AIWG_ROOT/` token resolves correctly in dev repos, npm installs, and custom installs alike. `link-check` skill validates every ref. 1,400+ broken refs fixed.
Composite skillsA skill can be a collection of `@$AIWG_ROOT/` links with minimal framing — the agent decides how deep to follow each one. High reuse, no duplication, context efficiency by design.
aiwg-dev addonFull developer toolkit for building AIWG extensions: `validate-component`, `dev-doctor`, `link-check`, `devkit-*` scaffolding skills.
Skills as canonical extension typeSKILL.md is now the source format. Commands are generated at deploy time for providers that need them. Claude Code and Cursor use skills natively. `aiwg add-command` deprecated in favour of `aiwg add-skill`.
Daemon — fully operational`aiwg daemon-init && aiwg daemon start`. Web UI at localhost:7474. YAML profiles, scheduled tasks, Telegram multi-room, autonomous thinking engine with safety constraints and budget cap, Docker containerization. Cross-session memory persists across restarts.
Mission ControlMulti-loop background orchestration: `aiwg mc start` → `aiwg mc dispatch` → `aiwg mc watch`. Parallel agent loops run as background missions with a live status dashboard. State persists across context resets.
Behaviors — 5th artifact typeBEHAVIOR.md: subscribe to system events (file writes, deploys, schedules) and react automatically. Framework source dirs in all components. `aiwg add-behavior` scaffolding. Deployed to OpenClaw.
Provider-watcherDaemon add-on that watches for provider updates, runs scheduled tasks, and opens PRs automatically when new versions are detected.
SOUL.md — agent identityAgents now have persistent character: worldview, opinions, reasoning traits. Unlike voice profiles (how they speak), soul files encode what they believe. `soul-create`, `soul-enable`, `soul-blend`, four pre-built SDLC agent souls.
AIWG self-maintenance`aiwg sync` — update + redeploy + verify in one command. AIWG Steward agent for complex installation repairs. Self-maintenance rule with CLI-first principle and pre-flight trigger table.
Remote install systemInstall any framework, addon, or extension directly from the registry — no repo clone required.
Project-level `aiwg.config`Per-project provider registry, deployment manifest, and `aiwg run` scripts. Replaces manual provider configuration.
VS Code extension`vscode-extension/` — `@aiwg` Copilot chat participant, MCP auto-config, status bar, sidebar tree, JSON Schema for `aiwg.config.json`. Phase 1 + 2 complete.
Daemon platform tiersTier 1 (native headless: claude-code, opencode, warp, openclaw, codex), Tier 2 (PTY adapter), Tier 3 (unsupported). Formalized in capability matrix.
PTY adapter`aiwg daemon pty start/list/stop` — bridge any Tier 1 TUI over a pseudo-terminal. Sessions persist; `node-pty` is optional.
Contract syntax for skills`requires:`, `ensures:`, `errors:`, `invariants:` on SKILL.md files. `contract-manifest` + `contract-validate` skills catch dependency gaps at wiring time.
`issue-planner` + `induct-research` skillsResearch-grounded SDLC backlog generation with human approval gate. `induct-research` routes findings to Gitea / GitHub / Jira / Codehound.
`human-authorization` ruleAgents must confirm before irreversible or high-stakes implied actions. Recommendation ≠ authorization. HIGH enforcement.
5 OpenProse antipattern rules`god-session`, `vague-discretion`, `context-bloat`, `parallel-then-synthesize`, `implicit-dependencies` — derived from OpenProse research. aiwg-utils now ships 13 rules.
`no-time-estimates` ruleAgent-oriented estimation replacing wall-clock time. aiwg-utils now ships 14 rules.
prose-integration addon complete`prose-detect` + `prose-install` + `prose-resolution` rule. Step 0 detection centralized. 7-skill count. Integration guide.
`[all]` platforms token`platforms: [all]` in agent files replaced at deploy time. No more hardcoded provider lists in grounding agent definitions.
Skill namespace strategyMulti-layer collision prevention: slug prefix + subdir + frontmatter namespace. Per-platform adapters. Collision detection in `use`/`doctor`.
`aiwg serve` + Web DashboardLocal HTTP server, WebSocket PTY bridge, React app with xterm.js terminal, Mission Control UI.
Artifact index: typed edges & filename-metadataCross-graph set queries, citation sidecar parser, filename-derived metadata without content reading.
agentic-installer addon`setup.aiwg.io/v1` SetupManifest YAML language. Script-first multi-platform installation: 11 templates, 3 skills, 1 agent, 2 rules. (#663–#667)
`aiwg-ci-safety` ruleAgents may not touch `.gitea/workflows/` without human authorization. CI templates for users live in `agentic/code/frameworks/*/ci/`. HIGH.
OpenClaw as 10th platformFirst platform with native behaviors support (`~/.openclaw/behaviors/`). `aiwg use sdlc --provider openclaw`. ClawHub package publication documented.
Hermes as first-class platformGraduates from MCP sidecar to `--provider hermes`. Full artifact deployment, 96 skills declare Hermes compatibility, token-optimized AGENTS.md template, MCP sidecar with 5-tool whitelist.
Copilot & Windsurf overhaulsCopilot: agents → `.agent.md`, commands → `.prompt.md`, rules → `.instructions.md` with `applyTo` globs. Windsurf: rules migrate to `.windsurf/rules/` with `trigger: always_on`.
ops-complete frameworkOperational infrastructure framework built on the YAML metalanguage. Kubernetes-inspired envelope. Four extensions: `sys` (fleet/hardware), `it` (CMDB/DR), `dev` (CI/CD), `stream` (streaming infra).
RLM enhancements`quality_gate` per TaskNode, `preferred_model` per node, `chunking_strategy`, `batch_size` for map-reduce. Three new examples. Six AIWG-specific antipatterns documented.
Composable RULES-INDEX hierarchyEach component owns its own `rules/RULES-INDEX.md`. The CLI assembles them at `aiwg use` time. Addon authors no longer edit files they don't own.
aiwg-guide contextual help skill`aiwg-guide` activates automatically when users ask how to use AIWG. Covers all 50 commands, all 9 providers, and links directly into the corpus for deeper reading.
AIWG.md hook file architectureAIWG context decoupled from CLAUDE.md into a toggleable `AIWG.md`. CLAUDE.md shrinks from 488+ lines to a 12-line wrapper. `hook-enable` / `hook-disable` / `hook-regenerate`.
15-article getting-started seriesSeven situation guides, five framework guides, key-addons overview, flow/gate/sdlc-accelerate reference — written in user vocabulary, not framework jargon.
Specification-complete layer (Layer 3 + 4)Elaboration now produces behavioral specs and pseudo-code specs, making construction-phase code generation translation rather than design. 6 new templates, deepened gate criteria, `/flow-use-case-realization` orchestration, 6-layer traceability.
Semantic memory kernelNew `semantic-memory` addon with 5 kernel skills (`memory-ingest`, `memory-lint`, `memory-query-capture`, `memory-log-append`, `memory-log-render`) that any consumer can use by declaring a `memory.topology` contract. Four frameworks migrated; existing skill names + UX preserved via delegation pattern. Per ADR-021.
`llm-wiki` addonThin topology on top of the kernel — 5 page-template profiles (book-companion, personal, research-deep-dive, business-team, generic), Obsidian-native `crossRefStyle: wikilink`, interactive profile picker on `aiwg use llm-wiki`.
`MemoryTopology` contract in manifestsNew schema with `namespace`, `rawSources`, `derivedPages`, `index`, `log`, `crossRefStyle`, `pageTemplate`, `ingestRequires`, `lintRules`. Four `crossRefStyle` values supported. Validated by `aiwg doctor` via `validateMemoryTopology()`. All four core frameworks declare topologies.
Training framework → marketplace plugin`training-complete` extracted to standalone repo at `jmagly/aiwg-training`. Main aiwg shrinks by ~20K lines. Dual-stack: agentic SKILL.md surface + optional Python CLI with JS hooks. 144 tests pass. Install via `/plugin install training@aiwg`. Per ADR-022.
`aiwg session`One command launches a fully-prepared agentic session: version check, doctor, auto-repair, deployment verification, optional MCP injection, then provider launch or IDE instructions. Self-healing by default — falls back through `aiwg sync` → full reinstall → `aiwg feedback` if repair fails.
`aiwg feedback`File GitHub issues from the CLI without leaving the terminal. System context (version, OS, provider, frameworks) collected automatically. Routes through `gh` CLI → browser URL → stdout. Surfaces automatically from `aiwg doctor` on unresolvable issues.
`aiwg serve` WebSocket fixSandbox WebSocket connections were silently 404-ing (`createNodeWebSocket` missing in `@hono/node-server` v1.19.14). Replaced with native Node.js upgrade-event router + `ws` package. `ws` auto-installs on first use.
ADR template: 5 new sectionsSource verification & claim tracking, implementation sketch, concurrency/shared state model, testing strategy, multi-level Definition of Done — the gaps that cause ADRs to be rejected or ignored.

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:

TemplateID PrefixPurpose
State Machine Spec`DES-SM-`Stateful entity lifecycles (states, transitions, guards, entry/exit actions)
Decision Table`DES-DT-`Complex branching logic (2^N rule completeness, simplification)
Activity Diagram Spec`DES-ACT-`Business process flows (swim lanes, fork/join, exception paths)
Method Interface Contract`DES-MIC-`Design-by-contract per method (preconditions, postconditions, invariants)
Data Flow Spec`DES-DFS-`End-to-end data tracing (source → transformation → destination)
Pseudo-Code Spec`DES-PSC-`Language-neutral algorithms (Layer 4)

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:

TierPlatformsCapability
Tier 1claude-code, opencode, warp, openclaw, codexNative headless daemon — runs without a display server
Tier 2claude-code, codexPTY adapter secondary mode — can also drive the TUI
Tier 3copilot, factory, cursor, windsurfUnsupported — requires IDE or display server

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

LayerMechanismCoverage
1 — slug prefix`aiwg-{name}` universal slug for all deployed skill filesAll 10 platforms
2 — subdirectory`aiwg/` subdirectory for platforms that support deep recursion9 of 10 platforms
3 — frontmatter`namespace: aiwg` in SKILL.md frontmatter for MCP SEP-986 alignmentAll 10 platforms
4 — short aliasesOpt-in via `--aliases` flag; suppressed by defaultAll 10 platforms

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:

GroupPlatformsBehavior
A — deep recursionclaude-code, opencode, cursor, warp, openclaw, codex, copilot, factory`aiwg/` subdirectory + `aiwg-` slug prefix
B — one-levelwindsurfFlat deploy with `aiwg-` slug prefix only (no subdirectory)
D — skiphermesNamespace layers skipped; Hermes uses aggregated AGENTS.md instead

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:

SkillPurpose
`prose-detect`7-signal installation detector (env var → config → local → plugin → home → global → not found)
`prose-install`Install OpenProse with confirmation; `npx` → `git clone` fallback
`prose-reader`Read and parse OpenProse documents
`prose-run`Execute OpenProse programs
`prose-validate`Validate OpenProse output
`forme-manifest`Generate forme manifests
`prose-bridge`(rule) Bridge between AIWG and OpenProse runtimes

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):

RuleLevelSummary
`god-session`HIGHAgent with >7 distinct responsibilities must decompose
`vague-discretion`HIGHLoop/gate conditions must be concrete and measurable
`context-bloat`MEDIUMPass file paths not contents; trim excessive background
`parallel-then-synthesize`MEDIUMParallelism is wrong when tasks aren't independent
`implicit-dependencies`MEDIUMSub-agents start clean; pass all context explicitly

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

TypeWhen to use
`script`Known operation — use this first
`detect`Check environment state
`ask`Collect user input
`verify`Post-operation validation
`agentic`Exception handling only
`platform-route`Branch by OS/distro
`chain`Invoke sub-project manifest

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:

ThingLocationPurpose
AIWG's own CI`.gitea/workflows/`Runs tests on this repo — never touch without human authorization
CI templates for users`agentic/code/frameworks/*/ci/`Inert source data deployed via `aiwg use --ci-hooks-enabled`

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