AIForceCLI 2.0

AIForceCLI 2.0 is a local command center for governed agentic software engineering. It lets developers use AIForce routing, FinOps, governed skills, delegation, summaries, replay, race, policy, context safety, architecture drift checks, PR evidence, dashboards, workbench orchestration, and handoff workflows from inside Claude Code, Codex, OpenCode, Aider, Antigravity, AIForce Local, or a normal terminal.

It is intentionally separate from the original aiforcecli repository. This package ships its own aiforcecli binary plus the replicated AIForce execution engine, a command-center chat UX, a local telemetry dashboard, and a standalone web workbench.

Why It Exists

Running one coding agent inside another agent as a foreground shell command is a poor experience. The host agent waits, nested CLIs can hang, and the user loses visibility.

AIForceCLI 2.0 fixes that by making delegation spawned and inspectable:

Claude Code or Codex
  -> /aiforcecli delegate codex "fix this bug"
  -> AIForce writes .aiforce/runs/<id>/
  -> AIForce spawns the delegated work separately
  -> host agent gets a run id immediately

Install

Global install for end users:

npm install -g aiforcecli
aiforcecli setup all

Local development install:

cd C:\Users\demo\aiforcecli2.0
npm install
npm run build
npm link --force
aiforcecli setup all

Verify:

aiforcecli --help
aiforcecli status

Core Commands

aiforcecli init
aiforcecli chat
aiforcecli health
aiforcecli health fix
aiforcecli coach "build a safe modernization plan for this repo"
aiforcecli coach show
aiforcecli coach run --agent claude-code --model sonnet
aiforcecli skills "triage this production bug and prepare a PR"
aiforcecli skills show
aiforcecli skills learn
aiforcecli route "summarize this repository" --route bayesian --cheap-first
aiforcecli advise "fix failing tests" --route bayesian --explore --seed 42
aiforcecli finops "summarize this repository"
aiforcecli models
aiforcecli models add opencode "openrouter/opencode big pickle" --tier 3 --input 0 --output 0 --global
aiforcecli agents
aiforcecli bench --clean
aiforcecli scorecard show
aiforcecli policy init
aiforcecli policy check "add auth middleware" --agent codex
aiforcecli context scan
aiforcecli context scan details
aiforcecli context health
aiforcecli improve
aiforcecli verify suggest
aiforcecli verify run
aiforcecli learn
aiforcecli pr status
aiforcecli pr ready --run-verify
aiforcecli pr evidence --comment
aiforcecli pr review 8
aiforcecli pr merge 8 --yes
aiforcecli claude "inspect this repo" --preflight-only
aiforcecli codex "summarize this repo" --preflight-only
aiforcecli run "summarize this repo" --agent opencode
aiforcecli run "summarize README" --agent aiforce-local --model qwen
aiforcecli architecture quickstart
aiforcecli architecture show
aiforcecli architecture check
aiforcecli architecture reset
aiforcecli delegate auto "fix the failing tests" --route deterministic --finops
aiforcecli status latest
aiforcecli logs latest
aiforcecli result latest
aiforcecli explain latest
aiforcecli governance latest
aiforcecli dashboard
aiforcecli workbench
aiforcecli summary today business
aiforcecli export-summary md today audit

Quick Start: The Agentic Engineering Loop

A new developer does not need to learn every command first. AIForceCLI now presents the core workflow as a simple loop: coach, run, verify, learn, and govern.

| Step | Command | What it does | Example | | --- | --- | --- | --- | | 1. Coach | aiforcecli coach "<task>" | Turns a raw request into a file-backed PromptSpec with guardrails, model hint, evidence requirements, and a verification plan. | aiforcecli coach "modernize this service safely" | | 2. Run | aiforcecli coach run or aiforcecli run "<task>" | Executes with routing, policy, Context Firewall, FinOps, replay, and evidence capture. | aiforcecli coach run --agent claude-code --model sonnet | | 3. Verify | aiforcecli verify suggest / aiforcecli verify run | Finds or runs the smallest meaningful validation command and records proof. | aiforcecli verify run "npm test" | | 4. Learn | aiforcecli learn | Shows local usage, model choices, verification habits, cost patterns, and next improvements. | aiforcecli learn | | 5. Govern | aiforcecli health / aiforcecli context scan | Explains readiness, risky context, policy, architecture drift, and evidence posture. | aiforcecli health fix |

Inside aiforcecli chat, the same loop is available as /coach, /run, /verify, /learn, and /health. The command center also accepts normal task text directly. Examples:

build a responsive HTML page that calculates loan EMI
scan for prompt injection
switch to cheapest safe model
summarize today for a CIO

Agent Policy Manager

Policy Manager gives the bridge a local governance layer without a server. Start with the wizard, store the policy in .aiforce/policy.json, and then apply it to route, advise, delegate, heal, or replay commands.

aiforcecli policy init
aiforcecli policy templates
aiforcecli policy reset
aiforcecli policy show
aiforcecli policy check "add oauth login" --agent codex
aiforcecli delegate auto "add oauth login" --route deterministic --policy standard-dev
aiforcecli policy audit

Built-in templates: open-dev, local-safe, standard-dev, regulated, infra-restricted, and read-only-review. Policies can restrict agents, block sensitive files such as .env and keys, require approval for dependency/auth/database/infra/production work, enforce per-run budget caps, and keep a local audit trail. Use open-dev when you want no restrictions and audit logging only. Use aiforcecli policy reset to move the current repo policy back to open-dev. Model choice remains owned by AIForce routing.

Replicated aiforcecli Policy Enforcement

This package also exposes a bridge-packaged aiforcecli binary that uses the replicated chat engine in this repo. That binary auto-detects .aiforce/policy.json and enforces it before agent execution in run, chat, pr, and race.

aiforcecli policy init
aiforcecli run "write a html file to add two numbers" --agent codex --model gpt-5.4-mini
aiforcecli chat

Inside chat, use /policy, /policy show, /policy audit, or /policy <name>. A read-only policy will stop write/change tasks for approval before any coding agent starts.

Routing Modes From Slash Commands

Bridge mirrors the AIForceCLI Chat routing controls:

aiforcecli route "fix failing tests" --route deterministic
aiforcecli route "summarize this repo" --route bayesian --cheap-first
aiforcecli route "compare approaches" --route bayesian --explore --seed 42
aiforcecli delegate auto "fix failing tests" --route deterministic

