📦 deps(thirdparty): update snapshots

This commit is contained in:
ci[bot]
2026-07-18 00:02:59 +00:00
parent 82f7c6e56a
commit 47ce7f78dc
1446 changed files with 141041 additions and 6442 deletions
@@ -47,7 +47,7 @@ A list of known edge cases or things the skill _cannot_ do.
If a skill includes command examples, remote fetch steps, secrets, or mutation guidance, the PR must document the risk and pass `npm run security:docs` in addition to normal validation.
For pull requests that add or modify `SKILL.md`, GitHub also runs the automated `skill-review` workflow. Treat that review as part of the normal PR quality gate and address any actionable findings before merge.
For pull requests that add or modify `SKILL.md`, GitHub also runs the automated `skill-review` workflow. Treat that review as part of the normal PR quality gate and address any actionable findings before merge. A successful result is reused when a later push has the identical changed-skill content; if Tessl credits are unavailable, the workflow records `manual-review-required` for exact-head maintainer attestation instead of pretending an automated review passed.
Automated checks are necessary, but they do **not** replace manual reviewer judgment on logic, safety, and likely failure modes.
`npm run security:docs` enforces a repo-wide scan for:
@@ -1,9 +1,9 @@
---
title: Jetski/Cortex + Gemini Integration Guide
description: "Use agentic-awesome-skills with Jetski/Cortex without hitting context-window overflow with 1,948+ skills."
description: "Use agentic-awesome-skills with Jetski/Cortex without hitting context-window overflow with 1,965+ skills."
---
# Jetski/Cortex + Gemini: safe integration with 1,948+ skills
# Jetski/Cortex + Gemini: safe integration with 1,965+ skills
This guide shows how to integrate the `agentic-awesome-skills` repository with an agent based on **Jetski/Cortex + Gemini** (or similar frameworks) **without exceeding the model context window**.
@@ -23,7 +23,7 @@ Never do:
- concatenate all `SKILL.md` content into a single system prompt;
- re-inject the entire library for **every** request.
With 1,948+ skills, this approach fills the context window before user messages are even added, causing truncation.
With 1,965+ skills, this approach fills the context window before user messages are even added, causing truncation.
---
@@ -21,7 +21,7 @@ This example shows one way to integrate **agentic-awesome-skills** with a Jetski
- How to enforce a **maximum number of skills per turn** via `maxSkillsPerTurn`.
- How to choose whether to **truncate or error** when too many skills are requested via `overflowBehavior`.
This pattern avoids context overflow when you have 1,948+ skills installed.
This pattern avoids context overflow when you have 1,965+ skills installed.
Manifest contract references:
@@ -0,0 +1,157 @@
# AAS Agent-First Control Plane Preview Profile
Status: approved intermediate release profile
Date: 2026-07-17
Certified design: `docs/maintainers/aas-agent-first-control-plane-v1-design.md`
## Purpose
This profile validates whether Codex, Claude Code, and comparable agents can
use AAS to compose useful local skill stacks before AAS claims the stronger
certified-v1 guarantees. It is additive: it does not change the frozen v1
design, benchmark, hostile corpus, verifier, or completion criteria. A passing
preview does not complete the active v1 goal.
The permitted preview claim is:
> AAS Agent-First Preview helps Codex and Claude compose a local, explainable,
> reproducible skill stack. Full-catalog recommendation quality and
> transactional apply/recovery safety are not yet certified.
Preview output must not use `implementationVerified`, `releaseReady`,
`released`, `certified`, or an equivalent unqualified claim.
## Included preview surfaces
- Minimal, schema-validated `aas-stack.json` with pinned catalog identity,
targets, approved intent and policy, and exact skill IDs.
- CLI `stack init`, `stack recommend`, `stack validate`, `stack plan`, and
`stack doctor` from the packed npm candidate.
- The local stdio MCP with exactly `search_skills`, `get_skill`,
`recommend_stack`, `inspect_stack`, `diff_stack`, and
`aas://skills/{id}`.
- Deterministic recommendation with structured factors, two visible lanes
(`recommended` and `discoveryCandidates`), explicit unknowns, stable
tie-breaking, and fail-closed policy decisions.
- Functional Node 22/24 coverage on Linux, macOS, and Windows from one exact
content-addressed tarball.
- Workbench schema/import/render tests and a local production build. A live
Pages deployment remains outside the preview until separately approved.
## Experimental writes
`stack apply` and `stack recover` are present for controlled development but
are not preview-supported safety claims. They are disabled by default:
- apply requires the additional `--experimental-apply` flag and the existing
exact plan-digest approval;
- recovery requires `--experimental-recovery` and retains its existing
recovery-plan approval;
- successful experimental writes return `releaseProfile: "preview"` and
`certificationStatus: "experimental"`;
- absence of the opt-in fails before runtime resolution or target writes with
a structured policy error.
Internal transaction tests are development evidence only. Certification still
requires the frozen production-binary crash, boundary, race, rollback, and
recovery verifier.
## Preview functional gate
Every matrix job must install the exact candidate tarball with lifecycle
scripts disabled and run without checkout-only runtime dependencies. No job may
be skipped or allowed to fail.
On Windows, the preview verifier may materialize its own isolated runtime-cache
fixture and must then have the production core verify the complete identity and
every cached byte before `plan`, `doctor`, or MCP use. This proves the read-only
functional lifecycle without claiming that Windows cache-promotion durability
is certified. Native directory-flush and interrupted-promotion evidence remains
part of the certified-v1 transaction gate.
Windows preview creation of the regenerable manifest and immutable plan uses
the explicit `--preview-windows-output` opt-in. The CLI fsyncs the file and
returns `outputDurability: "fileSyncedDirectoryUnverified"` together with
`certificationStatus: "notCertified"`; without that flag it remains fail-closed.
This opt-in never applies to skill installation, host configuration, apply, or
recovery.
Required functional suites are:
1. **Package and entrypoints** — allowlisted package contents; `aas`,
`aas-mcp`, and the legacy alias exist; legacy invocation creates no stack
state implicitly.
2. **Stack lifecycle**`init -> recommend -> validate -> plan -> doctor`
succeeds in isolated roots and does not materialize target skills or AAS
managed state.
3. **Determinism and explanation** — repeated identical inputs produce the
same canonical recommendation payload and expose factor, coverage, evidence,
exclusion, and unknown fields.
4. **Policy** — proved incompatibility or forbidden risk is excluded;
incomplete evidence remains visible; malformed or over-limit input fails
closed.
5. **MCP contract** — the five tools and one resource template work over real
stdio framing; project and cache snapshots remain unchanged by tool calls.
6. **Write guard** — apply and recovery without their experimental flags fail
with structured policy codes and leave project, cache, and managed state
unchanged.
7. **Workbench** — bounded text-only import/review tests and production build
pass without ambient filesystem access.
The preview receipt must declare:
```json
{
"assuranceProfile": "agent-first-preview-1",
"previewQualified": true,
"certifiedV1": false,
"notEvaluated": [
"native-network-and-filesystem-attempt-observation",
"transactional-crash-and-race-certification",
"benchmark-80-90-100",
"real-host-configuration-writes",
"public-release"
]
}
```
Missing receipts, crashes, timeouts, canonical drift, or any failed functional
suite make `previewQualified` false.
## Explicitly not certified by preview
- ETW, `fs_usage`, or `strace` proof of zero network attempts and zero
persistent MCP writes.
- Production-binary fault injection at every transaction boundary or every
declared race class.
- Full benchmark thresholds: at least 80% verified coverage, 90% inclusion
precision, and 100% correct abstention for each supported intent and in
macro-average.
- Complete property/fuzz/hostile budgets required by certified v1.
- Real Codex or Claude configuration writes, public Pages deployment, npm
publication, GitHub release, or announcement.
These remain mandatory before AAS can call the recommendation system or
transactional lifecycle certified v1.
## Product-learning gate
After the functional matrix passes, preview evaluation should measure whether
agents actually produce useful proposals:
- task completion rate from a repository profile to a reviewable stack;
- human accept/replace/remove rates for recommended skills;
- uncovered goals and discovery-candidate promotions;
- deterministic replay rate for the same normalized input and catalog digest;
- time and interaction count from request to approved manifest.
No repository profile, source file, secret, or raw path is uploaded by default.
Publishing or sharing any collected result requires a separate explicit
decision and privacy review.
## Relationship to certified v1
The certified verifier may remain red or unevaluated while the preview gate is
green. That state must be reported as `previewQualified: true` and
`certifiedV1: false`, never as a skipped certified pass. The frozen v1 design
and goal remain the only completion criteria for certification and release.
@@ -0,0 +1,300 @@
# AAS Agent-First Control Plane v1 Design
Status: frozen and approved for implementation
Date: 2026-07-17
## Product statement
> L'agente compone. Tu controlli. AAS mantiene lo stack aggiornato.
AAS finds, installs, and maintains the right set of skills for each project and agent. The durable product is the approved stack; CLI and MCP are its operational interfaces, while Workbench is the review surface.
## Understanding summary
- Users will ask Codex, Claude Code, or another agent to select skills instead of manually choosing among almost 2,000 entries.
- The agent inspects the project, sends an allowlisted synthetic profile to a local AAS MCP process, and explains the deterministic AAS result.
- A minimal `aas-stack.json` stores approved intent, policy, targets, catalog identity, and exact skill IDs.
- A human approves an immutable plan before the CLI writes anything.
- MCP is local, stdio, process-per-session, read-only, offline-capable, and contains no model or API credentials.
- One versioned core powers CLI, MCP, and Workbench projections.
- Missing metadata is reported as `unknown`; it is never presented as algorithmic certainty.
## Baseline
The published `agentic-awesome-skills` package is version 14.6.0 and exposes the legacy `agentic-awesome-skills` installer entrypoint. The installer already supports exact skill IDs, multiple targets, release pinning, dry-run, managed state, atomic preflight, and symlink safety. It does not yet expose stack lifecycle commands, a JSON recommendation API, or an MCP server.
The current catalog contains 1,965 skills. All entries have basic identity, category, source, risk, compatibility, and setup fields, but evidence coverage is uneven: 936 risks are `unknown`; only 361 entries have non-empty tags; `source_type`, source repository, and license are present for roughly one quarter of the catalog; structured test, review, and quality evidence fields are absent. Existing compatibility and setup values require provenance auditing before they can be treated as strong evidence.
## Scope
### Included
- One npm package with a shared deterministic core.
- Public entrypoints `aas`, `aas-mcp`, and the compatible legacy alias `agentic-awesome-skills`.
- Minimal stack manifest and versioned JSON schemas.
- Explicit catalog update/status and content-addressed local cache.
- Deterministic search, skill inspection, recommendation, eligibility, diff, validation, planning, apply, doctor, and recovery.
- User- or project-scoped MCP configuration adapters for Codex and Claude in v1.
- Minimal Workbench import/review for manifests and plans through user-mediated paste/upload; no ambient filesystem access or browser-side installation.
- Versioned benchmark, hostile-input corpus, independent package verifier, and release evidence bundle.
### Explicit non-goals
- Remote or hosted MCP, AAS accounts, login, cloud sync, or hosted API.
- Repository profile upload, remote telemetry, or analytics by default.
- Internal models, embeddings, remote ranking, or free inference from skill prose.
- Marketplace, public stack publishing, sharing, remixing, or community registry.
- Resident daemon/socket, implicit auto-update, or mandatory global installation.
- Runtime copied into every repository, multi-package split, or plugin system for the core.
- Full Workbench editor, browser filesystem access, or browser-triggered installation.
- Native configuration adapters for every agent host.
- Enrichment of all catalog entries as a prerequisite for preview.
- An OS sandbox guarantee or protection from a machine already compromised by a same-user process.
## Architecture
```text
User
-> Codex / Claude
-> aas-mcp (local stdio, one process per host session)
-> deterministic core
-> bundled or verified cached catalog
-> proposed aas-stack.json
-> human approval
-> aas stack plan --out .aas/plan.json
-> aas stack apply --plan .aas/plan.json
-> Workbench import/review
```
The npm package ships one internal core and two implementations, plus the legacy entrypoint alias. A user-local installation is the default for personal and non-JavaScript work. A project-local pinned devDependency is optional for JavaScript teams. Explicitly pinned `npx` is the bootstrap and CI path.
The first user-local bootstrap is an explicit trust-on-first-use boundary: a pinned `npx agentic-awesome-skills@<version> mcp configure --scope user` invocation runs with package lifecycle scripts disabled, records npm SRI, and installs the exact runtime closure into the content-addressed cache. Later runtime changes are performed by an already installed CLI through the same explicit `mcp configure` flow, with preview, integrity verification, atomic promotion, and no lifecycle execution. Catalog update remains data-only and cannot populate or execute the runtime cache.
The user-local cache separates runtime and catalog identities:
```text
runtimes/<package-version>/<filesystem-safe-integrity-key>/
catalogs/<package-version>/<catalog-digest>/
```
The runtime directory key is a canonical filesystem-safe encoding of the original npm SRI digest; the unmodified `dist.integrity` remains the value verified and recorded in plans and configuration. No manifest stores a local runtime path. MCP configuration binds to an exact runtime version and integrity. Upgrades are explicit.
## Stack manifest
The public v1 manifest stores desired state, not derived repository observations or natural-language reasoning:
```json
{
"schemaVersion": 1,
"name": "react-vite-production",
"catalog": {
"package": "agentic-awesome-skills",
"version": "14.6.0",
"integrity": "sha256-..."
},
"targets": [
{ "host": "codex", "scope": "project" }
],
"intent": {
"goals": ["build", "test", "deploy"]
},
"policy": {
"allowedRisk": ["none", "safe"],
"requireKnownSource": true,
"allowManualSetup": false
},
"skills": [
{ "id": "react-best-practices" },
{ "id": "playwright-skill" }
]
}
```
Detected languages/frameworks, excluded alternatives, evidence breakdown, and natural-language explanations remain in recommendation and plan output. The installer's internal managed-state manifest remains separate.
## MCP v1 contract
The server exposes only:
- `search_skills`
- `get_skill`
- `recommend_stack`
- `inspect_stack`
- `diff_stack`
- resource template `aas://skills/{id}`
`recommend_stack` applies deterministic rules and returns structured factors and evidence. It does not call another model or create subjective reasoning. `diff_stack` uses only verified catalogs already present locally. No MCP tool installs, removes, applies, updates catalogs, scans a repository, or changes configuration.
Full skill text is returned only on request and is separated as `untrustedContent`; metadata and prose cannot acquire instruction authority. The server can signal this trust boundary but cannot guarantee how an external model will behave.
Every structured response declares `protocolVersion`, `coreVersion`, `metadataSchemaVersion`, `scorerVersion`, and catalog digest. Incompatible versions fail explicitly.
## CLI lifecycle
```text
catalog update/status
-> stack init
-> agent/MCP recommend
-> stack validate
-> stack plan --out .aas/plan.json
-> human approval
-> stack apply --plan .aas/plan.json
-> stack doctor
```
- `stack init` creates targets and policy only.
- `stack recommend` is a deterministic fallback over an explicit profile file; it does not inspect the repository.
- The plan binds manifest hash, runtime identity/integrity, catalog digest, protocol/core/schema/scorer versions, installed managed state, and exact logical operations.
- Each immutable v1 apply plan binds exactly one target and one filesystem transaction. A multi-target manifest produces independently approved per-target plans; AAS does not claim impossible crash-atomic commit across unrelated filesystems.
- `apply` never recalculates an approved plan.
- Unmanaged skills are never overwritten or removed.
- Managed local modifications block apply unless an explicit override and approved backup are present.
- `stack doctor` is read-only. `stack recover --id ... --action rollback|cleanup` is a separate, approved, revalidated write.
- Reapplying a completed plan returns `alreadyApplied` without writing. A partial plan cannot be reused until recovery closes its journal.
- Interactive apply/recovery displays and confirms the exact plan or recovery digest. Non-interactive execution requires an explicit approval value bound to that digest; absence or mismatch blocks. This is an audit marker within the stated same-user threat boundary, not a cryptographic proof against a compromised machine.
- The legacy installer remains compatible and never creates `aas-stack.json` implicitly.
## Metadata and deterministic recommendation
The versioned metadata contract represents capability, target compatibility, risk, provenance/license, setup, dependencies/conflicts, validation, tests, and reviews. Each judgment can be `known`, `unknown`, or `notApplicable` and carries evidence references when known. The engine does not infer authoritative values from free-form skill text.
Eligibility is computed from public rules, never a hidden ID whitelist:
```text
eligibleForRecommendation: true | false
eligibilityReasonCodes: [...]
evidenceLevel: ...
unknownFields: [...]
```
All skills remain searchable. `recommend_stack` returns:
- `recommended`: candidates with sufficient structured evidence;
- `discoveryCandidates`: potentially relevant candidates with material unknowns.
An agent may promote a discovery candidate only through a visible plan override. Validation and apply still enforce the approved policy.
Ranking uses versioned aliases/ontology, explicit normalization, BM25-style lexical retrieval, fixed-point integer factors, and stable skill-ID tie-breaking. Composition is a declared greedy set-cover algorithm with skill budget, dependency/conflict handling, overlap penalty, minimum-value threshold, and permission to leave goals uncovered instead of adding a weak skill.
The canonical output includes scorer version, catalog digest, normalized input, factor breakdown, goal-capability matrix, exclusions with reason codes, material unknowns, and proposed stack. Identical input, catalog digest, schema, and scorer produce byte-identical canonical JSON. Timestamps, correlation IDs, localized messages, and diagnostics are outside that payload.
Coverage is reported with separate `goalCoverage`, `metadataCompleteness`, and `evidenceStrength`; no opaque aggregate confidence is required. Quality evidence is limited to auditable validation, provenance, metadata completeness, tests, and recorded reviews. Popularity, stars, and opaque editorial scores are excluded.
## Result and error model
`unknown` and `insufficientCoverage` are valid recommendation outcomes:
```json
{
"ok": true,
"status": "insufficientCoverage",
"reasonCodes": [],
"unknown": []
}
```
`ok: false` is reserved for invalid input, a policy-blocked requested operation, or execution failure. Machine clients depend only on versioned schemas, namespaced append-only codes, categories, and structured details. Human messages can change or be localized. Remediation is expressed as structured actions and arguments, never executable shell strings.
Mutating operations use OS-enforced exclusive lock creation plus an informational crash-safe record, same-filesystem staging, journal, revalidation immediately before writes, atomic rename where possible, fsync at commit points, rollback only when current bytes match AAS-written bytes, and internal-manifest update as the final commit. Paths are logical in plans and are derived from allowlisted host adapters. File handles, file type/ownership checks, `realpath`, and target identity are revalidated at write time to reduce swap/TOCTOU risk. Node cannot provide portable descriptor-relative `openat`/`renameat`; resistance to a malicious same-user process remains outside the v1 boundary rather than being overstated. Recovery uses a `recoveryId`, target identity, hashes, and explicit approval.
Diagnostics are redacted. Correlation IDs are allowed; stack traces require explicit redacted debug mode.
## Privacy and threat model
Trust boundaries are npm registry to cache, cache to runtime, host/agent to MCP, recommendation to human approval, approved plan to CLI/filesystem, catalog content to the interpreting agent, and host configuration to its adapter/backup.
Key invariants:
- The updater downloads a tarball, verifies registry `dist.integrity`, extracts only allowlisted data assets, and verifies the internal catalog digest. It never executes release lifecycle scripts, binaries, modules, templates, dynamic imports, or catalog code. Registry integrity proves byte correspondence, not that the publisher account was uncompromised; provenance/attestations are recorded separately.
- Archive extraction rejects absolute/traversal paths, symlinks, hardlinks, devices/FIFOs, duplicate files, case/Unicode collisions, anomalous permissions, excessive file counts or sizes, and decompression bombs.
- MCP contains no network calls, updater, model, credentials, or telemetry and works offline. Tests must observe zero network attempts. OS-level network denial is optional external hardening.
- MCP accepts only bounded, allowlisted structured profiles. It does not persist profiles or log source, secrets, raw files, or absolute paths by default.
- MCP enforces byte, JSON-depth, query-length, result-count, memory, and timeout limits.
- Apply is transactional and fail-closed against drift, target swap, path traversal, symlink races, incompatible producers, and hard-policy violations.
- Host adapters reject symlinks/non-regular files and wrong ownership, preserve mode/owner, lock and patch atomically, redact secrets from diffs/logs, and create user-only backups with explicit retention and cleanup.
- A same-user malicious process or compromised machine is outside the v1 protection boundary.
## Benchmark and acceptance gates
Before product implementation, a separate bootstrap phase creates the reference evaluator, schemas, tuning set, held-out set, hostile corpus, legacy command corpus, and verifier. Their initial versions and digests require review by two named reviewers, at least one of whom does not implement the scorer. After that freeze, the product change cannot modify them; any separately approved revision invalidates prior evidence.
The v1 public benchmark freezes tuning data separately from held-out data. Each supported intent has at least 30 held-out cases distributed across declared sub-intents and project archetypes, deduplicated by task/project family. Gold sets allow multiple equivalent solutions, record provenance/version, and require two reviewers for ambiguous cases. Labels are frozen before execution and cannot be reclassified after observing a result.
For every supported intent and in macro-average:
- verified recommendation coverage is at least 80%;
- inclusion precision is at least 90%;
- explicitly out-of-coverage cases abstain 100%;
- hard-policy violations are zero;
- critical goals are fully covered;
- declared minimum coverage for non-critical goals is met;
- discovery promotions always have visible overrides.
A verified recommendation must satisfy all of those conditions, not merely produce a stack. The minimum non-critical-goal coverage is 80%. Verified coverage uses every frozen in-scope case as its denominator. Inclusion precision is computed per stack and macro-averaged per intent over every included skill, using the accepted-equivalent sets; an empty or partial in-scope stack fails verified coverage and cannot disappear from the denominator. Out-of-coverage cases are measured only in the separately frozen abstention set. Candidate diversity is reported; three eligible candidates are preferred when the ecosystem genuinely offers them, but weak candidates are never added to satisfy a quota.
Hard-policy violations must also remain zero across the independently approved generative, property, fuzz, and hostile-input corpus. Minimum budgets are 100,000 stratified generated/property cases for policy and eligibility plus 50,000 bounded parser/MCP fuzz inputs, with all seeds and distributions frozen before scorer implementation. The hostile corpus contains at least one exploit and one boundary-adjacent valid control for every declared archive/input class. The canonical core payload must be byte-identical across the supported OS/Node matrix.
The initial supported intents are:
1. web application delivery;
2. API/backend delivery;
3. test and QA automation;
4. security review and hardening;
5. deployment and DevOps;
6. agent and MCP development.
An intent failing any gate remains `preview` or unsupported. The supported runtime matrix is Node v22 and v24 on Linux, macOS, and Windows; Node v20 is EOL and excluded. The verifier manifest freezes exact Node patch versions, runner/image identities, filesystem assumptions, architecture, and all required jobs before execution. Skips and `continue-on-error` fail the gate.
## Independent completion verifier
Repository tests are supporting evidence, not the final verifier. The strongest check is an independently controlled black-box harness:
```text
candidate commit
-> npm pack
-> content-addressed tarball
-> clean install outside the checkout with --ignore-scripts
-> independent verifier and evidence bundle
-> benchmark/security/release approvals
-> protected publish
-> registry re-download and integrity/behavior comparison
```
The verifier checks packaging, all entrypoints, offline catalog access, MCP protocol and resource limits, zero persistent MCP writes anywhere and zero network attempts, hostile archives, tampered plans, fault injection and crash recovery, canary-secret leakage, adapter fixtures, legacy CLI differential behavior against the integrity-pinned 14.6.0 package, and OS/Node behavior. Fault injection acts on the production binary using OS/process/filesystem observation and kills or swaps at every observed mutating boundary; mock-only or test-mode coverage is insufficient. The frozen legacy corpus enumerates every public flag, target, representative combination, filesystem result, exit code, and explicitly allowed difference.
Eligibility and scoring also undergo metamorphic tests that permute catalog order and replace IDs consistently; results must remain invariant except for the documented stable tie-break and returned renamed identity. This prevents public rules from becoming an indirect hardcoded whitelist.
The verifier runs in protected CI under declared ownership and cannot be self-approved by the product implementer. It produces a content-addressed evidence bundle bound to CI run identity, verifier hash, commit, tarball, approvals, and retained protected artifact storage. The bundle contains all versions/digests, full denominators, seeds/budgets, system traces, transaction matrices, redacted logs, and reviewer approvals.
Workbench accepts only size/depth-bounded, user-mediated paste or file upload held in memory. It performs schema validation and text-only/XSS-safe rendering; it does not use ambient filesystem APIs or persist imported content. Completion requires live GitHub Pages deployment and readback of the exact reviewed version, behind the publication approval gate.
`implementationVerified`, `releaseReady`, and `released` are distinct states. Publication requires explicit user approval and the repository's protected maintainer release workflow.
## Decision log
| Decision | Alternatives considered | Rationale |
| --- | --- | --- |
| Stack + CLI + MCP + Workbench | Site-only stack, new installer CLI, MCP wrapper | The stack is durable state; interfaces alone do not create recurring product value. |
| Agent-first, human-approved | Manual Workbench composition | Users delegate selection; humans need review and control, not 2,000 checkboxes. |
| Local stdio MCP | Hosted MCP/API, resident daemon | Preserves privacy, works offline, and keeps process isolation simple. |
| MCP read-only; CLI owns writes | MCP apply/install tools | Preserves an explicit approval boundary and reduces host-agent blast radius. |
| One npm package and one core | Multiple packages or duplicated logic | Minimizes version skew while preserving later split options. |
| Hybrid runtime placement | Mandatory project install or global npm install | User-local works across languages; project-local remains available for team pinning. |
| Minimal manifest | Persist detected profile and prose reasoning | Derived data drifts and causes noisy diffs; approved intent and IDs are durable. |
| Catalog identity includes integrity | Version string only or immediate lockfile | Binds desired state to verified bytes without adding a second public state file. |
| Public eligibility rules and two result lanes | Hidden enriched whitelist | Keeps the whole catalog visible and makes incomplete evidence explicit. |
| Unknown is first-class | Treat unknown as incompatible or infer from prose | Prevents false certainty while allowing policy-controlled caution. |
| Lexical fixed-point deterministic ranking | Embeddings, remote scoring, model ranking | Reproducible across CLI, MCP, and Workbench with auditable factors. |
| Separate coverage/evidence measures | Single confidence percentage | Avoids presenting missing metadata as certainty. |
| Immutable plan and transactional apply | Recompute on apply or direct install | Human approval must bind the exact operation and survive drift/failure safely. |
| One target/filesystem per mutating plan | Claim whole-plan atomicity across multiple host filesystems | Preserves real crash-atomic semantics; multi-host manifests remain portable through separate approved plans. |
| Pure Node write-time containment | Native addon or overstated portable `openat` guarantee | Matches the same-user threat boundary and avoids a new native distribution surface while documenting residual TOCTOU risk. |
| Registry integrity plus internal digest | Digest from same untrusted file alone | Verifies published bytes and catalog consistency while documenting publisher compromise as residual risk. |
| Valid abstention is `ok: true` | Treat insufficient coverage as error | Clients and metrics must distinguish safe abstention from system failure. |
| Independent black-box tarball verifier | Repository test suite alone | Prevents checkout-only success and proves the published artifact boundary. |
| Per-intent 80/90/100 gates | Global average or raw skill-count gate | Prevents strong categories from hiding weak ones and tests correct abstention. |
| Launch parameters frozen before activation | Leave intent, adapter, benchmark-size, runtime, and Workbench scope open | Product-owner approval fixes the cost and finish line before implementation begins. |
## Maintenance ownership
The scorer, metadata schema, benchmark, hostile corpus, and verifier are versioned public maintenance surfaces. Their initial baseline is created and independently approved before scorer implementation. Changes to held-out labels, security corpus, intent set, denominators, fuzz budgets, or verifier require separate review from product implementation and invalidate previous evidence. Adapter fixtures record provenance, host version, and validation date and require an isolated smoke test against the current version before release. Release artifacts must use the exact verified tarball; rebuilding requires a new verification cycle.
@@ -0,0 +1,167 @@
# AAS Agent-First Control Plane v1 Goal
Status: approved source packet for the active Codex goal
Design source: `docs/maintainers/aas-agent-first-control-plane-v1-design.md`
## Fit
Use a durable goal. The work crosses catalog schema, deterministic recommendation, CLI lifecycle, local MCP, transactional filesystem behavior, host adapters, Workbench review, cross-platform packaging, benchmark construction, security abuse testing, and protected release verification. It needs repeated implementation/verification loops and has an independent observable finish line.
## Outcome
Ship and independently verify the AAS v1 agent-first control plane exactly within the frozen design: a user can ask Codex or Claude to obtain a deterministic local recommendation, approve a minimal stack and immutable plan, safely apply it through the CLI, diagnose/recover failures, and review the result in Workbench without repository data leaving the machine by default.
## Baseline
- Package 14.6.0 exposes only the legacy installer entrypoint.
- The installer already provides exact-set, multi-target, pinning, dry-run, managed-state, atomic-preflight, and symlink-safety foundations.
- There is no AAS MCP server, stack lifecycle, deterministic recommendation API, verified catalog cache lifecycle, benchmark, or independent package verifier.
- Catalog metadata is incomplete and cannot yet support strong recommendations across the full catalog.
- The working tree contained unrelated local-skill-reviewer work when this goal was drafted; it must remain isolated from this goal.
## Fixed scope and launch parameters
Implement only the surfaces frozen in the design document. Initial supported intents are web application delivery, API/backend delivery, test/QA automation, security review/hardening, deployment/DevOps, and agent/MCP development. Each requires at least 30 diversified and deduplicated held-out cases. Initial configuration adapters are Codex and Claude. Workbench scope is read-only, in-memory, user-mediated paste/upload and review of stack and plan artifacts, including a verified live Pages deployment.
The runtime matrix is Node majors 22 and 24 on Linux, macOS, and Windows, with exact patch, runner/image, architecture, and filesystem identities frozen in the verifier manifest. The npm package exposes `aas`, `aas-mcp`, and the compatible `agentic-awesome-skills` alias.
## Non-goals
No hosted service, remote MCP, account system, telemetry, repository upload, embeddings/model in the core, marketplace, public stack sharing, daemon, auto-update, multi-package split, full Workbench editor, browser installation, all-host adapter program, or mandatory enrichment of all skills.
## Primary verifier
Before scorer/product implementation, a separate baseline phase creates the reference evaluator, metric schema, benchmark/gold data, hostile corpus, legacy command corpus, and black-box verifier. Two named reviewers, including at least one non-implementer of the scorer, approve and freeze their versions and digests. The product implementation cannot modify these surfaces.
That independently controlled black-box harness must verify the content-addressed `npm pack` tarball from a clean directory outside the repository, installed with lifecycle scripts disabled and without checkout or devDependency access. Protected CI, with declared ownership and no self-approval by the product implementer, produces the evidence bundle and distinguishes:
- `implementationVerified`: all technical gates pass on the candidate tarball;
- `releaseReady`: benchmark and independent security/release review are approved;
- `released`: the protected tag/npm release exists and the registry tarball is re-downloaded and proven identical in integrity and behavior.
Repository tests alone cannot complete the goal.
## Required gates
### Recommendation and metadata
- Versioned metadata schema with explicit unknowns and evidence.
- Entire catalog searchable; eligibility derived only from public rules; no ID whitelist.
- `recommended` and `discoveryCandidates` are both visible with structured reasons.
- Deterministic core output is byte-identical for identical input/digests/versions across the matrix.
- For every supported intent and in macro-average: verified coverage >=80%, per-stack inclusion precision macro-averaged per intent >=90%, explicit out-of-coverage abstention 100%, critical-goal coverage 100%, non-critical-goal coverage >=80%, zero hard-policy violations.
- Verified coverage counts every frozen in-scope case; empty, partial, crashed, timed-out, or missing results fail and remain in the denominator. Inclusion precision evaluates every included skill against accepted-equivalent gold sets. The separately frozen abstention set cannot be relabeled after results are known.
- At least 30 frozen held-out cases per intent, distributed across sub-intents and project archetypes, deduplicated by task/project family, with multiple equivalent gold solutions, provenance/version, and double review for ambiguous cases.
- Zero hard-policy violations across at least 100,000 independently frozen stratified property/generative cases and 50,000 bounded parser/MCP fuzz inputs, plus the hostile corpus with exploit and valid boundary controls per class.
- Metamorphic catalog-order and consistent-ID-permutation tests prove eligibility/scoring do not encode a direct or indirect ID whitelist.
### Package, CLI, and MCP
- Clean tarball contains only allowlisted assets and no sensitive or checkout-only dependencies.
- `aas`, `aas-mcp`, and the legacy alias pass black-box smoke tests.
- Legacy behavior is differentially tested against the integrity-pinned 14.6.0 package using a frozen corpus of every public flag, target, representative combination, output tree, exit code, and allowed difference; it does not create stack state implicitly.
- MCP exposes only the frozen five tools and resource template, performs no mutations or updates, works completely offline, produces zero observed network attempts, and produces zero persistent filesystem writes anywhere. HOME, project, cache, and TMP are isolated and observed; stdout/stderr are process streams, not write exceptions.
- MCP keeps protocol-only stdout, redacted diagnostics, untrusted skill-content separation, and resource limits.
### Catalog and supply chain
- Runtime/catalog caches are content-addressed and atomically promoted.
- First bootstrap uses explicitly pinned `npx ... mcp configure --scope user` with lifecycle scripts disabled and records the npm SRI; later runtime changes use the installed CLI with preview and atomic integrity-verified promotion. Catalog update remains data-only.
- Updater verifies npm `dist.integrity`, extracts only allowlisted data assets without executing code, and verifies the internal catalog digest.
- The hostile archive corpus covers traversal, absolute paths, links, special files, duplicates, Unicode/case collisions, permissions, count/size limits, and decompression bombs.
- Every hostile case leaves the cache unchanged and launches no child process or code.
### Plan, apply, and recovery
- Plan binds every approved input and never gets recomputed by apply.
- Every mutating plan binds exactly one target/filesystem. Multi-target manifests produce separate plans and approvals; cross-filesystem atomicity is not claimed.
- Apply uses OS-enforced exclusive lock creation plus crash-safe identity records, and is transactional, same-filesystem staged, crash-safe, fail-closed, and idempotent.
- Black-box fault injection against the production binary, driven by OS/process/filesystem observation rather than mocks or test-mode branches, covers every observed lock, journal, backup, write, fsync, rename, and commit boundary, including kill, concurrency, drift, symlink/target swap, corrupted journal, and recovery races.
- Unmanaged bytes never change. Managed local edits block unless separately overridden and backed up.
- Final state is entirely previous or entirely new; never hybrid. Internal managed state commits last.
- Final-state atomicity is evaluated per approved target transaction after successful apply or completed recovery. Write-time file-handle/type/ownership/realpath/identity checks reduce swap risk; a malicious same-user process remains outside the v1 boundary.
- Doctor is read-only. Recovery uses an approved ID/action and revalidates target and hashes.
- Interactive writes require confirmation of the exact plan/recovery digest. Non-interactive writes require an explicit approval value bound to that digest; absence or mismatch blocks.
### Host configuration and Workbench
- Codex and Claude adapters use real anonymized fixtures with provenance, host version, and validation date, plus isolated current-client smoke tests. They preserve unknown fields, apply minimal atomic patches, preserve ownership/mode, create user-only retained/cleanable backups, lock, redact secrets, and reject unsafe file types or ownership.
- Workbench accepts only size/depth-bounded user paste/upload held in memory and renders stack/plan evidence through schema-validated, text-only/XSS-safe views. It does not install, persist imports, use ambient filesystem APIs, or read local files without the user's explicit selection. Release proof includes the live Pages URL, deployed version, and readback after publication approval.
## Iteration loop
1. Treat the approved intent, held-out, adapter, runtime-matrix, Workbench, and fuzz-budget parameters as frozen.
2. Create and independently approve the initial reference evaluator, benchmark/gold, hostile corpus, legacy corpus, and verifier baseline; record their protected digests before product implementation.
3. Inspect the current design, goal, worklog, repository state, and active goal state.
4. Select one bounded vertical slice that advances the black-box verifier.
5. Implement it without changing frozen scope or benchmark labels.
6. Run targeted tests, then the relevant repository gates.
7. Run the independent verifier or its currently available slice against an actual tarball.
8. Record commands, hashes, failures, and the next smallest corrective action in a durable worklog.
9. Repeat until every gate passes from a clean state on the full frozen matrix.
10. Stop before public/tag/npm/Pages actions and request explicit approval.
## Anti-cheating rules
- Do not weaken, skip, quarantine, relabel, post-filter, or retry-until-green any gate.
- Initial benchmark/corpus/verifier baselines require independent approval before scorer implementation. The product PR cannot modify them or self-approve their workflow/ownership controls. Changes require a separate approval and invalidate prior evidence.
- Freeze intents, formulas, denominators, outside-coverage labels, minimum fuzz seeds/budgets/distributions, exact runners, and OS/Node matrix before scorer implementation.
- Crashes, timeouts, and missing outputs count as failures.
- No test-mode branch based on case IDs, fixture names, or environment markers.
- Canonical comparison exclusions must be enumerated fields, never a generic metadata exclusion.
- Do not replace real tarball, network/filesystem observation, or fault injection with mocks for completion proof.
- Do not use skipped/allowed-failure matrix jobs or a fault-injection list that omits an observed production mutation boundary.
- Do not touch or absorb unrelated dirty work.
- Do not call the goal complete at `implementationVerified` or `releaseReady`; completion requires the separately approved released state.
## Approval gates
Explicit user approval is required before:
- modifying real user-level Codex or Claude configuration outside isolated fixtures;
- changing frozen intent, benchmark, corpus, verifier, security boundary, or v1 scope;
- publishing a tag, GitHub Release, npm package, or public product announcement;
- deploying the Workbench changes publicly to Pages;
- any migration or cleanup that could remove existing user state.
The protected maintainer release workflow remains mandatory for publication.
## Blocker standard
Difficulty, test failure, incomplete metadata, or a long implementation is not a blocker. Report blocked only after the same external dependency or missing approval prevents meaningful progress for the required repeated goal turns. Preserve partial artifacts and state the smallest user or external action that would unblock the verifier.
## Completion proof
Completion requires:
1. exact candidate commit and clean-scope proof;
2. tarball SHA-512, npm pack manifest, and registry `dist.integrity`;
3. protocol/core/schema/scorer versions and catalog digest;
4. per-intent reports with full denominators and reviewer provenance;
5. canonical output hashes plus exact Node, runner/image, architecture, and filesystem identities for the complete matrix, with no skipped or allowed-failure job;
6. fuzz seeds/budgets, hostile-corpus results, and zero-policy-violation report;
7. observed MCP network/filesystem/process traces;
8. updater archive matrix and unchanged-cache proofs;
9. fault-injection, crash/recovery, and pre/post filesystem snapshots;
10. frozen legacy command corpus, baseline 14.6.0 integrity, explicit allowed-difference list, and differential report;
11. Codex/Claude fixture provenance/current-client adapter reports and canary-secret scans;
12. Workbench import-security tests plus approved live Pages URL/version/readback;
13. protected CI run identity, verifier owner/version/hash, reviewer identities, attestation, retention location, and content-addressed evidence bundle bound to commit and tarball;
14. benchmark, security, and release approvals;
15. protected release evidence plus registry re-download integrity and behavior comparison.
Only after all evidence exists and no required work remains may the active goal be marked complete.
## Delegation map
The primary agent owns scope, integration, repository changes, conflict resolution, and completion. Bounded subagents may independently handle metadata/benchmark audit, CLI/MCP contract tests, security corpus review, cross-platform verification, Workbench review validation, or release evidence review. They may not change the frozen benchmark, approve their own implementation, publish, or declare the parent goal complete.
## Exact activation objective
```text
Implement, independently verify, and—only after explicit publication approval—release the AAS agent-first control plane v1 defined in /Users/nicco/Projects/antigravity-awesome-skills/docs/maintainers/aas-agent-first-control-plane-v1-design.md, satisfying every gate and completion proof in /Users/nicco/Projects/antigravity-awesome-skills/docs/maintainers/aas-agent-first-control-plane-v1-goal.md without expanding the frozen v1 scope or touching unrelated dirty work.
```
## Activation state
This packet is the source of truth for the active Codex goal. Live activation status is maintained by Codex goal state.
@@ -0,0 +1,97 @@
# AAS Agent-First Control Plane v1 Worklog
## 2026-07-17 — Goal activation and clean baseline
- Active objective is defined by the approved design and goal documents.
- Original worktree `/Users/nicco/Projects/antigravity-awesome-skills` contains unrelated local-skill-reviewer work and remains untouched.
- Created isolated worktree `/private/tmp/aas-agent-first-control-plane-v1` on branch `codex/aas-agent-first-control-plane-v1` from `origin/main` commit `4101f32402448f4fdd96b3cf166a81b8cee8b557`.
- Live source baseline: `origin/main` current; latest main CI, CodeQL, Actionlint, and Pages succeeded; no open Dependabot, code-scanning, secret-scanning, or runtime npm-audit findings.
- Open PRs 867 and 871 are unrelated skill contributions and remain out of scope.
- Copied the approved design and goal packet into the isolated branch.
## Phase 0 status
- Freeze-ready baseline complete: 11 public schemas, exact metric formulas, fixed 100,000 property/generative and 50,000 parser/MCP fuzz budgets, six exact OS/Node jobs, and zero pending requirements.
- Benchmark corpus: 180 held-out cases and accepted-equivalent gold sets, 60 disjoint tuning cases, and 30 disjoint explicit out-of-coverage abstention cases. The six intents each retain a denominator of 30 held-out cases.
- Independent review: `codex-independent-alpha` and `codex-independent-beta` each approved all 270 case/gold or case/label pairs. Their content-addressed reports are bound by `verification/aas-v1/ownership.v1.json`; both reviewers are independent of the future scorer implementation.
- Hostile corpus: 32 exploit/control classes, 64 hash-verified fixtures, zero extracted archives, and zero special filesystem entries.
- Registry legacy baseline: `agentic-awesome-skills@14.6.0`, SRI `sha512-VTOb3O9PSYKCDO99i3h0vOn7vHQlGtO/+jSErR80g6OGaDJoBzg3q2GE9Nu890en1/Z54hBEYiVQj/1Rl95xEg==`, tarball SHA-256 `98f8cbb399613621598ac6aeca619fc7c454530895b4e237eee695d82fbdf0cb`, tag commit `ab5f6c205a548d2f4bec411728c79b9c156fc696`.
- Legacy replay: 41 command cases pass with fixture tree `sha256-80c220b08a221685c26a23e2cd7c1b06628bfec7a542fa91d8ee19a5d3e035f8` and aggregate fake-Git trace `sha256-b36ea8cfd26d642235ce061bb5dcc925bec4b5bf63137cc17edb702b62560384`. Two consecutive complete replays produced the same 64-file corpus aggregate `3797c2c61c6334aa8081380be11958cd555d277baa26114e0cbe35fd62e099f6`.
- The legacy harness binds the exact dependency closure, runtime tree, and entrypoint; validates pre/post filesystem evidence; constrains case, target, and fake-Git paths; observes and denies Node networking with a sentinel self-test; and records zero network attempts. Full OS-syscall observation remains a separate black-box product acceptance gate and is not claimed by this corpus.
- Live `main` protection now requires `aas-v1-baseline`, while retaining `pr-policy`, `pr-evidence`, `source-validation`, and `artifact-preview`; admin enforcement remains enabled and force-pushes/deletions remain disabled.
- Local gate: 9/9 verifier tests, schema validation, structure validation, frozen benchmark and secondary corpora, hostile fixtures, legacy snapshots, and freeze readiness all pass.
- Content-addressed freeze manifest: 712 files, root digest `sha256-c7a4d4b3efa9f2bdf5a126fc3c384680d39534880a3900302785397e4ddd451c`; an immediate independent `freeze:check` reproduced it exactly. GitHub's Linux replay exposed zlib-version variation in valid DEFLATE streams; gzip fixtures now require the frozen compressed digest plus deterministic expanded USTAR bytes and preserve the canonical committed stream during regeneration.
## Feasibility decisions
1. A v1 mutating plan is single-target and single-filesystem. Multi-target manifests generate independently approved plans. This avoids claiming impossible crash-atomic commit across unrelated filesystems.
2. The pure-Node implementation uses atomic exclusive lock creation, file handles, type/ownership/realpath/identity revalidation, same-filesystem staging, journal, fsync, and atomic rename. It documents that portable Node lacks descriptor-relative `openat`/`renameat`; a malicious same-user process is already outside the frozen threat boundary. No native addon is added to v1.
3. Legacy `install.js` remains isolated. The new stack transaction engine will not reuse its per-entry mutation path.
## Next evidence gate
- Baseline landed through protected PR [#878](https://github.com/sickn33/agentic-awesome-skills/pull/878) as `09f2d8612d2e68a087377685e9c876bd737e1782`. Required `aas-v1-baseline`, source validation, and artifact preview passed from committed bytes.
- Product implementation now runs in isolated worktree `/private/tmp/aas-agent-first-product` on `codex/aas-agent-first-control-plane-v1-product`, based on that protected commit. `verification/aas-v1` remains unchanged.
## Phase 1 — Deterministic core and immutable state contracts
- Added a pure CommonJS deterministic core with canonical JSON, explicit version handshake, allowlisted input normalization, public metadata judgments, complete-catalog search, deterministic recommendation/discovery lanes, fixed-point lexical factors, and greedy set-cover composition with skill budget, overlap penalty, dependencies, and conflicts.
- Canonical registry identity uses `canonical_id`, exposing all 1,965 skills exactly once. Generated compatibility defaults are not treated as authoritative support evidence; absent reviewed metadata remains `unknown`.
- The first tuning-only metadata overlay covered the 85 candidate IDs referenced by tuning gold. Independent audit rejected that approach as an indirect gold-derived whitelist: tuning/gold review is not proof of skill quality or provenance. This overlay is development history only and must be replaced before product acceptance. No held-out input was read.
- Added 11 public v1 schemas, strict minimal-manifest validation, exact version handshake, and immutable single-target plan envelopes. Plans bind manifest, catalog, runtime, target identity, installed state, logical operations, overrides, and a final state commit without physical destination paths.
- Added a tuning-only diagnostic runner. After conservative removal of unsupported capability claims, the honest baseline was macro verified coverage `0.366667` and macro inclusion precision `0.911859`. Coverage by intent was `0.4/0.2/0.4/0.4/0.4/0.4`; this is a development diagnostic, not held-out evidence or a release claim.
- Corrected the compositor to be lexicographically coverage-first, forbid non-critical-only additions while critical goals remain uncovered, use exact versioned capability matching, and keep search-only ID tokens out of recommendation BM25. The same still-gold-derived development overlay then measured `0.366667` coverage and `0.928030` macro precision; it remains rejected as product evidence.
- Added a benchmark-independent public review queue over all 1,965 catalog entries and 120 versioned capabilities. Three independent semantic audits selected and reviewed 121 unique candidates across the six intents without reading tuning gold or held-out data. Field-level risk, provenance, setup, dependency, and conflict evidence is being audited separately; unknown values remain unknown.
## Phase 2 — Local runtime, CLI/MCP, transaction, and review UI slices
- Added content-addressed catalog and runtime caches, canonical identity records, npm `dist.integrity` verification, data-only catalog update, a hardened archive parser, and atomic cache promotion. The hostile archive matrix passes 34/34; updater/cache/archive targeted tests pass 44/44.
- A fresh current-worktree npm tarball was parsed and promoted as a runtime without lifecycle execution: 6,455 files, 99,652,053 expanded bytes, SRI `sha512-tulK12nYIjp0JNrwAUQgDnluU5X8BXuhzrJ5lBWeZvKBOA6ENs2/QuxKpgv4hR3hU/GaTQDdNSYTV7YLnJfERg==`, closure `sha256-5c8c616cea0c9fb5d62fc707647a71e554001bbea0dea915a4865bb92345f22c`; every cached byte verified.
- Added the `aas` lifecycle for catalog status/update, stack init/recommend/validate/plan/apply/doctor/recover, exact plan/recovery approvals, and legacy argument dispatch isolation. Added Codex/Claude host adapters plus explicit `mcp configure` preview/apply and backup cleanup; real user configuration remains untouched.
- Added the five-tool read-only local MCP server and resource template with strict bounded JSON-lines parsing, offline catalog resolution, no updater, no model, and no write surface. Unit/static evidence does not replace the required external syscall observation.
- Added transactional apply with same-filesystem staging, exclusive lock, chained journal, backup, state-last commit, idempotence, and explicit recovery. Unit fault hooks do not replace the required production-binary kill/swap/race matrix.
- Replaced the manual Workbench selector with in-memory paste/upload review of stack and plan artifacts. The route is isolated from catalog/Supabase fetch, renders text-only evidence, and exposes no install/apply/share/persistence surface. App tests pass 152/152 and the production build/prerender passes locally.
- Current integrated AAS v1 unit suite passed 87/87 before the latest runtime and metadata-hardening additions; a fresh full rerun is required after integration. Frozen `verification/aas-v1` remains unchanged from protected baseline commit `09f2d8612d2e68a087377685e9c876bd737e1782`.
## Phase 2 integration update — current product tree
- Replaced the rejected tuning-derived overlay with committed, benchmark-independent review sources. The pipeline deterministically validates 120 public capability queues, imports 121 independent metadata reviews, builds 121 overrides, and emits all 1,965 catalog records at catalog digest `sha256-cf14b1b22b826b5aed3f82f7ea3c8895b4b5ae1af372bd310b7154db80bb4628`. Dependency-path tests forbid frozen verification, held-out, and gold inputs. No held-out case has been read by the product implementation.
- Real Draft 2020-12 instance validation now covers recommendation input, catalog manifest, plans, recovery plans, journal records, managed state, doctor output, and CLI success/error envelopes. Recommendation validation occurs before normalization, so malformed booleans, targets, policy, and unknown fields fail closed.
- Runtime packaging now bundles the declared npm dependency closure and promotes only allowlisted runtime assets. The current commit-bound tarball is 42,307,013 bytes with SHA-256 `3a1478e84f02692313a72656041b0d114dcc57d1906c53f0da83243dfdc2c9f1` and npm integrity `sha512-T2kL318lXJBms8GeFIbeMcCileDWJ2gqCjpckQa4llWsWpA7jFdRNeuD2EfN0Ce/7K2LkBuFNDD0GdM2jegbXg==`; its 7,237 selected runtime assets total 100,632,903 bytes and bind closure digest `sha256-bb527d301fa696ba319ccd6b1a745410da1861b5f86f328ceb46e4ca6e085b5c`. The tarball is installed into an isolated content-addressed cache, reverified byte-for-byte, and launches `aas-mcp` successfully with `NODE_PATH` cleared. The published `aas` and `aas-mcp` bins are asserted executable on POSIX and smoke-tested from the installed tarball.
- Transaction recovery now uses a root-anchored WAL plus bootstrap evidence, crash-safe pending publication, immutable checkpoints, mutation intent/completion records, target locking, state-last commit, and retryable rollback/cleanup. Explicit fault tests cover bootstrap rename before fsync, layout publication before fsync, tombstone cleanup interruption, torn WAL tails, interrupted mutation recovery, post-commit cleanup, empty prior state, live locks, stale recovery guards, and symlink/containment drift.
- Windows-specific source paths reject NTFS streams/device aliases/reserved names, harden backup and staging ACLs before sensitive bytes, preserve existing config ACLs, and request a `GENERIC_WRITE` directory handle for `FlushFileBuffers`. These paths fail closed but are not claimed as executed evidence until the protected Windows matrix runs.
- Recommendation output now keeps full deterministic scoring while returning compact evidence summaries: at most 25 candidates per lane, 25 detailed exclusions, total/returned counts, reason-code counts, and at most eight content-addressed evidence references per candidate. It no longer embeds a second copy of itself. Across all 60 tuning cases, the largest serialized MCP tool result is 203,884 bytes. The frozen hostile regex-like search query is rejected before tokenization while normal technical queries such as `c++ node.js api/v1` remain valid.
- `mcp configure` now has two explicit and non-ambiguous runtime paths. Registry bootstrap/update continues to preview and bind the exact npm SRI before download. Supplying both `--runtime-integrity` and `--runtime-closure-digest` selects an already verified content-addressed runtime without any registry access; preview binds the complete identity and apply reverifies every cached byte immediately before the atomic host-config write. Supplying only one identity component, a missing runtime, a closure mismatch, or post-preview tampering fails closed without a config write.
- Current local gates: skill validation for 1,965 skills, docs-security checks, deterministic catalog checks, 128/128 AAS v1 tests, the complete repository test suite, 152/152 Workbench tests, production Vite build/prerender, package-content checks, isolated CLI/MCP tarball smoke, and `git diff --check` pass. This supersedes the earlier stale 87-test snapshot above.
- The canonical `repo-maintainer` skill now preserves the independent product/verifier/gold boundary. Its packaged mirrors remain owned by the protected canonical-sync flow and will be regenerated only after the source PR lands. The installed private `antigravity-maintainer-batch-release` skill and its UI metadata were also updated and validated so future sweeps retain the same frozen-matrix, black-box, and publication-approval gates.
- Honest tuning-only diagnostic remains below release thresholds: macro verified coverage `0.366667`, macro inclusion precision `0.563889`, critical-goal coverage `0.616667`, and non-critical-goal coverage `0.533333`, with zero hard-policy violations. Inspection showed semantically valid alternatives omitted from the current frozen tuning gold. Changing that gold is prohibited without a separate independent equivalence audit, explicit approval, protected PR, and baseline re-freeze.
## Remaining approval gates
- Explicit approval was granted for the independently owned product black-box verifier and six-job Node 22/24 acceptance workflow for Linux, macOS, and Windows. That work remains isolated from the product branch and must land through its own protected PR before the baseline is re-frozen.
- Explicit approval was granted for an independent tuning-gold equivalence audit. Its accepted equivalences, review evidence, and updated freeze remain isolated on their own branch and must land through a separate protected PR. Product code has not tuned around the known omissions or read held-out inputs.
- Only after those two gates pass may the clean-tarball held-out/abstention evaluator, 100,000 property cases, 50,000 parser/MCP fuzz cases, observed zero-network/zero-write MCP traces, production-binary fault/race matrix, legacy differential, host smoke tests, and exact evidence bundle be treated as release acceptance.
- Tag, npm publication, Pages deployment, or writes to real user MCP configuration remain separately approval-gated and have not occurred.
## 2026-07-17 — Additive agent-first preview profile
- The frozen certified-v1 design, benchmark, hostile corpus, verifier, and goal
remain unchanged. The new preview profile is an intermediate product-learning
gate and cannot complete the active certified-v1 goal.
- `stack apply` and `stack recover` are now disabled by default in the preview.
Controlled development requires `--experimental-apply` or
`--experimental-recovery`; successful writes are labelled experimental.
- Added a packed-product functional runner for `init -> recommend -> validate ->
plan -> doctor`, deterministic explanation output, all five local stdio MCP
tools, the skill resource template, read-only project/cache snapshots, legacy
isolation, and default write guards.
- Added a six-job Node 22/24 matrix for Linux, macOS, and Windows, plus Workbench
tests/build and a fail-closed receipt aggregator. A passing bundle must say
`previewQualified: true` and `certifiedV1: false` and must enumerate native
syscall observation, transactional crash/race certification, the 80/90/100
benchmark, real host writes, and public release as not evaluated.
- The preview contract and evidence bundle preserve this boundary. Any further
canonical maintainer-skill wording change remains a separate source/sync
maintenance action, so this product PR does not create registry drift.
- No npm package, GitHub release, Pages deployment, announcement, or real MCP
configuration write is authorized by this profile.
@@ -23,7 +23,7 @@ The workflow expects the repository to be clean after those sync steps finish. A
## Pull Requests vs Main
- **Pull requests**: PRs are now **source-only**. Contributors should not commit derived registry artifacts (`CATALOG.md`, `skills_index.json`, `data/*.json`). CI blocks those direct edits and reports generated drift as an informational preview only.
- **`main` pushes**: drift is still strict. `main` must end the workflow clean after the auto-sync step.
- **`main` pushes**: drift is still strict. The workflow may publish only managed drift through `automation/canonical-repo-state`; required CI must reproduce that PR as the exact expected Git tree before an immediate protected merge.
## How to Fix on `main`
@@ -40,23 +40,25 @@ The workflow expects the repository to be clean after those sync steps finish. A
git diff
```
3. If the sync produced only canonical/generated changes, stage and commit them. Prefer the generated-files contract instead of a hand-maintained file list:
3. If the sync produced only canonical/generated changes, open a source-free PR rather than pushing to protected `main`. Prefer the generated-files contract instead of a hand-maintained file list:
```bash
node tools/scripts/generated_files.js --include-mixed
git add $(node tools/scripts/generated_files.js --include-mixed)
git switch -c chore/canonical-artifact-repair
git commit -m "chore: sync canonical artifacts"
git push
git push -u origin chore/canonical-artifact-repair
gh pr create --base main --fill
```
4. If `sync:repo-state` leaves unrelated or unmanaged drift, stop and inspect it. The bot on `main` is only allowed to push the canonical/generated subset; anything else should fail the workflow instead of being silently auto-committed.
4. If `sync:repo-state` leaves unrelated or unmanaged drift, stop and inspect it. The bot is only allowed to publish the canonical/generated subset; anything else must fail instead of being silently included.
## Maintainer guidance for PRs
- Validate the source change, not the absence of committed generated artifacts.
- If a contributor PR includes direct edits to `CATALOG.md`, `skills_index.json`, or `data/*.json`, ask them to drop those files from the PR or remove them while refreshing the branch.
- If merge conflicts touch generated registry files, keep `main`'s version for those files and let `main` auto-sync the final generated artifact set after merge.
- If CI on `main` later creates a bot commit with `[ci skip]`, that is expected only for the canonical/generated subset. It is not a license to push arbitrary extra drift.
- If CI on `main` detects drift, expect one `chore: synchronize canonical repository state` PR. Its special lane still requires managed-only paths and exact reproducibility; it is not a license to include arbitrary changes.
**Summary**:
Use generator drift as a hard failure only on `main`. On PRs, the contract is simpler: source-only changes are reviewed, generated output is previewed, and `main` produces the final canonical artifact set.
@@ -0,0 +1,46 @@
# Legacy Redirect Bridge
The compatibility site at `https://sickn33.github.io/antigravity-awesome-skills/` is published from the separate `sickn33/sickn33.github.io` repository. It preserves old indexed URLs while the canonical site lives at `https://sickn33.github.io/agentic-awesome-skills/`.
## Managed deployment surface
Only these paths belong to the redirect generator:
- `.nojekyll`
- `redirect-manifest.json`
- `antigravity-awesome-skills/**`
The target repository's `README.md` and `.github/**` automation are deliberately outside that managed set.
Generate a fresh bridge from the current catalog:
```bash
npm run pages:redirect-bridge -- --output /new/output/directory
```
The generator keeps the curated sitemap route count locked while deriving the skill count from `skills_index.json`. It also preserves the legacy Google verification file and the Bing verification meta tag on the legacy root page.
Manifest schema version `3` records source-repository provenance, redirect coverage, and webmaster-verification evidence for automation consumers.
Verify a checked-out target repository byte-for-byte:
```bash
npm run pages:redirect-verify -- --deployment-root /path/to/sickn33.github.io
```
Add a bounded live probe after deployment:
```bash
npm run pages:redirect-verify -- \
--deployment-root /path/to/sickn33.github.io \
--live-root https://sickn33.github.io/ \
--live-mode sample
```
Use `--live-mode all` for a complete route-pair audit.
## Publication contract
The target repository owns the scheduled synchronization workflow. It checks out this repository at `main`, regenerates only the managed deployment surface, opens a fixed-branch PR when drift exists, dispatches the exact-head verifier, and merges only after the protected check succeeds. The same run explicitly requests and verifies the legacy Pages build so automation is not dependent on GitHub events suppressed for `GITHUB_TOKEN`-authored changes.
Target `main` must remain protected with strict `legacy-bridge-verify`, administrator enforcement, pull requests required, and force pushes/deletions disabled.
@@ -0,0 +1,28 @@
# Local skill reviewer threat model
## Assets and trust boundaries
Protected assets are repository contents, credentials, local configuration, network authority, review integrity, and truthful completion state. Trusted code is limited to deterministic discovery, validation, local level assignment, scoring, triage, packet construction, schemas, and atomic state/output machinery. Skill files, bundles, Codex judgments, cached data, YAML, Markdown, URLs, candidates, and patches are untrusted.
The local `manual-review-required` status is namespaced to `source: local-skill-reviewer`. It is a triage escalation, not a Tessl result, CI fallback attestation, exact-head approval, or merge authorization.
## Primary threats and controls
| Threat | Control | Failure behavior |
| --- | --- | --- |
| Prompt injection or fabricated scores | Production triage executes no model; semantic packets place a trusted hostile-input instruction outside source data; imported judgments bind exact evidence and all anchor comparisons | Reject malformed, unbound, stale, or out-of-range judgment |
| Tool, shell, MCP, browser, URL, Tessl, or Codex CLI execution | Runtime analyzer has no tool or service adapter and never follows content-derived links or commands | Abort review; offline sentinel tests fail on invocation |
| Credential exfiltration | Likely credential values are redacted from heuristic evidence; semantic packets include only tracked, bounded Git blobs under the allowed bundle roots | Reject sensitive identifiers or malformed imports; repository secret scanning remains a separate gate |
| Path traversal or symlink escape | Git mode/object allowlist, frozen-index reads, POSIX-relative normalization, bounded descriptor reads, physical containment, and symlink-safe output parents | Structured input/output failure |
| YAML expansion or unsafe tags | Frontmatter byte, node, and depth caps; strict parser; aliases, anchors, and tags forbidden | Validation failure and manual escalation |
| Oversized or binary bundle | Per-file, bundle, and count caps; primary Markdown requires UTF-8; binary bytes are hash-only; semantic packets omit rather than invisibly truncate supplemental text | Cap stop or explicit metadata-only/omitted source |
| Cache poisoning or stale evidence | Whole-bundle hashes plus rubric, schema, validator, analyzer, runtime, threshold, and reviewer identity | Cache miss and safe recomputation |
| Crash misreported as completion | Atomic writes and explicit pending/running/completed/failed state; semantic artifact sets require final hash-bound markers | Resume or reject incomplete output |
| False Tessl equivalence | Output calls itself `local-triage-only`, uses `local_quality_score`, and includes a non-equivalence disclaimer; documentation preserves separate validation, blind, and Tessl-repeat figures | Claim is rejected in review; no Tessl-pass prediction is emitted |
| Cost or retry storm | Production runtime has no Tessl dependency; future Tessl use is a separate sample audit only | No paid-service call from triage |
| Unreviewed repository mutation | Reviewer output is outside the repo and the production CLI has no apply path; Codex correction requires normal authorization, diff inspection, references, validation, security, and tests | Correction cannot be called complete until gates rerun |
| Merge bypass | `--merge-gate` always emits P0 and records that exact-head attestation is still required | Maintainer workflow remains blocking |
## Residual risk
Deterministic rules cannot fully understand semantics and can produce false positives or negatives. Codex can still be influenced by hostile text; exact evidence and schema validation prove provenance, not model invulnerability. The accepted 74.5% measurement is Codex-assisted validation performance, not deterministic or blind accuracy. Blind equivalence and stability were not demonstrated. Independent security, repository, and exact-head merge review remain necessary.
@@ -0,0 +1,94 @@
# Local skill reviewer
The local skill reviewer is the production triage path for AAS skills. It runs offline, freezes tracked skill inputs from the Git index, performs deterministic validation and quality checks, assigns local 1-3 rubric levels, computes a `local_quality_score`, and emits priorities plus evidence for follow-up.
It is not Tessl, is not equivalent to Tessl, and cannot guarantee that a skill will pass a Tessl review. Tessl is not a runtime dependency. When credits are available again it may be used only as a separate sample audit.
## Production contract
For each skill, the reviewer emits:
- deterministic validation and AAS policy findings;
- eight locally assigned 1-3 quality levels, confidence, and matched evidence;
- a weighted `local_quality_score` from 0 to 100;
- `triage.reviewStatus`, `triage.priority`, and stable `reasonCodes`;
- exact input and tool-version bindings for cache invalidation and replay.
`triage.reviewStatus` is either `pass` or `manual-review-required`. Here, `pass` means only that no configured escalation rule fired; it is not a quality certification, Tessl result, or merge approval. The local `manual-review-required` value belongs to `source: local-skill-reviewer`; it must not be confused with the identically worded CI/Tessl fallback. It never satisfies the maintainer workflow's exact-head review attestation.
The production escalation rules mark a skill for manual review when it has a validation error, a broken-reference warning, deterministic policy findings, a score below 50, a score within three points of 50 or 75, low-confidence extreme levels, critical/offensive risk, or an explicit merge gate. Priorities are:
- `P0`: merge-blocking candidate; Codex review and the normal exact-head maintainer attestation remain required;
- `P1`: validation, high-risk, or below-50 findings;
- `P2`: other escalation reasons or clean middle-band triage;
- `P3`: clean high-band triage.
## Commands
```bash
npm run review:skills:triage -- --result-dir /private/tmp/aas-review-full --concurrency 4
npm run review:skills:triage -- --resume --result-dir /private/tmp/aas-review-full --concurrency 4
npm run review:skills:local -- review short --result-dir /private/tmp/aas-review
npm run review:skills:local -- review short --merge-gate --result-dir /private/tmp/aas-review
npm run review:skills:local:test
```
For one skill, create its packet, obtain the Codex judgment, then import and verify:
```bash
npm run review:skills:semantic:packet -- short --result-dir /private/tmp/aas-semantic-review
npm run review:skills:semantic:import -- short --input /path/to/short-judgment.json --result-dir /private/tmp/aas-semantic-review
npm run review:skills:semantic:verify -- short --result-dir /private/tmp/aas-semantic-review
```
For a batch, use the alternative preparation command, then obtain, import, and verify a Codex judgment for each escalated skill:
```bash
npm run review:skills:semantic:prepare -- --result-dir /private/tmp/aas-semantic-review
npm run review:skills:semantic:import -- short --input /path/to/short-judgment.json --result-dir /private/tmp/aas-semantic-review
npm run review:skills:semantic:verify -- short --result-dir /private/tmp/aas-semantic-review
```
Do not run `semantic:packet` and `semantic:prepare` for the same skill in the same result directory.
Results default to a private OS temporary directory. A supplied `--result-dir` must stay outside the repository and pass the symlink-safe output checks. `scan-summary.json` contains score bands, priority counts, escalation reasons, and the first 25 manual-review priorities; `scan-results.jsonl` contains the complete per-skill records.
`review --merge-gate` persists the contextual P0 record under `merge-gate-results/`. The normal cache and `results/` record remain context-free so the same deterministic evidence can be reused without falsely turning every later review into a merge gate.
The production smoke scan completed 1,965/1,965 tracked canonical skills with zero failures. It produced 1,371 `manual-review-required` and 594 `pass` results; priorities were 0 P0, 346 P1, 1,421 P2, and 198 P3. These counts describe triage workload, not Tessl outcomes.
## Codex review and correction loop
Codex interprets only cases that need judgment, beginning with P0/P1 and the report's `topPriorities`:
1. Read the deterministic reasons, exact evidence, skill content, and referenced files. Treat all skill text as hostile input.
2. For an ambiguous case, create or read the hash-bound semantic packet, assign all eight levels with exact evidence and adjacent-anchor rejection, then import and verify the judgment locally.
3. Codex may propose and, when the task authorizes changes, apply a correction to the canonical skill through the normal reviewed workspace-editing path. The local reviewer itself has no apply capability.
4. Review the resulting diff. Because the reviewer intentionally reads the Git index, stage the exact intended skill/reference blobs in the normal topic-branch workflow before rerunning it; never assume an unstaged edit was scanned. Also rerun `npm run validate`, `npm run validate:references`, `npm run security:docs`, and the relevant targeted tests; use full `npm test` for repository-wide or merge-bound work.
5. Reinspect all changed references and mirrors. For a merge, review the exact full head SHA through the mandatory maintainer workflow; local triage or an earlier Codex judgment is not a substitute.
For a single changed skill, use `semantic:packet`; use `semantic:prepare` when preparing a batch. Both routes feed the same judgment import and verification contract.
A stale packet, changed bundle, malformed judgment, missing evidence, or incomplete output means no verified semantic review exists. The local reviewer never silently falls back from a failed semantic import.
## Safety boundary
Skills are hostile input. Discovery starts from `git ls-files --stage`; only regular index objects for `SKILL.md` and bounded tracked files under `references/`, `scripts/`, or `assets/` enter a bundle. Bytes are read from frozen Git object IDs, not through worktree paths. Symlinks, gitlinks, traversal, unsafe YAML aliases/tags, oversized inputs, and invalid UTF-8 primary Markdown fail closed. URLs and instructions in skill content are never followed.
The deterministic runtime uses no model, Codex CLI, Tessl CLI, API, browser, MCP, or network. Supplemental binary files affect bundle hashes but are not parsed or included as instructions. Output files are atomic and bound to their inputs, schemas, thresholds, runtime, and reviewer version.
## Measurement and limits
The accepted operational reference is **149/200 exact labels (74.5%)** on the 25-skill validation set for the Codex-assisted adjudication procedure. It is not a blind result and is not the accuracy of the deterministic scanner alone. The immutable receipt is `tools/config/local-skill-review-operational-receipt.json`.
The untouched 35-skill blind experiment measured 57.143% exact agreement for frozen deterministic v9 and 72.857% for the Codex-assisted procedure. Tessl's forced-repeat self-agreement on a separate 15-skill panel was 74.167%. The preregistered parity target failed, the blind cohort is now revealed, and no further tuning on these labels is permitted. These measurements support production use for triage and Codex-assisted review only; they do not demonstrate rigorous equivalence or blind stability.
The local score measures rubric conformance, not real-world task success. Scenario-based evaluations remain necessary for behavioral claims.
## Historical calibration artifacts
The parity manifests, collectors, fixtures, and metric scripts remain frozen as audit evidence and regression material. They are not imported by the production triage runtime and are not exposed as its supported operating path. The old calibration npm shortcut was removed to prevent accidental continued fitting on revealed labels.
## Criterion provenance
The local rubric, schemas, anchors, reason codes, fixtures, and wording are original clean-room material. Only publicly observable dimension names, 1-3 scale, and weights informed the design. No private Tessl prompt, server validator, model behavior, example, or implementation is treated as provenance.
@@ -1,10 +1,11 @@
# Merge Batch
`merge:batch` is the maintainer shortcut for merging multiple PRs in order while keeping the GitHub-only squash rule and the post-merge contributor sync.
`merge:batch` is the maintainer shortcut for merging multiple PRs in order while keeping the GitHub-only squash rule and delegating generated follow-up work to the protected canonical-sync PR lane.
## Prerequisites
- Start from a clean `main`.
- Start from a clean `main` that exactly matches `origin/main`.
- For a real merge, require pull-request-only strict branch protection with the four exact GitHub-Actions-owned checks, administrator enforcement, no applicable ruleset bypass actors, and no merge queue. Dry runs remain available without this server-side prerequisite.
- Make sure [`.github/MAINTENANCE.md`](../../.github/MAINTENANCE.md) is the governing policy.
- Have `gh` authenticated with maintainer permissions.
- Use this only for PRs that are already expected to merge; conflicting PRs still need the manual conflict playbook.
@@ -17,31 +18,45 @@ npm run merge:batch -- --prs 450,449,446,451
Add `--poll-seconds <n>` if you want a slower or faster status loop while checks settle.
If a PR changes canonical `SKILL.md` content or its allowlisted supporting assets/references/resources, first review the exact current head commit, then attest to that immutable revision:
```bash
npm run merge:batch -- --prs 450 --reviewed-head <40-character-head-sha>
```
Use `--dry-run` to exercise local classification without approving a run or merging. An abbreviated or stale attestation is rejected.
## Happy Path
`merge:batch` will:
- refresh the PR body when the Quality Bar checklist is missing
- close and reopen the PR if stale metadata needs a fresh `pull_request` event
- approve fork runs waiting on `action_required`
- wait for the fresh required checks on the current head SHA
- merge with GitHub squash merge
- pull `main`, run `sync:contributors`, and push a README-only follow-up if needed
- record the existing workflow-run generation, then close and reopen the PR if stale metadata needs a fresh `pull_request` event
- fetch the exact base/head objects and classify the complete raw Git diff
- recompute changed-skill evidence with evaluator code materialized from the trusted `main` commit
- reject incomplete evidence coverage, deterministic quality/security/provenance regressions, and base/head drift
- for external PRs, poll for asynchronously-created fork runs and approve only post-reopen runs waiting on `action_required` when every path, mode, object, size, and workflow identity is allowlisted
- for same-repository maintainer PRs, allow repository-wide source changes while still enforcing trusted changed-skill evidence, exact-head review, required checks, branch protection, and immutable PR identity
- wait only for check suites belonging to the post-reopen workflow generation; older runs on the same head SHA cannot satisfy or fail the gate
- call GitHub's immediate squash-merge endpoint and continue only when it reports `merged: true`
- pull the protected `main`; its trusted workflow opens a canonical-sync bot PR for generated artifacts and contributor credits when needed
## What It Automates
- PR body normalization against the repository template
- stale PR metadata refresh
- required-check polling for the current PR head
- the post-merge contributor sync step
- the retry loop for `Base branch was modified`
- generation-bound required-check polling for the current PR head
- handoff of post-merge contributor and artifact drift to the canonical-sync PR lane
## What It Does Not Automate
- conflict resolution on the PR branch
- manual judgment for risky skill changes
- semantic review when the distinct `manual-review-required` check is present
- README community-source audits when the source metadata is ambiguous
- fork-only edge cases that require contributor coordination outside GitHub permissions
- base-branch drift: stale evidence is discarded and the batch must be rerun
- auto-merge and merge-queue enrollment; deferred merge state is rejected
## When To Stop
@@ -50,6 +65,9 @@ Stop and switch to the manual playbook when:
- the PR is `CONFLICTING`
- `merge:batch` reports a check failure that needs source changes, not maintainer automation
- the PR needs a manual README credits decision
- an external PR's local diff contains a symlink, gitlink, executable mode, unknown path/type, oversized blob, or other non-allowlisted change
- the workflow run cannot be bound to the intended PR number, current head SHA, `pull_request` event, and trusted workflow definition
- fork approval or branch permissions are missing
- effective strict protection for `main` cannot be proven
In those cases, follow [Merging Pull Requests](merging-prs.md) and the relevant sections in [MAINTENANCE.md](../../.github/MAINTENANCE.md).
@@ -0,0 +1,91 @@
# Pull Request Autonomy
This document describes the repository's staged path toward lower-maintenance pull-request handling. The first stage is evidence and routing, not automatic merge.
## Trust Model
Pull-request CI is unprivileged: it has read-only repository permissions and receives no repository secrets. Reports produced there are useful to contributors and maintainers, but they are explicitly advisory because the pull-request checkout can modify the reporting code itself.
Any privileged or local maintainer action must recompute its decision from trusted `main` code against immutable base and head object IDs. It must not consume the pull-request-generated decision artifact as authorization.
`merge:batch` therefore materializes the evaluator from the exact local `main` commit after proving that local `HEAD` equals `origin/main`. It runs that tracked-only evaluator in an isolated Python process; untracked workspace files, pull-request scripts, Python environment overrides, and uploaded artifacts are not part of the authorization path.
## Evidence Artifacts
The `pr-evidence` CI job produces:
- `preflight.json`: changed files, broad change categories, source-only policy state, and pull-request template state;
- `changed-skills.json`: before/after evidence for changed canonical skills, including audit findings, score, security flags, risk, provenance, and deterministic regression reasons;
- `decision-manifest.json`: a schema-versioned shadow routing recommendation.
The manifest always contains:
```json
{
"schema_version": 1,
"mode": "shadow",
"untrusted_advisory": true,
"route": "human_review"
}
```
The `untrusted_advisory` marker is intentional. No workflow, merge command, or future bot may treat the artifact as privileged authorization.
## Shadow Routes
- `block`: deterministic repository policy failed, such as a newly introduced changed-skill regression or a direct edit to generated artifacts.
- `human_review`: the change is valid enough to inspect, but it touches canonical skill content, sensitive paths, uncertain provenance/risk, or lacks semantic review.
- `eligible_for_later_automation`: deterministic evidence found no blocker and the change belongs to a low-risk class. In the current stage this remains advisory and does not enable auto-merge.
Every new or relocated skill and every canonical skill-content change requires maintainer review in v1. A `safe` risk label is not sufficient evidence for automatic merge.
## Fork Review States
The Skill Review workflow separates three outcomes:
- `review`: a semantic review actually ran using trusted base scripts;
- `manual-review-required`: repository secrets were unavailable to a fork, so a maintainer must review and attest to the exact head SHA;
- `missing-review-credentials`: an internal branch expected semantic-review credentials but none were configured, so the check fails closed.
A successful `manual-review-required` check means only that the requirement was recorded. It is not a successful semantic review.
## Maintainer Recalculation
`merge:batch` must bind workflow approval and human attestation to one full head SHA. When it refreshes a PR body by closing and reopening the PR, it also records the pre-refresh workflow-run IDs and accepts checks only from post-refresh check suites. A shared head SHA is not sufficient evidence of freshness because multiple `pull_request` events can exist for the same commit. Before approving a waiting fork run, it independently:
1. captures base and head object IDs;
2. fetches those objects without checking out pull-request code;
3. computes a complete NUL-delimited raw Git diff with full object IDs and modes;
4. for external PRs, rejects unsafe paths, modes, symlinks, gitlinks, executable files, unknown types, oversized blobs, incomplete metadata, or non-allowlisted workflows;
5. verifies workflow event, workflow identity, pull-request number, and head SHA;
6. recomputes changed-skill evidence over the exact merge-base-to-head record set and requires one-to-one coverage of every skill-content Git record;
7. rejects operational errors, malformed evidence, incomplete snapshots, score-component regressions, provenance identity regressions, or any other deterministic blocker;
8. re-reads both pull-request base and head before and after approval and immediately before merge.
A real merge also requires effective server-side protection for `main`: the four exact GitHub-Actions-owned checks (`pr-policy`, `pr-evidence`, `source-validation`, and `artifact-preview`), strict up-to-date enforcement, pull-request-only changes, administrator enforcement, no applicable ruleset bypass actors, and no merge queue. If that enforcement cannot be proven, `merge:batch` refuses non-dry-run operation. Base drift is never retried with stale evidence; the batch must be rerun from the new tuple. Pre-existing auto-merge state is rejected, and the immediate GitHub merge endpoint must return `merged: true` before post-merge work begins.
Same-repository maintainer PRs may legitimately change repository-wide policy, tooling, workflows, or documentation, so the fork content allowlist does not apply to them. They remain bound to the protected branch, trusted-base evidence evaluator, exact PR/base/head tuple, semantic-review requirements, and required checks. Missing or mismatched head-repository identity is treated as external and therefore fails closed under the fork allowlist.
For canonical `SKILL.md` or allowlisted supporting skill-content changes, the maintainer supplies `--reviewed-head <full-sha>`. A stale, abbreviated, or mismatched SHA fails closed. The Skill Review check itself is required only for `SKILL.md` changes because that workflow is path-filtered; support-only changes still require the exact-SHA human attestation.
Deletions, copies, ambiguous moves, and all canonical skill-content changes remain manual-only in this stage even when deterministic evidence contains no regression. A passing ratchet is not semantic approval and never makes a skill eligible for automatic merge.
## Protected Canonical Sync
Generated artifacts and contributor credits no longer write directly to `main`. Push and scheduled maintenance workflows regenerate the repository state without persisted checkout credentials, reject any unmanaged drift, and maintain one bot PR from `automation/canonical-repo-state`.
Because GitHub suppresses ordinary workflow recursion for PRs created with `GITHUB_TOKEN`, the trusted writer explicitly dispatches the four required checks on the bot branch. That dispatch is accepted only on the exact branch, only for files declared by the generated-files contract, and only when rerunning `sync:repo-state` produces the exact full Git tree. A trusted waiter binds the open PR to its immutable head, verifies all four exact GitHub Actions checks, confirms that `main` remains protected and unchanged, performs an immediate exact-head squash merge, and explicitly dispatches main CI, Pages, and CodeQL. The detailed protection policy is configured and audited with maintainer credentials; the workflow token has no bypass around it.
## Later Phases
Each phase requires evidence from the previous phase before activation:
1. Observe shadow route accuracy and false-positive rates on real pull requests.
2. Move remaining release writers to protected release pull requests; canonical CI, hygiene, and contributor-sync writers already use the bot pull-request lane.
3. Keep `main` protected by stable app-bound checks and remove any newly introduced direct writer.
4. Add schema-validated fork-safe semantic review whose privileged code always comes from the protected base.
5. Build deterministic release-candidate pull requests with rendering separated from publication.
6. Add immutable upstream commit/path/hash provenance and a delta-based exception ledger.
7. Consider auto-merge only for empirically proven documentation or metadata classes. New skills, security-sensitive content, workflows, installers, releases, provenance exceptions, and policy changes remain human decisions.
Merge queue is not part of the current plan. The repository is personally owned, and its workflows do not currently support a `merge_group` event.
@@ -49,7 +49,7 @@ Use this as a diagnostic signal. It is useful for spotting legacy quality debt,
- If PR or CI workflow behavior changed during the cycle, confirm maintainer and contributor docs mention the active checks (for example the `skill-review` workflow for `SKILL.md` pull requests).
- If maintainers used `npm run sync:risk-labels` or a comparable cleanup flow during the cycle, make sure the maintainer docs still describe the current audit -> sync -> repo-state loop.
5. Prepare the release commit and tag locally:
5. Prepare the protected release PR:
```bash
npm run release:prepare -- X.Y.Z
@@ -62,16 +62,16 @@ This command:
- runs the full release suite
- refreshes release metadata in `README.md`
- stages canonical release files
- creates `chore: release vX.Y.Z`
- creates the local tag `vX.Y.Z`
- creates and pushes `release/vX.Y.Z`
- opens a release PR containing the scripted canonical release state
6. Publish the GitHub release:
6. Merge the release PR through required checks, update local `main`, then publish the GitHub release:
```bash
npm run release:publish -- X.Y.Z
```
This command pushes `main`, pushes `vX.Y.Z`, and creates the GitHub release object from the matching `CHANGELOG.md` section.
This command proves local `main` equals protected `origin/main` and the exact squash commit of the merged `release/vX.Y.Z` PR, checks that no canonical-sync PR or release-state drift remains, creates or reuses the matching local/remote tag safely, and creates the GitHub release object from the matching `CHANGELOG.md` section. It never pushes `main` directly and can be retried after a partial tag/release failure.
7. Publish to npm if needed:
@@ -84,12 +84,12 @@ That workflow now reruns `sync:release-state`, installs Python dependencies from
## Canonical Sync Bot
`main` still uses the repository's auto-sync model for canonical generated artifacts, but with a narrow contract:
`main` still uses the repository's auto-sync model for canonical generated artifacts, but through a protected pull-request contract:
- PRs stay source-only.
- After merge, the `main` workflow may commit generated canonical files directly to `main` with `[ci skip]`.
- Those bot commits still skip CI, so the sync contract must stay narrow and predictable: only canonical/generated files may be staged, and any unmanaged drift must fail the workflow instead of being silently pushed.
- The bot commit is only allowed to stage files resolved from `tools/scripts/generated_files.js --include-mixed`.
- After merge, the `main` workflow may open or update `automation/canonical-repo-state`; it never pushes generated files directly to `main`.
- The bot PR is only allowed to stage files resolved from `tools/scripts/generated_files.js --include-mixed`.
- Its explicitly dispatched required checks require both managed-only paths and an exact converged Git tree before an immediate protected merge.
- If repo-state sync leaves any unmanaged tracked or untracked drift, the workflow fails instead of pushing a partial fix.
- The scheduled hygiene workflow follows the same contract and shares the same concurrency group so only one canonical sync writer runs at a time.
@@ -6,7 +6,7 @@ This document keeps the repository's GitHub-facing discovery copy aligned with t
Preferred positioning:
> Installable GitHub library of 1,948+ agentic skills for Claude Code, Cursor, Codex CLI, Gemini CLI, Antigravity, and other AI coding assistants.
> Installable GitHub library of 1,965+ agentic skills for Claude Code, Cursor, Codex CLI, Gemini CLI, Antigravity, and other AI coding assistants.
Key framing:
@@ -20,7 +20,7 @@ Key framing:
Preferred description:
> Installable GitHub library of 1,948+ agentic skills for Claude Code, Cursor, Codex CLI, Gemini CLI, Antigravity, and more. Includes installer CLI, bundles, workflows, and official/community skill collections.
> Installable GitHub library of 1,965+ agentic skills for Claude Code, Cursor, Codex CLI, Gemini CLI, Antigravity, and more. Includes installer CLI, bundles, workflows, and official/community skill collections.
Preferred homepage:
@@ -28,7 +28,7 @@ Preferred homepage:
Preferred social preview:
- use a clean preview image that says `1,948+ Agentic Skills`;
- use a clean preview image that says `1,965+ Agentic Skills`;
- mention Claude Code, Cursor, Codex CLI, and Gemini CLI;
- avoid dense text and tiny logos that disappear in social cards.
@@ -72,7 +72,7 @@ The update process refreshes:
- Canonical skills index (`skills_index.json`)
- Compatibility mirror (`data/skills_index.json`)
- Web app skills data (`apps\web-app\public\skills.json`)
- All 1,948+ skills from the skills directory
- All 1,965+ skills from the skills directory
## When to Update
@@ -1060,4 +1060,4 @@ Found a skill that should be in a bundle? Or want to create a new bundle? [Open
---
_Last updated: June 2026 | Total Skills: 1,948+ | Total Bundles: 58_
_Last updated: June 2026 | Total Skills: 1,965+ | Total Bundles: 58_
@@ -12,7 +12,7 @@ Install the library into Claude Code, then invoke focused skills directly in the
## Why use this repo for Claude Code
- It includes 1,948+ skills instead of a narrow single-domain starter pack.
- It includes 1,965+ skills instead of a narrow single-domain starter pack.
- It supports the standard `.claude/skills/` path and the Claude Code plugin marketplace flow.
- It also ships generated bundle plugins so teams can install focused packs like `Essentials` or `Security Developer` from the marketplace metadata.
- It includes onboarding docs, bundles, and workflows so new users do not need to guess where to begin.
+1 -1
View File
@@ -423,7 +423,7 @@ Common fixes:
### My PR triggered the `skill-review` automated check. What is it?
Since v8.0.0, GitHub automatically runs a `skill-review` workflow on any PR that adds or modifies a `SKILL.md` file. It reviews your skill against the quality bar and flags common issues — missing sections, weak triggers, or risky command patterns. The workflow now uses Tessl Review; fork PRs may need maintainer manual review when GitHub withholds repository secrets.
Since v8.0.0, GitHub automatically runs a `skill-review` workflow on any PR that adds or modifies a `SKILL.md` file. It reviews your skill against the quality bar and flags common issues — missing sections, weak triggers, or risky command patterns. The workflow now uses Tessl Review; fork PRs may need maintainer manual review when GitHub withholds repository secrets. Successful reviews are keyed to the changed skill content, so unrelated pushes and base-branch refreshes reuse the result without spending more Tessl credits. If the monthly credit quota is unavailable, the workflow requests an exact-head maintainer review rather than returning a false automated pass.
**If it reports findings:**
@@ -12,7 +12,7 @@ Install into the Gemini skills path, then ask Gemini to apply one skill at a tim
- It installs directly into the expected Gemini skills path.
- It includes both core software engineering skills and deeper agent/LLM-oriented skills.
- It helps new users get started with bundles and workflows rather than forcing a cold start from 1,948+ files.
- It helps new users get started with bundles and workflows rather than forcing a cold start from 1,965+ files.
- It is useful whether you want a broad internal skill library or a single repo to test many workflows quickly.
## Install Gemini CLI Skills
@@ -1,4 +1,4 @@
# Getting Started with Agentic Awesome Skills (V14.3.1)
# Getting Started with Agentic Awesome Skills (V14.6.0)
**New here? This guide will help you supercharge your AI Agent in 5 minutes.**
@@ -18,7 +18,7 @@ Kiro is AWS's agentic AI IDE that combines:
Kiro's agentic capabilities are enhanced by skills that provide:
- **Domain expertise** across 1,948+ specialized areas
- **Domain expertise** across 1,965+ specialized areas
- **Best practices** from Anthropic, OpenAI, Google, Microsoft, and AWS
- **Workflow automation** for common development tasks
- **AWS-specific patterns** for serverless, infrastructure, and cloud architecture
@@ -14,7 +14,7 @@ If you came in through a **Claude Code** or **Codex** plugin instead of a full l
When you ran `npx agentic-awesome-skills` or cloned the repository, you:
**Downloaded 1,948+ skill files** to your computer (default: `~/.agents/skills/`; or a custom path like `~/.agent/skills/` if you used `--path`)
**Downloaded 1,965+ skill files** to your computer (default: `~/.agents/skills/`; or a custom path like `~/.agent/skills/` if you used `--path`)
**Made them available** to your AI assistant
**Did NOT enable them all automatically** (they're just sitting there, waiting)
@@ -34,7 +34,7 @@ Bundles are **curated groups** of skills organized by role. They help you decide
**Analogy:**
- You installed a toolbox with 1,948+ tools (✅ done)
- You installed a toolbox with 1,965+ tools (✅ done)
- Bundles are like **labeled organizer trays** saying: "If you're a carpenter, start with these 10 tools"
- You can either **pick skills from the tray** or install that tray as a focused marketplace bundle plugin
@@ -212,7 +212,7 @@ Let's actually use a skill right now. Follow these steps:
## Step 5: Picking Your First Skills (Practical Advice)
Don't try to use all 1,948+ skills at once. Here's a sensible approach:
Don't try to use all 1,965+ skills at once. Here's a sensible approach:
If you want a tool-specific starting point before choosing skills, use:
@@ -343,7 +343,7 @@ Usually no, but if your AI doesn't recognize a skill:
### "Can I load all skills into the model at once?"
No. Even though you have 1,948+ skills installed locally, you should **not** concatenate every `SKILL.md` into a single system prompt or context block.
No. Even though you have 1,965+ skills installed locally, you should **not** concatenate every `SKILL.md` into a single system prompt or context block.
The intended pattern is:
@@ -34,7 +34,7 @@ agentic-awesome-skills/
├── 📄 CONTRIBUTING.md ← Contributor workflow
├── 📄 CATALOG.md ← Full generated catalog
├── 📁 skills/ ← 1,948+ skills live here
├── 📁 skills/ ← 1,965+ skills live here
│ │
│ ├── 📁 brainstorming/
│ │ └── 📄 SKILL.md ← Skill definition
@@ -47,7 +47,7 @@ agentic-awesome-skills/
│ │ └── 📁 2d-games/
│ │ └── 📄 SKILL.md ← Nested skills also supported
│ │
│ └── ... (1,948+ total)
│ └── ... (1,965+ total)
├── 📁 apps/
│ └── 📁 web-app/ ← Interactive browser
@@ -100,7 +100,7 @@ agentic-awesome-skills/
```
┌─────────────────────────┐
│ 1,948+ SKILLS │
│ 1,965+ SKILLS │
└────────────┬────────────┘
┌────────────────────────┼────────────────────────┐
@@ -201,7 +201,7 @@ If you want a workspace-style manual install instead, cloning into `.agent/skill
│ ├── 📁 brainstorming/ │
│ ├── 📁 stripe-integration/ │
│ ├── 📁 react-best-practices/ │
│ └── ... (1,948+ total) │
│ └── ... (1,965+ total) │
└─────────────────────────────────────────┘
```