---
name: timeback-curriculum-alpha
description: Use when building apps, reports, QA probes, migration checks, or deliverables against the TimeBack platform3 Curriculum Alpha surface. The skill teaches agents to call the live surface for standards frameworks, CASE-backed components, registry-native Knowledge Components and graphs, placement candidates, gate contracts, universal remediation, and TimeBack source-shaped ingest. Do not query raw databases, parse CASE packages, copy enums, compute mastery or next-task selection, or store Content, Results, Events, roster, credential, Policy, or secret data.
---

# TimeBack Curriculum Alpha

Use this skill when the user asks for a working app, report, QA probe, migration check, integration proof, or customer deliverable that uses the TimeBack platform3 Curriculum Alpha surface.

Do not use it for direct CASE export work, raw database work, Results mastery or next-task ownership, Content authoring, Events activity streams, People and Orgs roster facts, credentials, NWEA/MAP reports, or Policy threshold math.

## Install

Install the whole `pack/` directory as one skill. Do not split the reference files away from `SKILL.md`.

Hosted Codex install:

```bash
SKILL_DIR="${CODEX_HOME:-$HOME/.codex}/skills/timeback-curriculum-alpha"
BASE="https://platform3-andymontgomery-9773s-projects.vercel.app/curriculum/alpha/skill_pack/pack"
mkdir -p "$SKILL_DIR/references" "$SKILL_DIR/checks" "$SKILL_DIR/agents"
curl -fsSL "$BASE/SKILL.md" -o "$SKILL_DIR/SKILL.md"
curl -fsSL "$BASE/agents/openai.yaml" -o "$SKILL_DIR/agents/openai.yaml"
for f in canonical-surface worked-example source-shaped-ingest runnable-check response-samples leak-check; do
  curl -fsSL "$BASE/references/$f.md" -o "$SKILL_DIR/references/$f.md"
done
curl -fsSL "$BASE/references/authoring-subject-registry.json" -o "$SKILL_DIR/references/authoring-subject-registry.json"
curl -fsSL "$BASE/checks/verify-skill-pack.mjs" -o "$SKILL_DIR/checks/verify-skill-pack.mjs"
curl -fsSL "$BASE/checks/import-standards-framework-dir.mjs" -o "$SKILL_DIR/checks/import-standards-framework-dir.mjs"
```

Hosted Claude Code install:

```bash
SKILL_DIR="$HOME/.claude/skills/timeback-curriculum-alpha"
BASE="https://platform3-andymontgomery-9773s-projects.vercel.app/curriculum/alpha/skill_pack/pack"
mkdir -p "$SKILL_DIR/references" "$SKILL_DIR/checks" "$SKILL_DIR/agents"
curl -fsSL "$BASE/SKILL.md" -o "$SKILL_DIR/SKILL.md"
curl -fsSL "$BASE/agents/openai.yaml" -o "$SKILL_DIR/agents/openai.yaml"
for f in canonical-surface worked-example source-shaped-ingest runnable-check response-samples leak-check; do
  curl -fsSL "$BASE/references/$f.md" -o "$SKILL_DIR/references/$f.md"
done
curl -fsSL "$BASE/references/authoring-subject-registry.json" -o "$SKILL_DIR/references/authoring-subject-registry.json"
curl -fsSL "$BASE/checks/verify-skill-pack.mjs" -o "$SKILL_DIR/checks/verify-skill-pack.mjs"
curl -fsSL "$BASE/checks/import-standards-framework-dir.mjs" -o "$SKILL_DIR/checks/import-standards-framework-dir.mjs"
```

Hosted file-backed / Perplexity Computer install:

```bash
SKILL_DIR="./skills/timeback-curriculum-alpha"
BASE="https://platform3-andymontgomery-9773s-projects.vercel.app/curriculum/alpha/skill_pack/pack"
mkdir -p "$SKILL_DIR/references" "$SKILL_DIR/checks" "$SKILL_DIR/agents"
curl -fsSL "$BASE/SKILL.md" -o "$SKILL_DIR/SKILL.md"
curl -fsSL "$BASE/agents/perplexity-computer.md" -o "$SKILL_DIR/agents/perplexity-computer.md"
for f in canonical-surface worked-example source-shaped-ingest runnable-check response-samples leak-check; do
  curl -fsSL "$BASE/references/$f.md" -o "$SKILL_DIR/references/$f.md"
done
curl -fsSL "$BASE/references/authoring-subject-registry.json" -o "$SKILL_DIR/references/authoring-subject-registry.json"
curl -fsSL "$BASE/checks/verify-skill-pack.mjs" -o "$SKILL_DIR/checks/verify-skill-pack.mjs"
curl -fsSL "$BASE/checks/import-standards-framework-dir.mjs" -o "$SKILL_DIR/checks/import-standards-framework-dir.mjs"
```

