implement-op

name	implement-op
description	Modify op code to match the manifest-declared interface, making spec tests pass.

Arguments

op_name, manifest_signature, source_op, source_test — passed by align-family orchestrator.

Contract

• Input: op_name, manifest_signature, source_op, source_test
• Output: modified op code + commit + observations list (returned to orchestrator)
• Termination (success): python scripts/validate_manifest.py --check-op <name> all levels pass + new tests pass.
• Termination (blocked): fix requires changes beyond Op layer. Return blocked with reason.
• Constraint: must NOT modify src/tileops/manifest/. Must NOT modify tests written by test-op in this align-op run (spec contract). MAY update pre-existing tests in <source_test> whose call-sites use the legacy API. The parent orchestrator (align-op) handles the manifest flip at FLIP_STATUS. If your implementation needs a contractual-field change to make tests pass, return BLOCKED — do not edit the manifest yourself.
• Behavioral compatibility: default param values (from manifest) must produce identical results to the old implementation. The old API shape (e.g., __init__(M, N)) is NOT preserved — the manifest defines the target interface.

Workflow

stateDiagram-v2
    [*] --> ANALYZE
    ANALYZE --> DIAGNOSE: semantic knowledge extracted
    DIAGNOSE --> VALIDATE: gap already resolved (base class fixed by previous op)
    DIAGNOSE --> IMPLEMENT: gap exists
    IMPLEMENT --> VALIDATE: sub-step completed
    VALIDATE --> IMPLEMENT: sub-step failed
    VALIDATE --> MARK_DONE: all pass
    VALIDATE --> BLOCKED: fix exceeds Op layer scope
    MARK_DONE --> COMMIT
    COMMIT --> [*]
    BLOCKED --> [*]: return blocked to orchestrator

Dual-path policy

Before refactoring a base class, count its subclasses:

grep -rlE "class\s+[A-Z][A-Za-z0-9]*\s*\(\s*<BaseName>\s*\)" src/tileops/ops/

• One subclass (the op being migrated): refactor the base in place. No dual-path.
• Multiple subclasses: keep the legacy __init__ path alongside the new one so unmigrated siblings still pass. Cleanup gate removes the legacy path after all siblings migrate.

Do NOT preemptively migrate siblings to avoid dual-path — that violates per-op scope.

Steps

1. ANALYZE

Read existing code (source_op) to extract semantic knowledge:

• What the computation does (the algorithm)
• Where constraints are hardcoded (e.g., dim=-1, reshape(-1, N))
• What the generalization path is

Manifest = WHAT (target interface). Existing code = HOW (computation logic). The delta is the work.

This analysis is internal — not persisted.

2. DIAGNOSE

Check if the gap still exists. A previous op's migration may have fixed the shared base class.

• Gap resolved → skip to VALIDATE
• Gap exists → proceed to IMPLEMENT

3. IMPLEMENT

Decompose into independently verifiable sub-steps. Each sub-step either succeeds or fails with precise location (→ BLOCKED). No retry loops — if a sub-step fails with the same error twice, the task is beyond current scope.

Agent determines sub-steps based on the specific gap. Do not follow a fixed recipe.

4. VALIDATE

Run all checks:

python scripts/validate_manifest.py --check-op <op_name>
python -m pytest <source_test> -v

All must pass. If not, return to IMPLEMENT.

5. MARK_DONE

Record observations — design knowledge discovered during migration:

• Patterns (e.g., "scan ops need transpose, reduction ops reshape")
• Edge cases
• Abstraction opportunities

Do not change the manifest or a design doc to match code that does not conform — the spec is the reference, not a record of the implementation. Observations are returned to the orchestrator and surfaced in the PR.

6. COMMIT

Commit code changes only. Do not commit manifest changes.