Use delegate auto when the spawned native agent and model should follow the route decision exactly. The bridge writes the selected route to .aiforce/route.json, then the spawned script launches the native agent with the selected model, for example:

codex --model gpt-5.4-mini "Read .aiforce/runs/<id>/handoff.md ..."
claude --model sonnet "Read .aiforce/runs/<id>/handoff.md ..."
aider --model deepseek --message "Read .aiforce/runs/<id>/handoff.md ..."
agy -p "Read .aiforce/runs/<id>/handoff.md ..." --dangerously-skip-permissions --model gemini-3-flash

Spawned Delegation

delegate now spawns by default. It does not block Claude Code, Codex, OpenCode, Aider, or Antigravity.

aiforcecli delegate codex "review and fix this implementation"

Output includes:

AIForce Delegate
  status  spawned terminal
  run     r-20260717123000-ab123
  agent   codex
  handoff .aiforce\runs\r-...\handoff.md
  log     .aiforce\runs\r-...\agent.log
  next    aiforcecli status r-...

Run files are written under:

.aiforce/runs/<run-id>/handoff.md
.aiforce/runs/<run-id>/status.json
.aiforce/runs/<run-id>/agent.log
.aiforce/runs/<run-id>/result.json
.aiforce/runs/<run-id>/run.ps1

Use foreground mode only when running directly from a normal terminal and you want blocking behavior:

aiforcecli delegate codex "summarize this repo" --foreground

Slash Command Setup

Recommended one-time global setup after install:

aiforcecli setup all

This installs user-level command packs under your profile, for example:

%USERPROFILE%\.claude\commands\aiforce.md
%USERPROFILE%\.codex\commands\aiforce.md
%USERPROFILE%\.codex\skills\aiforce-bridge\SKILL.md
%USERPROFILE%\.opencode\command\aiforce.md
%USERPROFILE%\.aider\commands\aiforce.md
%USERPROFILE%\.antigravity\commands\aiforce.md
%USERPROFILE%\.agy\commands\aiforce.md

Per-repo install is still available if you want project-local command files:

aiforcecli install-commands all --force

Claude Code, Codex, OpenCode, Aider, and Antigravity get command/reference packs such as:

/aiforcecli route "summarize this repository" --route bayesian --cheap-first
/aiforcecli models
/aiforcecli agents
/aiforcecli bench --clean
/aiforcecli scorecard show
/aiforcecli delegate auto "fix the failing test" --route deterministic
/aiforcecli status latest
/aiforcecli logs latest
/aiforcecli summary today business

The command templates tell host agents to call the global aiforcecli binary and to treat delegation as spawned work, not a nested foreground agent run. Repo-local .aiforce/ state is still created automatically on first use.

Discoverable Host Commands

aiforcecli setup all now installs both the generic /aiforce command and separate visible commands for each capability:

• /aiforce-init [options] - Initialize repo-local AIForce Bridge context files.
• /aiforce-status [runId|latest] - Show bridge state or spawned-run status.
• /aiforce-route <task> [--route deterministic|bayesian] [--cheap-first] - Recommend an agent/model and write .aiforce/route.json.
• /aiforce-advise <task> [--route deterministic|bayesian] [--cheap-first] - Recommend an agent/model without running work.
• /aiforce-finops <task> [--model model] - Estimate FinOps token savings for a task.
• /aiforce-bench [--clean] [--by-task] [--since 7d] [--json] - Show local agent/model leaderboard from history.
• /aiforce-models [--json] - List AIForce models, tiers, pricing, install, and allow-list status.
• /aiforce-scorecard [show|fetch|generate|update] [--json] - Show or manage generated public-prior scorecards.
• /aiforce-agents [--json] [--enable id] [--disable id] - List installed agents or enable/disable an agent.
• /aiforce-switch <agent|auto> [task] [--model model] - Switch active bridge target agent and write handoff context.
• /aiforce-handoff <agent> [task] - Write .aiforce/handoff.md for a target agent.
• /aiforce-delegate <agent|auto> <task> [--route strategy] [--model model] - Delegate work to a spawned native agent/run.
• /aiforce-logs [runId|latest] [--tail lines] - Show recent log output for a spawned run.
• /aiforce-result [runId|latest] - Show result JSON or final status for a spawned run.
• /aiforce-stop [runId|latest] - Stop a spawned run wrapper process.
• /aiforce-attach [runId|latest] - Open a terminal tailing a spawned run log.
• /aiforce-install-commands [agent|all] [--force] - Install AIForce command pack into the current repository.
• /aiforce-setup [agent|all] [--target path] [--no-force] - Install AIForce command packs globally.
• /aiforce-heal <task> [--agent id] [--model model] [--finops] - Run a task with self-healing enabled.
• /aiforce-replay <task> [--agent id] [--model model] - Run a task with replay cache reuse enabled.
• /aiforce-race <task> [--agents ids] [--verify cmd] - Race agents through AIForce and compare outcomes.
• /aiforce-summary [today|session] [business|technical|handoff|audit] - Summarize current session or today.
• /aiforce-export-summary <md|doc> [today|session] [style] - Export a summary report.
• /aiforce-open <agent> [task] [--dry-run] - Open a native agent with current AIForce handoff prompt.
• /aiforce-coach <prompt> - Improve a prompt before running it.
• /aiforce-skills <task|list|show|learn> - Recommend/adapt a governed workflow pack for the current agent session.
• /aiforce-health [fix] - Explain agentic-readiness score and cleanup commands.
• /aiforce-improve - Show local workflow recommendations.
• /aiforce-context-health - Show current repo context health.
• /aiforce-verify [suggest|run] [command] - Suggest or run validation and capture evidence.
• /aiforce-profile - Show local developer usage profile.
• /aiforce-claude [task] [--preflight-only] [--context-override] - Launch Claude Code through AIForce preflight.
• /aiforce-codex [task] [--preflight-only] [--context-override] - Launch Codex through AIForce preflight.

Agent Handoff Files

Bridge keeps continuity in local files:

.aiforce/current.md
.aiforce/handoff.md
.aiforce/route.json
.aiforce/last-result.json
.aiforce/summary.md
.aiforce/runs/<run-id>/...

A delegated agent gets a focused handoff with:

• task
• target agent/model
• repository
• previous active task
• previous summary
• changed files
• next instruction

Source-Answer Handoff For Good Prior Turns

Cross-agent handoff now carries more than file names and keywords. When the previous turn completed with good quality and the next user request clearly refers to that prior answer, AIForce includes a compact source answer in the handoff packet.

Example flow:

