/applying-licenses

name: ring:applying-licenses
description: "Applying or switching a repository's license (Apache 2.0, Elastic License v2, or Proprietary): rewrites the LICENSE file, updates Go/TS source headers, sets SPDX identifiers, and validates consistency after user confirmation. Use when asked to set, apply, or switch a license, or when scaffolding a service with no LICENSE. Skip when license, headers, and SPDX already match, or for non-code repos."

License Management

When to use

• User requests to set, apply, or switch a license on a repository
• Scaffolding a new service from the boilerplate
• Task mentions "license", "licensing", "license header", "Apache 2.0", "ELv2", "proprietary"
• Gate 0 of dev-cycle when no LICENSE file exists

Skip when

• Repository already has requested license AND all headers match AND SPDX is correct (verified)
• Non-code repositories (documentation-only, design assets)

Related

**Complementary:** ring:running-dev-cycle, ring:implementing-tasks

You orchestrate. Agents update source headers. NEVER apply a license without user confirmation.

License Types

| License | SPDX | Use Case | |---------|------|----------| | Apache 2.0 | `Apache-2.0` | Open source (e.g., Midaz core) | | Elastic License v2 | `Elastic-2.0` | Source-available products | | Proprietary | `LicenseRef-Proprietary` | Internal/closed repositories |

Header Templates

Apache 2.0 — Go

// Copyright (c) {YEAR} {COPYRIGHT_HOLDER}
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

Elastic License v2 — Go

// Copyright (c) {YEAR} {COPYRIGHT_HOLDER}
// Use of this source code is governed by the Elastic License 2.0
// that can be found in the LICENSE file.

Proprietary — Go

// Copyright (c) {YEAR} {COPYRIGHT_HOLDER}. All rights reserved.
// This source code is proprietary and confidential.
// Unauthorized copying of this file is strictly prohibited.

TypeScript: wrap the same text in `/** ... */`.

Gate 0: Detection

Orchestrator runs directly:

# 1. Detect LICENSE file
ls LICENSE LICENSE.md LICENSE.txt 2>/dev/null
head -5 LICENSE 2>/dev/null

# 2. Identify type
grep -l "Apache License" LICENSE* 2>/dev/null → apache
grep -l "Elastic License" LICENSE* 2>/dev/null → elv2
grep -l "All rights reserved" LICENSE* 2>/dev/null → proprietary

# 3. Sample current source headers
head -5 $(find . -name "*.go" ! -path "*/vendor/*" ! -name "*.pb.go" | head -5)
head -5 $(find . -name "*.ts" ! -path "*/node_modules/*" | head -5)

# 4. Detect language
test -f go.mod && echo "Go project"
test -f package.json && echo "TypeScript project"

Determine:

• `current_license`: apache | elv2 | proprietary | none
• `language`: go | typescript | both
• `copyright_holder`: from existing headers, else detect from git config (`git config user.name` / remote org), else ask the user
• `year`: current year

Gate 1: User Confirmation

Present summary and wait for explicit APPROVED:

Current license: {current_license}
Target license: {target_license}
Language: {language}
Copyright: {copyright_holder} ({year})

Changes:
- LICENSE file: CREATE/REPLACE with {target_license}
- Source headers: UPDATE {N} files
- README badge: UPDATE

Proceed? (APPROVED / CANCEL)

STOP if user does not confirm.

Gate 2: Implementation

After confirmation:

**1. Replace LICENSE file** (orchestrator writes directly):

• Apache 2.0: fetch from https://www.apache.org/licenses/LICENSE-2.0.txt
• ELv2: write canonical ELv2 text
• Proprietary: write the proprietary license template

**2. Update source headers** (dispatch agent):

Task:
  subagent_type: "ring:backend-go"  # use "ring:backend-ts" for TS/JS sources
  description: "Update license headers to {target_license}"
  prompt: |
    Update all source file headers to {target_license} format.
    Copyright: {copyright_holder}, {year}
    
    Files to update:
    - Go: find . -name "*.go" ! -path "*/vendor/*" ! -name "*.pb.go" ! -name "*/mocks/*"
    - TS: find . -name "*.ts" -o -name "*.tsx" ! -path "*/node_modules/*"
    
    Header template: {header_template}
    
    For each file:
    1. Remove existing copyright block (first comment block if it mentions Copyright)
    2. Add new header at top of file
    3. Preserve package declaration and imports
    
    Output: list of files updated

Gate 3: Validation

Orchestrator runs:

# All files should have consistent headers
grep -rL "Copyright (c)" $(find . -name "*.go" ! -path "*/vendor/*" ! -name "*.pb.go")
grep -rL "Copyright (c)" $(find . -name "*.ts" ! -path "*/node_modules/*")

# LICENSE file exists and has correct type
head -3 LICENSE | grep -i "{target_keyword}"

Report:

• Files missing headers: list
• LICENSE file status: PASS/FAIL
• Consistency: PASS/FAIL (if mismatches found, dispatch agent to fix)