Local artifact install from this repository:

```bash
mkdir -p ~/.codex/skills/timeback-curriculum-alpha
cp -R pack/* ~/.codex/skills/timeback-curriculum-alpha/
```

## Curriculum In 60 Seconds

Curriculum is the shared map of what there is to learn and the reusable paths through that map. It is the same for every student.

The current Alpha model keeps standards and reusable course structure in stock CASE while governing source lineage and KCs in typed Alpha relations:

- Standards and reusable course/component structure use `case.cf_document`, `case.cf_item`, and `case.cf_association`.
- Standards-source lineage uses `alpha.standards_source_release` and `alpha.standards_source_row_binding`; governed KCs use `alpha.knowledge_component` and `alpha.knowledge_component_version`; KC graph semantics use `alpha.kc_prerequisite` and `alpha.kc_relation`; standards links use `alpha.standard_kc_map`.
- Every Curriculum component is a `case.cf_item`; the surface returns a storage-validated `kind` property for track, course, lesson, practice, review, mastery_gate, and the other component kinds.
- Track, grade, course, unit, lesson, practice, review, quiz, test, mastery_gate, remediation_pocket, and placeholder are component kinds, not separate tables.
- KCs have governed Alpha identities and versions; new `/kcs` writes explicitly assert `stored_as=alpha.knowledge_component`, include `definition`, omit CASE fields, and require callers to capture the returned canonical `kc_id`. Optional `source_kc_id` is creation provenance only and never an active alias or create replay key. Retry with the original Idempotency-Key or exact canonical `kc_id`; semantic edits append through `/kcs/{kcId}/versions`.
- Identity `publication_status` is ETag/If-Match mutable and remains separate from version `draft|firm`. Record review decisions separately; approve the complete published course through `/courses/{courseId}/approvals`; require routing to echo that exact KC-version snapshot. Publication or assignment never firms a version.
- `alpha.kc_prerequisite` is the sole prerequisite DAG and is written/read through `/kc-prerequisites` with exact active tenant-owned registry UUIDs. `alpha.kc_relation` owns other typed graph semantics. KCs have no containment tree.
- Incept or the learning scientist owns clustering grain. Curriculum preserves every non-empty authored `scope_kc_refs` array, including lessons with multiple KCs; one-KC-per-lesson examples are not a store constraint. A sealed producer may explicitly author one exact content-bearing lesson with `scope_kc_refs=[]` plus `kc_scope_decision=authoritative_no_kc`; Curriculum never pads that factual absence.
- The authoring/catalog `subject_id` contract is the generated `references/authoring-subject-registry.json`; never copy or extend its list locally.
- `social_studies` is a canonical authoring/catalog `subject_id`; economics, history, geography, and civics remain course-grain disciplines rather than separate Platform3 subject ids.
- Component containment uses stock CASE `isChildOf`; KC prerequisites use `alpha.kc_prerequisite`; other KC graph semantics use `alpha.kc_relation`; KC-to-standard maps use `alpha.standard_kc_map`; framework alignment uses stock CASE association types.
- Content is flat and referenced through the exact typed tuple `target_ref={content_id,content_version_id,content_kind}` plus registered `renderer_ref`. Curriculum checks Content-owned release eligibility at authoring and launch, never substitutes latest, and never stores Content bodies, answer keys, producer evidence, or renderer implementations.
- Renderer rows are platform Applications routing registrations. Use `/alpha/curriculum/v1/renderer-registry` to resolve ids and inspect `registered_for_routing`, `verified_rendering`, `rendering_state`, and `capability_matrix_url` separately. Accepted Content kinds do not prove rendering.
- The current matrix verifies exactly 8/21 QTI item interaction types, including the bounded graphicGapMatch text-label/rect-target subset. `renderer:qti-test` also verifies the exact test/test-bank launch composition: Curriculum owns deterministic `next-form` selection, Content owns the exact selected form and ordered question refs, and the player renders only members inside that 8/21 interaction subset. Other item interactions fail visibly.

For a student-specific app, ask Results for student state or next task first, then resolve returned Curriculum refs here.

## First Actions

1. Open the canonical docs before making claims:
   - Customer website: https://platform3-andymontgomery-9773s-projects.vercel.app/curriculum/alpha/customer_website
   - Data dictionary: https://platform3-andymontgomery-9773s-projects.vercel.app/curriculum/alpha/data_dictionary
   - Architecture decisions: https://platform3-andymontgomery-9773s-projects.vercel.app/curriculum/alpha/architecture
   - Integration proof: https://platform3-andymontgomery-9773s-projects.vercel.app/curriculum/alpha/integration