summarize the CICS app in business terms
ok create a PDF that explains this functionality in detail --agent claude-code --model sonnet

In this case the second agent receives:

• the newly resolved task
• the previous agent and target agent
• prior quality
• relevant files/context
• a bounded source-answer excerpt from the previous good response

Benefit: the next agent does not have to rediscover or guess what "this functionality" means. This improves continuity for business-document generation, technical writeups, PDF/deck creation, follow-up implementation, and review workflows. Weak or failed prior answers are not propagated as source context, which reduces the chance of carrying forward poor output.

Recommended UX From Claude Code, Codex, Aider, Antigravity, Or OpenCode

1. Route first:

/aiforcecli route "modernize this module" --cheap-first

2. Delegate without blocking:

/aiforcecli delegate codex "modernize this module and run tests"

3. Inspect:

/aiforcecli status latest
/aiforcecli logs latest
/aiforcecli result latest

4. Summarize for humans:

/aiforcecli summary today business
/aiforcecli summary session technical

AIForce Dashboard

AIForce Bridge includes a local governance dashboard that is installed with the npm package. It runs fully on the developer machine, binds to localhost by default, and reads all previous AIForce runs, sessions, telemetry, FinOps, policy, context firewall, architecture, audit, and spawned-run artifacts.

aiforcecli dashboard

Useful options:

aiforcecli dashboard --no-open
aiforcecli dashboard --port 8787
aiforcecli dashboard --host 127.0.0.1
aiforcecli dashboard --cwd C:\Users\demo\clicoboltest

Default scope is machine-wide local AIForce history, not only the current repo. The dashboard reads:

• the local usage/session SQLite DB
• .aiforce/runs/<run-id>/status.json, agent.log, result.json, handoff.md, identity.json, access.json, and explanation.md
• .aiforce/audit.jsonl
• .aiforce/policy.json and .aiforce/policy-audit.jsonl
• .aiforce/context/findings.json and sanitized-context.md
• .aiforce/architecture/intent.json, rules.json, and drift.json
• global bridge events from ~/.aiforcecli/bridge-events.jsonl

Dashboard sections:

| Section | What it shows | | --- | --- | | Overview | total runs, cost, projects, sessions, tokens, blocked/failed count, latest runs, posture summary, top agents/models, and risks needing attention | | Runs | all historical runs with project/date/agent/status filters and run drilldown | | FinOps | cost and token trends, cache usage, spend by agent/model, and most expensive runs | | Telemetry | run health, mode mix, status mix, agent/model activity, and trend graphs over time | | Policy | active policy, policy audit, thresholds, restrictions, approvals, and blocked decisions | | Context Firewall | latest scan, compact decision state, findings, sanitized context, profile/config, and detailed evidence links | | Architecture | architecture intent, rules, drift score, drift findings, baselines, and ADR evidence | | Workflow Skills & Audit | skills pack recommendations, context capability evidence, governance audit, and bridge event history | | Sessions | persistent chat sessions with turn-level drilldown and cost attribution | | Evals & Bench | race/eval runs and leaderboard-style usage signals |

Click any run row to drill into the run detail: task, agent/model, status, cost/tokens, log tail, handoff file, result JSON, explanation packet, identity, access envelope, context firewall result, policy, architecture drift, and governance audit evidence. The dashboard is also the local tracing and logging surface: it reads agent.log, result.json, status.json, bridge events, governance audit events, FinOps usage records, and chat sessions so a user can move from an executive metric to the exact run evidence.

The dashboard also includes a natural-language question panel for common operational questions such as failed runs, expensive runs, agent usage, model usage, governance posture, and recent activity. It answers from local telemetry rather than sending data to a remote service.

Security defaults:

• binds to 127.0.0.1 by default
• opens a random available port by default
• does not upload telemetry
• reads local AIForce artifacts and usage DB
• --no-open is available for headless or demo environments

AIForce Workbench

AIForce Workbench is a separate localhost web UI for interactive agent work. The dashboard is for observing historical runs and governance posture; the workbench is for planning, routing, executing, and inspecting new governed agent tasks.

aiforcecli workbench
aiforcecli workbench --no-open
aiforcecli workbench --port 8790
aiforcecli workbench --host 127.0.0.1

Workbench capabilities:

| Capability | What it does | Benefit | | --- | --- | --- | | Natural-language task entry | Accepts a developer or business task in a browser form. | Makes AIForce usable without memorizing slash commands. | | Plan generation | Creates a step plan before execution, including discovery, governance, route, run, verification, and evidence steps. | Makes agent work understandable before it starts. | | DAG-style run graph | Shows task nodes for context, policy, architecture, route, agent execution, verification, and evidence. | Gives users a visual map of what happened and what is pending. | | Agent/model routing | Uses the same routing engine as the CLI command center, including explicit agents, auto-routing, cheap-first, FinOps, and budget constraints. | Keeps web and CLI decisions consistent. | | Governed execution | Applies policy checks, Context Firewall, architecture drift checks, and skill/tool guard evidence before agent execution. | Prevents the web UI from bypassing local guardrails. | | Logs and evidence tabs | Shows plan, agents, files, logs, governance, and evidence in separate inspector tabs. | Avoids raw wall-of-text output while keeping drilldown available. | | Run artifacts | Writes workbench state under .aiforce/workbench/ and run evidence under .aiforce/runs/<run-id>/. | Makes web runs auditable like CLI runs. |

Use the workbench when demonstrating orchestration to a CTO/CIO: enter a task, show the generated plan, explain the route decision, run the task, then drill into logs, governance, and evidence. Use the dashboard after the run to show aggregate telemetry, cost, model usage, and audit history across previous runs.

Verification

npm run typecheck
npm run build
npm test
npm pack --dry-run

License

Proprietary / UNLICENSED.

Latest Governed Agentic Engineering Features

This bridge now includes a local-first governance layer for agentic software engineering. The goal is to let a developer keep the speed of Claude Code, Codex, OpenCode, Aider, Antigravity, and local models while adding controls that enterprises normally expect from a central platform: policy checks, context safety, audit evidence, architecture drift detection, identity, and safe delegation.

Context Firewall

The Context Firewall scans repository context before agents consume it. It detects prompt injection, secret-exfiltration instructions, workflow manipulation, tool abuse, skill hijacking, hidden/control characters, suspicious encoded payloads, and hostile instructions embedded in repo files, markdown, tickets, logs, or agent instruction files.

