uwf-requirements

name: uwf-requirements description: "Write and track the requirements pack: PRD + NFRs + acceptance criteria + risks."

UWF Requirements Skill

Overview

Requirements are stored in a SQLite database:

.github/skills/uwf-requirements/uwf-requirements.db

The schema is defined by requirements-schema.yaml in the same directory. Numbers are auto-assigned per type and role (e.g. FR-001, NFR-002, AC-003).

Note: uwf-requirements.db is in .gitignore and must not be committed. The requirements markdown artifact in tmp/workflow-artifacts/ is committed.

All requirements operations MUST use the deterministic script:

node .github/skills/uwf-requirements/requirements.mjs <command> [options]

Agents must never write to the database directly.

Script reference

Update field flags: --title, --type, --description, --priority, --status, --source, --stage

Valid types:

Valid priorities (MoSCoW): must · should · could · wont

Valid statuses: draft · accepted · deferred · rejected

All output is JSON. Exit code 0 = success, 1 = operational error, 2 = usage error.

Example invocations

# Add a functional requirement
node .github/skills/uwf-requirements/requirements.mjs add \
  --role issues \
  --type functional \
  --title "User can create an issue from the CLI" \
  --description "The CLI must accept a title and description and persist the issue to SQLite" \
  --priority must \
  --source "intake section: Goal"

# Add an acceptance criterion
node .github/skills/uwf-requirements/requirements.mjs add \
  --role issues \
  --type acceptance_criteria \
  --title "Issue is queryable by status after creation" \
  --priority must

# Add a risk
node .github/skills/uwf-requirements/requirements.mjs add \
  --role issues \
  --type risk \
  --title "SQLite file corruption on concurrent writes" \
  --description "WAL mode mitigates but does not eliminate risk under high concurrency" \
  --priority should

# List all functional requirements
node .github/skills/uwf-requirements/requirements.mjs list --role issues --type functional

# Accept a requirement
node .github/skills/uwf-requirements/requirements.mjs accept --id 1

Requirements procedure

1. Read the intake ({outputPath}/{role}-intake.md) and discovery ({outputPath}/{role}-discovery.md) artifacts.
2. Add requirements via requirements.mjs add as you derive them — one record per requirement. Use --source to cite the intake section or discovery id that motivated it.
3. Write the output document {outputPath}/{role}-requirements.md using the sections below, drawing content from the DB (list --role {role}).
4. Accept requirements that are well-defined and in scope via requirements.mjs accept --id <n>.
5. Defer or reject out-of-scope items via defer / reject rather than deleting them.

Output document structure

{outputPath}/{role}-requirements.md must contain these sections, populated from the DB:

Goal / Non-goals

• State the primary goal in one sentence.
• List explicit non-goals (things intentionally out of scope).

Functional Requirements

Drawn from list --type functional. Format each as:

**FR-NNN** *(priority)* — <title>
<description>
Source: <source>

Non-Functional Requirements

Drawn from list --type non_functional. Cover at minimum:

• Performance
• Security
• Reliability
• Cost
• Operability

Data Requirements

Drawn from list --type data. Include data shape, retention policy, and classification where relevant.

Acceptance Criteria

Drawn from list --type acceptance_criteria. Each criterion must be testable (pass/fail verifiable).

Risks + Mitigations

Drawn from list --type risk. Format each as:

**RK-NNN** *(priority)* — <title>
Risk: <description>
Mitigation: <how it is addressed>

Schema reference

requirements

Defined by requirements-schema.yaml.

Error conditions