2. Use `CURRICULUM_BASE_URL` if credentials supply it. Otherwise use:
   `https://platform3-andymontgomery-9773s-projects.vercel.app/curriculum/alpha/implementation/api`
3. Choose the credential path:
   - Demo: call `POST $CURRICULUM_BASE_URL/dev/mint?tenantId=demo`, then use the returned bearer token.
   - Real or reviewer tenant: use the operator-supplied bearer token such as `CURRICULUM_TOKEN` or `CURRICULUM_REVIEWER_JWT`. Never print or commit tokens.
4. Read `GET $CURRICULUM_BASE_URL` and keep its docs links, quickstart routes, allowed values, response shapes, and module boundaries beside you.
5. Read `references/worked-example.md` for the Grade 3 course tree and gate recipe.
6. Before final output, run `node checks/verify-skill-pack.mjs` and include the evidence summary.

## Happy Path: Grade 3 Course And Gate Panel

```sh
export CURRICULUM_BASE_URL="${CURRICULUM_BASE_URL:-https://platform3-andymontgomery-9773s-projects.vercel.app/curriculum/alpha/implementation/api}"
export CURRICULUM_TOKEN="${CURRICULUM_TOKEN:-$(curl -fsSL -X POST "$CURRICULUM_BASE_URL/dev/mint?tenantId=demo" | jq -r '.token')}"
export COURSE_ID="${COURSE_ID:-66666666-6666-4666-8666-666666666660}"
export GATE_ID="${GATE_ID:-bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb0}"
export KC_ROOT_ID="${KC_ROOT_ID:-eeeeeeee-eeee-4eee-8eee-eeeeeeeeeee0}"

curl -fsSL "$CURRICULUM_BASE_URL/alpha/curriculum/v1/components/$COURSE_ID/tree" \
  -H "Authorization: Bearer $CURRICULUM_TOKEN" \
  | jq '{root_component_id, kinds: [.components[].kind], stored_as: [.components[].stored_as] | unique}'

curl -fsSL "$CURRICULUM_BASE_URL/alpha/curriculum/v1/kcs/$KC_ROOT_ID" \
  -H "Authorization: Bearer $CURRICULUM_TOKEN" \
  | jq '{kc_id, current_version_id, kc_granularity, subject_id, grade_ids, stored_as}'

curl -fsSL "$CURRICULUM_BASE_URL/alpha/curriculum/v1/kc-prerequisites?kcId=$KC_ROOT_ID" \
  -H "Authorization: Bearer $CURRICULUM_TOKEN" \
  | jq '{data: [.data[] | {prerequisite_id, prerequisite_kc_id, dependent_kc_id, stored_as}]}'

curl -fsSL "$CURRICULUM_BASE_URL/alpha/curriculum/v1/gates/$GATE_ID/remediation?studentId=student_demo&resultRecordId=result-demo-gate-fail" \
  -H "Authorization: Bearer $CURRICULUM_TOKEN" \
  | jq '{gate_component_id, remediation_entries, results_owner}'
```

Render returned fields exactly as returned. Do not infer subject, grade, component kind, association type, gate status, or next task from names, CASE payload internals, or standards codes.

## Verification Drift Rule

Drift rule: the shared demo tenant is cumulative. Standards-framework and standard totals may exceed the convergence answer; the verifier fails only if the live count drops below the convergence floor and records positive drift as live_cumulative_above_convergence.

Placement drift rule: the shared demo tenant may accumulate extra QA mastery gates. The verifier requires the placement policy ref, the pinned gate, and at least the convergence-pinned candidate count; positive drift is recorded as live_cumulative_above_convergence.

Redeploy-window rule: the verifier retries transient network errors, retryable non-200 status mismatches, and invalid JSON responses with short backoff before failing. Stable platform assertions remain exact after a response is accepted.

## API Perimeter

The public Curriculum Alpha surface exposes these route families:

```text
POST   /dev/mint?tenantId=demo
POST   /alpha/curriculum/v1/components
GET    /alpha/curriculum/v1/components/{componentId}
PATCH  /alpha/curriculum/v1/components/{componentId}
POST   /alpha/curriculum/v1/components/{componentId}/repoint
DELETE /alpha/curriculum/v1/components/{componentId}
POST   /alpha/curriculum/v1/kcs
GET    /alpha/curriculum/v1/kcs
GET    /alpha/curriculum/v1/kcs/{kcId}
POST   /alpha/curriculum/v1/kcs/{kcId}/versions
GET    /alpha/curriculum/v1/kcs/{kcId}/versions
GET    /alpha/curriculum/v1/kcs/{kcId}/versions/{versionId}
PATCH  /alpha/curriculum/v1/kcs/{kcId}
POST   /alpha/curriculum/v1/kc-review-decisions
GET    /alpha/curriculum/v1/kc-review-decisions
POST   /alpha/curriculum/v1/kc-firming-events
GET    /alpha/curriculum/v1/kc-firming-events
POST   /alpha/curriculum/v1/courses/{courseId}/approvals
GET    /alpha/curriculum/v1/courses/{courseId}/approvals
POST   /alpha/curriculum/v1/kc-prerequisites
GET    /alpha/curriculum/v1/kc-prerequisites
DELETE /alpha/curriculum/v1/kcs/{kcId}
POST   /alpha/curriculum/v1/associations
GET    /alpha/curriculum/v1/associations
GET    /alpha/curriculum/v1/associations/{associationId}
PATCH  /alpha/curriculum/v1/associations/{associationId}
GET    /alpha/curriculum/v1/standards-frameworks
GET    /alpha/curriculum/v1/standard-kc-maps
POST   /alpha/curriculum/v1/standards-frameworks/import
GET    /alpha/curriculum/v1/components
GET    /alpha/curriculum/v1/renderer-registry
GET    /alpha/curriculum/v1/components/{componentId}/tree
GET    /alpha/curriculum/v1/courses/{courseId}/next-lesson
GET    /alpha/curriculum/v1/tracks/{trackId}/placement-candidates
GET    /alpha/curriculum/v1/gates/{componentId}
GET    /alpha/curriculum/v1/gates/{componentId}/status
GET    /alpha/curriculum/v1/gates/{componentId}/next-form
GET    /alpha/curriculum/v1/gates/{componentId}/remediation
POST   /alpha/curriculum/v1/ingest/timeback-course-refs
```

Use `Authorization: Bearer <token>` on every non-mint call. Use `Idempotency-Key` on writes and ingest. For PATCH component corrections, association resequencing, and KC identity publication/retirement, send the current ETag through standard `If-Match` or the hosted compatibility `X-Curriculum-If-Match`. Mutable resource ETags are owned by the API; do not invent validators.

## Non-Negotiables

- Do not query Postgres, Supabase, CASE tables, raw SQL, or derived `alpha.curriculum_*` views for user-facing workflows. Call the Alpha surface.
- Do not parse CASE CFPackages, standards codes, names, URLs, or free text to recover typed facts. Read typed fields.
- Do not copy allowed-value tables into the app. Read `GET /` or the hosted data dictionary.
- Do not create local track, course, component, KC, renderer, alias, external-course, or standards tables.
- Do not send a semantic source id or legacy CASE KC id to graph, scope, remediation, standards-map, or Content `/kc-tags` operations. Create a governed KC through Curriculum `/kcs`, capture its returned canonical `kc_id`, and fail closed unless `GET /kcs/{kcId}` repeats the registry identity and exact current version.
- Do not launch a course merely because its components and KC identities are published. Append/review semantic edits, publish identities with If-Match, approve the complete course snapshot, and require next-lesson to echo the approval and exact firm KC versions.
- Do not compute mastery, confidence, decay, next-task selection, gate pass, score, XP, content effectiveness, placement, rewards, or Policy thresholds.
- Gate fields live on the gated component as `passing_criteria_ref` and `on_fail`. Threshold numbers and reward amounts stay in Policy.
- Universal remediation reasons are typed: `never_learned`, `forgot`, and `careless`. Apps never classify misses.
- Source-shaped TimeBack ingest is a surface call. The caller sends source-shaped records and never pre-normalizes to CASE.
- Parsed standards-framework directory import is a Curriculum helper over the surface, not a caller-owned CASE parser. Validate each JSON file first; skip-and-warn top-level arrays or non-framework JSON; call `POST /alpha/curriculum/v1/standards-frameworks/import` for materialization.

If the user job needs a missing primitive, stop and report a surface gap with the canonical docs and failing workflow. Do not patch around it in the skill pack.

## Reference Files

- Read `references/canonical-surface.md` for object, endpoint, credential, header, boundary, and field guidance.
- Read `references/worked-example.md` for the course tree, registry KC/prerequisite graph, placement, gate, status, and remediation recipe.
- Read `references/source-shaped-ingest.md` for the write-approved TimeBack ingest recipe.
- Read `references/response-samples.md` for abbreviated live response shapes.
- Read `references/runnable-check.md` for the shortest proof command.
- Read `references/leak-check.md` before shipping an app, report, QA probe, migration check, or deliverable.
- Run `checks/verify-skill-pack.mjs` to prove the pack passes static no-leak checks and live surface checks.