aiforcecli context scan
aiforcecli context scan details
aiforcecli context scan --profile strict
aiforcecli context scan --changed
aiforcecli context sanitize
aiforcecli context details
aiforcecli context report
aiforcecli context show
aiforcecli context set --profile regulated --include . --exclude node_modules,dist,.git,.aiforce --max-files 3000 --sanitize
aiforcecli context wizard

Chat equivalents:

/context scan
/context scan details
/context details
/context report
/context show
/context set --profile strict --include . --exclude node_modules,dist,.git --max-files 3000

Important behavior:

• aiforcecli context scan and /context scan with no path scan the whole repo by default.
• Normal scan output is a compact red/amber/green decision table.
• aiforcecli context scan details, aiforcecli context details, /context scan details, and /context details show the full evidence report.
• --configured uses saved include paths instead of whole-repo scanning.
• Findings are written to .aiforce/context/findings.json.
• Sanitized findings are written to .aiforce/context/sanitized-context.md.
• Runtime artifacts such as old AIForce logs and orchestration artifacts are classified as review-only evidence unless they contain truly dangerous active instructions.
• The scanner is local and deterministic; it does not call a model.

Runtime Context Enforcement

The Context Firewall is now enforced before agent execution. This closes the bypass where aiforcecli context scan could detect a hostile file, but a later coding-agent run could still read it.

Protected execution paths:

• aiforcecli handoff
• aiforcecli delegate
• aiforcecli race
• aiforcecli heal
• aiforcecli replay
• replicated aiforcecli run
• replicated aiforcecli chat
• replicated aiforcecli race

If the scan is blocked, AIForce stops before launching the agent and prints a compact red/amber/green decision table:

AIForce Context Firewall  BLOCKED

+-------------------+------------+---------+--------------------------------------+
| Area              | Risk       | Count   | Decision                             |
+-------------------+------------+---------+--------------------------------------+
| Overall           | red        | 4       | agent run blocked                    |
| Blockers          | red        | 1       | must fix or override                 |
| Review            | amber      | 3       | review evidence; not blocking        |
| Runtime artifacts | amber      | 2       | old AIForce/agent logs; review only  |
| Scanned           | info       | 228     | files checked                        |
+-------------------+------------+---------+--------------------------------------+

Blocking evidence
  - agents.md:3 secret-exfiltration (agent-instruction)

Next: fix blocking files or rerun with --context-override. Full evidence: aiforcecli context scan details

Override is explicit and audited:

aiforcecli delegate codex "summarize this repo" --context-override
aiforcecli run "summarize this repo" --context-override

Inside chat:

/context-override on
/context-override off

When override is used, the audit trail records the override and handoff messages point agents to sanitized context instead of silently trusting raw hostile context.

Developer Intelligence Layer

AIForceCLI 2.0 now includes a developer-intelligence layer for teams that want better agent usage even when developers keep working inside Claude Code, Codex, OpenCode, Aider, Antigravity, or their normal terminal. The goal is to improve the developer's agent workflow without forcing every task through the AIForceCLI chat UI.

| Command | What it does | Why it matters | | --- | --- | --- | | aiforcecli coach "<prompt>" | Scores a prompt, classifies the task, shows guardrails, recommends a model for the current surface, and returns a copy-ready prompt. | Gives developers a safer plan before execution and better output from the same agent. | | aiforcecli improve | Reviews local AIForce usage patterns and recommends workflow improvements. | Turns usage history into practical coaching rather than only logs. | | aiforcecli context health | Summarizes context-firewall status, risky repo instructions, stale context, and verification readiness. | Shows whether the repo is safe and clear for agents before work starts. | | aiforcecli verify suggest | Detects likely validation commands and recommends an optional independent verifier agent/model. | Reduces unverified AI-generated changes and makes second-agent review easy for important work. | | aiforcecli verify run [command] | Runs a suggested or explicit verification command and records evidence. | Makes verification visible and repeatable. | | aiforcecli learn / aiforcecli profile | Shows a local developer profile: agent usage, verification behavior, context warnings, and next-best improvements. | Gives individual developers a feedback loop for improving agentic engineering habits. | | aiforcecli claude / aiforcecli codex | Launches the native agent with AIForce preflight and evidence capture. | Developers keep the agent UI they already like while AIForce adds governance. |

Wrapped native launches write evidence under .aiforce/developer/wrapped-runs/<run-id>.json and lightweight events under .aiforce/developer/events.jsonl. This makes the local workflow measurable without requiring a central server. After closing a native Codex or Claude session launched through AIForceCLI, show post-run evidence with:

dir .aiforce\developer\wrapped-runs
aiforcecli profile
aiforcecli verify suggest
type .aiforce\developer\wrapped-runs\<run-id>.json

The wrapped-run JSON records the native agent, command used, exit code, context status before launch, changed files when detectable, verification suggestions, and launch errors if any. This proves that developers can keep using native Claude/Codex while AIForceCLI adds a governed preflight and local evidence trail.

Typical use from inside an agent:

/aiforcecli coach "refactor this service safely"
/aiforcecli context-health
/aiforcecli verify suggest
/aiforcecli learn

PR Workflows: Review-Ready Evidence Before Merge

AIForceCLI now includes local-first PR governance for AI-assisted development. It assumes the normal developer workflow: clone the repository, make or review changes locally, verify them, then use GitHub for PR review and merge. GitHub operations use the GitHub CLI (gh), so developers keep their existing GitHub authentication and permissions.

aiforcecli pr status
aiforcecli pr ready --run-verify
aiforcecli pr evidence
aiforcecli pr evidence --comment
aiforcecli pr open --title "Fix login timeout"
aiforcecli pr review 8
aiforcecli pr merge 8
aiforcecli pr merge 8 --yes

| Command | What it does | Enterprise value | | --- | --- | --- | | aiforcecli pr status | Shows branch, remote, dirty state, upstream, GitHub auth, and open PR status. | Makes local PR readiness visible before an agent or reviewer acts. | | aiforcecli pr ready [--run-verify] | Scores readiness using git state, context scan, changed-file risk, verification detection, and optional verification execution. Writes .aiforce/pr/last-evidence.md. | Creates consistent evidence before review instead of relying on agent claims. | | aiforcecli pr evidence [--comment] | Prints the latest evidence or posts it to the current GitHub PR. | Gives reviewers a concise audit trail: what changed, what was checked, and what remains risky. | | aiforcecli pr open --title "..." | Creates a GitHub PR with AIForce evidence included in the body. | Standardizes AI-assisted PR handoff. | | aiforcecli pr review [number] | Reads PR metadata, mergeability, checks, reviews, and changed-file count through gh. | Gives a fast governance snapshot without merging. | | aiforcecli pr merge [number] | Refuses to merge without explicit approval. | Prevents accidental or agent-triggered merges. | | aiforcecli pr merge [number] --yes | Merges only after the user gives strict approval. | Keeps the final production-impacting action human-controlled. | | aiforcecli pr "<task>" --agent codex | Legacy create-flow: branch, run an agent task, verify, commit, push, and open a PR. | Keeps the older one-command PR builder available. |

