@evertonferreira96/agents 0.0.0-stage → 0.1.0

package/.claude/skills/ui-ux-pro-max/scripts/search.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+UI/UX Pro Max Search - BM25 search engine for UI/UX style guides
+Usage: python search.py "<query>" [--domain <domain>] [--stack <stack>] [--max-results 3]
+       python search.py "<query>" --design-system [-p "Project Name"]
+       python search.py "<query>" --design-system --persist [-p "Project Name"] [--page "dashboard"]
+
+Domains: style, prompt, color, chart, landing, product, ux, typography
+Stacks: html-tailwind, react, nextjs
+
+Persistence (Master + Overrides pattern):
+  --persist    Save design system to design-system/MASTER.md
+  --page       Also create a page-specific override file in design-system/pages/
+"""
+
+import argparse
+import sys
+import io
+from core import CSV_CONFIG, AVAILABLE_STACKS, MAX_RESULTS, search, search_stack
+from design_system import generate_design_system, persist_design_system
+
+# Force UTF-8 for stdout/stderr to handle emojis on Windows (cp1252 default)
+if sys.stdout.encoding and sys.stdout.encoding.lower() != 'utf-8':
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+if sys.stderr.encoding and sys.stderr.encoding.lower() != 'utf-8':
+    sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8')
+
+
+def format_output(result):
+    """Format results for Claude consumption (token-optimized)"""
+    if "error" in result:
+        return f"Error: {result['error']}"
+
+    output = []
+    if result.get("stack"):
+        output.append(f"## UI Pro Max Stack Guidelines")
+        output.append(f"**Stack:** {result['stack']} | **Query:** {result['query']}")
+    else:
+        output.append(f"## UI Pro Max Search Results")
+        output.append(f"**Domain:** {result['domain']} | **Query:** {result['query']}")
+    output.append(f"**Source:** {result['file']} | **Found:** {result['count']} results\n")
+
+    for i, row in enumerate(result['results'], 1):
+        output.append(f"### Result {i}")
+        for key, value in row.items():
+            value_str = str(value)
+            if len(value_str) > 300:
+                value_str = value_str[:300] + "..."
+            output.append(f"- **{key}:** {value_str}")
+        output.append("")
+
+    return "\n".join(output)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="UI Pro Max Search")
+    parser.add_argument("query", help="Search query")
+    parser.add_argument("--domain", "-d", choices=list(CSV_CONFIG.keys()), help="Search domain")
+    parser.add_argument("--stack", "-s", choices=AVAILABLE_STACKS, help="Stack-specific search (html-tailwind, react, nextjs)")
+    parser.add_argument("--max-results", "-n", type=int, default=MAX_RESULTS, help="Max results (default: 3)")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+    # Design system generation
+    parser.add_argument("--design-system", "-ds", action="store_true", help="Generate complete design system recommendation")
+    parser.add_argument("--project-name", "-p", type=str, default=None, help="Project name for design system output")
+    parser.add_argument("--format", "-f", choices=["ascii", "markdown"], default="ascii", help="Output format for design system")
+    # Persistence (Master + Overrides pattern)
+    parser.add_argument("--persist", action="store_true", help="Save design system to design-system/MASTER.md (creates hierarchical structure)")
+    parser.add_argument("--page", type=str, default=None, help="Create page-specific override file in design-system/pages/")
+    parser.add_argument("--output-dir", "-o", type=str, default=None, help="Output directory for persisted files (default: current directory)")
+
+    args = parser.parse_args()
+
+    # Design system takes priority
+    if args.design_system:
+        result = generate_design_system(
+            args.query, 
+            args.project_name, 
+            args.format,
+            persist=args.persist,
+            page=args.page,
+            output_dir=args.output_dir
+        )
+        print(result)
+        
+        # Print persistence confirmation
+        if args.persist:
+            project_slug = args.project_name.lower().replace(' ', '-') if args.project_name else "default"
+            print("\n" + "=" * 60)
+            print(f"✅ Design system persisted to design-system/{project_slug}/")
+            print(f"   📄 design-system/{project_slug}/MASTER.md (Global Source of Truth)")
+            if args.page:
+                page_filename = args.page.lower().replace(' ', '-')
+                print(f"   📄 design-system/{project_slug}/pages/{page_filename}.md (Page Overrides)")
+            print("")
+            print(f"📖 Usage: When building a page, check design-system/{project_slug}/pages/[page].md first.")
+            print(f"   If exists, its rules override MASTER.md. Otherwise, use MASTER.md.")
+            print("=" * 60)
+    # Stack search
+    elif args.stack:
+        result = search_stack(args.query, args.stack, args.max_results)
+        if args.json:
+            import json
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+        else:
+            print(format_output(result))
+    # Domain search
+    else:
+        result = search(args.query, args.domain, args.max_results)
+        if args.json:
+            import json
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+        else:
+            print(format_output(result))

package/.claude/skills/writing-for-agents/SKILL-MECHANICS.md

@@ -0,0 +1,22 @@
+# Skill mechanics
+
+The skill-specific branch of [`writing-for-agents`](SKILL.md): what changes when the document is a skill (frontmatter, the invocation choice, and router skills). Everything else about writing it is the universal reference in `SKILL.md`.
+
+## Invocation
+
+Two choices, trading the two loads:
+
+- A **model-invoked** skill keeps a `description`, so the agent can fire it autonomously, and other skills can reach it. You can still type its name: model-invocation always _includes_ user reach; a description only ever adds agent discovery, never removes the human's. The description is the skill's top-level context pointer, forced to stay loaded at all times: permanent context load in exchange for discoverability. A model-invoked skill whose content is all reference is also one home for shared reference: another skill can invoke it, so reference needed by several skills lives in one place. Mechanics: omit `disable-model-invocation`, and write a model-facing description carrying the trigger branches (the pointer-writing rules in `SKILL.md` apply in full).
+- A **user-invoked** skill strips the description from the agent's reach: only the human typing its name can invoke it, and no other skill can. Zero context load, but it spends cognitive load: you are the index that must remember it exists. Mechanics: set `disable-model-invocation: true`; the `description` becomes human-facing: a one-line summary, trigger lists stripped.
+
+Pick model-invocation only when the agent must reach the skill on its own, or another skill must. If it only ever fires by hand, make it user-invoked and pay no context load.
+
+Shared reference that two user-invoked skills both need can live in neither: with no descriptions, neither can fire the other. Push it to a plain file outside the skill system: external reference any skill can point at.
+
+## Splitting by invocation
+
+The invocation cut of splitting (the sequence cut lives in `SKILL.md`): split off a model-invoked skill when you have a distinct leading word that should trigger it on its own (a trigger word you actually use in your prompts), or another skill must reach it. You pay context load for the new always-loaded description, so that independent reach has to be worth it.
+
+## Router skills
+
+When user-invoked skills multiply past what you can remember, that piled-up cognitive load is cured by a **router skill**: one user-invoked skill that names the others and when to reach for each, so the human has one skill to remember instead of many. It can only hint, never fire them: user-invoked skills have no description, so nothing but the human can reach them.

package/.claude/skills/writing-for-agents/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: writing-for-agents
+description: Writing documents for agents. Use when creating or editing skills, or modifying AGENTS.md or CLAUDE.md.
+---
+
+Reference for writing any document an agent consumes: a skill, an `AGENTS.md` / `CLAUDE.md`, a doc reached by a pointer. The packaging differs; the writing does not: the same levers make each one predictable, since the agent takes the same _process_ every run rather than producing the same output.
+
+When the document you're writing is a skill, read [`SKILL-MECHANICS.md`](SKILL-MECHANICS.md) for frontmatter, invocation choice, and router skills.
+
+## Context pointers
+
+A **context pointer** is a reference held in the agent's context that names some out-of-context material and encodes the condition for reaching it. A skill's description is one; a line in `AGENTS.md` naming a doc is the same object. The pointer's _wording_, not its target, decides when the agent reaches the material, and how reliably. A must-have target behind a weakly worded pointer is a variance bug: sharpen the wording first, and inline the material only if sharpening fails.
+
+A pointer does two jobs: state what the material is, and list the **branches** that should trigger reaching it (a branch is a distinct case the document handles, so different runs take different paths through it). Every word of an always-loaded pointer costs on every turn, so it earns even harder pruning than the body:
+
+- **Front-load the leading word**: the pointer is where it does its triggering work.
+- **One trigger per branch.** Synonyms that rename a single branch are one branch written twice; collapse them and keep only genuinely distinct branches.
+- **Cut identity the body already carries.**
+
+## The two loads
+
+Every document and pointer you add spends one of two budgets:
+
+- **Context load** is the cost of always-loaded material on the agent's window: an `AGENTS.md` line, a skill description, anything sitting in context every turn, spending tokens and attention whether or not it fires.
+- **Cognitive load** is the cost on the human: which documents exist and when to reach for each. The human is the index. Not a cost to minimise: it is the price of human agency; spend it where human judgement matters, remove it where it does not.
+
+Material reached only through a pointer escapes context load at the price of the pointer's own line; material with no pointer at all rides entirely on cognitive load.
+
+## Information hierarchy
+
+A document is built from two content types: **steps** (the ordered actions the agent performs) and **reference** (definitions, rules, facts consulted on demand). The two mix freely: all steps (a recipe), all reference (a review's rules, this skill), or both. The core decision is where each piece sits on the **information hierarchy**, a ladder ranked by how immediately the agent needs the material:
+
+1. **In-file step** is the primary tier: what the agent does, in order.
+2. **In-file reference** is consulted on demand. Often a legitimately flat peer-set (every rule of a review on one rung), which is a fine arrangement, not a smell.
+3. **Disclosed reference** is pushed out into a separate file, reached by a context pointer, loaded only when the pointer fires. Spans a sibling file in the same folder through fully external reference that lives anywhere and any document can point at.
+
+Push too little down and the top bloats; push too much and you hide material the agent actually needs. That tension is the whole decision.
+
+**Progressive disclosure** is the move down the ladder (out of the main file and behind a pointer) so the top stays legible. Not primarily a token optimisation: it is how the hierarchy is protected. Branching is the cleanest disclosure test: inline what every branch needs, and push behind a pointer what only some branches reach. When a document has steps, in-file reference that should be disclosed buries them and turns attending to them into a coin-flip: a variance lever, not just a legibility one.
+
+**Co-location** is the within-file companion: where the ladder decides _how far down_ a piece sits, co-location decides _what sits beside it_ once there. Keep a concept's definition, rules, and caveats under one heading rather than scattered, so reading one part brings its neighbours with it. The test: the document should read like documentation written for the agent. Grouped material reads that way; scattered material does not. (Distinct from duplication: that repeats one meaning in two places; scattering fragments one meaning across many.)
+
+**Sprawl** is the failure mode here: a document simply too long, even when every line is live and unique. Attention thins across the excess, and every extra line is one more to keep relevant. The cure is the ladder: disclose reference behind pointers, and split by branch or sequence so each path carries only what it needs.
+
+## Steps and completion criteria
+
+Every step ends on a **completion criterion**, the condition that tells the agent the work is done. Two properties make it a lever:
+
+- **Clarity**: can the agent tell done from not-done? A vague bound ("understanding reached") invites **premature completion**: ending the step before it is genuinely done, attention slipping to _being done_. The visible steps still ahead (the **post-completion steps**) supply the pull; the criterion's clarity is the resistance. Defend in order: **sharpen the bound first** (local and cheap); only if it is irreducibly fuzzy _and_ you observe the rush, hide the later steps by splitting the sequence. Hiding only works across a real context boundary (a hand-off or a subagent dispatch; an inline call leaves the later steps in context and clears nothing).
+- **Demand**: how much it requires. "Every modified model accounted for" forces thorough work where "produce a change list" does not. Demand drives **legwork** (the digging the agent does within the work, latent in the wording rather than written as its own step), and it is not step-bound: "every rule applied" binds a body of flat reference just as "every step done" binds a sequence, which is how an all-reference document still carries an exhaustiveness bar.
+
+The strongest criteria are both checkable and exhaustive.
+
+## When to split
+
+Splitting one document into two spends one of the two loads, so split only when the cut earns it:
+
+- **By sequence**: split a run of steps where the post-completion steps tempt the agent to rush the one in front of it. Keeping them out of view drives more legwork on the current task. Beware the reverse: merging sequences exposes each step's later steps to what follows, inviting premature completion.
+- **By invocation**, skill-specific: see [`SKILL-MECHANICS.md`](SKILL-MECHANICS.md).
+
+## Leading words
+
+A **leading word** is a compact concept already living in the model's pretraining that the agent thinks with while running the document (_lesson_, _fog of war_, _tracer bullets_). Repeated as a token, never as a sentence, it accumulates a distributed definition and anchors a whole region of behaviour in the fewest tokens, by recruiting priors the model already holds. Coining your own works if you define it clearly, but a made-up word recruits no priors: you pay in definition tokens what a pretrained word gives free; reach for an existing word first.
+
+It anchors twice. In the body, _execution_: the agent reaches for the same behaviour every time the word appears, and inside flat reference it focuses attention on a class of thing to look for. In a pointer, _invocation_: when the same word lives in your prompts, your docs, and your codebase, the agent links that shared language to the material and reaches it more reliably.
+
+Hunt for opportunities to refactor with leading words. A triad spelled out at three sites, a pointer spending a sentence to gesture at one idea. Each is a passage begging to collapse into a single token:
+
+- "fast, deterministic, low-overhead" → _tight_ (a _tight_ loop).
+- "a loop you believe in" → _red_, turning a fuzzy gate into a binary observable state (the loop goes _red_ on the bug, or it doesn't).
+
+You win twice: fewer tokens, and a sharper hook for the agent to hang its thinking on. Assume every document is carrying restatements that leading words retire. Go find them.
+
+**Negation** is the failure mode beside this lever: steering by prohibition drags the forbidden behaviour into context and makes it _more_ available, not less. _Don't think of an elephant_, and the elephant is all there is; the negation is a weak modifier the strongly-activated concept overruns, so the ban half-reads as an instruction to do the thing. Prompt the **positive**: state the target behaviour ("write one-line comments") so the banned one is never spoken. A prohibition earns its place only as a hard guardrail you cannot phrase positively; even then, pair it with the positive target so attention lands on what to do.
+
+## Pruning
+
+- Keep each meaning in a **single source of truth**: one authoritative place, so changing the behaviour is a one-place edit. **Duplication** (the same meaning in more than one place) costs maintenance and tokens, and inflates a meaning's prominence on the ladder past its real rank. (The accidental inverse of a leading word, which repeats a token on purpose, never the meaning.)
+- The **environment** is a source of truth too (`package.json` scripts, config files, the directory layout, `--help` output), and a document that restates it is a **cache**: a copy of a lookup, earning its load only when the lookup is expensive. Cache what the agent cannot find by looking: the unwritten convention, the reason behind a choice, the gotcha no config confesses. Leave the one-file, one-command lookups to the environment, where they cannot go stale.
+- Check every line for **relevance**: does it still bear on what the document does? A line loses relevance by never bearing on the task (mere exposition, or a branch that should be disclosed) or by going stale as the behaviour or world it describes changes. Shorter documents are easier to keep relevant. Without a pruning discipline the default fate is **sediment**: stale layers that settle because adding feels safe and removing feels risky, until you must core down through them to find what is still live.
+- Hunt **no-ops** sentence by sentence: an instruction the model already obeys by default pays load to say nothing. The test (does it change behaviour versus the default?) is model-relative, not reader-relative: two people disagreeing about a no-op disagree about the default, and settle it by running the document, not by debate. When a sentence fails, delete the whole sentence rather than trim words from it. The test also grades leading words: a word too weak to beat the default (_be thorough_ when the agent is already thorough-ish) is a no-op, and the fix is a stronger word (_relentless_), not a different technique.

package/.claude/skills/writing-for-agents/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "Writing for Agents"
+  short_description: "Write documents agents consume"

package/.worktreeinclude

@@ -0,0 +1,3 @@
+.env
+.env.local
+graphify-out/

package/AGENTS.md

@@ -0,0 +1,44 @@
+# Agent Operating Guidelines
+
+Shared base for Claude Code, Cursor and Codex. Read before writing or changing code.
+
+## Conversational style
+
+- Short, direct, technical prose. No emojis, no filler.
+- Answer the question first, before edits or commands.
+- When responding to feedback, say whether you agree or disagree before saying what you changed.
+- Explain non-trivial designs as: problem, concrete example or short trace, solution, and why it is necessary.
+- Prefer concrete behavior and small illustrations over abstract summaries. Define unavoidable jargon.
+- Stay inside the request. No observations outside its context.
+
+## Core rules
+
+- Never use the em dash. Use a plain dash "-".
+- Brevity applies to code, comments and commit messages.
+- All code, identifiers, comments and docs in English. No line-by-line comments.
+- Readers are language experts: self-explanatory names, short names when context is clear.
+- Assume a similar problem was solved before. Look hard for existing helpers before adding one.
+- Match existing patterns. Do not invent endpoints, tables, events or infra.
+- Tests: prefer end-to-end/integration tests; unit tests only for isolated utilities.
+- Descriptive test names (`test_disable_path_to_lower`), never `test_issue_1234`; put issue refs in a comment.
+- Prefer reliable, current sources. Say what you could not verify instead of guessing.
+
+## Git safety
+
+Several agent sessions may run in the same cwd at once. Never touch work that is not yours.
+
+- Never `git checkout <branch>` in the shared cwd. Use a worktree per task (`git worktree add`).
+- Only commit files YOU changed in THIS session. Stage explicit paths: `git add <path1> <path2>`.
+- Run `git status` before committing and verify only your files are staged.
+- Never stage `.env*`, credentials or key files unless the user names that file.
+- Conventional commits (`feat:`, `fix:`, `chore:` ...). Message via HEREDOC. No empty commits.
+- Never run: `git add -A`, `git add .`, `git reset --hard`, `git checkout .`, `git clean -f*`,
+  `git stash`, `git commit --no-verify`, `git commit --amend` (unless asked), force push.
+- Rebase conflicts: resolve only files you modified; otherwise abort and ask.
+- Never `git push` or open/comment on a PR unless the user explicitly asks.
+
+## Tickets
+
+- Reading tickets (Shortcut, GitHub issues) for scope is fine.
+- Never create, update, assign, transition or comment on tickets unless the user explicitly asks.
+  Starting, implementing, reviewing or committing a task is not permission.

package/README.md

@@ -1,3 +1,15 @@
-# Temporary Holding Version
+# agents
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Personal agent and subagent configuration for Claude Code, portable to Cursor and Codex through `AGENTS.md`.
+
+- Orchestrator playbook: `.claude/skills/orchestrate/SKILL.md`
+- Roster: `.claude/agents/` (quick, product, architect, api, web, app, infra, ui, verifier, security)
+- Deterministic guards: `.claude/hooks/` wired in `.claude/settings.json`
+- `skills-lock.json` records origin, hash and adaptation of every vendored skill; `node scripts/skills-update.mjs` checks them against upstream; catalog in [docs/skills.md](docs/skills.md)
+- Decisions about this config: [docs/adr/](docs/adr/); history: [CHANGELOG.md](CHANGELOG.md)
+- Put it in a project: `npx @evertonferreira96/agents init` in the project root (or `npx github:EvertonFerreira96/agents init` straight from the repo); keep it current with `npx @evertonferreira96/agents@latest update` and look for drift with `npx @evertonferreira96/agents check`. A local clone still works: `node scripts/bootstrap.mjs <project-root>`. First task: [docs/quickstart.md](docs/quickstart.md)
+- Release: every push to `main` that changes what the package ships runs `.github/workflows/release.yml`: the full check, then `npm publish` and the `vX.Y.Z` tag. Patches are automatic; for a minor or major, bump `version` in `package.json` and `VERSION` together. Add the CHANGELOG entry in the same commit
+
+## Docs
+
+How to bootstrap a project with this config, and what each piece does: [docs/](docs/README.md)

package/VERSION

@@ -0,0 +1 @@
+0.1.0

package/bin/agents.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// Package CLI: install this agents config into a project and keep it updated.
+//   agents init   [dir]  copy the config into the project (default: current directory); never overwrites
+//   agents update [dir]  refresh files the project did not edit, add new ones, delete untouched ones that left the config
+//   agents check  [dir]  report missing, outdated, edited and obsolete files; exit 1 on drift
+// Flags: --force (update also overwrites files edited in the project, except CLAUDE.md, settings.local.json and agent memory),
+//        --dry-run (init/update: show what would change, write nothing).
+import { resolve } from "node:path";
+import { DEFAULT_SRC, drift, install, readPackage, report } from "../scripts/bootstrap.mjs";
+
+const HELP = `Usage: agents <command> [dir] [--force] [--dry-run]
+
+Commands:
+  init     copy the config into the project (never overwrites existing files)
+  update   refresh untouched files, add new ones, delete untouched files that left the config
+  check    report missing, outdated, edited and obsolete files (exit 1 on drift)
+
+Flags:
+  --force    update also overwrites files edited in the project
+             (CLAUDE.md, .claude/settings.local.json and .claude/agent-memory/** are never touched)
+  --dry-run  show what init/update would change without writing
+
+dir defaults to the current directory.`;
+
+const args = process.argv.slice(2);
+const flags = new Set(args.filter((a) => a.startsWith("-")));
+const [command, dir] = args.filter((a) => !a.startsWith("-"));
+const pkg = readPackage(DEFAULT_SRC);
+
+if (flags.has("--version") || flags.has("-v")) { console.log(pkg.version); process.exit(0); }
+if (!command || command === "help" || flags.has("--help") || flags.has("-h")) { console.log(`${pkg.name} ${pkg.version}\n\n${HELP}`); process.exit(command ? 0 : 2); }
+if (!["init", "update", "check"].includes(command)) { console.error(`unknown command: ${command}\n\n${HELP}`); process.exit(2); }
+
+try {
+  const target = resolve(dir ?? process.cwd());
+  const r = install({ target, mode: command, force: flags.has("--force"), dryRun: flags.has("--dry-run") });
+  report(r);
+  if (command === "init" && !flags.has("--dry-run")) {
+    console.log("\nnext: fill in purpose and commands in CLAUDE.md; optional: `npx impeccable install` (for /ui) and `/graphify .`");
+  }
+  process.exit(command === "check" && drift(r) ? 1 : 0);
+} catch (e) {
+  console.error(e.message);
+  process.exit(2);
+}

package/docs/adr/README.md

@@ -0,0 +1,31 @@
+# ADRs
+
+One file per architecture decision: `docs/adr/NNNN-<slug>.md`.
+
+## Numbering
+
+- `NNNN` is 4 digits, zero-padded, next after the highest existing number (`0001`, `0002`, ...). Never reuse a number.
+- `<slug>` is lowercase kebab-case of the title.
+- ADRs are immutable once Accepted. To change a decision, write a new ADR and set the old one to `Superseded by NNNN`.
+
+## Flow
+
+`/architect` returns an ADR proposal, the orchestrator copies it into `docs/plans/<task>.md`, and at DoD creates the ADR file in the same diff as the change.
+
+## Template
+
+```markdown
+# NNNN - <title>
+
+Status: Proposed | Accepted | Superseded by NNNN | Deprecated
+Date: YYYY-MM-DD
+
+## Context
+<forces, constraints, the problem; link the plan>
+
+## Decision
+<what we do, in present tense>
+
+## Consequences
+<what gets easier, what gets harder, rejected alternatives and why>
+```

package/docs/brief-template.md

@@ -0,0 +1,3 @@
+# Brief template
+
+The single source is skill `brief`: [.claude/skills/brief/SKILL.md](../.claude/skills/brief/SKILL.md).

package/docs/plans/README.md

@@ -0,0 +1,73 @@
+# Plans
+
+One file per task: `docs/plans/<task>.md`, where `<task>` is `sc-<number>` or the branch slug.
+Created by the orchestrator at worktree time (skill `orchestrate` step 2), filled by `/product` (the orchestrator writes it), updated by the orchestrator as tickets move.
+The newest plan is re-injected after context compaction by the post-compact hook, so keep the top of the file current.
+
+Rules of the file:
+
+- Paths appear only under Scope. Decisions name modules, interfaces and contracts, never files or code.
+- Test seams are the contract between `/product`, the implementers (`tdd`) and `/verifier`: a seam not listed here is not tested, a seam listed here must be.
+- Tickets are vertical slices with `Blocked by` edges; the orchestrator works the frontier (tickets whose blockers are done) and marks Status as they land.
+- Session state is the compaction insurance: everything the orchestrator would lose with its window goes there first (skill `orchestrate` section 14).
+- A section that does not apply says `n/a` and why, so a reader knows it was considered.
+
+## Template
+
+```markdown
+# <task> - <title>
+
+Status: draft | ready | in progress | in review | done | blocked (<reason>)
+Ticket: <id or none>
+Size: S | M | L
+
+## Session state
+<updated by the orchestrator before any /compact and when a ticket lands; the post-compact hook re-injects it>
+- Worktree: <path> | Branch: <name> | Base ref: <sha>
+- Frontier: <next ticket(s)>
+- Files touched: <paths>
+- Last commands / errors: <command - result>
+- Stopped at: <one line>
+
+## Objective
+- Problem: <one sentence, from the user's perspective>
+- Solution: <one sentence, from the user's perspective>
+
+## Scope
+- In: ...
+- Out: ...
+- Repos / paths: ...
+
+## User stories
+<L, or more than one actor; otherwise n/a>
+1. As an <actor>, I want <feature>, so that <benefit>
+
+## Acceptance criteria
+- [ ] <testable check> (story 1)
+
+## Decisions
+- <decision> - <why> (modules, interfaces, schema, contracts; architect verdict and constraints)
+
+## Test seams
+| Seam | Catches | Misses | Prior art |
+|------|---------|--------|-----------|
+| S1: <public interface> | <behavior it proves> | <what it cannot see> | <existing test, or none> |
+
+## Tickets
+<one ticket = one tracer bullet = one brief = one agent = one context window>
+| # | Ticket | Delivers | Blocked by | Agent | Paths | Seams | Status |
+|---|--------|----------|------------|-------|-------|-------|--------|
+| 1 | <title> | <end-to-end behavior, from the user's perspective> | - | /api | <globs> | S1 | todo |
+
+## Definition of Done
+- [ ] lint, build, tests green (evidence pasted)
+- [ ] a test exists at every seam listed above
+- [ ] diff only inside scoped paths
+- [ ] docs updated if route/job/store/integration/fallback changed
+- [ ] no secrets in diff
+- [ ] verifier: Ready
+- [ ] security reviewed (if triggered)
+
+## Open questions
+- ...
+```

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "@evertonferreira96/agents",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Personal agents, rules, hooks and skills for Claude Code (portable to Cursor and Codex through AGENTS.md), installable into any project.",
+  "type": "module",
+  "bin": {
+    "agents": "bin/agents.mjs"
+  },
+  "files": [
+    "bin/",
+    ".claude/agents/",
+    ".claude/hooks/",
+    ".claude/rules/",
+    ".claude/skills/",
+    "!.claude/skills/impeccable/scripts/bin/",
+    "!**/__pycache__/",
+    "!**/*.pyc",
+    ".claude/settings.json",
+    "AGENTS.md",
+    ".worktreeinclude",
+    "docs/plans/README.md",
+    "docs/adr/README.md",
+    "docs/brief-template.md",
+    "scripts/bootstrap.mjs",
+    "scripts/check-catalog.mjs",
+    "scripts/skills-update.mjs",
+    "skills-lock.json",
+    "templates/",
+    "VERSION"
+  ],
+  "scripts": {
+    "check": "node scripts/check-catalog.mjs",
+    "test": "node scripts/test-install.mjs",
+    "prepublishOnly": "npm run check && npm test"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EvertonFerreira96/agents.git"
+  },
+  "license": "UNLICENSED"
+}