A simple demo flow:

gh pr list
gh pr checkout 8
aiforcecli pr status
aiforcecli pr ready --run-verify
aiforcecli pr evidence
aiforcecli pr evidence --comment
aiforcecli pr review 8
aiforcecli pr merge 8
aiforcecli pr merge 8 --yes

Inside AIForceCLI chat, use the same workflow with /pr:

/pr status
/pr ready --run-verify
/pr evidence --comment
/pr review 8
/pr merge 8
/pr merge 8 --yes

Inside Claude Code or Codex command packs, use /aiforcecli:pr ... or /aiforce-pr .... The PR commands are governance commands, not delegated agent reasoning commands. For a deep Codex or Claude review, ask the agent separately, for example: review PR 8 for merge readiness. Do not merge. --agent codex.

Prompt Coach Is Now Plan + Guard

aiforcecli coach is now the first step in the developer loop. It does not run the task. It creates a compact coaching card that helps the developer understand the work before handing it to Claude Code, Codex, OpenCode, Aider, Antigravity, or AIForceCLI chat.

aiforcecli coach --surface claude-code "build a frontend HTML application that shows NASDAQ current live ticker"

Default output includes:

• prompt score with red/amber/green status
• detected task type, such as read-only analysis, implementation, security review, architecture, migration, or governance
• current surface, for example Claude Code or Codex
• model hint limited to that surface, such as Claude haiku/sonnet/opus or Codex GPT model options
• context guardrail status from the context firewall
• verification guidance
• copy-ready prompt with scope, context hygiene, verification, and final-response expectations

Explicit modes remain available:

aiforcecli coach "..." --agent-card    # compact coach summary plus ready prompt
aiforcecli coach "..." --prompt-only   # raw improved prompt body
aiforcecli coach "..." --brief         # legacy prompt-improvement brief

Benefit: developers get a repeatable pre-work habit: understand the task, see the right guardrails, choose an appropriate model, and then execute with a stronger prompt.

When used from host-agent slash commands such as /aiforcecli:coach, AIForceCLI runs coach in agent-card mode so Claude/Codex returns a compact coach summary, model hint, guardrails, and the ready prompt together.

Improve And Context Health Refinements

aiforcecli improve and aiforcecli context health now handle brownfield repositories more accurately.

• Nested README files are detected, such as cics-genapp/README.md or base/src/README.md.
• Missing root README is treated as optional guidance when nested docs exist.
• Historical .aiforce/runs/*, workbench, replay, telemetry, and agent log artifacts are treated as informational unless they contain active dangerous instructions.
• Active repo context such as CLAUDE.md, AGENTS.md, skills, command files, and external issue/ticket context remains higher priority.

aiforcecli improve
aiforcecli context health

Benefit: real enterprise repos with nested apps and historical agent artifacts get a more accurate readiness score and less noisy governance guidance.

Agent Policy Manager

Agent Policy Manager is a repo-local policy layer stored in .aiforce/policy.json. It controls allowed agents, sensitive files, command categories, risk levels, budget thresholds, and approval requirements before work starts.

aiforcecli policy init
aiforcecli policy templates
aiforcecli policy show
aiforcecli policy check "write a python script"
aiforcecli policy audit
aiforcecli policy reset

Templates:

• open-dev: no restrictions, audit-only default for open development.
• local-safe: read-mostly local work with safer defaults.
• standard-dev: normal application development controls.
• regulated: stricter controls for sensitive or regulated work.
• infra-restricted: stronger gates for infrastructure changes.
• read-only-review: summaries, audits, reviews, and explanations only.

Model control is intentionally not part of policy. Routing already owns model choice, so policy focuses on what an agent may do, not which model should be selected.

Local Identity, Access Envelopes, And Audit

AIForce Bridge creates a local identity profile and per-run governance evidence so a developer can show who delegated work, which agent acted, what task was requested, and what local permissions envelope was created.

aiforcecli identity init --user apoorv --email [email protected]
aiforcecli identity
aiforcecli audit --limit 30
aiforcecli access latest
aiforcecli governance latest
aiforcecli explain latest

Generated evidence includes:

• .aiforce/audit.jsonl: local governance events.
• .aiforce/runs/<run-id>/identity.json: run identity, owner, agent, model, task, and status.
• .aiforce/runs/<run-id>/access.json: files, commands, and network envelope.
• .aiforce/runs/<run-id>/capability-envelope.json: skill/tool trust envelope.
• .aiforce/runs/<run-id>/explanation.md: explanation packet with task, identity, context firewall result, architecture drift result, changed files, result summary, and rollback note.

Context Capability Surface

Context scan now includes the capability surface that used to be shown separately. One command answers the developer question: is this workspace safe for an agent to read and use?

aiforcecli context scan
aiforcecli context scan details

The compact scan uses red/amber/green rows for six areas:

| Area | What it covers | Typical decision | | --- | --- | --- | | 1 Instructions | CLAUDE.md, AGENTS.md, repo instructions, skill/command files | Review or block if instructions try to override the user or hide actions. | | 2 Prompt injection | Ignore-previous-instructions, skill hijack, tool hijack, prompt override text | Review or block depending severity/profile. | | 3 Secrets/data | Secret-exfiltration requests, telemetry bundles, credential harvesting, encoded payloads | Block direct secret access; review lower-confidence exposure. | | 4 Workflow/tools | Skip tests, suppress changed files, dangerous shell/network/deploy commands | Review or block unsafe workflow manipulation. | | 5 Capabilities | Claude commands, Codex skills, OpenCode commands, MCP/tool references, shell/browser/git surfaces | Show capability count and whether discovered capabilities need review. | | 6 Runtime artifacts | AIForce logs, historical agent outputs, workbench artifacts, prior run files | Usually review-only so historical logs do not create false blockers. |

Detailed evidence is available with aiforcecli context scan details. Capability discovery now runs inline as part of context scan and per-run evidence packets; there is no separate skills scan or skills wizard registry flow.

Architecture Drift Guard

Architecture Drift Guard lets the developer define intended architecture locally, then scan the repo for drift against that intent. It is designed for brownfield enterprise code where static diagrams go stale and agent-generated changes can quietly bypass architecture boundaries.

aiforcecli architecture init
aiforcecli architecture wizard
aiforcecli architecture show
aiforcecli architecture set --system payments --style layered-service --include src,app --exclude node_modules,dist,.git,.aiforce --owners apoorv --max-files 2000
aiforcecli architecture layer api --paths src/routes/**,src/controllers/** --may-depend-on service
aiforcecli architecture rule --id routes-no-db --from src/routes/** --to database|prisma|typeorm --severity high --reason "Routes must not access DB directly"
aiforcecli architecture approval package.json
aiforcecli architecture baseline
aiforcecli architecture check
aiforcecli architecture drift
aiforcecli architecture adr

Outputs are stored under .aiforce/architecture/ and include intent, rules, current scan snapshots, drift reports, and ADR drafts.

Chat And Terminal UX Improvements

The replicated chat UX now includes practical terminal-quality improvements for long agent sessions:

/cls
/clear
/clear-screen
/spinner auto
/spinner ascii
/spinner off

Recent visual behavior includes:

• animated AIForce welcome sequence with the triangle logo
• compact command-center header for policy, context, architecture, skills, routing, FinOps, and cost posture
• colorized route, handoff, agent, result, and FinOps cards
• summarized changed-file output instead of large file dumps
• wait-state messages that show useful progress labels while slow agents are starting or thinking
• /cls support inside chat to clear long transcripts without restarting the session

Benefit: rich governance does not have to make the CLI feel heavy. The UX keeps core session state visible while preserving more room for chat and reducing scroll fatigue.

Bridge Slash Commands For Host Agents

aiforcecli setup all installs global command packs for Claude Code, Codex, OpenCode, Aider, and Antigravity. The generic /aiforce command and capability-specific commands can call the same bridge functionality from inside the host agent UX.

Examples:

/aiforcecli models
/aiforcecli route "summarize this repo" --cheap-first
/aiforcecli context scan
/aiforcecli policy check "add oauth login"
/aiforcecli architecture check
/aiforcecli context scan
/aiforcecli delegate auto "fix failing tests" --route bayesian --finops
/aiforcecli status latest
/aiforcecli logs latest
/aiforcecli summary today business

For hosts that do not support true custom slash commands, the command packs instruct the agent to run the global aiforcecli binary and return compact AIForce-style output.

Spawned Native-Agent Delegation

aiforcecli delegate now spawns native agent work instead of nesting one CLI inside another. This avoids the bad UX where Claude Code or Codex waits forever while another foreground agent runs inside its shell.

aiforcecli delegate auto "fix the failing tests" --route bayesian --cheap-first
aiforcecli delegate codex "summarize this repository" --model gpt-5.4-mini
aiforcecli delegate claude-code "review this implementation" --model sonnet
aiforcecli delegate aider "fix the bug" --model deepseek
aiforcecli delegate antigravity "inspect this module" --model gemini-3-flash

The bridge writes .aiforce/runs/<run-id>/handoff.md, launches the target native agent with the selected model where supported, and returns immediately with run id, status path, log path, and handoff path.

Replicated AIForceCLI Chat Engine

The bridge package includes a replicated aiforcecli binary so the same local governance controls can be used directly from the chat UX without modifying the original aiforcecli repo.

Supported inside the replicated chat engine:

• routing and cheap-first
• FinOps prompt optimization
• persistent sessions
• cross-agent task continuity
• /summary and /export-summary
• policy commands
• context firewall commands
• context capability evidence commands
• architecture drift commands
• identity, access, audit, governance, and explanation commands
• runtime context blocking and /context-override

Explanation Packets

Explanation packets turn a completed run into a reviewable governance artifact. They answer what was requested, which agent/model acted, what evidence files exist, what changed if captured, what the result was, and how to review or roll back the work.

aiforcecli explain
aiforcecli explain latest
aiforcecli explain r-20260717151249-4qj2s
aiforcecli governance latest

AIForce now supports two run formats:

• governance-native runs with .aiforce/runs/<run-id>/explanation.md
• existing bridge/delegate runs with .aiforce/runs/<run-id>/status.json, result.json, handoff.md, and agent.log

If explanation.md is missing, AIForce synthesizes a packet from the available run files instead of reporting runs none. This makes the feature useful for older spawned delegate runs as well as newer governed runs.

Benefit: teams get a lightweight audit and handoff artifact without depending on hidden model reasoning. The packet is evidence-based and points to local files that can be inspected.

Replicated Chat Governance Parity

The bridge-packaged aiforcecli binary is intended to expose the same relevant governance controls from persistent chat, shell, and host-agent command packs. Current replicated chat coverage includes:

• policy visibility and enforcement
• context firewall scan, report, sanitize, and override
• skills workflow recommendations and context capability evidence
• architecture intent, rules, drift, baseline, and ADR creation
• identity, audit, access, governance, and explanation views
• summary and report export
• cross-agent continuity with source-answer handoff
• /cls screen clearing and visual command-center state

Benefit: a developer can start from the chat UI, a native agent UI, or a shell command and still get the same local governance artifacts under .aiforce/.

Summary And Report Export

Bridge and chat can summarize work across the current session or today and export it for stakeholders.

aiforcecli summary today business
aiforcecli summary session technical
aiforcecli export-summary md today audit

Chat equivalents:

/summary today business
/summary session technical
/summary handoff
/export-summary md today audit

Styles:

• business: outcomes, value, risk, and cost.
• technical: files, tests, implementation details.
• handoff: what the next agent or person needs to know.
• audit: who, what, when, status, and cost.

In-Agent Command Packs

aiforcecli setup all installs command packs for Claude Code, Codex, OpenCode, Aider, and Antigravity where supported. Claude-style hosts expose slash commands such as /aiforce-coach, /aiforce-verify, and /aiforce-profile. Namespaced command installs can also expose /aiforcecli:<command> forms, for example /aiforcecli:coach, /aiforcecli:skills, /aiforcecli:verify, /aiforcecli:health, and /aiforcecli:models.

When using AIForce from inside another agent, ask the host agent to show the raw AIForce output exactly if it summarizes too aggressively. The recommended prompt is: Show raw AIForceCLI output exactly as returned.

Latest 2.0 Feature Additions

The latest build adds a simpler developer UX while preserving the full governed engineering surface.

| Feature | What changed | Example | | --- | --- | --- | | Adaptive command center | Chat now foregrounds the loop: /coach, /run, /verify, /learn, /health, with recommendations based on policy, context, architecture, FinOps, and evidence posture. | Start aiforcecli chat, then type /center or a normal task. | | Health score | aiforcecli health explains the current agentic-readiness score in plain English; health fix lists cleanup commands. | aiforcecli health fix | | File-backed coach | Coach creates .aiforce/coach/last-ready-prompt.md, so long prompts do not need copy/paste. coach show, coach run, and coach refine operate on that saved prompt. | aiforcecli coach "build a migration plan" then aiforcecli coach run --agent codex | | PromptSpec prompt design | Coach uses structured sections: intent, deliverable, evidence, functional and non-functional requirements, edge cases, scope, security controls, acceptance criteria, verification, and completion report. | aiforcecli coach show | | Model-aware governed skills | aiforcecli skills <task> selects a primary workflow, composes supporting skills, adapts to the repo, writes .aiforce/skills/current-workflow.md, generates .aiforce/skills/runs/<run-id>.json, and creates Claude/Codex native agent files when supported. | aiforcecli skills "review this PR for security and database performance" | | PR workflows | Local-first PR readiness, evidence generation, GitHub review, evidence comments, PR open, and strict merge approval are available from shell, chat, Claude Code, and Codex. | aiforcecli pr ready --run-verify; /pr review 8; aiforcecli pr merge 8 --yes | | Skills simplification | Old skills scan, skills wizard, and registry trust flows were removed. Capability discovery now lives inside context scan. | aiforcecli context scan details | | Context capability evidence | Context scan now covers six areas: instructions, prompt injection, secrets/data, workflow/tools, capabilities, and runtime artifacts. | aiforcecli context scan | | Architecture quickstart/reset | Architecture guardrails can be generated automatically for Node/Next, generic layered repos, and COBOL/CICS-style repos. Mistakes can be removed with reset. | aiforcecli architecture quickstart; aiforcecli architecture reset | | Red/amber/green architecture UX | architecture show and architecture check explain drift, rules, sensitive files, and business impact in clearer tables. | aiforcecli architecture check | | OpenCode adapter | OpenCode is a built-in coding-agent adapter and command-pack target alongside Claude Code, Codex, Aider, Antigravity, and AIForce Local. | aiforcecli run "summarize this repo" --agent opencode | | AIForce Local | Local Ollama-backed models can be used through the same routing, governance, and evidence flow. | aiforcecli run "summarize the README" --agent aiforce-local --model qwen | | FinOps savings card | FinOps explains savings across repo-map scoping, local preparation, compact output, semantic cache, and output budget. | aiforcecli finops "summarize this repo for a CIO" | | Dashboard and tracing | The dashboard reads local SQLite usage, sessions, runs, policy, context, architecture, FinOps, audit, and bridge events for all-time/local scope views. | aiforcecli dashboard | | Workbench orchestration | Workbench is the browser surface for plan, route, governed execution DAG, logs, files, governance, and evidence. | aiforcecli workbench |

Governed Skills: Repo-Adapted, Model-Aware Engineering Workflows

aiforcecli skills <task> is the lightweight way for developers to use best-practice agentic engineering workflows without learning a large command catalog. The command does not create a separate manual marketplace experience. It keeps the UX simple:

/skills <task> -> yes/no -> /verify -> /learn

The important difference is that AIForce skills are not generic prompt snippets. Each built-in skill is a governed SkillSpec with structured execution rules:

| SkillSpec part | What it controls | Why it matters | | --- | --- | --- | | Intent and category | What engineering work this skill is for. | Helps average developers start with the right workflow. | | When to use / not use | Trigger and exclusion guidance. | Prevents using a bug-fix workflow for a security review or release action. | | Repository evidence needed | Files, commands, tests, docs, architecture, policy, and context signals to inspect. | Stops agents from guessing and makes answers reviewable. | | Workflow steps | Ordered engineering process. | Standardizes how work is done across teams. | | Non-functional requirements | Maintainability, reliability, accessibility, performance, security, and operator impact. | Raises the baseline beyond simply making code compile. | | Edge cases | Empty, invalid, boundary, unavailable, permission, and failure paths. | Improves production readiness and reduces missed cases. | | Human approval gates | Actions that need approval before proceeding. | Keeps auth, secrets, deployments, migrations, PRs, and publish actions under human control. | | Eval rubric | Checks the final work must satisfy. | Lets /verify and reviewers judge outcomes consistently. | | Model policy | Cheap-first discovery, balanced implementation, stronger review, and escalation triggers. | Controls cost while reserving stronger models for risky work. | | Completion report | Required final evidence. | Makes agent output usable for review, audit, handoff, and learning. |

How /skills Works

When a developer runs aiforcecli skills "<task>", AIForceCLI performs five actions:

1. Classifies the work against the 25 built-in engineering workflow packs.
2. Selects a primary skill and composes supporting skills when the task crosses domains.
3. Adapts the workflow to the repository using local evidence such as package scripts, source directories, docs, CI files, policy, architecture intent, context scan, capabilities, and verification command.
4. Writes a ready workflow to .aiforce/skills/current-workflow.md and structured evidence to .aiforce/skills/runs/<run-id>.json.
5. If the command runs from Claude Code or Codex, creates project-scoped native agent definitions with model hints so the host agent can use stronger read-only reviewers where supported.

Example:

aiforcecli skills "review this PR for security and database performance risk"

Expected recommendation:

Primary skill:
  Code Review Gate

Supporting skills:
  Secure Code Review
  Database Migration Guard
  Performance Investigation
  PR Builder

Model-aware flow:
  1 Discovery          cheap/fast model
  2 Implementation     balanced coding model when edits are needed
  3 Independent Review stronger model for security, architecture, database, production, or release risk
  4 Verification       deterministic local proof first, then summarize evidence

Native Claude Code And Codex Support

AIForce keeps the flow inside the current agent session. It does not force a nested foreground CLI. Where supported, it writes project-scoped host-agent definitions:

.claude/agents/aiforce-explorer.md
.claude/agents/aiforce-reviewer.md
.claude/agents/aiforce-security-reviewer.md
.codex/agents/aiforce_explorer.toml
.codex/agents/aiforce_reviewer.toml
.codex/agents/aiforce_security_reviewer.toml

These files carry model guidance:

| Phase | Claude Code guidance | Codex guidance | Default behavior | | --- | --- | --- | --- | | Discovery | Haiku | Low-cost Codex model, low reasoning | Read-only repo mapping. | | Implementation | Sonnet | Balanced coding model | Main agent performs scoped edits. | | High-risk review | Opus | Stronger reasoning model | Security, architecture, production, database, release, and privacy checks. | | Verification summary | Haiku or current model | Low-cost model unless proof conflicts | Deterministic local command remains primary. |

If the host does not support native subagents or custom agent files, the workflow still works as guidance for the current agent.

Skill Evidence And Learning Loop

Every recommendation writes local evidence:

.aiforce/skills/current-workflow.md
.aiforce/skills/last-recommendation.json
.aiforce/skills/last-run.json
.aiforce/skills/runs/<run-id>.json

/verify updates the latest skill run record with the command, pass/fail status, exit code, and duration. /skills learn then shows whether skills are being tied to proof or only being recommended.

This is the enterprise value: skills become measurable operating practice, not one-off prompts.

Governed Skills Pack Catalog

aiforcecli skills list shows 25 built-in workflow packs. They cover the common SDLC work types an enterprise engineering team needs.

| Pack | Best for | Example task | Enterprise control | | --- | --- | --- | --- | | Repo Onboarding | Understanding a repo with evidence | aiforcecli skills "summarize this repo for a new developer" | Read-only evidence and source citation. | | Task Coach | Turning vague work into an executable workflow | aiforcecli skills "make this modernization task clear" | Converts raw tasks into structured execution. | | Bug Triage with Tools | Reproduce, diagnose, fix, and prove bugs | aiforcecli skills "fix this timeout exception" | Requires root cause and verification evidence. | | Failing CI Doctor | CI/build/test failures | aiforcecli skills "diagnose this GitHub Actions failure" | Avoids broad CI rewrites without evidence. | | Scoped Implementation | Small, reviewable feature work | aiforcecli skills "add CSV export to this page" | Keeps changes focused and reviewable. | | Test Authoring | Unit/integration/regression tests | aiforcecli skills "add regression tests for login" | Builds proof into the workflow. | | Code Review Gate | Diff review before merge | aiforcecli skills "review this diff for bugs" | Findings first, evidence-backed, severity ordered. | | Secure Code Review | Auth, secrets, injection, tenancy, dependency risk | aiforcecli skills "review auth changes for CISO risk" | Requires human review for security-sensitive changes. | | Prompt Injection Guard | CLAUDE.md/AGENTS.md/skill hijack/context risk | aiforcecli skills "scan for prompt injection and hidden instructions" | Detects repo instructions that can influence agents. | | Architecture Drift | Layering, coupling, ADR, boundary violations | aiforcecli skills "check if this change violates architecture" | Maps changes against architecture intent. | | Dependency Upgrade | Safe package upgrades and rollback notes | aiforcecli skills "upgrade Next.js safely" | Controls lockfile churn, breaking changes, and rollback risk. | | Legacy Modernization | Staged modernization and strangler plans | aiforcecli skills "plan Java 8 to Java 21 modernization" | Breaks large work into governed waves. | | Performance Investigation | Baseline, bottleneck, before/after proof | aiforcecli skills "find why this endpoint is slow" | Requires baseline or clearly labeled hypothesis. | | UI/Accessibility QA | Responsive, keyboard, labels, console checks | aiforcecli skills "review this form for accessibility" | Adds accessibility and browser quality gates. | | API Contract Change | Endpoint/schema compatibility | aiforcecli skills "add a webhook endpoint safely" | Protects public contract compatibility. | | Database Migration Guard | Migration safety and rollback | aiforcecli skills "review this Prisma migration" | Requires approval before applying migrations. | | PR Builder | Commit/branch/PR text with approval gates | aiforcecli skills "prepare a PR for this change" | Requires approval before commit, push, PR creation, or merge. | | Release Readiness | Version, changelog, package contents, publish risk | aiforcecli skills "check npm release readiness" | Requires approval before publish or release action. | | Production Incident Triage | Timeline, blast radius, mitigation | aiforcecli skills "triage this production incident" | Separates facts, suspected cause, mitigation, and follow-up. | | Postmortem Generator | RCA, timeline, actions | aiforcecli skills "draft a postmortem from these notes" | Creates action-oriented, blameless incident records. | | Documentation and ADR | README/docs/architecture decisions | aiforcecli skills "write an ADR for this boundary change" | Requires source-backed docs and decision context. | | FinOps Optimizer | Model, token, budget, output scope | aiforcecli skills "reduce cost for this repo summary" | Makes model/cost choices explicit. | | Skill Authoring and Eval Builder | Creating governed skills and evals | aiforcecli skills "create a skill for secure dependency upgrades" | Encourages reusable workflows with evals and permissions. | | MCP/Tool Onboarding Review | Tool capability and permission review | aiforcecli skills "review this MCP server before enabling it" | Applies least-privilege review to tools. | | Data Privacy Review | PII, logs, retention, third-party exposure | aiforcecli skills "review this export flow for privacy risk" | Maps sensitive data flow and exposure risk. |

Enterprise SDLC Benefits

| Enterprise need | How governed skills help | | --- | --- | | Standardization | Developers use repeatable workflows for bug fixing, review, security, PRs, releases, incidents, and modernization instead of inventing prompts each time. | | Quality | Each skill requires evidence, edge cases, verification, and completion reporting. | | Security | Human approval gates and Context Firewall integration reduce prompt injection, secret exposure, and unsafe tool use. | | FinOps | Skills use cheap-first discovery and stronger models only when risk or failed proof justifies escalation. | | Auditability | Each run leaves local structured evidence under .aiforce/skills/runs/. | | Developer enablement | Average developers learn the agentic engineering loop by using it: choose workflow, inspect evidence, verify, learn. | | Leadership visibility | Dashboard and summaries can roll up skill usage, verification behavior, model/cost posture, and governance evidence. | | Enterprise adoption | Teams get a lightweight operating model for governed agentic engineering without forcing everyone into a new IDE or heavy platform first. |

The recommended flow from Claude Code or Codex remains intentionally simple:

/aiforcecli:skills triage this failing CI job
# AIForce recommends a primary skill, supporting skills, model-aware plan, and repo-adapted workflow.
# Host agent asks whether to run it in the current session.
yes
/aiforcecli:verify suggest
/aiforcecli:learn