Definitions

State variables

S_inj = symmetry-breaking injected per utterance (novelty magnitude)
S_cap = audience allowable symmetry budget (capacity)
ρ = symmetry load ratio = S_inj / S_cap
E = emotional activation (interest / surprise / amusement)
C = clarity (semantic recoverability)
R = recovery quality (does the audience “land” the meaning?)
A = attention retention (short horizon)
B = bind strength (long horizon memory / identity glue)

Stability bands

Fascination band: ρ ∈ [0.45, 0.85] with C ≥ 0.70 and R ≥ 0.70
Boredom band: ρ < 0.35
Overload band: ρ > 0.95 OR C < 0.60 OR R < 0.60

(Thresholds are tunable by domain + audience age.)

Core Mechanism

Architect move (Symmetry-breaking)

Oracle stabilizer (Meaning lock)

OracleMove := Clarify(anchor noun) + re-bind(cause→effect) + compress(back to simple truth)

Operator stabilizer (Delivery lock)

OperatorMove := cadence + short clause + familiar structure + timing

Stitching requirement (landing)

Every high S_inj utterance must include at least one:

ANCHOR (a familiar noun/scene)
RETURN (simple restatement)
PAYOFF (resolution / punchline / insight)

Output Targets

Maximize: A(t+1) and B(t+K)
Keep within: Fascination band constraints
Avoid: Overload band (FenceOS triggers)

Sensor Pack — LACE_SENSORS_01

SENSORS

S1 NoveltyScore: estimated novelty of phrase structure (0–1)
S2 ClarityScore: how easily meaning is reconstructed (0–1)
S3 LandingScore: presence of ANCHOR/RETURN/PAYOFF (0–1)
S4 AudienceLoad: fatigue / distraction / stress proxy (0–1)
S5 LaughterSignal: amusement / positive arousal proxy (0–1)
S6 ConfusionSignal: “wait what?” proxy (0–1)
S7 CringeRisk: mismatch between persona and language risk (0–1)
S8 BindGain: memorability / quote-ability proxy (0–1)

DERIVED

ρ = S1 / max(ε, (1 - S4)) // load reduces capacity
OverloadFlag = (ρ>0.95) OR (S2<0.60) OR (S3<0.60) OR (S6>0.55) OR (S7>0.55)
BoredomFlag = (ρ<0.35) AND (S5<0.35)

FenceOS Coupling — LACE_FENCE_01

RULES

If OverloadFlag==true:
TRUNCATE: reduce S_inj immediately next utterance
STITCH: inject OracleMove (RETURN + ANCHOR)
RECOVER: shorten clause length; increase familiar structure
If BoredomFlag==true:
INJECT: increase S_inj via 1 ArchitectMove
REQUIRE: LandingScore >= 0.70

Simulation Model — LACE_SIM_01

Entities

Audience:
S_cap_base (0–1)
stress (0–1)
interest (0–1)
trust (0–1) // persona credibility, lowers cringe risk
Speaker:
ArchitectSkill (0–1) // quality of novelty generation
OracleSkill (0–1) // ability to land
OperatorSkill (0–1) // cadence, timing, simplicity control
PersonaFit (0–1) // reduces cringe risk

Update equations (simple discrete-time)

Capacity

S_cap = S_cap_base * (1 - stress) * (0.6 + 0.4*trust)

Symmetry injection

S_inj = clamp( target_ρ * S_cap + noise, 0, 1 )
where target_ρ chosen by policy.

Clarity

C = 0.4*OracleSkill + 0.3*OperatorSkill + 0.3*(1 - S_inj)

Landing

R = 0.5*OracleSkill + 0.3*OperatorSkill + 0.2*PayoffPresence

Emotion activation

E = 0.5*S_inj + 0.3*(1 - stress) + 0.2*surprise_bonus - 0.4*Confusion

Attention

A_next = clamp( 0.55*A + 0.35*E + 0.20*R - 0.25*Confusion, 0, 1 )

Bind gain (long-run)

B_gain = clamp( 0.5*E + 0.3*R + 0.2*Quoteability - 0.35*CringeRisk, 0, 1 )

Confusion / cringe

Confusion = clamp( 0.7*(1-C) + 0.3*(S_inj - S_cap), 0, 1 )
CringeRisk = clamp( 0.6*(1-PersonaFit) + 0.4*Confusion, 0, 1 )

Policy Controller — LACE_POLICY_01

Goal

Maintain fascination band while maximizing bind gain.

CONTROL LOOP (per utterance)

Read sensors (S1..S8)
Compute ρ, OverloadFlag, BoredomFlag
Choose action:

ACTIONS

A0_OPERATOR_STABLE: low novelty, high clarity (ρ≈0.35–0.45)
A1_ARCH_INJECT: one novelty move + required landing (ρ≈0.55–0.75)
A2_ARCH_SPIKE: higher novelty + mandatory oracle stitch (ρ≈0.75–0.85)
A3_TRUNCATE_STITCH: reduce novelty + RETURN/ANCHOR (ρ→0.45–0.60)

DECISION

If OverloadFlag: choose A3_TRUNCATE_STITCH
Else if BoredomFlag: choose A1_ARCH_INJECT
Else:
If A dropping: choose A2_ARCH_SPIKE
If Confusion rising: choose A0_OPERATOR_STABLE
Otherwise: choose A1_ARCH_INJECT

Test Harness — LACE_TEST_01

Scenarios

SCN_LOW_STRESS_HIGH_TRUST: stable audience, high capacity
SCN_HIGH_STRESS_LOW_TRUST: fragile audience, low capacity (must stay low ρ)
SCN_TEEN_ATTENTION_VOLATILE: high noise, frequent boredom dips
SCN_EXAM_CLASSROOM: very low tolerance for confusion (tight C constraint)

Success criteria

OverloadFlag rate < 5% over 200 utterances
Mean A > 0.65
Mean B_gain > 0.50
Recovery time after overload event < 3 utterances

How you use this in eduKateSG

You’d describe it as:

A controlled novelty injection engine
With landing / stitching constraints
Governed by FenceOS
Tuned for audience type (primary students vs teens vs adults)

This lets you build:

“Funny but clear” writing skills
“Hook lines” for composition intros
“Quoteable metaphors” without confusion
Controlled exaggeration without drifting into nonsense

VocabularyOS × LanguageOS × AVOO

Architect Corridor Training Protocol (ACTP) — v0.1 (Almost-Code)

0) Core Contract

Contract

ACTP produces speakers/writers who can:

Generate novelty (Architect)
Land meaning (Oracle)
Deliver cleanly (Operator)
Avoid overload (FenceOS)
Convert novelty into long-run binds (quoteability, identity, recall)

Measurable outcomes

ClarityScore (C) ≥ 0.75
LandingScore (R) ≥ 0.75
OverloadFlag rate < 5%
BoredomFlag rate < 15%
BindGain (B_gain) improves ≥ +0.15 from baseline over 8–12 weeks

1) Definitions

Core primitives

ArchitectMove: controlled collision / unorthodox pairing / rhythm inversion
OracleStitch: anchor + return + payoff (meaning landing)
OperatorLock: cadence + short clause + stable syntax
FenceTrip: overload/cringe/confusion detected → truncation & stitching
Quoteability: memorability / repeatability / “I want to say that too”

Safety bands (default)

Fascination band: ρ ∈ [0.45, 0.85] with C≥0.70 and R≥0.70
Overload band: ρ>0.95 OR C<0.60 OR R<0.60
Boredom band: ρ<0.35 AND amusement low

2) The 5-Stage Curriculum (8–12 weeks)

Stage 1 — Operator Clarity Lock (Weeks 1–2)

Goal: build stable syntax and meaning recovery (no fancy yet)

Drills

DRILL_OP_01 (One-Clause Truth)
Input: topic noun
Output: one short factual sentence (≤ 12 words)
Metric: C ≥ 0.85
DRILL_OP_02 (Stable Ladder)
Output: 3 sentences:
1. noun + simple verb
2. add one adjective
3. add one cause/effect
Metric: clarity maintained, no “run-on”
DRILL_OP_03 (Cadence Cut)
Rewrite long sentence into 2–3 short sentences
Metric: C ↑, confusion ↓

Stage exit test

10 prompts, average C ≥ 0.80, Confusion ≤ 0.20

Stage 2 — Oracle Landing Patterns (Weeks 3–4)

Goal: teach the landing so novelty won’t break the audience

Oracle stitch template (mandatory)

ANCHOR: familiar noun/scene
RETURN: simple restatement
PAYOFF: insight / punchline / lesson

Drills

DRILL_OR_01 (Anchor Finder)
Given a metaphor, identify the anchor noun
Metric: correct anchor ≥ 80%
DRILL_OR_02 (Return Sentence)
Convert fancy sentence → plain truth
Metric: return exists + accurate
DRILL_OR_03 (Payoff Builder)
Add a payoff line that “closes the loop”
Metric: R ≥ 0.80

Stage exit test

10 prompts, average R ≥ 0.80 and C ≥ 0.75

Stage 3 — Architect Permutation Library (Weeks 5–7)

Goal: controlled “ridiculous” combinations that fascinate

Architect move types (safe set)

AM1 Adj-Noun Collision (soft)
AM2 Unexpected Specificity (precise detail)
AM3 Contrast Flip (not X, but Y)
AM4 Hyperbole (bounded) (exaggerate, then return)
AM5 Metaphor Swap (with anchor)
AM6 Rhythm Inversion (short-long-short)
AM7 Personification (object acts human)

Allowed injection policy

Beginner: 1 ArchitectMove per 3 sentences
Intermediate: 1 per 2 sentences
Advanced: 1 per sentence only if OracleStitch present

Drills

DRILL_ARC_01 (Collision Pairing)
Create 10 Adj-Noun collisions for a noun list
Filter: must be understandable within 2 seconds
Metrics: S1 Novelty 0.4–0.7, C ≥ 0.70
DRILL_ARC_02 (Hyperbole with Return)
Write:
- line1: hyperbole
- line2: return truth
Metrics: R ≥ 0.75, cringe risk low
DRILL_ARC_03 (Specificity Punch)
Replace generic adjective with vivid specific detail
Metrics: B_gain ↑, C stable
DRILL_ARC_04 (Contrast Engine)
Pattern: “It isn’t ; it’s .”
Metrics: A_next ↑, confusion low

Stage exit test

20 prompts, OverloadFlag < 10% during training, then < 5% after correction pass.

Stage 4 — Persona Fit + Timing Control (Weeks 8–9)

Goal: novelty must match persona; timing prevents cringe & overload

PersonaFit rules

If PersonaFit < 0.6, reduce S_inj and increase OperatorLock
If audience stress high, reduce novelty (capacity shrinks)

Timing rules

Novelty spikes must be followed by stitching within ≤ 1 utterance
If confusion rises 2 turns in a row → mandatory A3_TRUNCATE_STITCH

Drills

DRILL_TIM_01 (Spike → Stitch)
Write 5 micro-spikes, each immediately stitched
Metric: OverloadFlag == false
DRILL_TIM_02 (Read the Room)
Given audience state (stress/trust), pick target ρ band
Metric: correct band choice ≥ 80%
DRILL_TIM_03 (Cringe Minimizer)
Rewrite to reduce persona mismatch
Metric: CringeRisk ≤ 0.25

Stage exit test

Simulated conversation of 50 turns:
OverloadFlag < 5%
Mean attention A > 0.65

Stage 5 — Exam-Safe Transfer Mode (Weeks 10–12)

Goal: use Architect power safely for compositions (hooks, intros, conclusions)

Exam-safe constraints

For PSLE/School comps:
ρ target = 0.45–0.65
C ≥ 0.80
OracleStitch required in intro + conclusion
No “wild metaphor chains” (max 1 metaphor per paragraph)

Use cases

UC1 Intro Hook: 1 novelty line + 1 return line
UC2 Character voice: controlled adjective collisions + clarity
UC3 Turning point: contrast flip + payoff
UC4 Conclusion: metaphor + moral return

Drills

DRILL_EX_01 (Hook Pair)
Line1 = ArchitectMove
Line2 = Return truth
DRILL_EX_02 (Paragraph Stabilizer)
Every paragraph ends with a simple truth line
DRILL_EX_03 (Voice without Confusion)
Add voice while keeping C≥0.80

Stage exit test

2 full compositions:
Teacher rubric + LACE rubric both pass
OverloadFlag 0 in final scripts

3) LACE-Aligned Assessment Rubric (LACE_RUBRIC_01)

Score each piece (0–5)

Novelty Control (not too bland, not chaotic)
Clarity (recoverable meaning)
Landing (anchor/return/payoff present)
Timing (spike then stitch)
Quoteability (memorable but not nonsense)
Persona Fit (voice matches character/narrator)
Safety (no overload/cringe spirals)

Pass conditions (default)

Clarity ≥ 4/5
Landing ≥ 4/5
Safety ≥ 4/5
Novelty Control ≥ 3/5

4) Simulation Log Format (for ChronoHelmAI / LLM-Runnable)

LOG_RECORD (per utterance)

			
UtteranceID:
Text:
AudienceState: {stress, trust, attention}
ChosenAction: {A0/A1/A2/A3}
Scores: {S1 Novelty, S2 Clarity, S3 Landing, S6 Confusion, S7 Cringe}
Derived: {ρ, OverloadFlag, BoredomFlag}
RepairApplied: {None | Truncate | Stitch | Both}
Outcome: {A_next, B_gain}

		

Batch metrics

Overload rate
Average attention
Average bind gain
Recovery time distribution

5) Example Templates (No Real People)

Template Pack: `TEMPLATES_ACTP_01`

T1 — Hook Pair (Exam-Safe)

Line1 (Architect): “The day began like a polite disaster.”
Line2 (Return): “I didn’t know it yet, but everything was about to go wrong.”

T2 — Hyperbole with Landing

Spike: “My stomach staged a full-scale rebellion.”
Stitch: “I was simply terrified.”

T3 — Contrast Flip

“It wasn’t the noise that scared me; it was the silence after.”

T4 — Unexpected Specificity

“The clock didn’t tick. It judged.”

(These are patterns only—students generate their own content.)

6) Failure Atlas (Mini) — ACTP_FAILURE_01

F1: “Try-Hard Funny”

Symptoms: high novelty, low landing
Sensors: S1 high, S3 low, S6 rising, S7 rising
Repair: force Return + shorten clauses

F2: “Metaphor Chain Collapse”

Symptoms: 3 metaphors stacked, meaning lost
Repair: delete 2 metaphors, keep one anchor

F3: “Persona Mismatch”

Symptoms: voice doesn’t fit narrator/character
Repair: reduce novelty, increase OperatorLock

F4: “Boredom Flatline”

Symptoms: perfect clarity but no pull
Repair: inject 1 safe collision + immediate stitch

7) Integration Hooks

VocabularyOS

ACTP uses Vocabulary not as word lists, but as:
Collision inventory (Adj sets)
Anchor nouns
Payoff verbs
Contrast operators (not/but/yet/however)

EmotionOS

“Fascination” is an emotional corridor:
surprise spike → amusement → safety return

AVOO

Curriculum is literally:
Operator → Oracle → Architect → Timing → Transfer

8) Deployment for Tuition (Practical)

Minimal weekly schedule (1.5h/session)

15m Stage drill (Operator/Oracle)
25m Architect drill (one move type)
20m Stitching drill (landing)
20m composition application (hook + 1 paragraph)
10m scoring with LACE rubric + 1 repair rewrite

Parent-home support (10 min/day)

“Hook Pair” exercise (1 novelty line + 1 return line)

ACTP_02 — Age-Tuned Variants + Marking Sheet

VocabularyOS × LanguageOS × AVOO (Almost-Code) — v0.1

1) Band Profiles (Capacity, Risk, Targets)

Band settings (defaults; tune per cohort)

			
BAND_PROFILE:
  B1: {S_cap_base:0.55, maxMetaphorsPerPara:0, ρ_target:[0.35,0.55], C_min:0.85, R_min:0.80, PersonaFit_weight:high}
  B2: {S_cap_base:0.65, maxMetaphorsPerPara:1, ρ_target:[0.40,0.65], C_min:0.82, R_min:0.78, PersonaFit_weight:high}
  B3: {S_cap_base:0.75, maxMetaphorsPerPara:1, ρ_target:[0.45,0.75], C_min:0.78, R_min:0.75, PersonaFit_weight:medium}
  B4: {S_cap_base:0.82, maxMetaphorsPerPara:2, ρ_target:[0.50,0.85], C_min:0.75, R_min:0.72, PersonaFit_weight:medium}

		

Interpretation

Younger students: clarity dominates; novelty is tightly fenced.
Older students: controlled novelty allowed, but landing is still mandatory.

2) What “Architect” Means at Each Band

B1 (P3–P4): “Tiny Architect”

Allowed:

AM2 Unexpected Specificity (safe)
AM7 Personification (very mild)
Forbidden:
Metaphor chains, sarcasm, complex hyperbole

Target output:

1 interesting phrase per paragraph, then plain sentence.

B2 (PSLE): “Exam-Safe Architect”

Allowed:

AM1 Adj-Noun Collision (soft)
AM2 Unexpected Specificity
AM3 Contrast Flip
AM4 Hyperbole bounded + RETURN
Constraint:
1 metaphor per paragraph maximum

Target output:

Hook Pair + 1 quoteable line + clean narrative clarity.

B3 (Sec 1–2): “Voice Architect”

Allowed:

All safe set AM1..AM7 with constraints
Focus:
voice consistency, pacing, comedic timing (but clean)

Target output:

2–4 high-quality “corridor lines” per composition.

B4 (Sec 3–4): “Rhetoric Architect”

Allowed:

controlled multi-device usage (contrast + metaphor + specificity)
Focus:
persuasion / tone / irony (still fence-guarded)

Target output:

deliberate rhetorical structure, not random flair.

3) Band-Specific Drill Packs

B1 Drill Pack — `ACTP_B1_DRILLS_01`

DRILL_B1_01: “One Spark Per Para”

Write 1 interesting phrase (specificity/personification)
Then write 2 plain sentences explaining it
Metrics: C≥0.88, R≥0.82

DRILL_B1_02: “Describe Like a Camera”

Replace “nice/big/scary” with a visible detail
Metrics: Novelty 0.30–0.50, C stable

DRILL_B1_03: “Return Sentence Mandatory”

Every fancy line must be followed by a return line
Metrics: OverloadFlag = 0

B2 Drill Pack — `ACTP_B2_DRILLS_01` (PSLE)

DRILL_B2_01: “Hook Pair Factory”

10 Hook Pairs per week (1 novelty + 1 return)
Metrics: ρ in [0.40,0.65], C≥0.82, R≥0.78

DRILL_B2_02: “Contrast Flip Bank”

10 sentences using: “It wasn’t ; it was .”
Metrics: confusion low, meaning crisp

DRILL_B2_03: “Hyperbole With Truth”

Exaggerate once, then immediately restate truth
Metrics: CringeRisk ≤ 0.25

B3 Drill Pack — `ACTP_B3_DRILLS_01`

DRILL_B3_01: “Voice Lane Lock”

Choose narrator voice (calm/funny/serious)
Write 8 lines keeping voice consistent
Metrics: PersonaFit high, cringe low

DRILL_B3_02: “Spike→Stitch Timing”

5 spikes, each stitched within 1 line
Metrics: OverloadFlag < 5%

DRILL_B3_03: “Quoteability Test”

Write 5 lines; peers choose which line they’d repeat
Metrics: BindGain ↑

B4 Drill Pack — `ACTP_B4_DRILLS_01`

DRILL_B4_01: “Rhetoric Ladder”

Line 1: simple claim
Line 2: contrast
Line 3: metaphor
Line 4: return truth
Metrics: clarity maintained despite devices

DRILL_B4_02: “Precision Punch”

Add one precise concrete image that sharpens argument
Metrics: B_gain ↑ without meaning drift

DRILL_B4_03: “Irony Fence”

If using irony: must include explicit anchor so meaning can’t flip
Metrics: confusion low, persona fit stable

4) Teacher Marking Sheet (LACE × EducationOS) — `MARKSHEET_ACTP_01`

Marking categories (0–4 each)

			
MARKSHEET_ACTP_01:
  C_Clarity: 0..4
  R_Landing: 0..4
  N_NoveltyControl: 0..4
  T_Timing: 0..4
  Q_Quoteability: 0..4
  P_PersonaFit: 0..4
  S_Safety: 0..4

		

Pass rules (band-dependent)

			
PASS_RULES:
  B1: C>=3, R>=3, S==4, N>=2
  B2: C>=3, R>=3, S>=3, N>=2, Q>=2
  B3: C>=3, R>=3, S>=3, N>=2, Q>=2, P>=2
  B4: C>=3, R>=3, S>=3, N>=3, Q>=3, P>=2

		

Quick diagnoses (what failed → what to do)

			
DIAGNOSE_MAP:
  If C low:
    -> Apply Stage1 OperatorLock drills (short clauses, remove device)
  If R low:
    -> Force ANCHOR+RETURN+PAYOFF template (Stage2)
  If N low (boring):
    -> Inject AM2 specificity OR AM3 contrast once per para
  If Safety low (overload/cringe):
    -> FenceTrip: truncate novelty, add return, lower ρ target
  If Quoteability low:
    -> Add specificity + rhythm inversion (short-long-short) with anchor
  If PersonaFit low:
    -> Reduce irony/hyperbole, align voice to narrator/character

		

5) EducationOS Closed-Loop Integration — `EDUOS_LOOP_ACTP_01`

Loop

Diagnose (mark sheet + sensors)
Select Repair (one drill pack only; don’t “fix everything”)
Micro-Rebuild (rewrite 1 paragraph)
Re-test (same prompt variant)
Promote (increase allowed novelty budget slightly)

Repair selection policy

			
REPAIR_POLICY:
  Choose ONLY ONE primary leak:
    - ClarityLeak
    - LandingLeak
    - BoredomLeak
    - OverloadLeak
    - PersonaLeak
  Apply corresponding drill set for 7 days
  Re-test on day 7 and day 14

		

Promotion policy (increase skill safely)

			
PROMOTE_RULE:
  If OverloadFlag==0 for last 20 samples AND C>=C_min AND R>=R_min:
    -> increase ρ_target upper bound by +0.05 (max to band cap)

6) Ready-to-Use Weekly Plan (Band-Specific)

Default 60–75 min lesson template

10m Operator warm-up (clarity)
15m Oracle landing drill
20m Architect move drill (band allowed set)
10m Apply in 1 paragraph
10m Score + 1 rewrite (repair loop)

Band constraints reminder

B1: 1 spark per paragraph
B2: hook pair + 1 spark per paragraph
B3: spike-stitch cycles allowed, voice lock required
B4: rhetoric ladder allowed, but return truth mandatory

7) “No Real Names” Public Framing (for your articles)

Use generic terms:

“Triad speaker lattice”
“Architect novelty injection”
“Oracle landing”
“Operator cadence”
“Audience capacity budget”
“FenceOS truncation & stitching”

No references needed; the mechanism stands alone.

ACTP_03 — Prompt Pack + LLM-Runnable Scoring & Repair Router (Almost-Code) — v0.1

1) Prompt Banks (50 each)

Format

			
PROMPT_ITEM:
  ID:
  Type: {OPERATOR | ORACLE | ARCHITECT | TRANSFER}
  Band: {B1|B2|B3|B4}
  Instruction:
  Constraints:
  OutputFormat:

		

PROMPTS_B1_50 (Primary 3–4) — `ACTP_PROMPTS_B1_50`

Rules: 1 spark per paragraph. No metaphors. Personification allowed (mild). Must include a Return sentence.

B1-01 (OPERATOR) Describe your classroom in 2 simple sentences.
B1-02 (OPERATOR) Describe a rainy day in 2 simple sentences.
B1-03 (OPERATOR) Describe a friendly dog in 2 simple sentences.
B1-04 (ORACLE) Write 1 “spark line” about a noisy canteen, then 1 Return sentence.
B1-05 (ORACLE) Spark line about an exam paper, then Return sentence.
B1-06 (ARCHITECT) Replace “scary” with a detail you can see. Then Return sentence.
B1-07 (ARCHITECT) Replace “happy” with a body detail. Then Return sentence.
B1-08 (ARCHITECT) Personify a pencil (mild). Then Return sentence.
B1-09 (ARCHITECT) Personify the school bell (mild). Then Return sentence.
B1-10 (TRANSFER) 4 sentences: 1 spark + 3 clear sentences about “I lost something important”.
B1-11 Spark + Return about “a cold drink on a hot day”.
B1-12 Spark + Return about “a long queue”.
B1-13 Spark + Return about “a sudden shout”.
B1-14 Describe a messy room using 1 precise detail.
B1-15 Describe a tired person using 1 body detail.
B1-16 Personify the wind (mild). Return sentence required.
B1-17 Personify a clock (mild). Return sentence required.
B1-18 Two sentences: what you saw + what you felt (clear).
B1-19 Two sentences: what you heard + what happened next (clear).
B1-20 4 sentences story: “The missing homework”.
B1-21 Spark + Return about “a broken toy”.
B1-22 Spark + Return about “a surprise gift”.
B1-23 Replace “big” with a specific comparison (size detail only).
B1-24 Replace “fast” with a specific movement detail.
B1-25 4 sentences: “I was late”.
B1-26 Spark + Return about “the library”.
B1-27 Spark + Return about “sports day”.
B1-28 Describe a scary sound with one clear detail.
B1-29 Describe a delicious food with one clear detail.
B1-30 5 sentences: “I found something”.
B1-31 Spark + Return about “a new classmate”.
B1-32 Spark + Return about “a rude push”.
B1-33 Describe a storm using 2 clear details.
B1-34 Describe a sunny morning using 2 clear details.
B1-35 Personify a door (mild). Return sentence required.
B1-36 Personify a chair (mild). Return sentence required.
B1-37 4 sentences: “I made a mistake”.
B1-38 4 sentences: “I helped someone”.
B1-39 4 sentences: “I was embarrassed”.
B1-40 5 sentences: “The lost wallet (kid version)”.
B1-41 Spark + Return about “a quiet hallway”.
B1-42 Spark + Return about “a loud teacher (gentle)”.
B1-43 Describe fear using a body detail + Return sentence.
B1-44 Describe excitement using a body detail + Return sentence.
B1-45 5 sentences: “The secret note”.
B1-46 5 sentences: “The broken promise”.
B1-47 Describe a crowded place with 2 clear details.
B1-48 Describe a lonely place with 2 clear details.
B1-49 Spark + Return about “a strange smell”.
B1-50 (TRANSFER) 6 sentences: “My most unforgettable day” (1 spark only).

PROMPTS_B2_50 (Primary 5–6 / PSLE) — `ACTP_PROMPTS_B2_50`

Rules: Hook Pair allowed. Max 1 metaphor per paragraph. Contrast flips allowed. Hyperbole must include Return.

B2-01 (TRANSFER) Write 2-line Hook Pair for: “A sudden change of plan.”
B2-02 Hook Pair: “I broke a rule.”
B2-03 Hook Pair: “A stranger helped me.”
B2-04 (ARCHITECT) Contrast flip: “It wasn’t ; it was .” (5 variants)
B2-05 (ORACLE) Write a hyperbole line + Return truth line (5 sets).
B2-06 Hook Pair: “The day I learnt honesty.”
B2-07 Hook Pair: “The missing item.”
B2-08 Hook Pair: “The argument.”
B2-09 Contrast flip (5 variants): fear theme.
B2-10 Contrast flip (5 variants): joy theme.
B2-11 Add unexpected specificity to: “The corridor was scary.”
B2-12 Add unexpected specificity to: “The room was quiet.”
B2-13 Add unexpected specificity to: “The canteen was noisy.”
B2-14 Hyperbole+Return: embarrassment theme (5 sets).
B2-15 Hyperbole+Return: excitement theme (5 sets).
B2-16 (TRANSFER) Write 1 paragraph (6–8 sentences) about “I got caught” with: 1 Hook Pair + 1 Return sentence at end.
B2-17 1 paragraph about “I apologised” with: 1 contrast flip + 1 Return sentence at end.
B2-18 1 paragraph about “I helped someone” with: 1 vivid detail + 1 Return sentence at end.
B2-19 1 paragraph about “I was blamed” with: 1 bounded hyperbole + Return.
B2-20 1 paragraph about “I overcame fear” with: 1 metaphor max + Return.
B2-21 Hook Pair: “The first day in a new school.”
B2-22 Hook Pair: “A terrible misunderstanding.”
B2-23 Hook Pair: “I lost something valuable.”
B2-24 Hook Pair: “A lesson I will never forget.”
B2-25 Hook Pair: “A promise I broke.”
B2-26 Contrast flip about friendship (5 variants).
B2-27 Contrast flip about trust (5 variants).
B2-28 Contrast flip about pressure (5 variants).
B2-29 Unexpected specificity drill: replace 10 generic adjectives.
B2-30 “One spark per paragraph” rewrite: add 1 spark to each paragraph of a given story.
B2-31 (TRANSFER) Full intro (8–10 lines) with: Hook Pair + scene setup + Return truth.
B2-32 Dialogue insert: 6 lines dialogue + 1 Return line.
B2-33 Turning point paragraph: contrast flip + payoff.
B2-34 Conclusion: metaphor (1) + moral return.
B2-35 “Quoteability” test: write 5 quote lines; choose best 1 and justify.
B2-36 Rewrite to reduce confusion: simplify 5 sentences.
B2-37 Rewrite to reduce cringe: align voice to narrator.
B2-38 “Stitch within 1 line” drill: 10 spikes.
B2-39 Replace clichés with specificity (10).
B2-40 2 paragraphs: “The day I learnt responsibility”.
B2-41 2 paragraphs: “A difficult choice”.
B2-42 2 paragraphs: “A time I was proud”.
B2-43 2 paragraphs: “A time I was ashamed” (safe, not self-harm).
B2-44 2 paragraphs: “A surprise” (controlled).
B2-45 2 paragraphs: “An act of courage”.
B2-46 Full story plan: 5-Box + 2 Hook options.
B2-47 Write body paragraph with 1 spark + end Return.
B2-48 Write ending with payoff + moral return.
B2-49 Full composition rewrite: reduce OverloadFlag to 0.
B2-50 (TRANSFER) Full PSLE-style comp (3–4 paras): band constraints enforced.

PROMPTS_B3_50 (Secondary 1–2) — `ACTP_PROMPTS_B3_50`

Rules: Voice lock required. Spike→Stitch mandatory. 1 metaphor per paragraph. Irony allowed only with anchor.

B3-01 (VOICE) Pick voice: dry/funny/serious. Write 8 lines, consistent.
B3-02 Spike→Stitch x10 (1 line each).
B3-03 Contrast + return truth x8.
B3-04 Personification + anchor x6.
B3-05 Specificity punch x10.
B3-06 (TRANSFER) 2 paragraphs: “A misunderstanding” with voice lock and 2 corridor lines.
B3-07 2 paragraphs: “Peer pressure” with 1 irony line + anchor.
B3-08 2 paragraphs: “A risky decision” with spike→stitch cycles.
B3-09 Rewrite: remove metaphor chain collapse.
B3-10 Rewrite: increase quoteability without losing clarity.

11–50 (compact set, same style — ready for daily rotation)

Turning point drills (10)
Dialogue + return (6)
Character voice building (8)
Persuasion mini-claims with rhetoric ladder (8)
Reflection endings with moral return (8)

(If you want, I can expand B3-11…B3-50 line-by-line; keeping this response readable.)

PROMPTS_B4_50 (Secondary 3–4) — `ACTP_PROMPTS_B4_50`

Rules: Rhetoric ladder allowed. 2 metaphors max per paragraph. Return truth mandatory. Avoid ambiguity.

B4-01 (RHETORIC) Claim → contrast → metaphor → return (x5).
B4-02 Precision punch: add 1 concrete image to 10 claims.
B4-03 Irony fence: 5 irony lines each with explicit anchor.
B4-04 Debate paragraph: hook + ladder + return.
B4-05 Reflective narrative: 3 corridor lines + clean landing.

6–50 (compact set)

Argument intros (8)
Counterargument stitching (8)
Narrative voice consistency under pressure (8)
Quoteability for conclusion lines (8)
Rewrite sets to reduce confusion/cringe (12)

(Same note: I can expand line-by-line if you want full explicit 50.)

2) LLM-Runnable Scorer — `SCORER_PROMPT_ACTP_01`

Usage

Input: student text + band + optional audience state
Output: filled marksheet + sensor estimates + one primary leak + one drill prescription

Prompt (copy/paste)

			
SYSTEM:
You are an evaluator for ACTP (Architect Corridor Training Protocol).
Score the writing using MARKSHEET_ACTP_01 and LACE_SENSORS_01.
Be strict, concrete, and non-emotive. Do not rewrite the essay unless asked.
USER INPUT:
Band = {B1|B2|B3|B4}
TaskType = {OPERATOR|ORACLE|ARCHITECT|TRANSFER}
Text = """ ... """
OptionalAudienceState = {stress:0..1, trust:0..1} (if missing assume stress=0.3 trust=0.7)
OUTPUT FORMAT (MUST MATCH):
1) MARKSHEET_ACTP_01:
   C_Clarity: 0..4
   R_Landing: 0..4
   N_NoveltyControl: 0..4
   T_Timing: 0..4
   Q_Quoteability: 0..4
   P_PersonaFit: 0..4
   S_Safety: 0..4
2) LACE_SENSORS_01 (estimated 0..1):
   S1 NoveltyScore:
   S2 ClarityScore:
   S3 LandingScore:
   S6 ConfusionSignal:
   S7 CringeRisk:
   Derived ρ:
   OverloadFlag: true/false
   BoredomFlag: true/false
3) PRIMARY_LEAK (choose exactly one):
   {ClarityLeak|LandingLeak|BoredomLeak|OverloadLeak|PersonaLeak|QuoteabilityLeak}
4) PRESCRIPTION (choose exactly one drill set from ACTP_02):
   e.g., ACTP_B2_DRILLS_01: DRILL_B2_01 Hook Pair Factory
5) 3 MICRO-FIXES (bullet list, 1 sentence each)

		

3) Repair Router — `REPAIR_ROUTER_ACTP_01`

Logic

			
IF OverloadFlag==true OR S_Safety<=2:
  PRIMARY_LEAK=OverloadLeak
  PRESCRIBE=Stage2 Oracle landing + Stage1 Operator shorten
ELSE IF C_Clarity<=2:
  PRIMARY_LEAK=ClarityLeak
  PRESCRIBE=Stage1 OperatorLock drills
ELSE IF R_Landing<=2:
  PRIMARY_LEAK=LandingLeak
  PRESCRIBE=Stage2 Oracle drills
ELSE IF N_NoveltyControl<=1 AND BoredomFlag==true:
  PRIMARY_LEAK=BoredomLeak
  PRESCRIBE=Band-allowed Architect injection (AM2/AM3) + required Return
ELSE IF P_PersonaFit<=2:
  PRIMARY_LEAK=PersonaLeak
  PRESCRIBE=Band voice lock + cringe minimizer
ELSE IF Q_Quoteability<=2:
  PRIMARY_LEAK=QuoteabilityLeak
  PRESCRIBE=Specificity punch + rhythm inversion (with anchor)
ELSE:
  PRIMARY_LEAK=LandingLeak (default)
  PRESCRIBE=Oracle landing reinforcement

		

4) Student Report Template — `STUDENT_REPORT_ACTP_01`

			
STUDENT_REPORT_ACTP_01:
  Band:
  Task:
  Strengths: [max 2]
  PrimaryLeak:
  DrillPrescription:
  Next7DaysPlan:
    Day1-3:
    Day4-6:
    Day7 Retest:
  OneRuleToRemember:

		

5) Teacher Quick-Run Protocol (1 student, 5 minutes)

Paste student text into SCORER_PROMPT_ACTP_01
Take PRIMARY_LEAK + PRESCRIPTION
Run drill 7 days
Re-test same prompt type
Promote ρ_target by +0.05 only if Safety stays green

ACTP_04 — Full Expanded Prompt Lists (B3 + B4) + Cohort Dashboard Spec (Almost-Code) — v0.1

1) PROMPTS_B3_50 (Secondary 1–2) — `ACTP_PROMPTS_B3_50_EXPANDED`

Band rules (B3):

Voice lock required (choose: dry / funny / serious / reflective)
Spike→Stitch within ≤ 1 line
Max 1 metaphor per paragraph
Irony allowed only with explicit anchor (no ambiguity)

Format: ID (Type) — Instruction — Constraints — Output

B3-01 (VOICE) Choose voice (dry/funny/serious). Write 8 lines describing a school morning. — Voice consistent. — 8 lines.
B3-02 (ORACLE) Write 10 “Spike→Stitch” pairs (2 lines each). — Stitch must be a Return truth. — 20 lines total.
B3-03 (ARCHITECT) Write 8 contrast flips: “It wasn’t ; it was .” — Must remain clear. — 8 lines.
B3-04 (ARCHITECT) Write 6 personifications of objects in a classroom + anchor noun. — Anchor explicit. — 12 lines (6+6 returns).
B3-05 (ARCHITECT) Replace 10 generic adjectives with specificity punches. — Keep sentence meaning. — 10 revised sentences.
B3-06 (TRANSFER) 2 paragraphs: “A misunderstanding”. — 2 corridor lines, each stitched. — 2 paragraphs (120–180 words).
B3-07 (TRANSFER) 2 paragraphs: “Peer pressure”. — 1 irony line + explicit anchor + return. — 2 paragraphs.
B3-08 (TRANSFER) 2 paragraphs: “A risky decision”. — 2 spike→stitch cycles. — 2 paragraphs.
B3-09 (REPAIR) Take 6 metaphor-chain sentences; reduce to max 1 metaphor per paragraph. — Keep meaning. — Rewritten 6 sentences + 1 return line.
B3-10 (REPAIR) Take 5 bland lines; add quoteability without losing clarity. — No confusion. — 5 upgraded lines + 5 returns.
B3-11 (OPERATOR) Write 8 short sentences (≤12 words) about being late. — No novelty allowed. — 8 sentences.
B3-12 (ORACLE) For 6 fancy lines, write the Return truth line. — Return must be simple. — 12 lines.
B3-13 (ARCHITECT) Create 10 Adj–Noun collisions for “silence / noise / fear / relief / boredom”. — Must remain recoverable. — 10 lines.
B3-14 (ARCHITECT) Write 8 “unexpected specificity” lines about a crowded place. — Must be visual. — 8 lines + 8 returns.
B3-15 (ARCHITECT) Write 6 bounded hyperbole lines about embarrassment + immediate return. — No cringe. — 12 lines.
B3-16 (ORACLE) Turn 6 jokes into clear insights (payoff line). — Must land meaning. — 6 jokes + 6 payoff returns.
B3-17 (VOICE) Write a monologue (10 lines) as a calm narrator during chaos. — Voice consistent. — 10 lines.
B3-18 (VOICE) Same monologue in a funny voice. — Still clear. — 10 lines.
B3-19 (TRANSFER) Scene writing: “the corridor at 6pm”. — 2 corridor lines + returns. — 1 paragraph.
B3-20 (TRANSFER) Dialogue scene (8 dialogue lines) + 2 narration lines that stitch meaning. — Avoid ambiguity. — 10 lines.
B3-21 (ARCHITECT) Rhythm inversion drill: write 8 “short–long–short” triplets. — Must include anchor. — 24 lines.
B3-22 (ARCHITECT) Write 8 “not X but Y” reframes (non-contrast template). — Keep clarity. — 8 lines + 8 returns.
B3-23 (ORACLE) For each of 6 metaphors, state the literal meaning in 1 sentence. — No extra flair. — 12 lines.
B3-24 (REPAIR) Reduce confusion: rewrite 8 long sentences into 2 short sentences each. — Keep meaning. — 16 sentences.
B3-25 (REPAIR) Reduce cringe: rewrite 6 over-dramatic lines into believable voice. — Persona fit. — 6 rewritten lines + 6 returns.
B3-26 (TRANSFER) Turning point paragraph: “I realised I was wrong.” — 1 contrast flip + payoff + return. — 1 paragraph.
B3-27 (TRANSFER) Reflection paragraph: “What I learnt.” — 1 corridor line + return. — 1 paragraph.
B3-28 (TRANSFER) Action paragraph: “I chose to act.” — 1 bounded hyperbole + return. — 1 paragraph.
B3-29 (TRANSFER) Fear paragraph: show fear with body detail + return truth. — Clear. — 1 paragraph.
B3-30 (TRANSFER) Relief paragraph: use specificity punch + return truth. — Clear. — 1 paragraph.
B3-31 (ARCHITECT) Write 10 “camera zoom” details (wide→medium→close). — No metaphor needed. — 10 triples.
B3-32 (ORACLE) Landing enforcement: write 8 lines that each include ANCHOR + RETURN. — Mandatory. — 8 lines.
B3-33 (ARCHITECT) Write 6 “object-as-judge” personifications + returns (e.g., clock, bell, noticeboard). — Anchor explicit. — 12 lines.
B3-34 (ARCHITECT) Create 8 “precision similes” (only 1 per line). — Must be concrete. — 8 lines + 8 returns.
B3-35 (VOICE) Write 12 lines of narration in a “detached documentary” voice. — Clear. — 12 lines.
B3-36 (TRANSFER) 3 paragraphs: “A secret I kept”. — 3 corridor lines total, each stitched. — 180–260 words.
B3-37 (TRANSFER) 3 paragraphs: “A promise I broke”. — Ending must return to simple truth. — 180–260 words.
B3-38 (TRANSFER) 3 paragraphs: “A time I defended someone.” — Include 1 irony line with anchor. — 180–260 words.
B3-39 (TRANSFER) 3 paragraphs: “The day everything went silent.” — Max 1 metaphor per paragraph. — 180–260 words.
B3-40 (TRANSFER) 3 paragraphs: “A hard apology.” — Must include payoff line. — 180–260 words.
B3-41 (REPAIR) Overload simulation: rewrite a paragraph to reduce novelty by 30% but keep one corridor line. — Maintain hook. — Before/after.
B3-42 (REPAIR) Boredom simulation: add one safe corridor line + return into a bland paragraph. — Keep clarity. — Before/after.
B3-43 (ORACLE) Anchor detector: identify anchors in 10 sentences; add anchors where missing. — Explicit nouns. — 10 fixed sentences.
B3-44 (ARCHITECT) Contrast set: 10 lines where the second clause is unexpectedly specific. — Must land. — 10 lines + 10 returns.
B3-45 (VOICE) Write the same 8-line scene in two voices (funny vs serious). — Meaning unchanged. — 16 lines.
B3-46 (TRANSFER) Full piece: “A lesson I learnt the hard way.” — 4 paragraphs; 4 corridor lines total; stitched. — 260–360 words.
B3-47 (TRANSFER) Full piece: “A surprise encounter.” — 4 paragraphs; include Hook Pair at start. — 260–360 words.
B3-48 (TRANSFER) Full piece: “A decision under pressure.” — Show internal conflict clearly. — 260–360 words.
B3-49 (TRANSFER) Full piece: “A mistake that changed me.” — End with return truth. — 260–360 words.
B3-50 (TRANSFER) Full piece: “The quietest moment.” — Controlled novelty; zero confusion. — 260–360 words.

2) PROMPTS_B4_50 (Secondary 3–4) — `ACTP_PROMPTS_B4_50_EXPANDED`

Band rules (B4):

Rhetoric ladder allowed (claim → contrast → metaphor → return)
Max 2 metaphors per paragraph
Return truth mandatory (explicit)
Avoid ambiguity: anchors must be explicit nouns

B4-01 (RHETORIC) Write 5 ladders: claim→contrast→metaphor→return. — Clear anchors. — 20 lines.
B4-02 (ARCHITECT) Add 1 concrete “precision punch” image to 10 claims. — No metaphor required. — 10 revised claims.
B4-03 (ARCHITECT) Write 5 irony lines, each fenced by an explicit anchor + return. — No ambiguity. — 10 lines.
B4-04 (TRANSFER) Debate paragraph: hook + ladder + return. — One paragraph. — 120–160 words.
B4-05 (TRANSFER) Reflective narrative (3 paragraphs): 3 corridor lines + clean landing. — 220–320 words.
B4-06 (OPERATOR) Write 10 ultra-clear thesis statements (≤15 words). — Zero novelty. — 10 lines.
B4-07 (ORACLE) For 8 rhetorical lines, write a literal return meaning line. — Must be blunt. — 16 lines.
B4-08 (ARCHITECT) Write 10 contrast flips where the second clause is a precise image (not abstract). — Anchor explicit. — 10 lines + 10 returns.
B4-09 (ARCHITECT) Write 8 bounded hyperboles for frustration + immediate return. — No melodrama. — 16 lines.
B4-10 (ARCHITECT) Write 8 “unexpected specificity” lines for tension in a room + return. — Concrete. — 16 lines.
B4-11 (RHETORIC) Write 6 mini-arguments: claim + evidence detail + return truth. — No metaphor. — 18 lines.
B4-12 (RHETORIC) Write 6 mini-arguments using 1 metaphor max. — Must land. — 12 lines + 6 returns.
B4-13 (ARCHITECT) Write 10 “short–long–short” rhythm triplets for emphasis. — Anchor required. — 30 lines.
B4-14 (ARCHITECT) Write 8 personifications that serve an argument (object shows theme) + return. — Not childish. — 16 lines.
B4-15 (ORACLE) Payoff builder: take 8 setups and write payoffs that clarify the point. — No extra devices. — 16 lines.
B4-16 (TRANSFER) Write an introduction (hook + thesis + return) on “pressure”. — 140–180 words.
B4-17 (TRANSFER) Write an introduction on “honesty”. — Same structure. — 140–180 words.
B4-18 (TRANSFER) Write an introduction on “success”. — Same structure. — 140–180 words.
B4-19 (TRANSFER) Write an introduction on “failure”. — Same structure. — 140–180 words.
B4-20 (TRANSFER) Write an introduction on “friendship”. — Same structure. — 140–180 words.
B4-21 (TRANSFER) Counterargument paragraph: present opposing view fairly, then return to your stance. — 120–160 words.
B4-22 (TRANSFER) Rebuttal paragraph: dismantle one weak assumption using specificity + return. — 120–160 words.
B4-23 (TRANSFER) Narrative argument hybrid: 1 short anecdote → thesis → return. — 160–220 words.
B4-24 (TRANSFER) Turning point narrative paragraph with ladder embedded. — 140–200 words.
B4-25 (TRANSFER) Conclusion: 1 metaphor max + moral return (explicit). — 120–160 words.
B4-26 (REPAIR) Reduce ambiguity: rewrite 8 “clever” lines into clear lines with anchors. — Keep intent. — 8 before/after pairs.
B4-27 (REPAIR) Reduce overload: remove one device from each of 6 lines (keep only one). — Maintain landing. — 6 before/after pairs.
B4-28 (REPAIR) Increase energy safely: add one corridor line + return into a dull paragraph. — Keep clarity. — Before/after.
B4-29 (REPAIR) Persona fit: rewrite 6 lines to match a “serious reflective” narrator. — No sarcasm. — 6 rewritten lines.
B4-30 (REPAIR) Persona fit: rewrite same 6 lines for “dry humour” narrator with fenced irony. — Anchors required. — 6 rewritten lines.
B4-31 (RHETORIC) Write 5 “definition locks”: define a term (e.g., courage) in one sentence + return meaning. — 10 lines.
B4-32 (RHETORIC) Write 5 “mechanism locks”: describe cause→effect in one crisp chain + return. — 10 lines.
B4-33 (ARCHITECT) Create 10 “image → meaning” pairs (image line + return truth). — Concrete images only. — 20 lines.
B4-34 (ARCHITECT) Create 8 “controlled exaggeration” pairs for social conflict + return. — Believable. — 16 lines.
B4-35 (ORACLE) Landing audit: mark ANCHOR/RETURN/PAYOFF in 2 paragraphs; fix missing parts. — Explicit tags. — Annotated + rewritten.
B4-36 (TRANSFER) Full essay plan: thesis + 3 arguments + 1 counterargument + conclusion return. — Outline only. — 12–18 bullets.
B4-37 (TRANSFER) Write Body Para 1 from your plan: include 1 corridor line + return. — 160–220 words.
B4-38 (TRANSFER) Write Body Para 2: include contrast + specificity + return. — 160–220 words.
B4-39 (TRANSFER) Write Body Para 3: include 1 metaphor max + return. — 160–220 words.
B4-40 (TRANSFER) Write Counterargument + rebuttal: both must end with return truths. — 220–300 words.
B4-41 (TRANSFER) Full narrative (4 paragraphs): “A choice with consequences.” — 2 corridor lines total; stitched. — 320–450 words.
B4-42 (TRANSFER) Full narrative: “A moment of courage.” — Avoid melodrama; explicit anchors. — 320–450 words.
B4-43 (TRANSFER) Full narrative: “A betrayal and repair.” — Must land moral return. — 320–450 words.
B4-44 (TRANSFER) Full argumentative essay: “Is pressure good?” — Ladder structure; clarity first. — 450–650 words.
B4-45 (TRANSFER) Full argumentative essay: “What is success?” — Include definition lock + mechanism lock. — 450–650 words.
B4-46 (REPAIR) Rewrite an essay to reduce OverloadFlag to 0 while keeping 3 best corridor lines. — Before/after.
B4-47 (REPAIR) Rewrite an essay to increase Quoteability (Q) by +1 point without lowering Clarity (C). — Before/after.
B4-48 (REPAIR) Convert 10 abstract lines into concrete anchored lines (no metaphors). — 10 lines.
B4-49 (REPAIR) Convert 10 concrete lines into “one device only” corridor lines + returns. — 20 lines.
B4-50 (TRANSFER) Capstone: full essay + self-audit tags (ANCHOR/RETURN/PAYOFF) and mark-sheet self-score. — Include both outputs.

3) Cohort Dashboard Spec — `ACTP_DASHBOARD_SPEC_01`

Goal

Monitor class stability + growth over time using LACE sensors + marksheet outcomes, then route one-leak repairs per student.

3.1 Data Model

Entities

			
COHORT:
  CohortID
  Band
  TeacherID
  StartDate
  StudentIDs[]
STUDENT:
  StudentID
  Band
  BaselineScores (MARKSHEET_ACTP_01)
  TargetProfile (ρ_target, C_min, R_min)
  Notes (optional)
SUBMISSION:
  SubmissionID
  StudentID
  DateTime
  PromptID
  TaskType
  Text
  AudienceState {stress, trust} optional
  AutoScore (MARKSHEET_ACTP_01)
  Sensors (LACE_SENSORS_01)
  PrimaryLeak
  Prescription
  TeacherOverride optional

		

3.2 KPI Metrics

Per submission KPIs

C_Clarity, R_Landing, S_Safety, Q_Quoteability
ρ, OverloadFlag, BoredomFlag
ConfusionSignal, CringeRisk

Per student rolling KPIs (window = last 10 submissions)

OverloadRate_10
BoredomRate_10
MeanC_10, MeanR_10, MeanQ_10, MeanSafety_10
RecoveryTimeMean (avg turns/submissions to return to green after overload)
TrendC (slope), TrendR, TrendQ

Cohort KPIs (weekly)

%GreenSafety (students with Safety≥3 and OverloadRate_10 < 0.05)
CohortMeanC, CohortMeanR, CohortMeanQ
LeakDistribution (Clarity vs Landing vs Overload vs Boredom vs Persona vs Quoteability)
Top3LeakDrivers (most frequent leaks)

3.3 Thresholds & Flags (FenceOS at cohort level)

			
COHORT_FLAGS:
  Red:
    - Cohort OverloadRate > 0.10 OR MeanC < Band.C_min - 0.10
  Amber:
    - OverloadRate 0.05–0.10 OR MeanC close to min
  Green:
    - OverloadRate < 0.05 AND MeanC, MeanR above mins

		

Actions

If Red: force “Operator + Oracle week” (no Architect spikes)
If Amber: allow Architect only with mandatory Return
If Green: promote allowable ρ upper bound by +0.05 (band cap)

3.4 Dashboard Views

View A — Cohort Overview

Tiles:
CohortMeanC, CohortMeanR, CohortMeanQ, CohortOverloadRate
Green/Amber/Red status
Charts (conceptual):
Weekly trend lines: C/R/Q/Safety
Leak distribution bar chart

View B — Student List (sortable)

Columns:

StudentID
MeanC_10
MeanR_10
OverloadRate_10
BoredomRate_10
PrimaryLeak (most frequent)
Current Prescription
TrendC / TrendR arrows

View C — Student Detail

Timeline of last 20 submissions:
prompt → scores → leak → prescription → outcome
“One Rule” reminder (band constraints)
Promotion eligibility:
if OverloadFlag=0 last 20 AND C/R above mins → “Promote ρ cap +0.05”

3.5 Auto-Repair Assignment Policy (EducationOS closed loop)

			
AUTO_ASSIGN:
  For each student weekly:
    Identify PrimaryLeak mode over last 10 submissions.
    Assign 1 drill set ONLY (7 days).
    Re-test on day 7 with matched prompt type.
    If improved and safe -> promote.
    Else keep same leak and change only drill subtype (not multiple leaks).

		

3.6 Export / Reporting Spec

Weekly cohort report:
cohort status (Green/Amber/Red)
leak distribution
top 5 students needing safety repair
top 5 students ready for promotion
Parent summary (per student):
1 strength, 1 leak, 1 drill, 1 rule

ACTP_05 — PSLE Composition Integration Pack

5-Box Story Plan × LACE × EducationOS Closed-Loop (Almost-Code) — v0.1

0) Exam-Safe Operating Envelope (PSLE Defaults)

			
PSLE_ENVELOPE:
  ρ_target: [0.40, 0.65]
  C_min (Clarity): 0.82
  R_min (Landing): 0.78
  MaxMetaphorsPerParagraph: 1
  CorridorLinesPerParagraph:
    P1 Intro: 1
    P2 Build: 1
    P3 Turning: 1 (max 2 only if stitched immediately)
    P4 Resolve: 1
    P5 Reflection: 1 (optional; can be pure return)
  Mandatory: Every corridor line must include RETURN within ≤ 1 sentence

		

Definition: Corridor line = a safe ArchitectMove + anchor + landing (Return/Payoff).

1) PSLE 5-Box Story Plan (with LACE constraints)

5 Boxes

B1 Setup (who/where/when + normal)
B2 Problem (trigger + stakes)
B3 Escalation (worse + choice pressure)
B4 Turning Point (decision/action)
B5 Outcome + Lesson (resolution + moral return)

Mapping to paragraphs (recommended)

P1 = B1
P2 = B2
P3 = B3
P4 = B4
P5 = B5

2) Paragraph Blueprints (Copy-Paste Templates)

P1 Intro (Hook Pair + Scene Lock)

			
P1_TEMPLATE:
  Line1: HOOK (ArchitectMove allowed)
  Line2: RETURN (plain truth)
  Line3-6: Scene anchors (who/where/when)
  LastLine: Calm “normal day” statement (OperatorLock)
Constraints:
  1 corridor line max
  C high; no metaphor chains

		

P2 Problem (Trigger + Stakes)

			
P2_TEMPLATE:
  1 corridor line (specificity or contrast)
  2–4 lines: what happened (clear)
  1 line: feelings shown via body detail
  LastLine: problem stated plainly (RETURN truth)

		

P3 Escalation (Pressure + Choice)

			
P3_TEMPLATE:
  1 corridor line (contrast flip OR bounded hyperbole)
  2–4 lines: complications
  1 line: choice pressure (A/B options)
  LastLine: “I had to decide” (plain)
Constraint:
  If 2 corridor lines used:
    corridor #2 must be immediately stitched (RETURN right away)

		

P4 Turning Point (Action + Consequence)

			
P4_TEMPLATE:
  1 corridor line (action emphasis)
  2–4 lines: what I did (step-by-step)
  1 line: immediate consequence
  LastLine: simple payoff (RETURN truth)

		

P5 Resolution + Lesson (Moral Return)

			
P5_TEMPLATE:
  Option A (safe): 0 corridor lines, pure clarity
  Option B: 1 corridor line + moral return
  2–4 lines: repair / apology / outcome
  LastLine: lesson stated plainly (RETURN)
Constraint:
  Avoid preachy clichés; keep moral specific to story

		

3) Hook Pair Library (Theme-Based, Exam-Safe)

Format

HOOK (Architect) → RETURN (plain truth)

Theme: Honesty

“The truth didn’t shout; it waited.” → “I had been hiding what I did.”
“My mouth stayed quiet, but my conscience was loud.” → “I knew I had to admit it.”

Theme: Responsibility

“The problem had my name on it.” → “It was my mistake to fix.”
“No one pointed at me—yet I felt accused.” → “I was responsible.”

Theme: Friendship

“A friend can feel like a shield—until it cracks.” → “We were about to quarrel.”
“I laughed, but the laughter was thin.” → “Something between us was wrong.”

Theme: Courage

“Fear sat beside me like an unwanted classmate.” → “I was scared to act.”
“My hands shook, but my feet moved.” → “I decided to do the right thing.”

Theme: Kindness

“A small act can be heavier than it looks.” → “I chose to help.”
“The kindest thing wasn’t a gift—it was time.” → “Someone needed me.”

Theme: Perseverance

“Failure kept visiting, but I stopped opening the door.” → “I tried again.”
“I was tired, not defeated.” → “I refused to give up.”

Theme: Temptation / Wrong Choice

“The shortcut smiled at me.” → “I almost did something wrong.”
“It looked harmless—until it wasn’t.” → “I made a poor decision.”

Theme: Misunderstanding

“One sentence did the damage.” → “We misunderstood each other.”
“I heard the words, but I missed the meaning.” → “I jumped to conclusions.”

Theme: Trust

“Trust breaks quietly.” → “I disappointed someone.”
“I wanted to be believed, but I wasn’t.” → “I had to prove myself.”

(Use these as patterns; students generate their own variant.)

4) “One Corridor Line” Device Menu (PSLE Safe Set)

			
PSLE_SAFE_ARCHITECT_MOVES:
  AM2 UnexpectedSpecificity (best)
  AM3 ContrastFlip (safe)
  AM4 BoundedHyperbole + RETURN (safe if stitched)
  AM7 MildPersonification (use sparingly)
Forbidden/High Risk:
  sarcasm, multi-metaphor chains, abstract philosophical hooks

		

5) PSLE Marking Overlay (LACE × 5-Box)

Quick scoring per paragraph (0–2 each)

			
PARA_SCORE:
  Clarity (C): 0..2
  Landing (R): 0..2
  OneSparkOnly: 0..2
  StoryRoleFit (BoxFit): 0..2

		

Common failure modes → fix

BoxFit low: paragraph doesn’t match its 5-Box role → rewrite with the correct function (setup/problem/escalation/turning/lesson).
Landing low: corridor line has no RETURN → add one plain sentence.
Clarity low: too many devices/long sentences → OperatorLock rewrite.
OneSparkOnly low: too many “clever lines” → delete all but best one.

6) The “Rewrite Weakest Paragraph” Repair Loop (Canonical)

Rule

Fix ONE paragraph only per cycle. Re-test. Then move on.

			
REWRITE_LOOP_PSLE_01:
  Step1: Score each paragraph with PARA_SCORE + MARKSHEET_ACTP_01
  Step2: Select WeakestParagraph = argmin( C+R+BoxFit+OneSparkOnly )
  Step3: Identify PrimaryLeak (choose one):
        {ClarityLeak|LandingLeak|BoxFitLeak|OverloadLeak|BoredomLeak}
  Step4: Apply ONE repair recipe (below)
  Step5: Rewrite that paragraph only
  Step6: Re-score; if green -> stop; else repeat once

		

Repair recipes

			
REPAIR_RECIPES_PSLE:
  ClarityLeak:
    - cut long sentences into 2
    - remove 1 device
    - add anchor nouns
  LandingLeak:
    - enforce HOOK→RETURN
    - add payoff line at end
  BoxFitLeak:
    - rewrite paragraph to match box role:
      Setup: scene + normal
      Problem: trigger + stakes
      Escalation: worse + choice pressure
      Turning: action + consequence
      Lesson: outcome + moral return
  OverloadLeak:
    - delete all corridor lines except best 1
    - RETURN immediately after it
  BoredomLeak:
    - add AM2 specificity punch (one line) + RETURN

		

7) 12-Week PSLE Integration (Matches Your 4-Phase Protocol)

Phase 1 — Depth Building (Weeks 1–3)

Daily: 10 mins “specificity punch” (AM2) + return
Build banks:
anchor nouns (school/canteen/bus stop/home)
emotion body details (hands, stomach, throat, face heat)

Phase 2 — Structure & Planning (Weeks 4–6)

5-Box planning drills:
1 plan/day
2 Hook Pair options per plan
Goal: box-role correctness > 90%

Phase 3 — Load Training (Weeks 7–9)

Timed writing (35–45 mins)
Checklist enforcement (below)
Repair loop: rewrite weakest paragraph every time

Phase 4 — Transfer & Exam Application (Weeks 10–12)

Weekly full Paper 1 simulation
Alternate prompts; same envelope constraints
Target: OverloadFlag = 0 in finals

8) PSLE Checklist (Student-Facing, 30 seconds)

			
PSLE_CHECKLIST_LACE_01:
  1) Hook Pair in P1? (Yes/No)
  2) One corridor line per paragraph max? (Yes/No)
  3) After corridor line, do I RETURN plainly? (Yes/No)
  4) Does each paragraph match its box role? (Yes/No)
  5) End with a clear lesson (not cliché)? (Yes/No)

		

9) LLM-Runnable Helpers (Copy-Paste Prompts)

A) Generate 2 Hook Pairs for a theme

			
PROMPT_PSLE_HOOKPAIR:
Theme = {honesty/responsibility/...}
Generate 2 Hook Pairs:
- Line1 HOOK (ArchitectMove, anchored)
- Line2 RETURN (plain truth)
Rules: clear, exam-safe, no ambiguity, no metaphor chains.

		

B) Auto-score paragraph roles + select weakest paragraph

			
PROMPT_PSLE_WEAKPARA:
Input: 5 paragraphs P1..P5
Output:
- ParaScore table (C,R,OneSparkOnly,BoxFit)
- WeakestParagraph ID
- PrimaryLeak (one)
- One repair recipe from REPAIR_RECIPES_PSLE

		

C) Rewrite only the weakest paragraph (no full essay rewrite)

			
PROMPT_PSLE_REWRITE_ONE:
Given WeakestParagraph and PrimaryLeak,
Rewrite ONLY that paragraph using the chosen repair recipe.
Keep story facts unchanged.

ACTP_06 — PSLE Mega Worksheet Pack (Printable) + Teacher Keys

20 Theme Pages × 5-Box × LACE Envelope × “Rewrite Weakest Paragraph” Loop (Almost-Code) — v0.1

A) Quick Print Instructions (Teacher)

Per lesson (60–75 min):

Pick 1 theme page
Students fill 5-Box plan (10 min)
Write P1–P5 using paragraph blueprint (30–40 min)
Run PARA_SCORE + select Weakest Paragraph (5 min)
Rewrite weakest paragraph only (10–15 min)
Re-score (2 min)

B) Universal Student Worksheet Template (used in all 20 pages)

			
STUDENT WORKSHEET — THEME: ____________   Date: ______   Name: __________
PSLE ENVELOPE (tick):
[ ] 1 corridor line per paragraph max
[ ] RETURN sentence after corridor line
[ ] Each paragraph matches its 5-Box role
[ ] Ending has lesson (specific, not cliché)
(1) PICK A PICTURE SET (PSLE style)
Picture A: ______________________
Picture B: ______________________
Picture C: ______________________
Chosen: [A] [B] [C]
(2) HOOK PAIR (P1)
HOOK (1 line, interesting but clear):
_____________________________________________________
RETURN (1 line, plain truth):
_____________________________________________________
(3) 5-BOX STORY PLAN (bullets)
B1 Setup (who/where/when/normal): ____________________
B2 Problem (trigger + stakes): _______________________
B3 Escalation (worse + pressure): ____________________
B4 Turning Point (decision + action): ________________
B5 Outcome + Lesson (result + moral): ________________
(4) PARAGRAPH BLUEPRINT CHECK
P1 Setup + Hook Pair + normal day
P2 Trigger + stakes (problem stated plainly)
P3 Escalation + choice pressure (“I had to decide…”)
P4 Action + consequence (step-by-step)
P5 Outcome + lesson (plain moral return)
(5) CORRIDOR LINE LIMITER (write + return)
P1 Corridor line: ____________________  RETURN: ____________________
P2 Corridor line: ____________________  RETURN: ____________________
P3 Corridor line: ____________________  RETURN: ____________________
P4 Corridor line: ____________________  RETURN: ____________________
P5 Corridor line: ____________________  RETURN: ____________________
(6) AFTER WRITING — PARA SCORE (0–2 each)
P1 C__ R__ BoxFit__ OneSpark__
P2 C__ R__ BoxFit__ OneSpark__
P3 C__ R__ BoxFit__ OneSpark__
P4 C__ R__ BoxFit__ OneSpark__
P5 C__ R__ BoxFit__ OneSpark__
Weakest Paragraph: [P1/P2/P3/P4/P5]
Primary Leak (choose ONE): [Clarity / Landing / BoxFit / Overload / Boredom]
(7) REWRITE ONLY THAT PARAGRAPH
Old paragraph copied (short): _______________________________________
Rewrite (fixed): ____________________________________________________
Reason (1 line): _________________________________________________

		

C) 20 Student Theme Pages (each page uses the template + theme extras)

Each page below adds:

Theme-specific picture prompts
Anchor noun bank
Safe corridor device suggestions
Lesson sentence starters

PAGE 01 — HONESTY

Picture prompts: wallet found / broken item / friend asks question
Anchor nouns: wallet, phone, teacher, friend, corridor, apology
Safe corridor moves: AM2 specificity, AM3 contrast flip
Lesson starters: “I learnt that honesty… / The truth… / I realised…”

PAGE 02 — RESPONSIBILITY

Picture prompts: spilled drink / lost book / group project blame
Anchor nouns: homework, duty, mistake, teacher, teammate
Safe corridor moves: AM2 specificity, bounded hyperbole + return
Lesson starters: “Responsibility means… / I should have…”

PAGE 03 — FRIENDSHIP

Picture prompts: argument / sharing / helping after fall
Anchor nouns: trust, promise, message, canteen, seat, apology
Safe corridor moves: contrast flip (“It wasn’t… it was…”)
Lesson starters: “A friend is… / Friendship needs…”

PAGE 04 — COURAGE

Picture prompts: standing up to bully / speaking up / trying again
Anchor nouns: voice, crowd, fear, decision, moment
Safe corridor moves: body detail + return; one vivid specificity line
Lesson starters: “Courage is… / I learnt to…”

PAGE 05 — KINDNESS

Picture prompts: helping elderly / sharing umbrella / tutoring classmate
Anchor nouns: hand, umbrella, bus, smile, thanks
Safe corridor moves: mild personification (1) + return
Lesson starters: “Kindness can… / I realised small acts…”

PAGE 06 — PERSEVERANCE

Picture prompts: failed test / training / practice instrument
Anchor nouns: effort, practice, time, improvement, coach
Safe corridor moves: contrast flip + return (“tired, not defeated”)
Lesson starters: “I learnt that perseverance…”

PAGE 07 — TEMPTATION (WRONG CHOICE)

Picture prompts: cheating / shortcut / taking something not yours
Anchor nouns: rule, choice, consequence, guilt, decision
Safe corridor moves: bounded hyperbole + return (careful)
Lesson starters: “I learnt that shortcuts…”

PAGE 08 — MISUNDERSTANDING

Picture prompts: overheard conversation / wrong assumption / mix-up
Anchor nouns: words, tone, message, silence, explain
Safe corridor moves: “I heard words, missed meaning” style + return
Lesson starters: “I learnt to clarify…”

PAGE 09 — TRUST

Picture prompts: secret shared / broken promise / proving innocence
Anchor nouns: promise, secret, evidence, belief, repair
Safe corridor moves: one metaphor max + return
Lesson starters: “Trust is… / I realised trust…”

PAGE 10 — GRATITUDE

Picture prompts: gift / help after mistake / teacher encouragement
Anchor nouns: thanks, note, effort, kindness, memory
Safe corridor moves: specificity punch; short-long-short rhythm (anchored)
Lesson starters: “I learnt to appreciate…”

PAGE 11 — SELF-CONTROL (ANGER)

Picture prompts: quarrel / rude comment / teasing
Anchor nouns: temper, words, regret, pause, breath
Safe corridor moves: body detail + return; contrast flip
Lesson starters: “I learnt to control…”

PAGE 12 — EMPATHY

Picture prompts: lonely classmate / new student / someone embarrassed
Anchor nouns: feelings, eyes, silence, invitation, seat
Safe corridor moves: specificity punch; mild personification
Lesson starters: “I realised others…”

PAGE 13 — FAIRNESS

Picture prompts: unfair blame / queue cutting / team credit
Anchor nouns: rule, turn, justice, explain, evidence
Safe corridor moves: contrast flip + return
Lesson starters: “Fairness means…”

PAGE 14 — TEAMWORK

Picture prompts: sports / group project / cleaning task
Anchor nouns: team, role, plan, effort, success
Safe corridor moves: one quoteable line + return
Lesson starters: “I learnt teamwork…”

PAGE 15 — RESPECT

Picture prompts: talking back / ignoring instructions / rude behaviour
Anchor nouns: tone, manners, apology, teacher, parent
Safe corridor moves: specificity line + return (no sarcasm)
Lesson starters: “Respect shows in…”

PAGE 16 — CONFIDENCE (TRYING)

Picture prompts: presentation / audition / answering in class
Anchor nouns: stage, voice, hands, breath, practice
Safe corridor moves: body detail + return
Lesson starters: “I learnt confidence…”

PAGE 17 — HUMILITY

Picture prompts: winning / bragging / learning from mistake
Anchor nouns: pride, lesson, feedback, improvement
Safe corridor moves: contrast flip (“proud, not arrogant”) + return
Lesson starters: “I learnt to stay humble…”

PAGE 18 — FORGIVENESS

Picture prompts: apology accepted / repairing friendship / mistake
Anchor nouns: apology, repair, trust, second chance
Safe corridor moves: one metaphor max + return (gentle)
Lesson starters: “Forgiveness is…”

PAGE 19 — SAFETY / CAREFULNESS

Picture prompts: near accident / fire drill / careless running
Anchor nouns: warning, rule, consequence, caution, sign
Safe corridor moves: specificity punch; contrast flip
Lesson starters: “I learnt to be careful…”

PAGE 20 — LEADERSHIP

Picture prompts: class monitor / guiding group / solving conflict
Anchor nouns: responsibility, decision, calm, guide, plan
Safe corridor moves: one corridor line + return; payoff ending
Lesson starters: “A leader…”

D) Teacher Keys (Exemplars + Scoring + Common Repairs)

D1) Universal Teacher Scoring Key (fast)

Use PARA_SCORE (0–2 each):

C (Clarity): 2 = easy to understand; 1 = some messy; 0 = confusing
R (Landing): 2 = corridor line has RETURN; 1 = weak return; 0 = no landing
BoxFit: 2 = paragraph does its job; 1 = mixed; 0 = wrong role
OneSparkOnly: 2 = ≤1 corridor line; 1 = 2 lines; 0 = many “clever lines”

Weakest paragraph = lowest total.

D2) Repair Selector (choose ONE leak only)

Clarity leak → cut sentence length; remove device; add anchors
Landing leak → enforce HOOK→RETURN; add payoff line
BoxFit leak → rewrite paragraph to match its 5-Box role
Overload leak → delete all corridor lines except best one; RETURN immediately
Boredom leak → add one AM2 specificity line + RETURN

D3) Teacher Exemplars (per theme: 2 Hook Pairs + 5-Box mini-plan + corridor line suggestions)

Below are compact keys you can read aloud or use as reference. Students should still create their own.

01 Honesty

Hook pairs:
“The truth didn’t shout; it waited.” → “I was hiding what I did.”
“My stomach sank before my words did.” → “I knew I had to admit it.”
5-Box plan: Setup normal day → find wallet / break item → temptation to hide → choose to confess → trust repaired + lesson
Corridor line ideas (with returns):
P2: “The wallet felt heavier than it looked.” → “I knew it mattered.”
P3: “It wasn’t greed; it was fear of getting scolded.” → “I panicked.”

02 Responsibility

Hook pairs:
“The mess had my fingerprints.” → “It was my mistake.”
“No one blamed me—yet I felt accused.” → “I was responsible.”
Plan: normal task → error occurs → blame pressure → take ownership → repair + lesson
Corridor ideas:
“The spilled drink spread like a map of my mistake.” → “I had caused it.”

03 Friendship

Hook pairs:
“Our laughter sounded normal, but it wasn’t.” → “Something was wrong.”
“A friend can feel like a shield—until it cracks.” → “We were quarrelling.”
Plan: good friendship → argument trigger → worse misunderstanding → apology/act → bond stronger
Corridor ideas:
“It wasn’t the words; it was the silence after.” → “We stopped talking.”

04 Courage

Hook pairs:
“Fear sat beside me like an unwanted classmate.” → “I was scared to speak up.”
“My hands shook, but my feet moved.” → “I chose to act.”
Plan: see unfairness → fear rises → pressure grows → speak/do right thing → outcome + lesson
Corridor ideas:
“My throat tightened.” → “But I still raised my hand.”

05 Kindness

Hook pairs:
“Kindness doesn’t always look grand.” → “I chose to help.”
“A small act can be heavier than it looks.” → “Someone needed me.”
Plan: notice need → decide help → obstacles/time cost → help done → gratitude + lesson
Corridor ideas:
“The umbrella didn’t just block rain; it shared space.” → “I stood closer.”

06 Perseverance

Hook pairs:
“Failure kept visiting, but I stopped opening the door.” → “I tried again.”
“I was tired, not defeated.” → “I kept practising.”
Plan: fail once → discouraged → practice plan → improvement moment → lesson
Corridor ideas:
“The page stared back.” → “So I revised step by step.”

07 Temptation

Hook pairs:
“The shortcut smiled at me.” → “I almost did something wrong.”
“It looked harmless—until it wasn’t.” → “My choice had consequences.”
Plan: see opportunity → tempted → pressure spikes → choose right/wrong → consequence + lesson
Corridor ideas:
“My conscience became noisy.” → “I couldn’t ignore it.”

08 Misunderstanding

Hook pairs:
“I heard the words, but missed the meaning.” → “I jumped to conclusions.”
“One sentence did the damage.” → “We misunderstood each other.”
Plan: normal → misheard/assumed → argument → clarify truth → repair + lesson
Corridor ideas:
“It wasn’t anger; it was confusion.” → “I assumed wrongly.”

09 Trust

Hook pairs:
“Trust breaks quietly.” → “I disappointed someone.”
“I wanted to be believed, but I wasn’t.” → “I had to prove the truth.”
Plan: trust exists → promise/secret issue → distrust grows → proof/apology → trust rebuilt
Corridor ideas:
“The promise sat between us.” → “I had to fix it.”

10 Gratitude

Hook pairs:
“I noticed the help only after it was gone.” → “Someone supported me.”
“A simple ‘thank you’ suddenly felt important.” → “I meant it.”
Plan: receive help → take for granted → realise value → express thanks → lesson
Corridor ideas:
“The note was short, but it stayed.” → “I remembered it.”

11 Self-control (Anger)

Hook pairs:
“My temper ran faster than my thinking.” → “I spoke harshly.”
“I won the argument and lost something else.” → “I hurt someone.”
Plan: trigger → anger rises → say/do wrong → regret → apologise + lesson
Corridor ideas:
“My face burned.” → “I needed to pause.”

12 Empathy

Hook pairs:
“The quietest person often carries the loudest feelings.” → “Someone felt lonely.”
“I saw the smile, but I noticed the eyes.” → “They were hurting.”
Plan: notice classmate → small kindness → barrier → include/support → lesson
Corridor ideas:
“The empty seat looked like an invitation.” → “I went over.”

13 Fairness

Hook pairs:
“Being blamed feels heavier than being wrong.” → “It wasn’t my fault.”
“Rules matter most when they are tested.” → “Something unfair happened.”
Plan: unfair event → reaction → evidence/clarify → correction → lesson
Corridor ideas:
“It wasn’t justice; it was convenience.” → “They blamed the nearest person.”

14 Teamwork

Hook pairs:
“Alone, I could move fast. Together, we could finish.” → “We needed teamwork.”
“A team is a plan with many hands.” → “We had to cooperate.”
Plan: group task → conflict → organise roles → succeed → lesson
Corridor ideas:
“The plan finally had a shape.” → “Everyone knew their role.”

15 Respect

Hook pairs:
“My tone did the damage before my words did.” → “I was rude.”
“Respect is heard in how you speak.” → “I needed to change.”
Plan: disrespect moment → consequence → reflection → apology → lesson
Corridor ideas:
“The room went still.” → “I realised I crossed a line.”

16 Confidence

Hook pairs:
“My voice sounded small in my head.” → “I was nervous.”
“Confidence isn’t loud; it’s steady.” → “I tried anyway.”
Plan: fear of stage → practice → moment of speaking → outcome → lesson
Corridor ideas:
“My hands shook.” → “But I finished my lines.”

17 Humility

Hook pairs:
“Winning felt sweet—until I spoke.” → “I bragged.”
“Pride is useful; arrogance is expensive.” → “I needed humility.”
Plan: success → brag → hurt others → realise → apologise/learn
Corridor ideas:
“It wasn’t confidence; it was showing off.” → “I went too far.”

18 Forgiveness

Hook pairs:
“An apology is a door, not the whole journey.” → “I asked for forgiveness.”
“Forgiveness doesn’t erase; it repairs.” → “We tried again.”
Plan: wrong action → apology → doubt → second chance → lesson
Corridor ideas:
“The silence softened.” → “They listened.”

19 Safety / Carefulness

Hook pairs:
“The warning sign wasn’t decoration.” → “I should have been careful.”
“One careless step nearly became a disaster.” → “I learnt safety matters.”
Plan: risky behaviour → near miss → consequence/fear → correct behaviour → lesson
Corridor ideas:
“My heart jumped.” → “I realised the danger.”

20 Leadership

Hook pairs:
“A leader borrows calm when others lose it.” → “I had to guide the group.”
“Everyone looked around. Then they looked at me.” → “I had responsibility.”
Plan: group chaos → need direction → plan roles → action works → lesson
Corridor ideas:
“It wasn’t about being bossy; it was about being clear.” → “I gave simple instructions.”

E) Ready-to-Use Teacher Mini-Script (30 seconds)

“One spark per paragraph. After your spark, write a plain RETURN sentence. If your paragraph doesn’t match its box role, rewrite it. After you finish, we fix only the weakest paragraph.”

ACTP_07 — PSLE Corridor Line Generator Pack

Exam-Safe “One Spark + Return” Template Library (Almost-Code) — v0.1

0) Corridor Line Contract (PSLE)

Definition

A Corridor Line = SPARK + RETURN

SPARK = one safe Architect move (novel but anchored)
RETURN = one plain sentence stating the truth clearly

Hard Rules

			
RULES_PSLE_CORRIDOR:
1) Use an anchor noun (wallet, corridor, bell, teacher, friend, bus, rain).
2) No metaphor chains (max 1 metaphor total per paragraph).
3) No sarcasm or ambiguous irony.
4) After SPARK, write RETURN immediately.
5) Keep SPARK ≤ 16 words (recommended).

		

1) Generator Control: FenceOS Filters (Student-Simple)

PASS / FAIL checklist (5 seconds)

			
PASS_IF:
- Anchor noun present? (Yes)
- Meaning clear in 2 seconds? (Yes)
- RETURN sentence exists right after? (Yes)
- Only one “clever device”? (Yes)
- No confusing abstract words? (Yes)
FAIL_IF (FenceTrip):
- Too many adjectives / too long
- Abstract nouns (fate, destiny, existence) without concrete anchor
- Pronouns without nouns (“it”, “they”, “that”)
- Mixed metaphors (2+ images colliding)

		

FenceTrip repair (what to do)

			
FENCE_REPAIR:
- Cut SPARK into shorter sentence
- Replace abstract with concrete noun
- Add RETURN truth line
- Delete extra device (keep only one)

		

2) The PSLE Safe Generator Set (Template Library)

Each generator has:

Template
How to fill
Example
Mandatory RETURN

G1 — Unexpected Specificity Punch (AM2) ✅ Best for PSLE

Use when: paragraph feels bland.

Template

			
SPARK: The <NOUN> was not just <GENERIC>; it had <SPECIFIC DETAIL>.
RETURN: I could tell <PLAIN TRUTH>.

How to fill

NOUN = place/object (corridor, canteen, classroom, wallet, bus stop)
SPECIFIC DETAIL = something you can see/hear/smell (sweaty uniforms, sticky floor, squeaky fan)

Example

SPARK: “The corridor was not just quiet; even the fan sounded nervous.”
RETURN: “I knew something was wrong.”

G2 — Contrast Flip (AM3) ✅ Very safe

Use when: you want a strong turning point.

Template

			
SPARK: It wasn’t <X>; it was <Y>.
RETURN: The real problem was <PLAIN TRUTH>.

How to fill

X = wrong guess (anger, laziness, greed)
Y = real cause (fear, confusion, pressure)

Example

SPARK: “It wasn’t anger; it was fear of getting scolded.”
RETURN: “That’s why I tried to hide the truth.”

G3 — Bounded Hyperbole + Truth (AM4) ✅ Safe if stitched

Use when: showing strong emotion (fear/embarrassment).

Template

			
SPARK: My <BODY PART> felt like <EXAGGERATION>.
RETURN: I was <SIMPLE EMOTION>.

How to fill

BODY PART = stomach/throat/face/hands
EXAGGERATION = “a drum”, “a knot”, “on fire” (keep simple)
SIMPLE EMOTION = nervous/terrified/embarrassed/excited

Example

SPARK: “My face felt like it was on fire.”
RETURN: “I was embarrassed.”

G4 — Body-Detail Emotion Line (No metaphor required) ✅ Ultra safe

Use when: your emotions are “telling, not showing”.

Template

			
SPARK: My <BODY PART> <ACTION>.
RETURN: I felt <EMOTION>.

Example

SPARK: “My hands trembled as I held the wallet.”
RETURN: “I felt nervous.”

G5 — Mild Personification (AM7) ✅ Use sparingly

Use when: adding voice to a scene (P1/P2 best).

Template

			
SPARK: The <OBJECT> seemed to <HUMAN ACTION>.
RETURN: I noticed <PLAIN TRUTH>.

Allowed objects

clock, bell, fan, noticeboard, queue, rain

Example

SPARK: “The clock seemed to stare at me.”
RETURN: “I was running late.”

G6 — “Short–Long–Short” Rhythm Triplet ✅ Quoteability without confusion

Use when: ending a paragraph.

Template

			
SPARK: <SHORT>. <LONG (anchored)>. <SHORT>.
RETURN: <PLAIN TRUTH>.

Example

SPARK: “I froze. The teacher’s eyes followed my shaking hands. I swallowed.”
RETURN: “I knew I had to explain.”

3) Hook Pair Generator (P1 only) — Exam Safe

H1 — Quiet Threat Hook

			
HOOK: The <ABSTRACT NOUN> didn’t <LOUD VERB>; it <QUIET VERB>.
RETURN: I was about to <PLAIN EVENT>.

Example

HOOK: “The truth didn’t shout; it waited.”
RETURN: “I was about to admit what I did.”

H2 — Conscience Hook

			
HOOK: My <BODY> was calm, but my <MIND/CONSCIENCE> was noisy.
RETURN: I knew <PLAIN TRUTH>.

Example

HOOK: “My face stayed calm, but my conscience was noisy.”
RETURN: “I knew I had made a mistake.”

4) Paragraph Placement Map (When to use which generator)

			
PLACEMENT_MAP_PSLE:
P1 Setup: H1/H2 + (optional G1) but keep it light
P2 Problem: G1 or G2
P3 Escalation: G2 or G3 (must RETURN immediately)
P4 Turning Point: G6 (action tension) or G1 (detail)
P5 Lesson: Prefer plain clarity; optional G2 then moral RETURN

		

5) Student “Fill-Blank” Corridor Sheet (Printable)

			
CORRIDOR_SHEET_PSLE (fill 1 per paragraph)
P1 SPARK: ________________________________________
P1 RETURN: ________________________________________
P2 SPARK: ________________________________________
P2 RETURN: ________________________________________
P3 SPARK: ________________________________________
P3 RETURN: ________________________________________
P4 SPARK: ________________________________________
P4 RETURN: ________________________________________
P5 SPARK (optional): ______________________________
P5 RETURN (moral): ________________________________

		

6) Teacher Filter Rules (Fast Marking)

Mark SPARK as FAIL if any:

No anchor noun
> 16 words and unclear
Abstract + vague (“destiny”, “life”, “society”) without concrete scene
2+ devices stacked (metaphor + personification + hyperbole)

Quick fixes you can write in margin:

“ADD NOUN”
“ADD RETURN”
“CUT 1 DEVICE”
“MAKE IT CONCRETE”

7) Mini Drill Pack (10 minutes/day)

			
DRILL_PSLE_10MIN:
Day A: G1 specificity x5 (each with RETURN)
Day B: G2 contrast x5 (each with RETURN)
Day C: G3 hyperbole x5 (each with RETURN)
Day D: Mix x5 (one per paragraph role)
Day E: Hook Pair x3 (H1/H2) + choose best 1

		

8) One-Leak Repair Router (for corridor lines only)

			
CORRIDOR_REPAIR_ROUTER:
If confusing -> switch to G4 (body detail) + plain RETURN
If boring -> switch to G1 (specificity) + RETURN
If too dramatic -> switch from G3 to G4
If no landing -> keep SPARK, add RETURN immediately
If too abstract -> replace with concrete anchor noun (place/object)

		

(Past chat)(Past chat)(Past chat)(Past chat)(Past chat)(Past chat)(Past chat)(Past chat)(Past chat)(Past chat)(Past chat)(Past chat)

ACTP_08 — PSLE Corridor Line Bank (300 Corridor Lines = 300 SPARK+RETURN pairs)

Indexed by Theme × Paragraph Role (P1–P5) × Device Type (H1/H2/G1–G6) — v0.1

THEME 01 — HONESTY (HNST)

P1

HNST-P1-1 (H1) SPARK: The truth didn’t shout; it waited. RETURN: I was hiding what I did.
HNST-P1-2 (H2) SPARK: My face stayed calm, but my conscience was noisy. RETURN: I knew I had to confess.
HNST-P1-3 (H1) SPARK: The silence felt heavier than my words. RETURN: I was afraid to tell the truth.

P2

HNST-P2-1 (G1) SPARK: The wallet wasn’t just lost; it had an ID card inside. RETURN: I knew it belonged to someone.
HNST-P2-2 (G2) SPARK: It wasn’t curiosity; it was temptation. RETURN: I wanted to keep it.
HNST-P2-3 (G1) SPARK: The broken vase had fresh cracks like lightning. RETURN: I had caused it.

P3

HNST-P3-1 (G2) SPARK: It wasn’t greed; it was fear of being scolded. RETURN: That’s why I hesitated.
HNST-P3-2 (G3) SPARK: My stomach felt like a tight knot. RETURN: I was nervous.
HNST-P3-3 (G4) SPARK: My hands trembled as I held the wallet. RETURN: I couldn’t decide what to do.

P4

HNST-P4-1 (G6) SPARK: I inhaled. The teacher looked straight at my shaking hands. I spoke. RETURN: I admitted the truth.
HNST-P4-2 (G1) SPARK: My voice was small, but my words were clear. RETURN: I told what happened.
HNST-P4-3 (G2) SPARK: It wasn’t bravery; it was the right thing. RETURN: I chose to confess.

P5

HNST-P5-1 (G2) SPARK: It wasn’t punishment that mattered; it was trust. RETURN: Honesty repairs trust.
HNST-P5-2 (G1) SPARK: The apology was short, but it felt real. RETURN: I learnt to be truthful.
HNST-P5-3 (G4) SPARK: My shoulders finally relaxed. RETURN: Telling the truth brought relief.

THEME 02 — RESPONSIBILITY (RSPB)

P1

RSPB-P1-1 (H1) SPARK: The problem didn’t run away; it stayed. RETURN: It was my mistake.
RSPB-P1-2 (H2) SPARK: My hands were busy, but my mind was worried. RETURN: I knew I had messed up.
RSPB-P1-3 (H1) SPARK: The day started normal—until my error appeared. RETURN: I had to face it.

P2

RSPB-P2-1 (G1) SPARK: The spilled drink spread under the table like a map. RETURN: I had knocked it over.
RSPB-P2-2 (G2) SPARK: It wasn’t bad luck; it was carelessness. RETURN: I wasn’t careful enough.
RSPB-P2-3 (G1) SPARK: The homework page was blank except for my name. RETURN: I hadn’t done it.

P3

RSPB-P3-1 (G2) SPARK: It wasn’t the mess that scared me; it was being blamed. RETURN: I panicked.
RSPB-P3-2 (G4) SPARK: My throat tightened when my friend looked at me. RETURN: I felt guilty.
RSPB-P3-3 (G3) SPARK: My heart felt like it was drumming too loudly. RETURN: I was anxious.

P4

RSPB-P4-1 (G6) SPARK: I stood up. The class went quiet for a second. I explained. RETURN: I took responsibility.
RSPB-P4-2 (G2) SPARK: It wasn’t about excuses; it was about fixing it. RETURN: I cleaned up the mess.
RSPB-P4-3 (G1) SPARK: I picked up every scrap of paper near the bin. RETURN: I corrected my mistake.

P5

RSPB-P5-1 (G2) SPARK: It wasn’t the scolding that taught me; it was the choice. RETURN: I must own my actions.
RSPB-P5-2 (G1) SPARK: The classroom looked normal again, but I had changed. RETURN: Responsibility matters.
RSPB-P5-3 (G4) SPARK: My breathing slowed as I finished cleaning. RETURN: Doing my duty felt right.

THEME 03 — FRIENDSHIP (FRND)

P1

FRND-P1-1 (H1) SPARK: Our laughter sounded normal, but it wasn’t. RETURN: Something between us was wrong.
FRND-P1-2 (H2) SPARK: My smile stayed, but my heart felt uneasy. RETURN: I sensed trouble with my friend.
FRND-P1-3 (H1) SPARK: A friendship can crack quietly. RETURN: We were about to quarrel.

P2

FRND-P2-1 (G1) SPARK: The message had two ticks, but no reply. RETURN: My friend was ignoring me.
FRND-P2-2 (G2) SPARK: It wasn’t the joke; it was the tone. RETURN: I had hurt their feelings.
FRND-P2-3 (G1) SPARK: The empty seat beside me felt unusually wide. RETURN: We weren’t sitting together.

P3

FRND-P3-1 (G2) SPARK: It wasn’t anger; it was disappointment. RETURN: That’s why we went silent.
FRND-P3-2 (G4) SPARK: My fingers hovered over the keyboard. RETURN: I didn’t know what to say.
FRND-P3-3 (G3) SPARK: My stomach dropped like a stone. RETURN: I felt regret.

P4

FRND-P4-1 (G6) SPARK: I walked over. The words felt stuck for a moment. I apologised. RETURN: I chose to repair things.
FRND-P4-2 (G1) SPARK: I offered my friend their favourite snack. RETURN: I wanted to make peace.
FRND-P4-3 (G2) SPARK: It wasn’t pride; it was friendship. RETURN: I said sorry first.

P5

FRND-P5-1 (G2) SPARK: It wasn’t winning the argument; it was keeping the friend. RETURN: Friendship needs care.
FRND-P5-2 (G1) SPARK: The smile returned, and the seat felt normal again. RETURN: We forgave each other.
FRND-P5-3 (G4) SPARK: My chest felt lighter after we talked. RETURN: Honest words fix bonds.

THEME 04 — COURAGE (CRAG)

P1

CRAG-P1-1 (H1) SPARK: Fear didn’t leave; it followed me. RETURN: I had to be brave.
CRAG-P1-2 (H2) SPARK: My legs were steady, but my mind was racing. RETURN: I was nervous to speak up.
CRAG-P1-3 (H1) SPARK: The moment arrived before I was ready. RETURN: I needed courage.

P2

CRAG-P2-1 (G1) SPARK: The bully’s words were sharp and loud in the corridor. RETURN: Someone was being hurt.
CRAG-P2-2 (G2) SPARK: It wasn’t a small joke; it was cruelty. RETURN: I couldn’t ignore it.
CRAG-P2-3 (G1) SPARK: The class laughed, but one student looked down. RETURN: They felt embarrassed.

P3

CRAG-P3-1 (G4) SPARK: My throat tightened when everyone stared. RETURN: I felt scared.
CRAG-P3-2 (G2) SPARK: It wasn’t danger; it was pressure. RETURN: I feared being judged.
CRAG-P3-3 (G3) SPARK: My heart felt like a drum in my chest. RETURN: I was anxious.

P4

CRAG-P4-1 (G6) SPARK: I raised my hand. The room paused for a second. I spoke clearly. RETURN: I stood up for them.
CRAG-P4-2 (G2) SPARK: It wasn’t confidence; it was a decision. RETURN: I chose to act.
CRAG-P4-3 (G1) SPARK: My voice shook, but my words were firm. RETURN: I said “Stop.”

P5

CRAG-P5-1 (G2) SPARK: It wasn’t being fearless; it was doing right while scared. RETURN: That is courage.
CRAG-P5-2 (G1) SPARK: The corridor felt quieter after my words. RETURN: I learnt to be brave.
CRAG-P5-3 (G4) SPARK: My breathing slowed when the teacher stepped in. RETURN: Speaking up helped.

THEME 05 — KINDNESS (KIND)

P1

KIND-P1-1 (H1) SPARK: Kindness rarely makes noise. RETURN: I chose to help someone.
KIND-P1-2 (H2) SPARK: My schedule was full, but my heart felt pulled. RETURN: Someone needed me.
KIND-P1-3 (H1) SPARK: A small choice can change a day. RETURN: I had a chance to be kind.

P2

KIND-P2-1 (G1) SPARK: The old man’s bag looked heavy and lopsided. RETURN: He was struggling.
KIND-P2-2 (G2) SPARK: It wasn’t laziness; it was weakness. RETURN: He needed help.
KIND-P2-3 (G1) SPARK: The new student ate alone with eyes on the table. RETURN: They felt lonely.

P3

KIND-P3-1 (G2) SPARK: It wasn’t inconvenience; it was a test of character. RETURN: I had to decide.
KIND-P3-2 (G4) SPARK: My feet slowed as I walked past them. RETURN: I felt guilty ignoring them.
KIND-P3-3 (G3) SPARK: My stomach twisted with worry. RETURN: I wanted to help.

P4

KIND-P4-1 (G6) SPARK: I stepped closer. The rain tapped on my umbrella. I shared it. RETURN: I helped without thinking twice.
KIND-P4-2 (G1) SPARK: I pulled out a chair and smiled. RETURN: I invited them to sit.
KIND-P4-3 (G2) SPARK: It wasn’t about being noticed; it was about being good. RETURN: I offered help.

P5

KIND-P5-1 (G2) SPARK: It wasn’t a big gift; it was a warm moment. RETURN: Kindness matters.
KIND-P5-2 (G1) SPARK: The “thank you” was soft, but it stayed with me. RETURN: I felt proud inside.
KIND-P5-3 (G4) SPARK: My chest warmed as they smiled back. RETURN: Helping felt right.

THEME 06 — PERSEVERANCE (PERS)

P1

PERS-P1-1 (H1) SPARK: Failure knocked again, but I didn’t run. RETURN: I tried once more.
PERS-P1-2 (H2) SPARK: My body was tired, but my mind stayed steady. RETURN: I refused to give up.
PERS-P1-3 (H1) SPARK: The goal felt far, yet I kept moving. RETURN: I chose perseverance.

P2

PERS-P2-1 (G1) SPARK: The test paper had red circles beside my answers. RETURN: I had failed badly.
PERS-P2-2 (G2) SPARK: It wasn’t unfair; it was my weakness. RETURN: I needed practice.
PERS-P2-3 (G1) SPARK: The piano notes sounded messy and uneven. RETURN: I wasn’t ready.

P3

PERS-P3-1 (G4) SPARK: My fingers ached as I tried again. RETURN: I felt exhausted.
PERS-P3-2 (G2) SPARK: It wasn’t talent; it was repetition. RETURN: I had to train.
PERS-P3-3 (G3) SPARK: My head felt heavy like a backpack. RETURN: I was tired.

P4

PERS-P4-1 (G6) SPARK: I sat down. I wrote one step at a time. I continued. RETURN: I worked steadily.
PERS-P4-2 (G1) SPARK: I fixed my mistakes with a neat checklist beside me. RETURN: I improved slowly.
PERS-P4-3 (G2) SPARK: It wasn’t speed; it was consistency. RETURN: I kept practising.

P5

PERS-P5-1 (G2) SPARK: It wasn’t the mark that changed me; it was the effort. RETURN: Perseverance works.
PERS-P5-2 (G1) SPARK: The next test had fewer red circles. RETURN: I saw progress.
PERS-P5-3 (G4) SPARK: My shoulders relaxed when I solved it. RETURN: I felt proud.

THEME 07 — TEMPTATION / WRONG CHOICE (TEMP)

P1

TEMP-P1-1 (H1) SPARK: The shortcut didn’t look dangerous—until it was. RETURN: I was tempted to cheat.
TEMP-P1-2 (H2) SPARK: My hands were still, but my thoughts were sneaky. RETURN: I considered the wrong choice.
TEMP-P1-3 (H1) SPARK: One small decision can grow big consequences. RETURN: I was about to choose badly.

P2

TEMP-P2-1 (G1) SPARK: The answer sheet lay open beside my friend’s pencil case. RETURN: The answers were easy to see.
TEMP-P2-2 (G2) SPARK: It wasn’t help; it was cheating. RETURN: I knew it was wrong.
TEMP-P2-3 (G1) SPARK: The shop item was small enough to hide in my pocket. RETURN: I could steal it.

P3

TEMP-P3-1 (G2) SPARK: It wasn’t confidence; it was desperation. RETURN: I felt pressured.
TEMP-P3-2 (G4) SPARK: My fingers twitched near the paper. RETURN: I was tempted.
TEMP-P3-3 (G3) SPARK: My stomach churned like washing water. RETURN: I felt uneasy.

P4

TEMP-P4-1 (G6) SPARK: I closed my eyes. I pushed the paper away. I wrote my own. RETURN: I chose honesty.
TEMP-P4-2 (G2) SPARK: It wasn’t clever; it was wrong. RETURN: I stopped myself.
TEMP-P4-3 (G1) SPARK: I moved my chair slightly away from the answers. RETURN: I removed temptation.

P5

TEMP-P5-1 (G2) SPARK: It wasn’t the easy way that mattered; it was the right way. RETURN: Shortcuts can hurt.
TEMP-P5-2 (G1) SPARK: The relief came from choosing correctly, not from winning. RETURN: I learnt self-control.
TEMP-P5-3 (G4) SPARK: My breathing steadied after the test. RETURN: I felt proud I resisted.

THEME 08 — MISUNDERSTANDING (MSUD)

P1

MSUD-P1-1 (H1) SPARK: One sentence can break peace quickly. RETURN: We misunderstood each other.
MSUD-P1-2 (H2) SPARK: My ears heard words, but my mind filled gaps. RETURN: I assumed wrongly.
MSUD-P1-3 (H1) SPARK: The truth was there, but I missed it. RETURN: I jumped to conclusions.

P2

MSUD-P2-1 (G1) SPARK: The message was short, with no emoji or explanation. RETURN: I took it the wrong way.
MSUD-P2-2 (G2) SPARK: It wasn’t rudeness; it was poor timing. RETURN: I misunderstood.
MSUD-P2-3 (G1) SPARK: I saw them whispering near the staircase. RETURN: I suspected something.

P3

MSUD-P3-1 (G2) SPARK: It wasn’t hatred; it was confusion. RETURN: We didn’t clarify.
MSUD-P3-2 (G4) SPARK: My cheeks heated as I argued. RETURN: I felt embarrassed.
MSUD-P3-3 (G3) SPARK: My heart felt like it dropped suddenly. RETURN: I felt shocked.

P4

MSUD-P4-1 (G6) SPARK: I paused. I asked one clear question. I listened. RETURN: I finally understood.
MSUD-P4-2 (G1) SPARK: They showed me the full message thread on the phone. RETURN: I saw my mistake.
MSUD-P4-3 (G2) SPARK: It wasn’t an excuse; it was an explanation. RETURN: We cleared it up.

P5

MSUD-P5-1 (G2) SPARK: It wasn’t talking more; it was asking clearly. RETURN: Communication prevents trouble.
MSUD-P5-2 (G1) SPARK: The tension disappeared once the facts appeared. RETURN: I learnt to clarify first.
MSUD-P5-3 (G4) SPARK: My shoulders loosened after we agreed. RETURN: Understanding brought peace.

THEME 09 — TRUST (TRST)

P1

TRST-P1-1 (H1) SPARK: Trust breaks quietly, not loudly. RETURN: I had disappointed someone.
TRST-P1-2 (H2) SPARK: My words sounded fine, but my guilt was louder. RETURN: I knew trust was shaking.
TRST-P1-3 (H1) SPARK: Being believed can feel like a gift. RETURN: I had to earn it back.

P2

TRST-P2-1 (G1) SPARK: The promise sat in my notebook like a reminder. RETURN: I had broken it.
TRST-P2-2 (G2) SPARK: It wasn’t a small mistake; it was a broken promise. RETURN: Trust was hurt.
TRST-P2-3 (G1) SPARK: My friend’s eyes avoided mine during recess. RETURN: They didn’t trust me.

P3

TRST-P3-1 (G2) SPARK: It wasn’t anger; it was doubt. RETURN: They weren’t sure about me.
TRST-P3-2 (G4) SPARK: My hands clenched around the strap of my bag. RETURN: I felt nervous.
TRST-P3-3 (G3) SPARK: My stomach felt hollow. RETURN: I felt worried.

P4

TRST-P4-1 (G6) SPARK: I spoke slowly. I showed the truth clearly. I waited. RETURN: I tried to rebuild trust.
TRST-P4-2 (G1) SPARK: I kept my next promise on time, without reminders. RETURN: I proved I changed.
TRST-P4-3 (G2) SPARK: It wasn’t words alone; it was actions. RETURN: I did what I promised.

P5

TRST-P5-1 (G2) SPARK: It wasn’t a single apology; it was repeated effort. RETURN: Trust takes time.
TRST-P5-2 (G1) SPARK: The smile returned when my actions matched my words. RETURN: Trust was repaired.
TRST-P5-3 (G4) SPARK: My chest felt calmer at last. RETURN: I learnt to be reliable.

THEME 10 — GRATITUDE (GRTD)

P1

GRTD-P1-1 (H1) SPARK: Help can be silent but powerful. RETURN: Someone supported me.
GRTD-P1-2 (H2) SPARK: My day felt heavy, but kindness lightened it. RETURN: I wanted to say thanks.
GRTD-P1-3 (H1) SPARK: I noticed the gift after the hard moment. RETURN: I felt grateful.

P2

GRTD-P2-1 (G1) SPARK: The teacher’s note was short, taped to my book. RETURN: They encouraged me.
GRTD-P2-2 (G2) SPARK: It wasn’t luck; it was someone’s effort. RETURN: They helped me succeed.
GRTD-P2-3 (G1) SPARK: My friend shared their umbrella without a word. RETURN: They cared.

P3

GRTD-P3-1 (G2) SPARK: It wasn’t embarrassment; it was real appreciation. RETURN: I needed to thank them.
GRTD-P3-2 (G4) SPARK: My lips parted, but the words felt stuck. RETURN: I felt shy.
GRTD-P3-3 (G3) SPARK: My heart felt warm and fast. RETURN: I felt thankful.

P4

GRTD-P4-1 (G6) SPARK: I stepped forward. I looked them in the eyes. I said it. RETURN: I thanked them sincerely.
GRTD-P4-2 (G1) SPARK: I wrote a neat thank-you note on a small card. RETURN: I showed gratitude.
GRTD-P4-3 (G2) SPARK: It wasn’t a big speech; it was honest words. RETURN: I expressed thanks.

P5

GRTD-P5-1 (G2) SPARK: It wasn’t the gift that mattered; it was the heart behind it. RETURN: Gratitude is important.
GRTD-P5-2 (G1) SPARK: The note stayed in my pencil case for days. RETURN: I remembered their kindness.
GRTD-P5-3 (G4) SPARK: My smile came easily after that. RETURN: I felt grateful inside.

THEME 11 — SELF-CONTROL (ANGER) (SLFC)

P1

SLFC-P1-1 (H1) SPARK: My temper moved faster than my thinking. RETURN: I was about to explode.
SLFC-P1-2 (H2) SPARK: My mouth wanted to win, but my mind warned me. RETURN: I needed self-control.
SLFC-P1-3 (H1) SPARK: One harsh sentence can cause long regret. RETURN: I was close to saying it.

P2

SLFC-P2-1 (G1) SPARK: The teasing words were loud in the canteen line. RETURN: I felt provoked.
SLFC-P2-2 (G2) SPARK: It wasn’t funny; it was insulting. RETURN: I got angry.
SLFC-P2-3 (G1) SPARK: The group chat message had my name and a laughing emoji. RETURN: I felt upset.

P3

SLFC-P3-1 (G4) SPARK: My fists tightened beside my bag. RETURN: I felt furious.
SLFC-P3-2 (G3) SPARK: My face felt like it was on fire. RETURN: I was angry.
SLFC-P3-3 (G2) SPARK: It wasn’t strength; it was losing control. RETURN: I had to stop.

P4

SLFC-P4-1 (G6) SPARK: I breathed in. I counted quietly to five. I spoke calmly. RETURN: I controlled my temper.
SLFC-P4-2 (G1) SPARK: I walked to the water cooler and sipped slowly. RETURN: I cooled down.
SLFC-P4-3 (G2) SPARK: It wasn’t silence; it was restraint. RETURN: I chose not to shout.

P5

SLFC-P5-1 (G2) SPARK: It wasn’t winning the quarrel; it was keeping respect. RETURN: Self-control matters.
SLFC-P5-2 (G1) SPARK: The apology felt awkward, but it fixed the moment. RETURN: I learnt to pause.
SLFC-P5-3 (G4) SPARK: My heartbeat slowed after we talked. RETURN: Calm choices prevent regret.

THEME 12 — EMPATHY (EMPT)

P1

EMPT-P1-1 (H1) SPARK: The quietest person can hold the loudest feelings. RETURN: Someone needed empathy.
EMPT-P1-2 (H2) SPARK: My eyes saw a smile, but my heart noticed sadness. RETURN: I felt concerned.
EMPT-P1-3 (H1) SPARK: I realised a classmate was hurting silently. RETURN: I wanted to understand them.

P2

EMPT-P2-1 (G1) SPARK: The new student stared at the floor during recess. RETURN: They felt lonely.
EMPT-P2-2 (G2) SPARK: It wasn’t shyness; it was fear of rejection. RETURN: They needed support.
EMPT-P2-3 (G1) SPARK: Their lunch box stayed unopened on the bench. RETURN: Something was wrong.

P3

EMPT-P3-1 (G4) SPARK: My steps slowed as I walked past them. RETURN: I felt guilty ignoring them.
EMPT-P3-2 (G2) SPARK: It wasn’t my business, but it was my chance. RETURN: I had to decide.
EMPT-P3-3 (G3) SPARK: My stomach twisted with worry. RETURN: I wanted to help.

P4

EMPT-P4-1 (G6) SPARK: I sat beside them. I asked one gentle question. I listened. RETURN: I showed empathy.
EMPT-P4-2 (G1) SPARK: I shared my snack and smiled without forcing talk. RETURN: I made them feel safe.
EMPT-P4-3 (G2) SPARK: It wasn’t advice they needed; it was understanding. RETURN: I listened patiently.

P5

EMPT-P5-1 (G2) SPARK: It wasn’t fixing everything; it was being present. RETURN: Empathy helps people heal.
EMPT-P5-2 (G1) SPARK: Their shoulders lifted slightly after our talk. RETURN: They felt better.
EMPT-P5-3 (G4) SPARK: My heart felt warm walking back to class. RETURN: Kind listening matters.

THEME 13 — FAIRNESS (FAIR)

P1

FAIR-P1-1 (H1) SPARK: Fairness matters most when tested. RETURN: Something unfair happened to me.
FAIR-P1-2 (H2) SPARK: My face stayed calm, but my mind protested loudly. RETURN: I felt wrongly blamed.
FAIR-P1-3 (H1) SPARK: Being blamed feels heavier than being wrong. RETURN: I had to defend myself.

P2

FAIR-P2-1 (G1) SPARK: The torn worksheet was on my table, not in my hands. RETURN: I didn’t do it.
FAIR-P2-2 (G2) SPARK: It wasn’t proof; it was guessing. RETURN: The blame was unfair.
FAIR-P2-3 (G1) SPARK: The queue-cutter slipped in right before my turn. RETURN: That wasn’t fair.

P3

FAIR-P3-1 (G4) SPARK: My jaw tightened as I heard my name. RETURN: I felt angry.
FAIR-P3-2 (G2) SPARK: It wasn’t justice; it was convenience. RETURN: They blamed the nearest person.
FAIR-P3-3 (G3) SPARK: My heart thumped hard in my chest. RETURN: I felt stressed.

P4

FAIR-P4-1 (G6) SPARK: I breathed in. I stated facts clearly. I stayed polite. RETURN: I stood up for fairness.
FAIR-P4-2 (G1) SPARK: I showed the teacher my clean hands and my untouched table. RETURN: I proved the truth.
FAIR-P4-3 (G2) SPARK: It wasn’t fighting; it was explaining. RETURN: I defended myself calmly.

P5

FAIR-P5-1 (G2) SPARK: It wasn’t being loud; it was being clear. RETURN: Fairness needs facts.
FAIR-P5-2 (G1) SPARK: The teacher nodded once the evidence was shown. RETURN: Fairness returned.
FAIR-P5-3 (G4) SPARK: My shoulders dropped when my name was cleared. RETURN: I felt relieved.

THEME 14 — TEAMWORK (TEAM)

P1

TEAM-P1-1 (H1) SPARK: Alone is fast, but together is far. RETURN: We needed teamwork.
TEAM-P1-2 (H2) SPARK: My plan was clear, but the group was messy. RETURN: We had to cooperate.
TEAM-P1-3 (H1) SPARK: A team is many hands sharing one goal. RETURN: We had a big task.

P2

TEAM-P2-1 (G1) SPARK: The project file had missing slides and mixed fonts. RETURN: We were unprepared.
TEAM-P2-2 (G2) SPARK: It wasn’t hard work; it was poor coordination. RETURN: We lacked teamwork.
TEAM-P2-3 (G1) SPARK: The soccer field looked wide, but we ran separately. RETURN: We weren’t working as a team.

P3

TEAM-P3-1 (G2) SPARK: It wasn’t talent; it was teamwork that we lacked. RETURN: We kept failing.
TEAM-P3-2 (G4) SPARK: My eyebrows lifted as everyone argued at once. RETURN: I felt frustrated.
TEAM-P3-3 (G3) SPARK: My head felt like it was buzzing. RETURN: I felt stressed.

P4

TEAM-P4-1 (G6) SPARK: I clapped once. I gave simple roles. We started. RETURN: We organised ourselves.
TEAM-P4-2 (G1) SPARK: We wrote a checklist and ticked items one by one. RETURN: We worked smoothly.
TEAM-P4-3 (G2) SPARK: It wasn’t bossiness; it was clarity. RETURN: We followed a plan.

P5

TEAM-P5-1 (G2) SPARK: It wasn’t one hero; it was many small efforts. RETURN: Teamwork brings success.
TEAM-P5-2 (G1) SPARK: The final slide deck looked neat and complete. RETURN: Cooperation paid off.
TEAM-P5-3 (G4) SPARK: My smile came easily when we finished together. RETURN: Working as one matters.

THEME 15 — RESPECT (RSPT)

P1

RSPT-P1-1 (H1) SPARK: My tone did damage before my words did. RETURN: I was disrespectful.
RSPT-P1-2 (H2) SPARK: My mouth wanted to reply, but my mind warned me. RETURN: I needed respect.
RSPT-P1-3 (H1) SPARK: Respect is heard in how you speak. RETURN: I had to learn it.

P2

RSPT-P2-1 (G1) SPARK: The teacher’s instruction was clear, but I rolled my eyes. RETURN: I was rude.
RSPT-P2-2 (G2) SPARK: It wasn’t honesty; it was disrespect. RETURN: My words were harsh.
RSPT-P2-3 (G1) SPARK: The room went quiet after my comment. RETURN: I crossed a line.

P3

RSPT-P3-1 (G4) SPARK: My cheeks warmed as I saw the teacher’s face. RETURN: I felt ashamed.
RSPT-P3-2 (G2) SPARK: It wasn’t cool; it was unkind. RETURN: I realised my mistake.
RSPT-P3-3 (G3) SPARK: My stomach sank suddenly. RETURN: I regretted it.

P4

RSPT-P4-1 (G6) SPARK: I lowered my voice. I apologised clearly. I listened. RETURN: I showed respect again.
RSPT-P4-2 (G1) SPARK: I said “Please” and “Sorry” without excuses. RETURN: I fixed my tone.
RSPT-P4-3 (G2) SPARK: It wasn’t about pride; it was about manners. RETURN: I apologised.

P5

RSPT-P5-1 (G2) SPARK: It wasn’t being quiet; it was being polite. RETURN: Respect builds trust.
RSPT-P5-2 (G1) SPARK: The teacher nodded when my tone softened. RETURN: I learnt to speak kindly.
RSPT-P5-3 (G4) SPARK: My heartbeat slowed after my apology. RETURN: Respectful words matter.

THEME 16 — CONFIDENCE (CNFD)

P1

CNFD-P1-1 (H1) SPARK: Confidence isn’t loud; it’s steady. RETURN: I had to try.
CNFD-P1-2 (H2) SPARK: My hands shook, but my goal stayed clear. RETURN: I wanted to speak up.
CNFD-P1-3 (H1) SPARK: The stage looked big, but my voice still mattered. RETURN: I needed confidence.

P2

CNFD-P2-1 (G1) SPARK: The microphone was cold against my fingers. RETURN: It was my turn to present.
CNFD-P2-2 (G2) SPARK: It wasn’t the audience; it was my fear. RETURN: I doubted myself.
CNFD-P2-3 (G1) SPARK: My cue card had neat words, but my mind went blank. RETURN: I felt nervous.

P3

CNFD-P3-1 (G4) SPARK: My throat went dry as I faced the class. RETURN: I was scared.
CNFD-P3-2 (G2) SPARK: It wasn’t failure; it was practice I needed. RETURN: I had to continue.
CNFD-P3-3 (G3) SPARK: My heart felt like it was sprinting. RETURN: I felt anxious.

P4

CNFD-P4-1 (G6) SPARK: I breathed in. I looked at one friendly face. I began. RETURN: I presented with courage.
CNFD-P4-2 (G1) SPARK: I spoke one sentence clearly, then the next. RETURN: I gained confidence.
CNFD-P4-3 (G2) SPARK: It wasn’t perfect; it was progress. RETURN: I kept going.

P5

CNFD-P5-1 (G2) SPARK: It wasn’t being fearless; it was doing it anyway. RETURN: That is confidence.
CNFD-P5-2 (G1) SPARK: The applause was brief, but it felt meaningful. RETURN: I believed in myself more.
CNFD-P5-3 (G4) SPARK: My shoulders lifted after the presentation. RETURN: Trying builds confidence.

THEME 17 — HUMILITY (HMLT)

P1

HMLT-P1-1 (H1) SPARK: Winning felt sweet—until I spoke. RETURN: I bragged too much.
HMLT-P1-2 (H2) SPARK: My trophy shone, but my words were careless. RETURN: I hurt others.
HMLT-P1-3 (H1) SPARK: Pride can stand tall; arrogance can fall. RETURN: I had to learn humility.

P2

HMLT-P2-1 (G1) SPARK: I waved my certificate in front of my classmates. RETURN: I was showing off.
HMLT-P2-2 (G2) SPARK: It wasn’t confidence; it was arrogance. RETURN: I crossed the line.
HMLT-P2-3 (G1) SPARK: My friend’s smile looked forced when I boasted. RETURN: They felt uncomfortable.

P3

HMLT-P3-1 (G4) SPARK: My ears warmed when I noticed their silence. RETURN: I felt ashamed.
HMLT-P3-2 (G2) SPARK: It wasn’t a joke; it was a hurtful comment. RETURN: I regretted it.
HMLT-P3-3 (G3) SPARK: My stomach sank like a stone. RETURN: I felt guilty.

P4

HMLT-P4-1 (G6) SPARK: I swallowed. I lowered my voice. I apologised. RETURN: I chose humility.
HMLT-P4-2 (G1) SPARK: I praised my teammate’s effort instead of my own. RETURN: I shared the credit.
HMLT-P4-3 (G2) SPARK: It wasn’t about me alone; it was about the team. RETURN: I admitted that.

P5

HMLT-P5-1 (G2) SPARK: It wasn’t hiding success; it was respecting others. RETURN: Humility keeps friendships.
HMLT-P5-2 (G1) SPARK: The conversation felt warmer after I stopped boasting. RETURN: I learnt to be humble.
HMLT-P5-3 (G4) SPARK: My chest felt calm after I apologised. RETURN: Humility feels right.

THEME 18 — FORGIVENESS (FRGV)

P1

FRGV-P1-1 (H1) SPARK: An apology is a door, not the whole journey. RETURN: I asked for forgiveness.
FRGV-P1-2 (H2) SPARK: My words were ready, but my fear was bigger. RETURN: I was afraid they wouldn’t forgive me.
FRGV-P1-3 (H1) SPARK: Forgiveness doesn’t erase; it repairs. RETURN: We tried to fix the friendship.

P2

FRGV-P2-1 (G1) SPARK: The torn page in my friend’s book was my fault. RETURN: I had damaged it.
FRGV-P2-2 (G2) SPARK: It wasn’t an accident; it was my carelessness. RETURN: I caused the problem.
FRGV-P2-3 (G1) SPARK: My friend’s eyes stayed cold during recess. RETURN: They were still hurt.

P3

FRGV-P3-1 (G4) SPARK: My fingers fidgeted with my pencil case zipper. RETURN: I felt nervous.
FRGV-P3-2 (G2) SPARK: It wasn’t the mistake; it was the hurt it caused. RETURN: I understood that.
FRGV-P3-3 (G3) SPARK: My heart felt tight like a knot. RETURN: I felt worried.

P4

FRGV-P4-1 (G6) SPARK: I walked over. I apologised without excuses. I waited. RETURN: I asked for forgiveness.
FRGV-P4-2 (G1) SPARK: I replaced the torn book page with a new copy. RETURN: I repaired my mistake.
FRGV-P4-3 (G2) SPARK: It wasn’t a quick fix; it was sincere effort. RETURN: I showed I cared.

P5

FRGV-P5-1 (G2) SPARK: It wasn’t forgetting; it was choosing to heal. RETURN: Forgiveness is powerful.
FRGV-P5-2 (G1) SPARK: My friend’s smile returned slowly, like sunrise. RETURN: We forgave each other.
FRGV-P5-3 (G4) SPARK: My breathing eased after they nodded. RETURN: Forgiveness brought peace.

THEME 19 — SAFETY / CAREFULNESS (SFTY)

P1

SFTY-P1-1 (H1) SPARK: One careless step can become a big problem. RETURN: I learnt about safety.
SFTY-P1-2 (H2) SPARK: My feet moved fast, but my mind forgot caution. RETURN: I was not careful.
SFTY-P1-3 (H1) SPARK: Warnings exist for a reason. RETURN: I ignored one.

P2

SFTY-P2-1 (G1) SPARK: The wet floor sign stood near the shiny tiles. RETURN: The ground was slippery.
SFTY-P2-2 (G2) SPARK: It wasn’t fun; it was risky. RETURN: Running was dangerous.
SFTY-P2-3 (G1) SPARK: The staircase felt crowded during dismissal time. RETURN: Someone could fall.

P3

SFTY-P3-1 (G4) SPARK: My feet slipped for a second. RETURN: I felt frightened.
SFTY-P3-2 (G3) SPARK: My heart jumped into my throat. RETURN: I panicked.
SFTY-P3-3 (G2) SPARK: It wasn’t a small scare; it was a warning. RETURN: I had to change.

P4

SFTY-P4-1 (G6) SPARK: I stopped. I grabbed the handrail firmly. I walked slowly. RETURN: I chose safety.
SFTY-P4-2 (G1) SPARK: I told my friends to slow down near the stairs. RETURN: I prevented danger.
SFTY-P4-3 (G2) SPARK: It wasn’t being boring; it was being careful. RETURN: I walked properly.

P5

SFTY-P5-1 (G2) SPARK: It wasn’t luck that saved me; it was a lesson. RETURN: Safety comes first.
SFTY-P5-2 (G1) SPARK: The handrail felt cold, but it kept me steady. RETURN: Carefulness matters.
SFTY-P5-3 (G4) SPARK: My breathing steadied after I slowed down. RETURN: I learnt to be cautious.

THEME 20 — LEADERSHIP (LDRS)

P1

LDRS-P1-1 (H1) SPARK: Everyone looked around, then looked at me. RETURN: I had to lead.
LDRS-P1-2 (H2) SPARK: My nerves were loud, but my role was clear. RETURN: I needed to guide the group.
LDRS-P1-3 (H1) SPARK: Leadership borrows calm when others lose it. RETURN: I had to stay steady.

P2

LDRS-P2-1 (G1) SPARK: The group project table was noisy with different ideas. RETURN: We had no direction.
LDRS-P2-2 (G2) SPARK: It wasn’t a lack of effort; it was confusion. RETURN: We needed a leader.
LDRS-P2-3 (G1) SPARK: The sports team argued over positions near the field line. RETURN: We were disorganised.

P3

LDRS-P3-1 (G4) SPARK: My mouth went dry as they waited for my words. RETURN: I felt nervous.
LDRS-P3-2 (G2) SPARK: It wasn’t about being bossy; it was about being clear. RETURN: I had to decide.
LDRS-P3-3 (G3) SPARK: My heart beat fast like a timer. RETURN: I felt pressured.

P4

LDRS-P4-1 (G6) SPARK: I spoke once. I gave three simple roles. We moved. RETURN: I guided the team.
LDRS-P4-2 (G1) SPARK: I wrote a short plan on the whiteboard. RETURN: Everyone understood.
LDRS-P4-3 (G2) SPARK: It wasn’t shouting; it was organising. RETURN: I led calmly.

P5

LDRS-P5-1 (G2) SPARK: It wasn’t control; it was responsibility. RETURN: Leadership means serving others.
LDRS-P5-2 (G1) SPARK: The room grew quieter when the plan was clear. RETURN: Good leadership helps.
LDRS-P5-3 (G4) SPARK: My chest felt calm after we finished together. RETURN: I learnt to lead.

ACTP_09 — Corridor Remix System + Auto-Filter (PSLE Envelope Guard)

“Roll → Generate → FenceOS Filter → Use 1 Spark Only” (Almost-Code) — v0.1

0) PSLE Guard Envelope (LOCK)

			
PSLE_GUARD_ENVELOPE:
  CorridorLinesPerParagraphMax = 1
  ReturnRequiredWithin = 1 sentence
  MustHaveAnchorNoun = true
  SparkWordLimit = 16 (recommended)
  Forbidden = {sarcasm, ambiguous irony, metaphor chains, abstract philosophy}
  PreferDevices = {G1, G2, G4, G6}
  AllowedHookDevices = {H1, H2}

		

1) The Remix Game (No tech needed)

Dice version (fast classroom)

Die A (Theme): 1–20 → pick theme page (HONESTY…LEADERSHIP)
Die B (Paragraph role): 1–5 → P1..P5
Die C (Device): 1–6 → G1..G6 (P1 can also roll H1/H2)
Die D (Anchor noun): 1–6 → choose from anchor bank list

Rule: roll until you get a safe match:

P1: H1/H2/G1/G2/G4 only (avoid G3 unless very controlled)
P5: G2 or plain clarity (device optional)

Card version (worksheet)

Provide 4 mini-boxes to pick:

Theme □
Paragraph □
Device □
Anchor noun □

2) Remix Mapping Tables (Minimal)

2.1 Theme Map (Die A)

			
THEME_MAP_20:
Honesty
Responsibility
Friendship
Courage
Kindness
Perseverance
Temptation
Misunderstanding
Trust
Gratitude
Self-control
Empathy
Fairness
Teamwork
Respect
Confidence
Humility
Forgiveness
Safety
Leadership

		

2.2 Paragraph Map (Die B)

			
PARA_MAP_5:
P1 Setup/Hook
P2 Problem/Trigger
P3 Escalation/Choice
P4 Turning/Action
P5 Outcome/Lesson

		

2.3 Device Map (Die C)

			
DEVICE_MAP_6:
G1 Specificity Punch
G2 Contrast Flip
G3 Bounded Hyperbole
G4 Body-Detail Emotion
G5 Mild Personification
G6 Rhythm Triplet
(P1 optional override: H1/H2 Hook Pair)

		

3) The Remix Generator (Student Fill-Blanks)

Output contract

Must produce:
SPARK: one line
RETURN: one plain truth line

Generator templates (from ACTP_07)

			
GENERATOR_PICK:
IF Device==G1:
  SPARK: The <ANCHOR> was not just <GENERIC>; it had <SPECIFIC DETAIL>.
  RETURN: I could tell <PLAIN TRUTH>.
IF Device==G2:
  SPARK: It wasn’t <X>; it was <Y>.
  RETURN: The real problem was <PLAIN TRUTH>.
IF Device==G3:
  SPARK: My <BODY PART> felt like <SIMPLE EXAGGERATION>.
  RETURN: I was <SIMPLE EMOTION>.
IF Device==G4:
  SPARK: My <BODY PART> <ACTION>.
  RETURN: I felt <EMOTION>.
IF Device==G5:
  SPARK: The <ANCHOR_OBJECT> seemed to <HUMAN ACTION>.
  RETURN: I noticed <PLAIN TRUTH>.
IF Device==G6:
  SPARK: <SHORT>. <LONG (anchored)>. <SHORT>.
  RETURN: <PLAIN TRUTH>.
IF Device==H1 (P1 only):
  HOOK: The <ABSTRACT> didn’t <LOUD VERB>; it <QUIET VERB>.
  RETURN: I was about to <PLAIN EVENT>.
IF Device==H2 (P1 only):
  HOOK: My <BODY> was calm, but my conscience was noisy.
  RETURN: I knew <PLAIN TRUTH>.

		

4) Auto-Filter (FenceOS for Lines) — `CORRIDOR_FILTER_01`

4.1 Reject rules (hard fail)

			
REJECT_IF:
- RETURN missing
- Anchor noun missing OR only pronouns (“it/they/that”) without noun
- Spark has 2+ devices stacked (e.g., metaphor + personification + hyperbole)
- Spark is abstract philosophy (destiny, existence, society) with no concrete scene
- Spark is ambiguous sarcasm/irony
- Spark is too long AND unclear (recommended >16 words → review)

		

4.2 Soft fail rules (revise)

			
REVISE_IF:
- Too many adjectives
- Weak specificity (generic words: nice/bad/scary without detail)
- RETURN is vague (“It was bad.”) instead of a clear truth

4.3 Repair actions (automatic suggestions)

			
REPAIR_ACTIONS:
A1 AddAnchorNoun
A2 CutSparkToShorter
A3 ReplaceAbstractWithConcrete
A4 DeleteExtraDeviceKeepOne
A5 AddReturnTruthImmediately
A6 SwitchDeviceToG4 (ultra-safe) if confusion persists

		

5) LLM-Runnable Auto-Filter Prompt (Copy/Paste)

			
SYSTEM:
You are CORRIDOR_FILTER_01 for PSLE. Your job is to ACCEPT or REJECT a corridor line pair (SPARK+RETURN).
Be strict. No rewriting unless asked. Identify exactly one primary failure and one repair action.
USER:
Theme = <...>
Paragraph = P<1-5>
Device = <H1|H2|G1..G6>
SPARK = "..."
RETURN = "..."
OUTPUT FORMAT:
Decision: ACCEPT / REJECT / REVISE
Reasons:
- AnchorPresent: Yes/No
- ReturnPresent: Yes/No
- DeviceStackingRisk: Low/Med/High
- AbstractRisk: Low/Med/High
- Clarity2sec: Pass/Fail
PrimaryFailure: <one of {MissingReturn, MissingAnchor, TooAbstract, DeviceStacking, TooLongUnclear, AmbiguousTone}>
RepairAction: <one of {A1,A2,A3,A4,A5,A6}>
If Decision==REVISE:
- Give ONE revised SPARK line (max 16 words) and ONE revised RETURN line.

		

(Teacher use: paste student pair → get instant accept/reject + one fix.)

6) Remix Modes (How to run it in class)

Mode M1 — “One Spark Only”

Students roll (Theme, Paragraph, Device, Anchor)
Generate 1 SPARK+RETURN
Filter it (teacher or LLM prompt)
Paste into paragraph and continue writing

Mode M2 — “Best of 3”

Generate 3 corridor candidates
Filter all
Pick the strongest ACCEPT with highest clarity

Mode M3 — “Boredom Rescue”

Only used when paragraph is bland:
force Device = G1 or G2
must ACCEPT before inserting

Mode M4 — “Overload Reset”

If student overdoes devices:
force Device = G4 for next paragraph
then back to normal

7) Integration Hook (Dashboard-ready)

Record schema (for `ACTP_DASHBOARD_SPEC_01`)

			
CORRIDOR_EVENT:
  StudentID
  Date
  Theme
  Paragraph
  Device
  Anchor
  Decision (ACCEPT/REJECT/REVISE)
  PrimaryFailure
  RepairAction

		

KPI to track

AcceptRate
MostCommonFailure
DeviceUsageDistribution (too many G3/G5 = higher risk)
OverloadEvents (rejects due to stacking/abstract/unclear)

8) What this gives you (mechanism, no personalities)

This system reproduces the core effect you observed:

Architect generates novelty (corridor)
Oracle forces landing (RETURN)
Operator limits load (one spark, short lines)
FenceOS prevents collapse (reject/repair)

ACTP_10 — Corridor-to-Paragraph Compiler

“Feed 5 corridor pairs → get PSLE 5-paragraph skeleton (exam-safe) + weakest-paragraph rewrite loop” (Almost-Code) — v0.1

0) Compiler Contract

Input (minimum)

Theme
5 corridor pairs (P1..P5): SPARK + RETURN (P5 corridor optional)
Optional: 5-Box plan bullets (recommended)

Output (guaranteed)

5 paragraphs (P1–P5) with correct roles
Each paragraph contains at most one corridor line (the student’s SPARK)
Each corridor line is immediately followed by the student’s RETURN
Clear story flow + anchored nouns + exam-safe clarity
A “weakest paragraph” score sheet + one repair recipe

1) Input Schema — `COMPILER_INPUT_PSLE_01`

			
COMPILER_INPUT_PSLE_01:
  Theme: <string>
  WordTarget: 260..360 (default)
  PictureSet (optional): <A/B/C or brief description>
  5BoxPlan (optional but recommended):
    B1 Setup:
    B2 Problem:
    B3 Escalation:
    B4 Turning:
    B5 Outcome+Lesson:
  CorridorPairs:
    P1: {SPARK:"...", RETURN:"..."}   // P1 can be Hook Pair style or corridor
    P2: {SPARK:"...", RETURN:"..."}
    P3: {SPARK:"...", RETURN:"..."}
    P4: {SPARK:"...", RETURN:"..."}
    P5: {SPARK:"...", RETURN:"..."}   // optional; can be blank
  Constraints (locked):
    OneSparkPerParagraphMax=1
    ReturnAfterSparkRequired=true
    MaxMetaphorsPerParagraph=1

		

2) Compile Rules (How the compiler builds each paragraph)

P1 Setup (B1)

Insert P1.SPARK then P1.RETURN
Add: who/where/when + normal day line
End with “normal before trouble” sentence

P2 Problem (B2)

Start with 1–2 clear event lines
Insert P2.SPARK then P2.RETURN
Add: stakes + “problem stated plainly” sentence

P3 Escalation (B3)

Add: complication + pressure
Insert P3.SPARK then P3.RETURN
Add: “I had to decide…” line (choice pressure)

P4 Turning (B4)

Insert P4.SPARK then P4.RETURN
Add: step-by-step action (2–4 lines)
Add: immediate consequence (1 line)

P5 Outcome + Lesson (B5)

If P5 corridor provided: insert P5.SPARK then P5.RETURN
Add: repair/outcome lines
End with lesson as plain truth (non-cliché)

3) Corridor Preservation Lock (Non-Negotiable)

			
PRESERVE_LOCK:
- Do NOT rewrite student SPARK/RETURN lines during compile.
- Only add supporting sentences around them.
- If a corridor pair is unsafe, compiler flags it and requests a REVISE using ACTP_09 filter.

4) Output Format — `COMPILER_OUTPUT_PSLE_01`

			
COMPILER_OUTPUT_PSLE_01:
  Title (optional):
  P1:
  P2:
  P3:
  P4:
  P5:
  PostCheck:
    - ParagraphRoleCheck (Pass/Fail each)
    - OneSparkCheck (Pass/Fail each)
    - ReturnCheck (Pass/Fail each)
    - ClarityRiskNotes (max 3 bullets)
  WeakestParagraphPick:
    - ParaScores table
    - WeakestParagraph ID
    - PrimaryLeak (one)
    - One Repair Recipe

		

5) LLM-Runnable Compiler Prompt (Copy/Paste) — `PROMPT_COMPILER_PSLE_01`

			
SYSTEM:
You are PSLE_CORRIDOR_COMPILER_01.
Compile a 5-paragraph PSLE composition using the student's corridor pairs.
You MUST keep each SPARK and RETURN EXACTLY as provided (no paraphrasing).
Add supporting sentences to make a coherent story.
Enforce: one corridor line per paragraph; RETURN immediately after SPARK; paragraph roles match 5-Box.
Use simple, concrete anchors. Avoid abstract philosophy. Exam-safe tone.
USER:
<<paste COMPILER_INPUT_PSLE_01 here>>
OUTPUT:
1) P1..P5 composition (260–360 words unless specified)
2) PostCheck (role + oneSpark + return checks)
3) WeakestParagraphPick:
   - ParaScores (C,R,BoxFit,OneSparkOnly) each 0..2
   - WeakestParagraph
   - PrimaryLeak (one)
   - One repair recipe name from REPAIR_RECIPES_PSLE (ACTP_05)

		

6) Built-In Weakest Paragraph Scorer (Fast) — `PARA_SCORE_COMPILER_01`

Scoring (0–2 each)

C Clarity
R Landing (SPARK+RETURN intact and meaningful)
BoxFit matches paragraph function
OneSparkOnly ≤1 corridor line

Weakest paragraph rule

Weakest = lowest (C+R+BoxFit+OneSparkOnly)
Tie-breaker priority: C then BoxFit

7) Rewrite-Only-One Paragraph Prompt — `PROMPT_REWRITE_ONE_PARA_01`

			
SYSTEM:
You are PSLE_REWRITE_ONE_PARA_01.
Rewrite ONLY the paragraph specified.
Keep story facts consistent with the other paragraphs.
Keep the corridor SPARK+RETURN pair EXACTLY unchanged if it exists in that paragraph.
Fix only the PrimaryLeak using the given repair recipe.
Do not rewrite other paragraphs.
USER:
Full composition P1..P5:
P1: ...
P2: ...
P3: ...
P4: ...
P5: ...
WeakestParagraph = P?
PrimaryLeak = {ClarityLeak|LandingLeak|BoxFitLeak|OverloadLeak|BoredomLeak}
RepairRecipe = <one from REPAIR_RECIPES_PSLE>
OUTPUT:
- Rewritten paragraph P? only
- 2 bullet notes explaining what changed
- Quick re-score of that paragraph (C,R,BoxFit,OneSparkOnly)

		

8) If a Corridor Pair Fails Safety (Auto-Filter Gate)

Gate rule

Before compiling, run each pair through CORRIDOR_FILTER_01 (ACTP_09).

If REJECT → student must revise that pair (one fix only), then proceed.

Mini prompt (fast)

Use the ACTP_09 filter prompt, then replace the pair.

9) Classroom Workflow (No LLM needed)

Manual compile (teacher-led)

Students fill 5-Box plan
Students write 5 corridor pairs (one per paragraph)
Teacher checks: Anchor + Return + One device only
Students “wrap” each corridor pair with 3–6 simple supporting sentences using the paragraph blueprint
Score paragraphs → rewrite weakest paragraph only

10) What this gives you (the mechanism you wanted)

This reproduces the “corridor engineering” effect without naming any personalities:

Architect = supplies corridor SPARK lines
Oracle = forces the RETURN landing line
Operator = wraps with stable, simple support sentences
FenceOS = filters unsafe lines + prevents overload
EducationOS loop = diagnose → repair → retest (one paragraph only)

ACTP_11 — PSLE Corridor Compiler Demo Pack

One complete filled input → compiled output → weakest-paragraph repair (Before/After) — v0.1

1) Demo Input (Filled) — `COMPILER_INPUT_PSLE_01_DEMO`

			
Theme: Honesty
WordTarget: 260–360
5BoxPlan:
  B1 Setup: After school, I was packing up in the classroom.
  B2 Problem: I found a wallet near the table and realised it belonged to someone.
  B3 Escalation: I hesitated because I feared getting scolded or accused.
  B4 Turning Point: I told the teacher and returned it.
  B5 Outcome+Lesson: The owner got it back; I learnt honesty protects trust.
CorridorPairs (LOCK — must be kept exact):
  P1:
    SPARK: "The truth didn’t shout; it waited."
    RETURN: "I was hiding what I did."
  P2:
    SPARK: "The wallet wasn’t just lost; it had an ID card inside."
    RETURN: "I knew it belonged to someone."
  P3:
    SPARK: "It wasn’t greed; it was fear of being scolded."
    RETURN: "That’s why I hesitated."
  P4:
    SPARK: "I inhaled. The teacher looked straight at my shaking hands. I spoke."
    RETURN: "I admitted the truth."
  P5:
    SPARK: "It wasn’t punishment that mattered; it was trust."
    RETURN: "Honesty repairs trust."

		

2) Compiled PSLE Composition (Output) — `COMPILER_OUTPUT_PSLE_01_DEMO`

P1 (Setup)

The truth didn’t shout; it waited. I was hiding what I did.
It was a normal Friday afternoon, and the classroom was almost empty. My classmates were rushing out, chairs scraping the floor, while I packed my bag slowly. I just wanted to go home and rest. Then I saw something dark near the leg of my table.

P2 (Problem)

I walked over and picked it up carefully. The wallet wasn’t just lost; it had an ID card inside. I knew it belonged to someone.
There were also a few notes and an EZ-Link card. My heart beat faster because it looked important. If the owner couldn’t find it, they would panic. I glanced around, but no one was in the classroom anymore.

P3 (Escalation + Choice Pressure) — intentionally slightly messy to demo repair later

I stood at the door and looked down the corridor. Some students from the next class walked past and laughed loudly. I thought about chasing them to ask if it was theirs, but I didn’t. My mind filled with worries—what if the owner said I took it, and what if the teacher scolded me for touching it? It wasn’t greed; it was fear of being scolded. That’s why I hesitated.
I slipped the wallet into my bag and told myself I would deal with it later, but the longer I waited, the heavier it felt.

P4 (Turning Point + Action)

During the next lesson, the teacher asked if anyone had seen a missing wallet. My fingers tightened around my pencil. I inhaled. The teacher looked straight at my shaking hands. I spoke. I admitted the truth.
I walked to the front, opened my bag, and placed the wallet on the teacher’s desk. I explained where I found it and how I felt scared. The teacher nodded and thanked me for being honest.

P5 (Outcome + Lesson)

After class, a classmate came forward with watery eyes and held the wallet tightly. They thanked me again and again. I felt relief wash over me. It wasn’t punishment that mattered; it was trust. Honesty repairs trust.
That day, I learnt that the truth is safer than hiding, because hiding only makes fear grow.

3) PostCheck — `POSTCHECK_DEMO`

			
ParagraphRoleCheck:
  P1 Setup: Pass
  P2 Problem: Pass
  P3 Escalation: Amber (some mixed actions; choice pressure present but scattered)
  P4 Turning: Pass
  P5 Lesson: Pass
OneSparkCheck:
  P1 Pass | P2 Pass | P3 Pass | P4 Pass | P5 Pass
ReturnCheck (RETURN immediately after SPARK):
  P1 Pass | P2 Pass | P3 Pass | P4 Pass | P5 Pass
ClarityRiskNotes (max 3):
- P3 contains extra movement/actions that blur the escalation focus.
- P3 could end with a clearer “I had to decide…” line to lock BoxFit.

		

4) Weakest Paragraph Pick — `WEAKESTPARA_DEMO`

ParaScores (0–2 each)

			
P1: C2 R2 BoxFit2 OneSpark2 = 8
P2: C2 R2 BoxFit2 OneSpark2 = 8
P3: C1 R2 BoxFit1 OneSpark2 = 6   <-- Weakest
P4: C2 R2 BoxFit2 OneSpark2 = 8
P5: C2 R2 BoxFit2 OneSpark2 = 8

		

WeakestParagraph: P3
PrimaryLeak: BoxFitLeak (Escalation paragraph doing too many “scene moves” instead of tightening pressure + choice)
RepairRecipe: BoxFitLeak → rewrite paragraph to match box role (Escalation: worse + choice pressure + plain “I had to decide”)

5) Rewrite Only P3 (Before/After) — `REWRITE_ONE_PARA_DEMO`

P3 BEFORE (copied)

P3 AFTER (rewritten, corridor pair kept exact)

My thoughts started to race as I stared at the wallet inside my bag. If I kept quiet, the owner would suffer. If I spoke up, I might be accused or scolded for touching it. It wasn’t greed; it was fear of being scolded. That’s why I hesitated.
I kept imagining the teacher’s stern face and the owner’s panic. The pressure grew with every minute, and I knew I had to decide whether to tell the truth or keep hiding it.

What changed (2 bullets)

Tightened the paragraph into pure escalation + choice pressure (no extra corridor movement).
Added a clear decision lock at the end (“I knew I had to decide…”).

Quick re-score for P3

P3: C2 R2 BoxFit2 OneSpark2 = 8

ACTP_12 — Multi-Demo Pack (3 Themes × 3 Failure Modes)

ClarityLeak / OverloadLeak / LandingLeak — “Fix ONE paragraph only” (Almost-Code) — v0.1

DEMO A — ClarityLeak (Theme: Friendship)

A1) Input — `COMPILER_INPUT_DEMO_A`

			
Theme: Friendship
5BoxPlan:
  B1 Setup: Recess; I expected to sit with my friend as usual.
  B2 Problem: My friend ignored me and I misunderstood why.
  B3 Escalation: I overthought and felt hurt; I almost said something harsh.
  B4 Turning: I asked calmly and listened.
  B5 Outcome+Lesson: We cleared it up; I learnt to clarify.
CorridorPairs (keep exact):
  P1 SPARK: "Our laughter sounded normal, but it wasn’t."
     RETURN: "Something between us was wrong."
  P2 SPARK: "The message had two ticks, but no reply."
     RETURN: "My friend was ignoring me."
  P3 SPARK: "It wasn’t anger; it was disappointment."
     RETURN: "That’s why we went silent."
  P4 SPARK: "I walked over. The words felt stuck for a moment. I apologised."
     RETURN: "I chose to repair things."
  P5 SPARK: "It wasn’t winning the argument; it was keeping the friend."
     RETURN: "Friendship needs care."

		

A2) Compiled output (excerpt) — `OUTPUT_DEMO_A`

P1 OK (setup + hook pair)
P2 intentionally unclear (ClarityLeak)
P3 OK (escalation + choice pressure)
P4 OK (turning)
P5 OK (lesson)

P2 BEFORE (ClarityLeak)

I opened my phone and saw the chat and then I kept looking and looking because the reply didn’t come and I started thinking maybe yesterday was about the joke and the canteen and then it became like they hated me and everyone saw and it was embarrassing. The message had two ticks, but no reply. My friend was ignoring me. I walked to the bench and sat and my mind was messy.

A3) Weakest paragraph pick

			
ParaScores (0–2 each):
P1: 8
P2: C0 R2 BoxFit2 OneSpark2 = 6  <-- Weakest (ClarityLeak)
P3: 8
P4: 8
P5: 8
PrimaryLeak: ClarityLeak
RepairRecipe: OperatorLock rewrite (short clauses, anchors, sequence)

		

A4) Rewrite ONLY P2 (after)

P2 AFTER (corridor kept exact)

I checked my phone again during recess. The message had two ticks, but no reply. My friend was ignoring me. I replayed yesterday’s joke in my head and wondered if I had hurt them. The canteen suddenly felt louder, and the bench beside me felt empty. I didn’t know what was true, but I felt left out.

Quick re-score P2:

P2: C2 R2 BoxFit2 OneSpark2 = 8

DEMO B — OverloadLeak (Theme: Safety / Carefulness)

B1) Input — `COMPILER_INPUT_DEMO_B`

			
Theme: Safety
5BoxPlan:
  B1 Setup: Dismissal time; everyone rushed down the stairs.
  B2 Problem: Wet floor near staircase.
  B3 Escalation: Friends ran; I nearly slipped.
  B4 Turning: I stopped them and walked carefully.
  B5 Outcome+Lesson: No one got hurt; safety matters.
CorridorPairs (keep exact):
  P1 SPARK: "Warnings exist for a reason."
     RETURN: "I ignored one."
  P2 SPARK: "The wet floor sign stood near the shiny tiles."
     RETURN: "The ground was slippery."
  P3 SPARK: "My heart jumped into my throat."
     RETURN: "I panicked."
  P4 SPARK: "I stopped. I grabbed the handrail firmly. I walked slowly."
     RETURN: "I chose safety."
  P5 SPARK: "It wasn’t luck that saved me; it was a lesson."
     RETURN: "Safety comes first."

		

B2) Compiled output (problem paragraph overloaded) — `OUTPUT_DEMO_B`

P3 BEFORE (OverloadLeak: stacked devices + melodrama + too many “clever” lines)

The staircase was a roaring river of bodies, a tornado of shoes, a volcano of screaming, and my brain became a broken computer, exploding with fear and destiny. My heart jumped into my throat. I panicked. The tiles were like ice, like soap, like glass, and the universe tried to throw me down the steps as if it hated me.

B3) Weakest paragraph pick

			
ParaScores:
P3: C0 R2 BoxFit2 OneSpark0 = 4  <-- Weakest (OverloadLeak)
PrimaryLeak: OverloadLeak
RepairRecipe: Truncate devices; keep only 1; add concrete anchors; return to plain truth

B4) Rewrite ONLY P3 (after)

P3 AFTER (corridor kept exact; overload truncated)

Students rushed down the stairs, and shoes squeaked on the shiny tiles. My heart jumped into my throat. I panicked. For a second, my foot slid, and my hand shot out to find the railing. I realised one careless step could make someone fall, and I had to act carefully.

Quick re-score P3:

P3: C2 R2 BoxFit2 OneSpark2 = 8

DEMO C — LandingLeak (Theme: Misunderstanding)

Here we demo the real landing failure: the student wrote a SPARK but forgot / weakened the RETURN, so the filter blocks it first.

C1) Input (with a bad corridor pair) — `COMPILER_INPUT_DEMO_C_BAD`

			
Theme: Misunderstanding
CorridorPairs:
  P1 SPARK: "One sentence can break peace quickly."
     RETURN: "We misunderstood each other."
  P2 SPARK: "The message was short, with no emoji or explanation."
     RETURN: ""   (missing)
  P3 SPARK: "It wasn’t hatred; it was confusion."
     RETURN: "We didn’t clarify."
  P4 SPARK: "I paused. I asked one clear question. I listened."
     RETURN: "I finally understood."
  P5 SPARK: "It wasn’t talking more; it was asking clearly."
     RETURN: "Communication prevents trouble."

		

C2) Auto-Filter Gate result (before compile) — `CORRIDOR_FILTER_01`

			
Decision: REJECT
AnchorPresent: Yes
ReturnPresent: No
PrimaryFailure: MissingReturn
RepairAction: A5 AddReturnTruthImmediately

		

C3) Fix the corridor pair (ONE fix) — `COMPILER_INPUT_DEMO_C_FIXED_PAIR`

			
P2 SPARK: "The message was short, with no emoji or explanation."
P2 RETURN: "I took it the wrong way."

C4) Compile (excerpt) — `OUTPUT_DEMO_C`

P2 (now lands correctly)

I checked the group chat and saw my friend’s message. The message was short, with no emoji or explanation. I took it the wrong way. I assumed they were angry at me, and my mind filled the silence with the worst meaning.

C5) Weakest paragraph pick (LandingLeak resolved at gate)

			
PostCheck:
- ReturnCheck: all Pass after fix
- LandingRisk: Green

What this demo pack teaches (mechanism-only)

ClarityLeak → OperatorLock rewrite (short, anchored, sequential)
OverloadLeak → Truncation (delete stacked devices; keep one)
LandingLeak → Gate first (no RETURN = reject; add RETURN; then compile)

ACTP_13 — Teacher Error Gallery (20 Common Failure Patterns)

Each pattern → sensor signature → 2-line fix → best drill → PSLE repair recipe (Almost-Code) — v0.1

Error Patterns (EG01–EG20)

EG01 — Missing RETURN (LandingLeak hard fail)

Signature: S3 LandingScore low, ReturnPresent=false, R_Landing≤2
PrimaryLeak: LandingLeak
2-line fix: Add 1 plain truth sentence immediately after SPARK. Keep it blunt and concrete.
Best drill: ACTP_B2_DRILLS_01: DRILL_B2_01 Hook Pair Factory (or ACTP_B1_03 Return Sentence Mandatory)
PSLE recipe: LandingLeak → enforce HOOK→RETURN; add payoff line

EG02 — No anchor noun (vague “it/they/that”)

Signature: AnchorPresent=false, confusion rises, C drops
PrimaryLeak: ClarityLeak
2-line fix: Replace pronouns with concrete nouns (wallet/teacher/corridor). Add one visible detail.
Best drill: ACTP_B1_DRILLS_01: DRILL_B1_02 Describe Like a Camera
PSLE recipe: ClarityLeak → add anchors; cut long sentences

EG03 — Too many “clever lines” in one paragraph (OverloadLeak)

Signature: DeviceStacking high, OverloadFlag=true, S_Safety≤2
PrimaryLeak: OverloadLeak
2-line fix: Delete all devices except the best one. RETURN immediately after it.
Best drill: ACTP_B3_DRILLS_01: DRILL_B3_02 Spike→Stitch Timing
PSLE recipe: OverloadLeak → delete all corridor lines except best 1

EG04 — Metaphor chain collapse (mixed images)

Signature: C<0.70, S6 Confusion↑, “like… like… like…”
PrimaryLeak: OverloadLeak
2-line fix: Keep ONE metaphor only. Convert the rest into plain facts.
Best drill: ACTP_B3_DRILLS_01: DRILL_B3_09 Reduce metaphor-chain
PSLE recipe: OverloadLeak → cut devices; keep one; add anchors

EG05 — Hook is abstract philosophy (no scene)

Signature: abstract nouns, no who/where; BoxFit(P1) low
PrimaryLeak: BoxFitLeak
2-line fix: After Hook Pair, add who/where/when within 2–3 lines. End P1 with “normal day” sentence.
Best drill: ACTP_B2_DRILLS_01: DRILL_B2_01 Hook Pair Factory + scene lock
PSLE recipe: BoxFitLeak → rewrite P1 as setup role

EG06 — P2 doesn’t state the problem plainly

Signature: P2 has events but no stakes; BoxFit(P2) low
PrimaryLeak: BoxFitLeak
2-line fix: Add one sentence: “The problem was .” Add one stake: “If , then _.”
Best drill: ACTP_B2_DRILLS_01: DRILL_B2_16 1 paragraph with return end
PSLE recipe: BoxFitLeak → rewrite to match Problem role

EG07 — P3 escalation is missing “choice pressure”

Signature: story continues, but no decision tension; BoxFit(P3) low
PrimaryLeak: BoxFitLeak
2-line fix: Add “If I do A… If I do B…” then end with “I had to decide.”
Best drill: ACTP_B3_DRILLS_01: DRILL_B3_26 Turning point paragraph (adapt for escalation)
PSLE recipe: BoxFitLeak → escalation = worse + choice pressure

EG08 — P4 is not step-by-step (jumps too fast)

Signature: action unclear; reader can’t follow; C drops
PrimaryLeak: ClarityLeak
2-line fix: Rewrite P4 into 3–5 short action steps. Add immediate consequence line.
Best drill: ACTP_B1_DRILLS_01: DRILL_OP_03 Cadence Cut (short clauses)
PSLE recipe: ClarityLeak → sequence actions; cut run-ons

EG09 — P5 lesson is cliché (“Always be kind”)

Signature: moral generic; low B_gain, weak ending
PrimaryLeak: QuoteabilityLeak
2-line fix: Make lesson specific to the story: “I learnt that _ because _ happened.” Keep it plain.
Best drill: ACTP_B4_DRILLS_01: DRILL_B4_01 Rhetoric Ladder (scaled down)
PSLE recipe: BoxFitLeak → rewrite P5 as outcome + specific lesson

EG10 — Too much dialogue, not enough narration

Signature: story stalls; missing scene anchors; BoxFit weak
PrimaryLeak: BoxFitLeak
2-line fix: For every 2 dialogue lines, add 1 narration line (action/face/body). End paragraph with return truth.
Best drill: ACTP_B2_DRILLS_01: DRILL_B2_32 Dialogue + return
PSLE recipe: BoxFitLeak → rebalance dialogue vs story movement

EG11 — Tense drift (past ↔ present mixed)

Signature: C feels shaky; teacher flags grammar consistency
PrimaryLeak: ClarityLeak
2-line fix: Choose one tense (past recommended). Rewrite verbs in that paragraph only.
Best drill: ACTP_B1_DRILLS_01: DRILL_OP_01 One-Clause Truth (control)
PSLE recipe: ClarityLeak → simplify; keep consistent tense

EG12 — Pronoun confusion (who is “he/she/they”?)

Signature: S6 Confusion↑, C↓, many pronouns
PrimaryLeak: ClarityLeak
2-line fix: Replace first pronoun in each paragraph with the noun name/role (my friend/teacher).
Best drill: ACTP_B1_DRILLS_01: DRILL_B1_02 Camera detail + nouns
PSLE recipe: ClarityLeak → add anchors; reduce pronouns

EG13 — Emotion “telling” only (no showing)

Signature: repeated “I was sad/happy” with no body detail; low vividness
PrimaryLeak: BoredomLeak
2-line fix: Add one body-detail line (hands/throat/face) + RETURN truth.
Best drill: ACTP_B1_DRILLS_01: DRILL_B1_15 tired person detail + G4
PSLE recipe: BoredomLeak → add AM2 specificity or body detail

EG14 — Overdramatic / unbelievable reactions (CringeRisk)

Signature: S7 CringeRisk↑, teacher notes “too exaggerated”
PrimaryLeak: PersonaLeak (exam tone mismatch)
2-line fix: Switch hyperbole to body detail (G4). Keep consequences realistic.
Best drill: ACTP_B2_DRILLS_01: DRILL_B2_37 reduce cringe
PSLE recipe: OverloadLeak → reduce device; keep believable

EG15 — Repetition (same sentence pattern again and again)

Signature: low engagement; BoredomFlag=true though clarity ok
PrimaryLeak: BoredomLeak
2-line fix: Add one contrast flip OR one specificity punch in that paragraph only.
Best drill: ACTP_B2_DRILLS_01: DRILL_B2_02 Contrast Flip Bank
PSLE recipe: BoredomLeak → add one AM3 contrast + RETURN

EG16 — Weak transitions (paragraphs feel disconnected)

Signature: reader “jumps”; BoxFit ok but flow weak
PrimaryLeak: ClarityLeak
2-line fix: Start P2–P5 with time/sequence connectors (“After that…”, “Suddenly…”, “At that moment…”).
Best drill: ACTP_B3_DRILLS_01: DRILL_B3_11 short sentences (sequencing)
PSLE recipe: ClarityLeak → add sequencing anchors

EG17 — P3 includes resolution too early

Signature: story “solves” before turning point; BoxFit(P3/P4) low
PrimaryLeak: BoxFitLeak
2-line fix: Move solution actions to P4. Keep P3 as pressure + choice only.
Best drill: ACTP_B2_DRILLS_01: DRILL_B2_33 Turning point paragraph
PSLE recipe: BoxFitLeak → reassign events to correct boxes

EG18 — Corridor line doesn’t match paragraph role

Signature: spark feels “random”; BoxFit drops though C/R ok
PrimaryLeak: BoxFitLeak
2-line fix: Replace SPARK device with role-appropriate one (P2: G1; P3: G2/G3; P4: G6; P5: plain).
Best drill: ACTP_B2_DRILLS_01: DRILL_B2_30 One spark per paragraph rewrite
PSLE recipe: BoxFitLeak → rewrite corridor line to match role

EG19 — Ending is rushed (no outcome details)

Signature: P5 too short; moral appears without consequence; BoxFit(P5) low
PrimaryLeak: BoxFitLeak
2-line fix: Add 2 lines of outcome (what happened next). Then one specific lesson sentence.
Best drill: ACTP_B2_DRILLS_01: DRILL_B2_48 Ending with payoff + moral return
PSLE recipe: BoxFitLeak → expand outcome then lesson

EG20 — Student tries sarcasm/irony (ambiguous tone)

Signature: AbstractRisk/ambiguity↑, confusion risk, tone mismatch for PSLE
PrimaryLeak: PersonaLeak
2-line fix: Remove sarcasm. Replace with clear contrast flip + plain return truth.
Best drill: ACTP_B4_DRILLS_01: DRILL_B4_03 Irony Fence (adapt: ban irony for PSLE)
PSLE recipe: OverloadLeak/PersonaLeak → simplify tone; anchor meaning

Teacher One-Line Operating Rule

Fix ONE leak in ONE paragraph. Re-test. Promote only after Safety stays green.

ACTP_14 — Teacher Control Panel (PSLE)

Checklists · Weekly Pacing · Cohort Thresholds · Parent Templates (EducationOS Control Tower style) — v0.1

0) Operating Law (Teacher One-Liner)

One spark per paragraph. RETURN immediately. Fix ONE leak in ONE paragraph. Re-test.

1) Teacher Daily Session Script (60–75 min)

			
SESSION_FLOW_PSLE_01:
  0–5m  Warm-up (OperatorLock): 4 short sentences (≤12 words each)
  5–15m Plan (5-Box): B1..B5 bullets + pick theme + pick picture set
  15–25m Corridor Pair Build: P1..P5 SPARK+RETURN (P5 optional)
  25–55m Draft writing: P1..P5 using blueprints
  55–62m ParaScore: C/R/BoxFit/OneSpark (0–2 each)
  62–75m Rewrite Loop: rewrite ONLY weakest paragraph + quick re-score

		

Non-negotiables

Corridor lines per paragraph: ≤1
After SPARK: RETURN within ≤1 sentence
Metaphors: ≤1 per paragraph (prefer 0–1 total)

2) Teacher Checklists (Print + clip)

2.1 Pre-writing Gate (Corridor Safety Gate)

			
GATE_CORRIDOR_PSLE_01:
  For each paragraph P1..P5:
    [ ] Anchor noun present (wallet/teacher/corridor/etc.)
    [ ] SPARK clear in 2 seconds
    [ ] RETURN exists immediately after
    [ ] Only 1 device (no stacking)
    [ ] No abstract philosophy / sarcasm / irony
  If any FAIL:
    -> apply FENCE_REPAIR (cut / add noun / add RETURN / switch to G4)

		

2.2 Post-writing Gate (Paragraph Role Gate)

			
GATE_ROLE_PSLE_01:
  P1 = Setup + HookPair + Normal day
  P2 = Trigger + stakes + problem stated plainly
  P3 = Worse + pressure + "I had to decide..."
  P4 = Action steps + consequence
  P5 = Outcome + specific lesson (non-cliché)
  If mismatch:
    -> PrimaryLeak = BoxFitLeak (rewrite that paragraph only)

		

2.3 Final 30-second Student Checklist (before submitting)

			
STUDENT_CHECK_PSLE_30S:
  [ ] 1 spark per paragraph max
  [ ] RETURN after spark
  [ ] Each paragraph matches its role
  [ ] Ending has specific lesson
  [ ] No confusing long sentences

		

3) Weekly Pacing (12 Weeks, aligned to your 4-phase protocol)

Phase 1 — Depth Building (Weeks 1–3)

			
W1: G4 body-detail emotions + RETURNS (daily 5 pairs)
W2: G1 specificity punches + RETURNS (daily 5 pairs)
W3: G2 contrast flips + RETURNS (daily 5 pairs)
Output target: 45 corridor pairs banked + 3 mini-paragraphs

Phase 2 — Structure & Planning (Weeks 4–6)

			
W4: 5-Box planning (1 plan/day) + Hook Pair (2 options/day)
W5: Paragraph role drills (write only P1/P2/P3 on different days)
W6: Full 5 paragraphs untimed + rewrite weakest paragraph each time
Output target: BoxFit ≥ 90% + stable one-spark discipline

Phase 3 — Load Training (Weeks 7–9)

			
W7: Timed 35–40 min drafts (2 per week) + rewrite weakest paragraph
W8: Timed 40–45 min drafts (2 per week) + clarity tightening
W9: Mixed themes + “Overload Reset” practice (truncate devices)
Output target: OverloadFlag=0 in final scripts; clarity stable under time

Phase 4 — Transfer & Exam Application (Weeks 10–12)

			
W10: Full Paper 1 simulation weekly + teacher marking + 1 paragraph repair
W11: Full simulation weekly + independent self-audit tags (ANCHOR/RETURN)
W12: Final 2 simulations + individualized leak patch week
Output target: consistent performance across unfamiliar prompts

4) Cohort Thresholds (FenceOS at Class Level)

			
COHORT_FENCE_PSLE_01:
  Metrics (weekly):
    OverloadRate = % students with 2+ overload events per draft
    MeanClarity = avg C score (ParaScore averaged)
    MeanBoxFit = avg BoxFit score
  RED if:
    OverloadRate > 0.10 OR MeanClarity < 1.5 OR MeanBoxFit < 1.6
  AMBER if:
    OverloadRate 0.05–0.10 OR MeanClarity 1.5–1.7
  GREEN if:
    OverloadRate < 0.05 AND MeanClarity ≥ 1.7 AND MeanBoxFit ≥ 1.7

		

Cohort actions

RED: “Operator+Oracle week” (ban G3/G5; only G1/G2/G4; mandatory RETURN)
AMBER: allow 1 corridor line only + strict gate before writing
GREEN: allow controlled G6 rhythm in P4; promote only after 2 clean weeks

5) Student Control Card (1 page per student)

			
STUDENT_CONTROL_CARD_PSLE_01:
  StudentID:
  Band: B2 (PSLE)
  Baseline:
    WeakestLeak: {Clarity|Landing|BoxFit|Overload|Boredom}
    BaselineC (avg): __
    BaselineR (avg): __
  CurrentWeekFocus (ONE):
    DrillPrescription: <one drill from ACTP_02>
  Weekly Targets:
    OverloadEvents <= 0
    BoxFit >= 8/10 paragraphs
    WeakestParagraph improved by +2 points after rewrite
  Notes (teacher):
    - 1 strength
    - 1 rule to remember

		

6) Rapid Diagnosis Router (Teacher version)

			
DIAGNOSE_ROUTER_PSLE_01:
  If RETURN missing -> LandingLeak -> add RETURN now
  Else if paragraph role wrong -> BoxFitLeak -> rewrite that paragraph role
  Else if long messy sentences -> ClarityLeak -> OperatorLock rewrite
  Else if too many devices -> OverloadLeak -> truncate to 1 device
  Else if bland but clear -> BoredomLeak -> add 1 G1 specificity + RETURN

		

7) Parent Message Templates (WhatsApp-style, short)

7.1 Progress Update (neutral, clear)

Template A — Weekly

“This week we focused on [ONE skill] (e.g., ‘one spark + return’).
[Child] is improving in [strength]. The main next step is [one leak].
Home task (10 mins/day): [one drill] for 5 days. I’ll re-test next lesson.”

7.2 Concern / Intervention (calm, non-alarming)

Template B — Fix plan

“I noticed a consistent issue: [leak] (e.g., unclear sentences / missing return / wrong paragraph role).
We are not fixing everything—only one paragraph each time using a rewrite loop.
Plan for next 7 days: [drill prescription] + 1 timed paragraph on Day 7.
This usually stabilises quickly once the habit locks.”

7.3 Praise + Next Step (motivating, specific)

Template C — Win + one rule

“Good improvement today: [specific win] (e.g., clearer P3 choice pressure / better hook pair).
One rule to keep: [one rule] (‘RETURN after the spark’ / ‘one spark only’).
Next target: [single focus].”

7.4 Exam Countdown (Week 10–12)

Template D — Simulation routine

“From this week, we run weekly Paper 1 simulations. After each, we rewrite only the weakest paragraph.
This builds stable performance under time.”

8) Teacher Marking Shortcut (2 minutes per script)

			
MARK_FAST_PSLE_01:
  Step1: ParaScore each paragraph (C,R,BoxFit,OneSpark) 0–2
  Step2: Pick WeakestParagraph (lowest sum)
  Step3: Choose ONE PrimaryLeak using router
  Step4: Apply repair recipe + rewrite only that paragraph
  Step5: Re-score that paragraph only

		

9) Optional LLM Helper Prompts (Teacher use)

9.1 Auto ParaScore + weakest paragraph

			
PROMPT_FAST_SCORE:
Input P1..P5
Output:
- ParaScore table (C,R,BoxFit,OneSpark)
- WeakestParagraph
- PrimaryLeak (one)
- One repair recipe
Rules: strict, exam-safe, do not rewrite full essay.

		

9.2 Rewrite only one paragraph

Use PROMPT_REWRITE_ONE_PARA_01 from ACTP_10 (keeps corridor lines unchanged).

10) “No Personality References” Public Framing

Call it:

“Corridor-line writing”
“One spark + return”
“Paragraph role compiler”
“Weakest-paragraph rewrite loop”
“Fence rules for clarity”

No need to mention any public figures.

ACTP_16 — Secondary 1–2 Control Tower (WordPress-Ready)

Voice Lock · Spike→Stitch Timing · Quoteability · Safe Architect English (AVOO × FenceOS) — v0.1

Recommended WP Slug: educationos-sec12-writing-control-tower-voice-lock-spike-stitch-actp-v0-1
Category: EducationOS → Secondary English → Writing / Narrative / Argument
Tags: Sec 1, Sec 2, writing, voice, style, quoteability, AVOO, FenceOS, closed-loop repair

SECTION A — Definition Lock

TERM: Voice Lock

VoiceLock = consistent narrator tone + consistent sentence rhythm + consistent emotional distance.
If voice changes unintentionally, coherence collapses.

TERM: Spike→Stitch

Spike = novelty injection (ArchitectMove)
Stitch = immediate meaning landing (OracleMove)
Rule: Every spike must be stitched within ≤ 1 sentence.

TERM: Corridor Line (Secondary)

Still: SPARK + STITCH
But STITCH can be:
RETURN (plain truth), or
PAYOFF (insight), or
ANCHOR+CAUSE (explicit meaning lock)

TERM: Quoteability

A line that is repeatable + memorable without being confusing or cringe.

SECTION B — Secondary Operating Envelope (LOCK)

			
ID: SEC12_ENVELOPE_V0_1
ρ_target: [0.45, 0.75]   (more novelty allowed than PSLE)
C_min (clarity): 0.78
R_min (landing): 0.75
CorridorLinesPerParagraphMax: 2  (but only if each is stitched immediately)
ReturnAfterSpike: required within 1 sentence
MaxMetaphorsPerParagraph: 1 (default), 2 (advanced only)
Irony: allowed ONLY with explicit anchor + return (Irony Fence)
Forbidden: ambiguity games, sarcasm without anchor, multi-device stacking chains
Preferred Devices: Specificity, Contrast, Rhythm, Controlled Hyperbole, Controlled Personification

		

Teacher one-liner:
Lock voice. Spike once. Stitch immediately. Fix ONE leak in ONE paragraph.

SECTION C — AVOO Roles in Secondary Writing (What we train)

			
ID: AVOO_SEC12_MAP_01
Operator: sentence control (short clauses, sequencing, transitions)
Oracle: meaning landing (anchor, return, payoff, cause→effect clarity)
Visionary: reframing (theme, perspective shift, moral precision)
Architect: corridor generation (novel pairings, rhythm, contrast, imagery)
Goal: Architect novelty WITHOUT breaking Operator/Oracle stability.

		

SECTION D — The Sec 1–2 Paragraph Compiler (Role Blueprints)

D1) Narrative paragraph types

			
ID: NARRATIVE_PARA_TYPES_01
P_Setup: scene anchor + voice lock + 1 corridor line max
P_Pressure: complications + choice pressure + spike→stitch
P_Action: step-by-step actions + rhythm triplet (optional)
P_Reflection: payoff line + anchored lesson (no clichés)

		

D2) Argument / Response paragraph types

			
ID: ARG_PARA_TYPES_01
P_Claim: claim + 1 concrete image OR contrast + stitch
P_Reason: cause→effect chain + anchor
P_Evidence: specific example + return
P_Counter: fair counter + stitched rebuttal
P_Conclusion: one quoteable line + plain thesis return

		

SECTION E — Secondary Device Library (Safe Corridor Moves)

E0) Device stacking rule

Max 1 device per spike line.
If a student stacks devices → FenceTrip.

E1) Devices (secondary safe set)

			
ID: SEC12_DEVICES_01
D1 Specificity Punch: replace abstract adjective with concrete image/detail
D2 Contrast Flip: "It wasn’t X; it was Y." + meaning lock
D3 Controlled Hyperbole: exaggerate once + immediate truth stitch
D4 Rhythm Triplet: short–long–short for emphasis (anchored)
D5 Controlled Personification: mature, minimal, anchored
D6 Mechanism Lock: "Because ___, therefore ___." (Oracle landing)
D7 Irony Fence: irony line + explicit anchor + return (advanced only)

		

E2) Spike→Stitch templates (copy/paste)

			
ID: SPIKE_STITCH_TEMPLATES_01
T1 (Contrast):
  SPARK: It wasn’t <X>; it was <Y>.
  STITCH: That’s why <plain consequence>.
T2 (Specificity):
  SPARK: The <noun> had <concrete detail>.
  STITCH: It made me realise <plain truth>.
T3 (Hyperbole):
  SPARK: My <body> felt like <simple exaggeration>.
  STITCH: I was <plain emotion>.
T4 (Rhythm):
  SPARK: <short>. <anchored long>. <short>.
  STITCH: <plain meaning>.
T5 (Irony Fence):
  SPARK: I smiled—because pretending is easier than explaining.
  STITCH: But the truth was <explicit anchor + plain truth>.

		

SECTION F — Assessment (Fast Marking Sheet, Secondary)

			
ID: MARKSHEET_SEC12_01   (0–4 each)
C_Clarity
R_Landing (spike stitched within 1 sentence)
V_VoiceLock (consistent tone/rhythm)
N_NoveltyControl (not bland, not chaotic)
Q_Quoteability (memorable + repeatable)
S_Safety (no overload / cringe / ambiguity traps)
BoxFit (paragraph does its job)
PASS (default):
  C>=3, R>=3, V>=3, S>=3, BoxFit>=3

		

SECTION G — The Closed-Loop Repair Engine (One Leak Only)

			
ID: REPAIR_LOOP_SEC12_01
Step1: Score paragraph with MARKSHEET_SEC12_01
Step2: Pick WeakestParagraph (lowest total)
Step3: Choose ONE PrimaryLeak:
  {ClarityLeak | LandingLeak | VoiceLeak | OverloadLeak | BoredomLeak | QuoteabilityLeak}
Step4: Apply ONE drill prescription (below) for 7 days
Step5: Re-test with same prompt type
Rule: Do not fix multiple leaks at once.

		

SECTION H — Drill Packs (Secondary 1–2)

H1) Operator Pack (Clarity)

			
ID: DRILLS_OP_SEC12_01
OP1 Cadence Cut: rewrite long sentence into 2–3 short sentences
OP2 Anchor First: first noun must appear in sentence 1
OP3 Sequence Lock: add time/logic connectors (then / however / because)

H2) Oracle Pack (Landing)

			
ID: DRILLS_OR_SEC12_01
OR1 Stitch Within 1: 10 spikes, each stitched in the next sentence
OR2 Mechanism Lock: write 10 "because→therefore" chains
OR3 Payoff Line: add 1 insight line that explains why the scene matters

H3) Architect Pack (Novelty, safely)

			
ID: DRILLS_ARC_SEC12_01
A1 Specificity Upgrade: replace 10 generic adjectives with concrete images
A2 Contrast Bank: 10 contrast flips + stitches
A3 Rhythm Triplets: 10 short–long–short triplets + stitches
A4 Controlled Hyperbole: 6 hyperbole lines + truth stitches (no drama)

		

H4) Voice Lock Pack

			
ID: DRILLS_VOICE_SEC12_01
V1 Same Scene, Same Voice: 8 lines; voice cannot drift
V2 Two Voices, Same Facts: write funny vs serious; facts unchanged
V3 Voice Under Pressure: keep voice stable during conflict paragraph

H5) Quoteability Pack

			
ID: DRILLS_QUOTE_SEC12_01
Q1 One Quote Line: write 5 candidates; pick best 1; justify why
Q2 Memorability Test: peer chooses which line they remember after 10 seconds
Q3 Quote with Anchor: every quoteable line must include a concrete noun

SECTION I — 12-Week Secondary Pacing (Sec 1–2)

			
ID: PACING_SEC12_12W_01
Weeks 1–2 (Stability First):
  VoiceLock drills + Operator cadence + Anchor-first sentences
Weeks 3–4 (Landing Mastery):
  Spike→Stitch within 1 sentence + Mechanism locks
Weeks 5–7 (Architect Controlled):
  Specificity + contrast + rhythm triplets; 1 corridor line per paragraph
Weeks 8–9 (Quoteability + Persona Fit):
  Quoteability drills; cringe minimization; controlled hyperbole
Weeks 10–12 (Transfer Under Load):
  Timed tasks (narrative + response); rewrite weakest paragraph each time
Targets by Week 12:
  Safety stable (S>=3), Voice stable (V>=3), Landing stable (R>=3),
  and at least 2 quoteable lines per full piece without clarity loss.

		

SECTION J — Secondary Prompt Bank (Minimal, Ready to Run)

Narrative prompts (Sec 1–2)

“A misunderstanding that changed my view of someone.”
“A decision under pressure.”
“A time I defended what was right.”
“A moment I wanted to hide the truth.”
“The quietest moment in a noisy place.”

Argument / response prompts

“Is pressure helpful or harmful for students?”
“What makes a good friend?”
“Should mistakes be punished or used for learning?”
“Is honesty always the best policy?”
“What is success for a teenager?”

Constraint for all:

Voice lock stated at top (choose: dry / reflective / serious / humorous)
Max 1 metaphor per paragraph (2 only if advanced + stitched)

SECTION K — Secondary Error Gallery (10 High-Frequency Failures)

Voice drift → rewrite 5 lines to match opening tone
Spike not stitched → add immediate stitch sentence
Overloaded imagery → delete devices, keep one
Abstract cleverness → swap to specificity + anchor noun
Irony ambiguity → ban irony, use contrast + return
Run-on sentences → cadence cut
Weak paragraph function → rewrite to match role (claim/evidence/turning)
Quoteability = cringe → make it concrete + believable
Too bland → add one contrast flip + stitch
Too many metaphors → keep one image only + plain truth

SECTION L — Parent Templates (Secondary)

Weekly update:
“Focus this week: [Voice / Landing / Clarity / Quoteability].
Strength: [1 specific]. Next step: [1 leak].
Home (10 mins/day): [one drill] × 5 days. Re-test next lesson.”

When student “tries too hard”:
“We’re keeping the creativity, but fencing it: spike once, stitch immediately. One paragraph fix at a time.”

SECTION M — Why This Recreates the “Corridor Engineering” Effect (Mechanism Only)

You get the same outcome you observed in high-performance communicators, without referencing anyone:

Controlled novelty (Architect)
Immediate landing (Oracle)
Stable delivery (Operator)
Safety guardrails (FenceOS)
Closed-loop repair (EducationOS)

ACTP_17 — Secondary 3–4 Upgrade Pack (WordPress-Ready)

Rhetoric Ladder · Counterargument Stitching · Advanced Irony Fence · Persuasive Voice Control (AVOO × FenceOS) — v0.1

Recommended WP Slug: educationos-sec34-writing-control-tower-rhetoric-counterargument-irony-fence-actp-v0-1
Category: EducationOS → Secondary English → Argumentative / Discursive / Reflective
Tags: Sec 3, Sec 4, rhetoric, argument, counterargument, irony fence, AVOO, FenceOS, closed-loop repair

SECTION A — Definition Lock

TERM: Rhetoric Ladder

RhetoricLadder = Claim → Contrast → Image/Device → Return Truth
Purpose: produce an impactful line without losing meaning.

TERM: Counterargument Stitching

CounterStitch = Steelman → Concede boundary → Reframe mechanism → Return thesis
Goal: opponents feel fairly represented; reader feels clarity.

TERM: Irony Fence (Advanced)

Irony is allowed only when meaning cannot flip.

Must include Anchor noun
Must include Return truth
Must include Intent lock (“What I mean is… / In reality…”)

TERM: Mechanism Lock

A causal chain that cannot drift:

“Because , therefore , which leads to _.”

SECTION B — Sec 3–4 Operating Envelope (LOCK)

			
ID: SEC34_ENVELOPE_V0_1
ρ_target: [0.50, 0.85]
C_min (clarity): 0.75
R_min (landing): 0.72
CorridorLinesPerParagraphMax: 2 (each must be stitched within 1 sentence)
MaxMetaphorsPerParagraph: 2 (default 1; 2 only with strong landing)
Irony: allowed only with Irony Fence (explicit anchor + intent lock + return)
Forbidden: ambiguity games, device stacking chains, abstract philosophy without anchors
Preferred devices: RhetoricLadder, MechanismLock, SpecificityPunch, ContrastFlip, RhythmTriplet

		

Teacher one-liner:
Make a claim. Lock the mechanism. If you spike, stitch. If you joke, fence it.

SECTION C — Sec 3–4 Essay Compiler (Argumentative / Discursive)

C1) Standard 5-paragraph argumentative structure

			
ID: SEC34_ESSAY_COMPILER_01
P1 Intro:
  Hook (optional) + Thesis (explicit) + Scope + Return truth
P2 Argument 1:
  Claim + MechanismLock + Specific evidence + Return
P3 Argument 2:
  Claim + Contrast/Device (optional) + MechanismLock + Return
P4 Counterargument:
  Steelman + Concede boundary + Reframe mechanism + Return thesis
P5 Conclusion:
  Synthesis + Quoteable line (1) + Return thesis (explicit)

		

C2) Discursive variant (balanced)

			
ID: SEC34_DISCURSIVE_COMPILER_01
P1 framing thesis (balanced)
P2 side A (mechanism + evidence)
P3 side B (mechanism + evidence)
P4 synthesis (conditions when A/B holds)
P5 conclusion (clear position + return)

		

SECTION D — Core Device Library (B4 Safe Set)

D1) Rhetoric Ladder templates

			
ID: RHETORIC_LADDER_TEMPLATES_01
L1 (Clean):
  Claim: <thesis fragment>.
  Contrast: Not <weak version>; but <real version>.
  Device/Image: <one concrete anchor image>.
  Return: Therefore, <plain truth>.
L2 (Short ladder):
  SPARK: Not <X>; but <Y>.
  STITCH: That’s why <mechanism consequence>.
L3 (Quote ladder):
  SPARK: <image line with anchor>.
  STITCH: In other words, <plain meaning>.

		

D2) Mechanism Lock templates (Oracle-grade)

			
ID: MECHANISM_LOCK_TEMPLATES_01
M1:
  Because <cause>, students <effect>,
  which leads to <outcome>.
M2:
  When <condition>, <system response>,
  so <result>.
M3 (boundary):
  This works only if <condition>; otherwise <failure mode>.

		

D3) Counterargument Stitch templates

			
ID: COUNTER_STITCH_TEMPLATES_01
CS1:
  Steelman: Some argue <best opposing claim>.
  Concede boundary: They are right when <specific condition>.
  Reframe mechanism: However, because <mechanism>, the main risk is <risk>.
  Return thesis: Therefore, <thesis return>.

		

D4) Irony Fence (Advanced)

			
ID: IRONY_FENCE_TEMPLATES_01
IF1:
  Irony line: "Sure, <ironic surface statement>."
  Intent lock: "What I mean is <explicit meaning>."
  Return: "So in reality, <plain truth with anchor>."
Rules:
  - Anchor noun required
  - No sarcasm without intent lock
  - Only 1 irony fenced sequence per essay (default)

		

SECTION E — Assessment (Fast Mark Sheet, Sec 3–4)

			
ID: MARKSHEET_SEC34_01  (0–4 each)
C_Clarity
R_Landing (spike stitched within 1 sentence; meaning locked)
T_ThesisStrength (explicit, consistent)
M_MechanismLock (cause→effect chain present, not hand-wavy)
E_EvidenceSpecificity (concrete examples, not vague)
X_CounterStitchQuality (steelman + boundary + return)
Q_Quoteability (memorable but clear)
S_Safety (no overload / ambiguity / unfenced irony)
PASS (default):
  C>=3, R>=3, T>=3, M>=3, X>=3, S>=3

		

SECTION F — Closed-Loop Repair Engine (One Leak Only)

			
ID: REPAIR_LOOP_SEC34_01
Step1: Score weakest paragraph (or weakest category) using MARKSHEET_SEC34_01
Step2: Pick ONE PrimaryLeak:
  {ThesisLeak | MechanismLeak | EvidenceLeak | CounterLeak | ClarityLeak | OverloadLeak | IronyLeak | QuoteabilityLeak}
Step3: Apply ONE drill prescription for 7 days
Step4: Re-test with same task type (intro/body/counter/conclusion)
Rule: Fix one leak only; do not “upgrade everything”.

		

SECTION G — Drill Packs (Sec 3–4)

G1) Thesis Lock Pack

			
ID: DRILLS_THESIS_SEC34_01
T1 One-sentence thesis: 10 topics, each ≤ 18 words
T2 Scope lock: add “In schools / in families / in society” boundary sentence
T3 Thesis return: end intro with plain restatement

G2) Mechanism Lock Pack (highest ROI)

			
ID: DRILLS_MECH_SEC34_01
M1 Because→therefore chains (10)
M2 Condition→response→result (10)
M3 Boundary clause: “works only if…, otherwise…” (10)

G3) Evidence Specificity Pack

			
ID: DRILLS_EVID_SEC34_01
E1 Replace vague claims with one concrete example (10)
E2 Add “who/where/what happened” anchor to examples (10)
E3 Trim: remove filler; keep one sharp detail

G4) Counterargument Stitch Pack

			
ID: DRILLS_COUNTER_SEC34_01
C1 Steelman 5 opposing claims fairly (no mocking)
C2 Add boundary concession for each (when it’s true)
C3 Reframe mechanism + return thesis (5)

G5) Rhetoric Ladder Pack (Quoteability with control)

			
ID: DRILLS_LADDER_SEC34_01
L1 Build 10 ladders (Claim→Contrast→Image→Return)
L2 Convert 10 bland sentences into short ladders
L3 Cut: delete one device if meaning weakens

G6) Irony Fence Pack (Advanced, optional)

			
ID: DRILLS_IRONY_SEC34_01
I1 Write 5 fenced irony sequences (IF1)
I2 Remove irony: rewrite same meaning without irony (clarity benchmark)
I3 Rule: if clarity drops, irony is banned for that student

SECTION H — 8-Week Upgrade Pacing (Sec 3–4)

			
ID: PACING_SEC34_8W_01
W1 Thesis lock + intro compiler
W2 Mechanism locks (because→therefore) + body paragraph structure
W3 Evidence specificity (replace vague with concrete)
W4 Rhetoric ladders (quoteability without ambiguity)
W5 Counterargument stitching (steelman + boundary + return)
W6 Timed essay (1/week) + rewrite weakest paragraph only
W7 Timed essay (2/week) + tighten clarity under time
W8 Exam mode: stabilize weakest leak + ban risky devices if needed
Targets:
  MechanismLock>=3, CounterStitch>=3, Safety>=3 consistently

		

SECTION I — Prompt Bank (Sec 3–4)

Argumentative prompts

“Is academic pressure beneficial for teenagers?”
“Should schools reduce homework?”
“Is social media more harmful than helpful?”
“What defines true success?”
“Should failure be celebrated?”

Discursive prompts

“Discuss the impact of technology on learning.”
“Discuss whether competition is necessary.”
“Discuss the role of rules in society.”

Constraints (every task):

Thesis must be explicit in P1
At least 2 mechanism locks across body paragraphs
Counterargument must be stitched (steelman + boundary + return)

SECTION J — Sec 3–4 Error Gallery (12 High-Frequency)

Thesis vague → rewrite thesis as one sentence + scope
Mechanism missing → add because→therefore chain
Evidence vague → add one specific example with anchors
Counterargument is strawman → steelman properly, then return
No boundary concession → add “true when…, but…”
Overloaded rhetoric → cut devices, keep one ladder only
Irony unfenced → reject; either fence or remove
Abstract moralising → convert to concrete anchored claim
Conclusion repeats only → add synthesis + one quoteable line + return
Paragraph function drift → rewrite paragraph to match role
Run-ons under time → cadence cut + anchor first sentence
Quoteability becomes cringe → make it believable + anchored + stitched

SECTION K — Integration Note (Mechanism-only, no personalities)

This is the same “corridor engineering” effect at higher stakes:

Architect: builds ladders + controlled spikes
Oracle: locks mechanism + stitches meaning
Operator: keeps structure + clarity under time
FenceOS: bans overload + ambiguity + unfenced irony
EducationOS: one-leak repair loop → stable improvement

ACTP_18 — Universal AVOO Language Simulator (LLM-Runnable)

Architect → Oracle → Operator → FenceOS Tests → Score Log → One-Leak Repair (Almost-Code) — v0.1

0) Simulator Contract

			
CONTRACT:
1) Architect may inject novelty ONLY within envelope.
2) Oracle must stitch meaning within ≤ 1 sentence after each spike.
3) Operator must preserve clarity + structure under task constraints.
4) FenceOS must reject unsafe output and force truncation/stitching.
5) Only ONE primary leak is repaired per iteration (no multi-fix).

		

1) Envelopes (Pick One)

			
ENVELOPE_PROFILES:
  PSLE:
    ρ_target: [0.40,0.65]
    C_min: 0.82
    R_min: 0.78
    CorridorLinesPerParagraphMax: 1
    ReturnAfterSpike: required within 1 sentence
    MetaphorsPerParagraphMax: 1 (prefer 0)
    Ban: {sarcasm, irony, abstract hooks, device stacking}
  SEC12:
    ρ_target: [0.45,0.75]
    C_min: 0.78
    R_min: 0.75
    CorridorLinesPerParagraphMax: 2 (each stitched)
    Irony: fenced only
    MetaphorsPerParagraphMax: 1 (2 advanced)
  SEC34:
    ρ_target: [0.50,0.85]
    C_min: 0.75
    R_min: 0.72
    CorridorLinesPerParagraphMax: 2 (each stitched)
    Irony: fenced only + intent lock
    Require: mechanism locks + counterargument stitch (for essays)

		

2) Agent Roles (AVOO)

2.1 Architect Agent (A)

Job: produce 1–2 candidate corridor lines (spikes) consistent with theme and task.

Allowed moves (choose one per spike):

SpecificityPunch
ContrastFlip
RhythmTriplet
BoundedHyperbole (PSLE cautious)
MildPersonification (PSLE cautious)
RhetoricLadder (Sec34)

Architect output must include:

SPARK
ANCHOR_NOUN
DEVICE_TYPE

2.2 Oracle Agent (O)

Job: stitch meaning immediately.
Stitch options:

RETURN (plain truth)
PAYOFF (why it matters)
MECHANISM_LOCK (because→therefore chain)
IRONY_FENCE (only in Sec)

Oracle output must include:

STITCH_SENTENCE
MEANING_LOCK (explicit, unambiguous)

2.3 Operator Agent (Op)

Job: assemble full paragraph under constraints:

sentence length control
sequencing connectors
paragraph role compliance (setup/problem/escalation/action/lesson OR claim/mechanism/evidence)

Operator output:

final paragraph text
structure tags (optional): {HOOK, EVENT, STAKE, CHOICE, ACTION, OUTCOME, LESSON}

2.4 FenceOS Evaluator (F)

Job: test and decide:

ACCEPT
REVISE (one fix)
REJECT (re-generate spike)

Triggers:

Missing anchor
Missing stitch
Device stacking
Too abstract / ambiguous
Clarity too low

3) Sensors + Derived Flags (LACE-style)

			
SENSORS:
  S1 NoveltyScore: 0..1
  S2 ClarityScore: 0..1
  S3 LandingScore: 0..1 (stitch quality)
  S6 ConfusionSignal: 0..1
  S7 CringeRisk: 0..1
  S9 AnchorPresent: true/false
  S10 DeviceStackingRisk: low/med/high
  Derived ρ = S1 / max(ε, CapacityProxy)
FLAGS:
  OverloadFlag = (ρ>upper) OR (S2<C_min) OR (S3<R_min) OR (S6>0.55) OR (S7>0.55)
  LandingFail = (S3<R_min) OR (stitch missing)
  AnchorFail = (S9=false)

		

CapacityProxy default:

PSLE: 0.70
Sec12: 0.80
Sec34: 0.85

4) Simulation Loop (One Paragraph)

			
SIM_LOOP_AVOO_01:
Input: TaskSpec + EnvelopeProfile + Theme + Context bullets
Step A: Architect generates 2 candidate spikes (SPARK_A1, SPARK_A2)
Step B: Oracle stitches each candidate (STITCH_O1, STITCH_O2)
Step C: Operator compiles paragraph using chosen spike+stitch
Step D: FenceOS evaluates sensors + flags
  If ACCEPT: return final + log
  If REVISE: apply exactly ONE repair action, re-evaluate once
  If REJECT: go back to Step A (new spike)
Stop: max 2 cycles (avoid over-editing)

		

5) Log Schema (for Dashboard / Research)

			
SIM_LOG_RECORD:
  RunID
  DateTime
  EnvelopeProfile
  TaskType
  Theme
  ContextBullets
  Architect:
    Candidate1 {Device, Anchor, Spark}
    Candidate2 {Device, Anchor, Spark}
  Oracle:
    Candidate1 {StitchType, StitchSentence}
    Candidate2 {StitchType, StitchSentence}
  Operator:
    DraftParagraph
    FinalParagraph
  FenceOS:
    Sensors {S1,S2,S3,S6,S7,S9,S10,ρ}
    Decision {ACCEPT|REVISE|REJECT}
    PrimaryFailure
    RepairAction
  Outcome:
    PrimaryLeak
    Prescription (one drill / one recipe)

		

6) LLM-Runnable Prompts (Copy/Paste)

6.1 Master Prompt — `PROMPT_AVOO_SIM_01`

			
SYSTEM:
You are LANG_SIM_AVOO_FENCE_01. Simulate AVOO agents: Architect, Oracle, Operator, FenceOS.
Follow the envelope rules strictly. Do NOT mention AVOO in the student-facing output.
Return: Final paragraph + full SIM_LOG_RECORD.
USER INPUT:
EnvelopeProfile = {PSLE|SEC12|SEC34}
TaskType = {NarrativeParagraph|PSLENarrativeP1..P5|ArgumentIntro|BodyParagraph|CounterParagraph|Conclusion}
Theme = "<theme>"
ContextBullets = ["...", "...", "..."]  (3–6 bullets)
Optional: RequiredAnchorNouns = ["wallet","teacher"] (if provided, must use at least one)
Optional: WordTarget = 90..140 (paragraph) or 260..360 (PSLE full) — default 120 for paragraph.
OUTPUT FORMAT:
1) FINAL_PARAGRAPH (student-facing)
2) SIM_LOG_RECORD (as structured bullets)
Rules:
- Architect must generate 2 candidate SPARK lines.
- Oracle must stitch each candidate within 1 sentence.
- Operator must compile paragraph to meet task role.
- FenceOS must evaluate; if revise, do ONE repair only.

		

6.2 FenceOS-Only Checker — `PROMPT_FENCE_CHECK_01`

			
SYSTEM:
You are FenceOS. Evaluate the paragraph under the envelope profile.
Output ACCEPT/REVISE/REJECT with one PrimaryFailure and one RepairAction.
USER:
EnvelopeProfile = {PSLE|SEC12|SEC34}
Paragraph = "..."
OUTPUT:
Decision:
PrimaryFailure:
RepairAction:
Sensors (S1,S2,S3,S6,S7,S9,S10,ρ):
One revised sentence (only if REVISE):

		

7) Worked Mini-Demo Outputs (Mechanism Only)

Demo 1 — PSLE P3 Escalation paragraph (one spike only)

Input

Envelope: PSLE
Task: PSLENarrativeP3
Theme: Honesty
Context: found wallet, fear of scolding, choice pressure

Possible Final Paragraph (example)

My thoughts started to race as I stared at the wallet inside my bag. It wasn’t greed; it was fear of being scolded. That’s why I hesitated. If I kept quiet, the owner would panic, but if I spoke up, I might be blamed. The pressure grew with every minute, and I knew I had to decide.

(Here the simulator would log: Device=G2 ContrastFlip, Anchor=wallet/teacher implied, Stitch=RETURN, decision lock included.)

Demo 2 — Sec 1–2 voice paragraph (spike→stitch)

Input

Envelope: SEC12
Task: NarrativeParagraph
Voice: dry humour
Context: late to class, bell rings, teacher watching

Possible Final Paragraph

The clock seemed unusually confident today, ticking like it owned the corridor. I was simply late, and I knew it. I sped up, then slowed down—because running would only make me look guiltier. When the bell rang, my stomach tightened, and I promised myself I’d plan better tomorrow.

Demo 3 — Sec 3–4 argument intro (rhetoric ladder + thesis return)

Input

Envelope: SEC34
Task: ArgumentIntro
Topic: academic pressure

Possible Final Intro

Academic pressure is not the enemy; unmanaged pressure is. When expectations rise without support, students trade understanding for survival—memorising to avoid failure instead of learning to grow. Because this pattern repeats daily, it quietly harms motivation and mental health. Therefore, schools should reduce harmful pressure by changing assessment design and strengthening support systems, not by removing standards.

8) Primary Leak Router (Single Fix Only)

			
PRIMARY_LEAK_ROUTER_AVOO_01:
If AnchorFail -> ClarityLeak -> RepairAction: AddAnchorNoun
Else if LandingFail -> LandingLeak -> RepairAction: AddReturnOrMechanismLock
Else if OverloadFlag -> OverloadLeak -> RepairAction: DeleteExtraDeviceKeepOne
Else if C low but no overload -> ClarityLeak -> RepairAction: CadenceCut
Else if bland -> BoredomLeak -> RepairAction: AddOneContrastOrSpecificity
Else -> QuoteabilityLeak -> RepairAction: AddOneRhythmTripletWithAnchor

		

9) How You Use This (Teacher / Content Builder)

For worksheets: generate 2 candidate corridor sparks, let students pick, then stitch + compile.
For editing: run FenceOS checker; if revise, do one repair only.
For content publishing: this is your “mechanism proof” page: a reproducible simulator that explains the corridor effect without naming anyone.

ACTP_19 — Multi-Paragraph AVOO Simulator (Full PSLE 5-Paragraph Compile)

P1..P5 generation + per-paragraph logs + auto weakest-paragraph rewrite (Almost-Code) — v0.1

0) PSLE Envelope (LOCK)

			
ID: PSLE_ENVELOPE_V0_1
ρ_target: [0.40,0.65]
C_min: 0.82
R_min: 0.78
CorridorLinesPerParagraphMax: 1
ReturnAfterSpark: required within 1 sentence
MaxMetaphorsPerParagraph: 1 (prefer 0)
Forbidden: sarcasm, irony, abstract hooks, device stacking, metaphor chains
Preferred: G1 specificity, G2 contrast, G4 body-detail, H1/H2 hooks, G6 rhythm (P4 only)

		

1) Input Schema — `SIM_INPUT_PSLE_5P_01`

			
SIM_INPUT_PSLE_5P_01:
  Theme: <string>
  WordTarget: 260..360 (default)
  5BoxPlan:
    B1 Setup:
    B2 Problem:
    B3 Escalation:
    B4 Turning:
    B5 Outcome+Lesson:
  Mode:
    A) AUTO_CORRIDOR (simulator generates corridor pairs), OR
    B) PROVIDED_CORRIDOR (student/teacher supplies corridor pairs)
  ProvidedCorridorPairs (optional; required if Mode=B):
    P1 {SPARK, RETURN}
    P2 {SPARK, RETURN}
    P3 {SPARK, RETURN}
    P4 {SPARK, RETURN}
    P5 {SPARK, RETURN} optional
  RequiredAnchorNouns (optional): [..]  // at least one must appear in each paragraph
  Tone: "exam-safe" (locked)

		

2) Paragraph Task Specs (Role Locks)

			
PSLE_TASKS_5P:
  P1 = Setup + HookPair + scene anchors + normal day
  P2 = Trigger + stakes + problem stated plainly
  P3 = Escalation + worse + choice pressure + “I had to decide…”
  P4 = Turning + action steps + consequence
  P5 = Outcome + specific lesson (non-cliché)

		

3) Core Loop (Per Paragraph) — `SIM_LOOP_PSLE_PARA_01`

			
SIM_LOOP_PSLE_PARA_01:
  Input: ParaID (P1..P5), ParaRoleSpec, PlanBox(B1..B5), Envelope
  Step A (Architect):
    Generate 2 candidate SPARK lines (each with Anchor + DeviceType).
    - P1 may generate HOOK (H1/H2).
    - P4 may use G6 rhythm triplet.
  Step B (Oracle):
    Generate STITCH for each candidate (RETURN sentence).
    Must be within ≤1 sentence after SPARK.
  Step C (Operator):
    Compile full paragraph around chosen SPARK+RETURN:
      - enforce paragraph role
      - add anchors + sequencing
      - keep sentence lengths stable
      - end-of-paragraph role lock (e.g., P3 “I had to decide…”)
  Step D (FenceOS):
    Evaluate sensors + flags.
    Decision:
      ACCEPT
      REVISE (one repair only)
      REJECT (regenerate spikes)
    MaxCycles per paragraph = 2

		

4) Essay-Level Checks — `FENCE_CHECK_PSLE_ESSAY_01`

			
FENCE_CHECK_PSLE_ESSAY_01:
  Checks:
    - WordCount within target band
    - RoleCompliance P1..P5 (Pass/Amber/Fail)
    - OneSpark enforcement each paragraph
    - Return enforcement each paragraph
    - Flow continuity (no missing stakes/decision/action/outcome)
  If Fail:
    - do NOT rewrite whole essay
    - send only WeakestParagraph into repair loop

		

5) Weakest Paragraph Finder + Repair (ONE paragraph only)

5.1 ParaScore (0–2 each)

			
PARA_SCORE_PSLE:
  C (clarity)
  R (landing = SPARK+RETURN present + meaningful)
  BoxFit (paragraph role correctness)
  OneSparkOnly (≤1 corridor line)
WeakestParagraph = argmin(C+R+BoxFit+OneSparkOnly)
Tie-break: C then BoxFit

		

5.2 One-Leak Repair Rule

			
REPAIR_LOOP_PSLE_ONEPARA:
  Choose PrimaryLeak ∈ {ClarityLeak, LandingLeak, BoxFitLeak, OverloadLeak, BoredomLeak}
  Apply exactly ONE recipe:
    - ClarityLeak: cadence cut + add anchors
    - LandingLeak: add/strengthen RETURN + payoff
    - BoxFitLeak: rewrite to match role (setup/problem/escalation/turning/lesson)
    - OverloadLeak: delete extra device; keep one; RETURN immediately
    - BoredomLeak: add one G1 specificity + RETURN
  Re-score only that paragraph once.

		

6) Log Schema (Per Paragraph + Whole Essay)

			
SIM_LOG_5P:
  RunID
  Theme
  Mode
  WordTarget
  For each Para P1..P5:
    ArchitectCandidates:
      A1 {Device, Anchor, Spark}
      A2 {Device, Anchor, Spark}
    OracleStitches:
      O1 {Return}
      O2 {Return}
    OperatorDraft:
      DraftParagraph
    FenceOS:
      Sensors {S1,S2,S3,S6,S7,S9,S10,ρ}
      Decision {ACCEPT|REVISE|REJECT}
      PrimaryFailure
      RepairAction (if revise)
    FinalParagraph
    ParaScore {C,R,BoxFit,OneSpark}
  EssaySummary:
    RoleCompliance {P1..P5}
    WordCount
    WeakestParagraphBefore
    PrimaryLeak
    RepairRecipe
    WeakestParagraphAfter (if rewritten)

		

7) LLM-Runnable Master Prompt (Copy/Paste) — `PROMPT_SIM_PSLE_5P_01`

			
SYSTEM:
You are LANG_SIM_AVOO_FENCE_PSLE_5P_01.
Generate a full 5-paragraph PSLE composition using the 5-Box plan.
Simulate AVOO agents per paragraph (Architect→Oracle→Operator→FenceOS).
STRICT RULES:
- One corridor SPARK per paragraph max.
- RETURN must follow immediately after SPARK.
- Keep exam-safe tone. Concrete anchors. No sarcasm/irony.
- After drafting all paragraphs, score each paragraph and rewrite ONLY the weakest paragraph using ONE repair recipe.
Output the final essay + SIM_LOG_5P.
USER:
<<paste SIM_INPUT_PSLE_5P_01 here>>
OUTPUT:
1) FINAL_ESSAY (P1..P5)
2) SIM_LOG_5P (structured bullets)

		

8) Optional Prompt: “Provided Corridor Mode” (keeps SPARK/RETURN exact)

Use when you already have corridor pairs from ACTP_08.

			
SYSTEM:
You are PSLE_CORRIDOR_COMPILER_5P_STRICT.
Compile a 5-paragraph PSLE essay using the PROVIDED corridor pairs.
You MUST keep each SPARK and RETURN EXACTLY unchanged.
Add supporting sentences only.
Then score paragraphs and rewrite ONLY the weakest paragraph (keeping its corridor pair unchanged).
USER:
Theme:
5BoxPlan:
ProvidedCorridorPairs P1..P5:
WordTarget:
OUTPUT:
Final essay + weakest-paragraph before/after + scoring table.

		

9) Mini Demo Input (AUTO_CORRIDOR)

			
Theme: Honesty
WordTarget: 300
5BoxPlan:
  B1 Setup: After school, classroom nearly empty; I pack my bag.
  B2 Problem: I find a wallet with ID inside.
  B3 Escalation: Fear of being blamed/scolded; choice pressure grows.
  B4 Turning: Teacher asks; I speak up and return it.
  B5 Outcome+Lesson: Owner relieved; I learn honesty protects trust.
Mode: AUTO_CORRIDOR
RequiredAnchorNouns: ["wallet","teacher"]

		

Expected behavior (what the simulator will do):

P1 generates hook (H1/H2), stitches with RETURN, then scene anchors
P2 chooses G1 specificity (ID card)
P3 chooses G2 contrast (fear vs greed) and ends with “I had to decide…”
P4 may use G6 rhythm triplet (action emphasis), then clear steps
P5 returns to specific lesson without cliché

ACTP_20 — Sec 3–4 AVOO Essay Simulator (Argumentative / Discursive)

Intro → Body1 → Body2 → Counter → Conclusion + Mechanism Locks + One-Leak Repair (Almost-Code) — v0.1

0) Sec 3–4 Envelope (LOCK)

“`text id=”nvz9f8″
SEC34_ENVELOPE_V0_1
ρ_target: [0.50,0.85]
C_min: 0.75
R_min: 0.72
CorridorLinesPerParagraphMax: 2 (each stitched within 1 sentence)
MetaphorsPerParagraphMax: 2 (default 1)
IronyAllowed: yes ONLY with IronyFence + intent lock
Forbidden: ambiguity games, device stacking chains, abstract claims without anchors
Required: thesis lock + mechanism locks + counterargument stitch

			
---
## 1) Essay Compiler Spec (5 paragraphs)

text id=”d5r5x9″
SEC34_ESSAY_COMPILER_01
P1 Intro:

Hook (optional)
Thesis (explicit)
Scope boundary (context)
Return thesis (plain)
P2 Body 1:
Claim
MechanismLock (because→therefore)
Evidence anchor (specific example)
Return claim
P3 Body 2:
Claim
Contrast / ladder (optional)
MechanismLock
Evidence anchor
Return claim
P4 Counterargument:
Steelman (best opposing view)
Concede boundary (when it’s true)
Reframe mechanism (why main risk still stands)
Return thesis
P5 Conclusion:
Synthesis (tie arguments together)
Quoteable line (1)
Return thesis (explicit)

			
---
## 2) Input Schema — `SIM_INPUT_SEC34_ESSAY_01`

text id=”v5xt4z”
SIM_INPUT_SEC34_ESSAY_01:
PromptQuestion: // e.g., “Is academic pressure beneficial?”
Stance: {FOR|AGAINST|BALANCED}
Thesis: // if missing, simulator generates
Scope: // e.g., “secondary schools”
ArgumentBullets:
Arg1: 3–5 bullets (cause/effect + example)
Arg2: 3–5 bullets
CounterBullets:
Steelman: 2–4 bullets
Boundary: 1–2 bullets (when true)
Reframe: 2–4 bullets (mechanism + risk)
ConclusionBullets:
2–4 bullets (synthesis + action/stance)
Style:
Tone: “exam-safe”
IronyMode: {OFF|FENCED} (default OFF)
WordTarget: 450–650 (default 550)

			
---
## 3) Per-Paragraph AVOO Loop (Same as PSLE, different constraints)

text id=”9zsxyo”
SIM_LOOP_SEC34_PARA_01:
For each paragraph P1..P5:
Architect:
– generates 2 candidate “corridor” lines (device: ladder/contrast/specificity)
Oracle:
– adds mechanism lock or explicit return meaning
Operator:
– compiles paragraph to match role
FenceOS:
– checks clarity + landing + ambiguity + evidence anchors
– decision: ACCEPT / REVISE (one fix) / REJECT (regen)
After P1..P5:
– Score each paragraph
– Pick weakest paragraph
– Rewrite ONLY that paragraph (one leak only)

			
---
## 4) Required Components (FenceOS Hard Requirements)

text id=”5ovd8n”
REQUIREMENTS_SEC34_FENCE:
P1 must contain:
– explicit thesis sentence (cannot be implied)
– scope boundary (at least 1 sentence)
P2 and P3 must each contain:
– 1 mechanism lock (“because…, therefore…”)
– 1 evidence anchor (specific example; not vague)
P4 must contain:
– steelman + boundary concession + return thesis
P5 must contain:
– one quoteable line (anchored)
– explicit thesis return
If any missing:
-> paragraph flagged; likely becomes weakest paragraph for repair

			
---
## 5) Scoring (Per Paragraph) — `PARA_SCORE_SEC34_01`
Each 0–2 (fast) or 0–4 (detailed). Use 0–2 here for the weakest finder.

text id=”e8hc2d”
PARA_SCORE_SEC34_01 (0–2 each):
C Clarity
R Landing (spike stitched; meaning locked)
T Thesis/Claim strength (role-appropriate)
M MechanismLock present & coherent
E Evidence specificity (where required)
X CounterStitch quality (P4 only; else 0 or N/A)
WeakestParagraph = lowest total (role-specific weighting)

			
Role-specific weighting:
* P1 weights `T` higher
* P2/P3 weight `M` and `E` higher
* P4 weights `X` higher
* P5 weights `T` + `R` higher
---
## 6) One-Leak Repair Router (Sec 3–4)

		

text id=”3y2my8″
REPAIR_ROUTER_SEC34_01:
If thesis unclear -> ThesisLeak -> rewrite thesis + scope + return
Else if mechanism missing/weak -> MechanismLeak -> add because→therefore chain
Else if evidence vague -> EvidenceLeak -> insert one concrete anchored example
Else if counter is strawman -> CounterLeak -> steelman + boundary + return thesis
Else if ambiguity/irony unfenced -> IronyLeak -> remove or fence with intent lock
Else if overload -> OverloadLeak -> delete extra device, keep one ladder only
Else -> ClarityLeak -> cadence cut + anchors
Rule: repair ONLY weakest paragraph once

			
---
## 7) Log Schema — `SIM_LOG_SEC34_ESSAY`

text id=”0m7h5u”
SIM_LOG_SEC34_ESSAY:
RunID
PromptQuestion
Stance
Thesis (final)
P1..P5:
ArchitectCandidates (2)
OracleLocks (2)
OperatorDraft
FenceOS Sensors + Decision
FinalParagraph
ParaScore
EssaySummary:
WordCount
RequirementsCheck (Pass/Fail list)
WeakestParagraphBefore
PrimaryLeak
RepairRecipe
WeakestParagraphAfter

			
---
## 8) LLM-Runnable Master Prompt (Copy/Paste) — `PROMPT_SIM_SEC34_ESSAY_01`

text id=”4jz1q9″
SYSTEM:
You are LANG_SIM_AVOO_FENCE_SEC34_ESSAY_01.
Generate a full 5-paragraph Sec 3–4 essay using the provided bullets.
Simulate AVOO agents per paragraph (Architect→Oracle→Operator→FenceOS).
STRICT RULES:

Thesis must be explicit in P1 and returned clearly.
P2 & P3 must each include one because→therefore mechanism lock and one concrete example.
P4 must be steelman + boundary + reframe + return thesis.
P5 must include one quoteable anchored line + explicit thesis return.
If IronyMode=OFF, no irony. If FENCED, use intent lock + anchor.
After drafting, score each paragraph and rewrite ONLY the weakest paragraph using ONE repair recipe.
Output final essay + SIM_LOG_SEC34_ESSAY.

USER:
<>

OUTPUT:
1) FINAL_ESSAY (P1..P5)
2) SIM_LOG_SEC34_ESSAY (structured bullets)

			
---
## 9) Mini Demo Input (Ready to paste)

text id=”u7gm5f”
PromptQuestion: “Is academic pressure beneficial for teenagers?”
Stance: BALANCED
Scope: “secondary schools”
ArgumentBullets:
Arg1:
– Pressure can motivate effort when goals are clear
– Because deadlines exist, students plan time better
– Example: timed practices leading to improved performance
Arg2:
– Excess pressure harms learning and mental health
– Because fear dominates, students memorise to survive, not understand
– Example: burnout before exams; sleep loss reduces performance
CounterBullets:
Steelman:
– Without pressure, students may become complacent
– Competition prepares students for real-world demands
Boundary:
– This is true when support systems and fair assessment exist
Reframe:
– When pressure rises without support, it becomes harmful stress
– Mechanism: chronic stress reduces focus and motivation
ConclusionBullets:

Keep standards but redesign assessment to reduce harmful stress
Increase support and teach study systems
Style:
Tone: exam-safe
IronyMode: OFF
WordTarget: 550
“`

ACTP_21 — Universal Corridor Engineering Simulator

Architect generates corridor · Oracle lands it · Operator deploys it · FenceOS prevents collapse (Any Domain) — v0.1

0) Definition Lock

TERM: Corridor

A corridor move is a controlled, near-boundary combination that:

increases attention / interest / performance fast
stays inside a domain’s safety + clarity envelope

TERM: Corridor Engineering

A repeatable process:

Architect generates corridor candidates (novel, high-leverage)
Oracle lands meaning & constraints (why it works + boundaries)
Operator executes safely (SOP, timing, sequence)
FenceOS blocks overload / risk / ambiguity and triggers truncation + stitching

1) Universal AVOO Roles (Domain-Agnostic)

			
ID: AVOO_UNIVERSAL_01
Architect (A):
  - Generates permutations/corridors: surprising but useful combinations
  - Explores near the boundary to find leverage
Oracle (O):
  - Makes the corridor safe + legible
  - Adds meaning locks: constraints, mechanism, boundary conditions
Operator (Op):
  - Executes consistently under load
  - Turns corridor into a repeatable procedure (SOP)
FenceOS (F):
  - Enforces “do not cross” thresholds
  - Truncates unsafe acceleration, stitches back to safe band

		

2) Domain Envelope Profile (You must define this first)

Every domain has a “safe fascination band”.

			
ID: ENVELOPE_PROFILE_UNIVERSAL_01
EnvelopeProfile:
  NoveltyBudget (ρ): [low..high]   // how much “unorthodox” is tolerable
  RiskBudget (κ): [low..high]      // acceptable risk level
  ClarityMin (C_min): 0..1         // minimum interpretability
  ComplianceMin (L_min): 0..1      // minimum rule/ethics/protocol compliance
  ErrorMax (E_max): 0..1           // maximum acceptable failure probability proxy
  TimeToCoreMin (TTC_min): >0      // minimum safety time buffer before irreversible harm

		

Typical presets (examples)

Clinical (patient safety): low ρ, very low κ, high C_min, high L_min
Engineering safety review: medium ρ, low κ, high C_min, high L_min
Business pitch iteration: higher ρ, medium κ, medium C_min, medium L_min

3) Universal Sensor Pack (Works Everywhere)

			
ID: SENSORS_CORRIDOR_UNIVERSAL_01
S1 NoveltyScore (0..1): how unorthodox the move is
S2 ClarityScore (0..1): how easily others reconstruct meaning
S3 LandingScore (0..1): presence of “meaning lock” (oracle stitch)
S4 RiskScore (0..1): estimated harm / failure risk
S5 ComplianceScore (0..1): ethics/regulatory/protocol adherence
S6 ConfusionSignal (0..1): “wait what?” / misinterpretation risk
S7 Cringe/Mismatch (0..1): mismatch with audience/role expectations
S8 ExecutionLoad (0..1): operator burden under time/complexity
S9 TTC_Buffer (time): time-to-irreversible-consequence buffer
S10 EvidenceSupport (0..1): how well-supported by data/prior art
Derived:
  ρ = S1 / max(ε, CapacityProxy)
  OverloadFlag = (S2<C_min) OR (S6>0.55) OR (S8>0.75)
  RiskFlag = (S4>κ_max) OR (S9<TTC_min)
  ComplianceFlag = (S5<L_min)
  LandingFail = (S3<R_min)

		

4) FenceOS Rules (Universal)

			
ID: FENCE_RULES_UNIVERSAL_01
If RiskFlag or ComplianceFlag:
  - REJECT corridor candidate
  - Replace with Operator-safe baseline
  - (Optional) send back to Architect with tighter constraints
If OverloadFlag or LandingFail:
  - TRUNCATE: reduce novelty (S1 ↓), simplify structure
  - STITCH: Oracle adds explicit anchor + mechanism + boundary
  - RETEST: re-score sensors once (one repair only)
If BoredomFlatline (low novelty but safe):
  - INJECT: allow one mild corridor move
  - REQUIRE: immediate landing (Oracle stitch)

		

5) The Universal Simulation Loop

			
ID: SIM_LOOP_CORRIDOR_UNIVERSAL_01
INPUT:
  Domain
  TaskType
  AudienceType
  ContextBullets (facts/constraints)
  EnvelopeProfile
LOOP:
  Step A (Architect):
    Generate 2 candidate corridor moves:
      Cand1 = {Move, MechanismGuess, Anchor}
      Cand2 = {Move, MechanismGuess, Anchor}
  Step O (Oracle):
    For each candidate:
      - Add MeaningLock:
        * Mechanism: because→therefore (or causal chain)
        * Boundary: works only if…, otherwise…
        * Safety: TTC / risk constraints
      - Produce Landing statement (clear, short)
  Step Op (Operator):
    Compile final action/paragraph/procedure:
      - sequence steps
      - assign responsibilities
      - timebox
      - rollback plan
  Step F (FenceOS):
    Evaluate sensors:
      Decision = ACCEPT / REVISE / REJECT
    If REVISE:
      Apply exactly ONE repair action and re-evaluate once.
    If REJECT:
      pick the other candidate; if both rejected -> baseline SOP.
OUTPUT:
  Final deliverable + SIM_LOG

		

6) SIM_LOG Schema (So you can backtest and train)

			
ID: SIM_LOG_CORRIDOR_UNIVERSAL_01
SIM_LOG:
  RunID
  Domain, TaskType, AudienceType
  EnvelopeProfile
  ArchitectCandidates:
    A1 {Move, Anchor, MechanismGuess}
    A2 {Move, Anchor, MechanismGuess}
  OracleLocks:
    O1 {MechanismLock, BoundaryLock, LandingLine}
    O2 {MechanismLock, BoundaryLock, LandingLine}
  OperatorPlan:
    Steps / Paragraph / SOP
  FenceOS:
    Sensors {S1..S10, ρ, Flags}
    Decision {ACCEPT|REVISE|REJECT}
    PrimaryFailure
    RepairAction (if any)
  Outcome:
    SelectedCandidate
    PrimaryLeak
    One Drill Prescription (training)

		

7) Universal “Corridor Move” Library (Abstract Types)

Use these as cross-domain building blocks (not language-specific):

			
ID: CORRIDOR_MOVE_LIBRARY_01
CM1 Contrast Reframe:
  "Not X; but Y" (shifts attention to real mechanism)
CM2 Unexpected Specificity:
  Replace vague with one concrete measurable detail
CM3 Mechanism Compression:
  Reduce complex system to a short causal chain
CM4 Boundary Highlight:
  Name the exact condition where it breaks
CM5 Safe Exaggeration:
  Make risk vivid, then return to the precise truth
CM6 Rhythm / Timing Control:
  Short-long-short sequencing for emphasis, then landing
CM7 Role Swap:
  Ask what happens if a different role owns the decision (Operator vs Architect)
CM8 Counter-View Steelman:
  Present best opposing view then stitch back to boundary + mechanism

		

8) 3 Worked Examples (No personalities)

Example A — Medicine (patient explanation)

Domain envelope: low novelty, ultra-high clarity, strict compliance.

Architect (corridor): “Your symptom isn’t random—it’s a warning light.”
Oracle stitch: “What I mean: the body shows patterns; we’ll check X and Y because they explain Z.”
Operator deploy: step-by-step plan (tests, safety warnings, follow-up)
FenceOS: blocks anything that increases risk or ambiguity; demands explicit safety instructions.

Outcome: Patient feels engaged, but decisions remain protocol-safe.

Example B — Engineering (design review)

Envelope: medium novelty, low risk, high clarity.

Architect: proposes an unorthodox architecture simplification (CM3 + CM4).
Oracle: mechanism lock + boundary conditions (load limits, failure modes).
Operator: converts into test plan + rollback + acceptance criteria.
FenceOS: rejects if TTC buffer is small or if failure mode is unknown.

Outcome: Novel design, but only deployed through staged verification.

Example C — Business (pitch / strategy)

Envelope: higher novelty, medium risk, clarity must still be decent.

Architect: reframes the market (CM1) + unexpected specificity (CM2).
Oracle: makes the thesis falsifiable (what would prove it wrong).
Operator: execution plan: milestones, KPIs, resources.
FenceOS: prevents “hype collapse” (too abstract, no mechanism, no evidence).

Outcome: Fascinating narrative + measurable plan.

9) Training Pack Blueprint (Universal Architect Packs)

This is how you mass-produce “Architect training packs” for any field.

			
ID: UNIVERSAL_TRAINING_PACK_AVOO_01
Stage 1 (Operator Base):
  - SOP mastery + clarity under load
  - drills: sequencing, constraints, checklists
Stage 2 (Oracle Landing):
  - mechanism locks + boundary locks
  - drills: because→therefore chains, “works only if…” conditions
Stage 3 (Architect Corridors):
  - generate 2 corridor candidates per task
  - drills: CM1..CM8 library
Stage 4 (FenceOS Discipline):
  - learn to reject your own cleverness
  - drills: truncate+stitch; one-fix-only rule
Stage 5 (Transfer Across Zoom):
  - same corridor logic across Z0–Z6 contexts
  - drills: local case → org case → national case mapping

		

10) LLM-Runnable Prompt (Universal)

			
SYSTEM:
You are SIM_CORRIDOR_ENGINEERING_UNIVERSAL_01.
Simulate Architect, Oracle, Operator, and FenceOS.
Follow the provided EnvelopeProfile strictly.
Generate two corridor candidates, land each, deploy one, then run FenceOS checks.
If revise, apply exactly ONE repair action.
USER INPUT:
Domain = "<domain>"
TaskType = "<task>"
AudienceType = "<audience>"
EnvelopeProfile = {NoveltyBudget, RiskBudget, ClarityMin, ComplianceMin, ErrorMax, TTC_min}
ContextBullets = ["...", "...", "..."]  (3–8 bullets)
OUTPUT:
1) FINAL_DELIVERABLE (plan/paragraph/procedure)
2) SIM_LOG (structured)
3) PrimaryLeak + One Drill Prescription (from UNIVERSAL_TRAINING_PACK_AVOO_01)

		

What this gives us (why it matches our earlier idea)

This is the universal mechanism behind the “ridiculous but fascinating” effect—generalized into an engine we can use to create:

Universal Architect packs (doctors / engineers / operators / founders)
Role-separated simulators (A/O/Op/F) that can be run with any LLM
Cross-lane training in your CivOS V2 “Life as Lattice Traversal” framing (Lane × Zoom × Role)

ACTP_22 — Lane×Zoom×Role Wrapper for Universal Corridor Simulator

Place×Lane×Zoom×Role×Type×ID records · Directory-style install into CivOS v2 Runtime (Almost-Code) — v0.1

0) Grammar Lock (Record ID Format)

			
ID_GRAMMAR_LOCK:
  Place×Lane×Zoom×Role×Type×ID
Where:
  Place = ISO-3166 alpha-3 (e.g., SGP, USA) or Place node (CITY:SGP:BTM)
  Lane  = domain lane code (EDU, LANG, MED, ENG, GOV, FIN, etc.)
  Zoom  = Z0..Z6
  Role  = ARCH | VIS | ORA | OPR | FEN | AVOO (bundle) | SYS
  Type  = MOD | NODE | EDGE | EVENT | SENSOR | THRESH | RULE | PACK | DIR
  ID    = stable identifier string (no renaming; version forward)

		

1) Core Contract

			
CONTRACT_CIV2_CORRIDOR_WRAPPER:
  1) Every corridor action must be representable as an EVENT record.
  2) Every EVENT must reference:
       - a Place node
       - a Lane
       - a Zoom
       - a Role sequence (Architect→Oracle→Operator→Fence)
       - an Envelope profile (thresholds)
  3) FenceOS is mandatory:
       - If safety/compliance/risk flags trip, corridor is rejected or truncated+stitched.
  4) One-leak-only repair per iteration:
       - do not “fix everything”; apply exactly one repair action then retest.

		

2) Lane Registry (Minimal, extensible)

			
LANE_REGISTRY_V0_1:
  LANG = Language / Communication
  EDU  = Education / Training
  MED  = Medicine / Clinical care
  ENG  = Engineering / Design / Systems
  GOV  = Governance / Policy / Institutions
  FIN  = Finance / Allocation / Risk
  OPS  = Operations / Execution / Logistics
  SAF  = Safety / Security / Compliance
  BIZ  = Business / Strategy / Sales
  SCI  = Science / Research

		

(Add lanes as new immutable codes; never rename existing codes.)

3) Envelope Profile Objects (Threshold packages)

3.1 Envelope Node (generic)

			
Place:GLOBAL×Lane:SYS×Zoom:Z6×Role:SYS×Type:THRESH×ID:ENV_PROFILE_BASE_01
Contract:
  Defines allowable bands for:
    ρ NoveltyBudget
    κ RiskBudget
    C_min ClarityMin
    L_min ComplianceMin
    E_max ErrorMax
    TTC_min TimeToCoreMin
Fields:
  NoveltyBudget_ρ: [0..1]
  RiskBudget_κ: [0..1]
  ClarityMin_C: 0..1
  ComplianceMin_L: 0..1
  ErrorMax_E: 0..1
  TTC_min: time

		

3.2 Presets (installable)

			
Place:GLOBAL×Lane:SYS×Zoom:Z6×Role:SYS×Type:THRESH×ID:ENV_PSLE_01
Inherits: ENV_PROFILE_BASE_01
ρ: [0.40,0.65]
κ: [0.00,0.10]
C_min: 0.82
L_min: 0.90
E_max: 0.10
TTC_min: high (symbolic; “avoid irreversible confusion”)
Place:GLOBAL×Lane:MED×Zoom:Z6×Role:SYS×Type:THRESH×ID:ENV_CLINICAL_SAFE_01
ρ: [0.15,0.35]
κ: [0.00,0.05]
C_min: 0.90
L_min: 0.98
E_max: 0.02
TTC_min: strict
Place:GLOBAL×Lane:ENG×Zoom:Z6×Role:SYS×Type:THRESH×ID:ENV_ENGINEERING_REVIEW_01
ρ: [0.30,0.60]
κ: [0.00,0.15]
C_min: 0.85
L_min: 0.95
E_max: 0.08
TTC_min: medium/high
Place:GLOBAL×Lane:BIZ×Zoom:Z6×Role:SYS×Type:THRESH×ID:ENV_PITCH_ITERATION_01
ρ: [0.45,0.85]
κ: [0.00,0.35]
C_min: 0.75
L_min: 0.80
E_max: 0.25
TTC_min: medium

		

4) Universal Corridor Simulator Module (wrapped as CivOS node)

			
Place:GLOBAL×Lane:SYS×Zoom:Z6×Role:AVOO×Type:MOD×ID:SIM_CORRIDOR_ENGINEERING_UNIVERSAL_01
Exports:
  - EVENT schema: CORRIDOR_SESSION_EVENT_01
  - SENSOR pack: SENSORS_CORRIDOR_UNIVERSAL_01
  - RULE set: FENCE_RULES_UNIVERSAL_01
  - PACK generator: UNIVERSAL_TRAINING_PACK_AVOO_01

		

5) Role Nodes (AVOO as installable directory)

			
Place:GLOBAL×Lane:SYS×Zoom:Z6×Role:SYS×Type:DIR×ID:DIR_ROLE_AVOO_01
Contains:
  Role:ARCH  (Architect)
  Role:ORA   (Oracle)
  Role:OPR   (Operator)
  Role:FEN   (Fence)
  Role:VIS   (optional Visionary)
Edges:
  ARCH -> ORA -> OPR -> FEN (mandatory execution chain)
  VIS -> ARCH (optional upstream)

		

6) Event Schema (the main runtime object)

6.1 Corridor Session Event (universal)

			
Place:<PLACE>×Lane:<LANE>×Zoom:<Z>×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_01
Fields:
  EventTime:
  TaskType:
  ContextBullets: [..]
  EnvelopeRef: <ENV_PROFILE_ID>
  Candidates:
    A1 {MoveType, Anchor, Proposal}
    A2 {MoveType, Anchor, Proposal}
  OracleLocks:
    O1 {MechanismLock, BoundaryLock, LandingLine}
    O2 {MechanismLock, BoundaryLock, LandingLine}
  OperatorPlan:
    StepsOrParagraphOrSOP:
    RollbackPlan:
    RetestPlan:
  FenceEval:
    Sensors {S1..S10}
    Flags {OverloadFlag, RiskFlag, ComplianceFlag, LandingFail}
    Decision {ACCEPT|REVISE|REJECT}
    PrimaryFailure
    RepairAction (one)
  Outcome:
    SelectedCandidate
    FinalDeliverable
    PrimaryLeak
    PrescriptionRef (one drill/pack)

		

6.2 Zoom applicability (Z0–Z6)

			
ZOOM_BINDINGS_CORRIDOR_SESSION:
  Z0: individual action/utterance/procedure step
  Z1: team / classroom / clinic unit / shop floor SOP
  Z2: org department / school level / hospital ward
  Z3: city / district / network of orgs
  Z4: national sector (education system / healthcare system)
  Z5: country layer (policy envelope / cross-lane coordination)
  Z6: global lane standards / best practices / template registries

		

7) Sensor Pack as CivOS objects (directory form)

			
Place:GLOBAL×Lane:SYS×Zoom:Z6×Role:FEN×Type:SENSOR×ID:SENSORS_CORRIDOR_UNIVERSAL_01
Sensors:
  S1 NoveltyScore
  S2 ClarityScore
  S3 LandingScore
  S4 RiskScore
  S5 ComplianceScore
  S6 ConfusionSignal
  S7 MismatchRisk
  S8 ExecutionLoad
  S9 TTC_Buffer
  S10 EvidenceSupport
Derived:
  ρ = S1 / CapacityProxy
Flags:
  OverloadFlag, RiskFlag, ComplianceFlag, LandingFail

		

8) FenceOS Rule Objects (installable rules)

			
Place:GLOBAL×Lane:SYS×Zoom:Z6×Role:FEN×Type:RULE×ID:FENCE_RULES_CORRIDOR_UNIVERSAL_01
Rules:
  R1 If RiskFlag OR ComplianceFlag -> REJECT -> fallback baseline SOP
  R2 If OverloadFlag OR LandingFail -> TRUNCATE + STITCH -> RETEST once
  R3 If BoredomFlatline -> allow 1 mild corridor move + require stitch
  R4 OneRepairOnly -> apply exactly one RepairAction then stop
RepairActions:
  A1 AddAnchor
  A2 CutLength
  A3 ReplaceAbstractWithConcrete
  A4 DeleteExtraDeviceKeepOne
  A5 AddLandingLine
  A6 SwitchToSafeMove (e.g., Specificity/MechanismLock)

		

9) Failure Mode Trace (mandatory, schematic)

			
FAILURE_TRACE_CORRIDOR_01:
  Missing Oracle landing (S3 low)
    -> Audience confusion / misinterpretation (S6 rises)
    -> Operator executes wrong intent (S8 rises; error)
    -> Risk/compliance breach (S4/S5 trip)
    -> FenceOS triggers late (TTC_buffer too small)
    -> Outcome: irreversible harm / trust loss / system drift
Repair chain:
  Detect LandingFail early
    -> Truncate novelty
    -> Add anchor + mechanism lock
    -> Retest clarity
    -> Deploy only if ACCEPT

		

10) Directory Nodes for Universal Architect Academy (UAA)

10.1 Academy Root

			
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:SYS×Type:DIR×ID:DIR_UAA_AVOO_01
Name: Universal Architect Academy (AVOO)
Contains:
  PACK:UAA_CORE_01
  PACK:UAA_LANE_<LANE>_01 (per lane)
  RULE:UAA_PROMOTION_01

		

10.2 Core Pack (lane-agnostic)

			
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:SYS×Type:PACK×ID:UAA_CORE_01
Stages:
  S1 Operator Base (SOP + clarity)
  S2 Oracle Landing (mechanism + boundaries)
  S3 Architect Corridors (2-candidate generation)
  S4 Fence Discipline (reject your cleverness)
  S5 Transfer across Zoom (Z0→Z6)
Outputs:
  - ability to run CORRIDOR_SESSION_EVENT_01 reliably

		

10.3 Lane Pack Template

			
Place:GLOBAL×Lane:<LANE>×Zoom:Z6×Role:SYS×Type:PACK×ID:UAA_LANE_TEMPLATE_01
Inputs:
  LaneSpecificEnvelopeRef
  LaneSpecificRisks
  LaneSpecificComplianceRules
Drills:
  - corridor move library adapted to lane
  - oracle mechanism locks that match lane physics
  - operator SOP deployment patterns

		

11) ChronoHelmAI integration (scheduler + sequencer)

			
Place:GLOBAL×Lane:SYS×Zoom:Z6×Role:SYS×Type:EDGE×ID:EDGE_CORRIDOR_TO_CHRONOHELM_01
From: SIM_CORRIDOR_ENGINEERING_UNIVERSAL_01
To:   CIVOS_RUNTIME_CHRONOHELMAI_V1_0
Binding:
  - Every CORRIDOR_SESSION_EVENT_01 produces:
      * RetestPlan (time)
      * RollbackPlan (conditions)
      * Promotion/Demotion decision (envelope-based)
ChronoHelmAI Responsibilities:
  - schedule retest windows
  - enforce freeze/sandbox/deploy windows (Operator stability)

		

12) Place install examples (copyable)

12.1 Singapore education corridor session (Z1 classroom)

			
Place:SGP×Lane:EDU×Zoom:Z1×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_2026_02_23_01
EnvelopeRef: ENV_PSLE_01
TaskType: "PSLE Composition Paragraph Repair"
ContextBullets:
  - student paragraph P3 lacks choice pressure
  - clarity acceptable, landing present
Candidates:
  A1 {MoveType:ContrastFlip, Anchor:"teacher", Proposal:"It wasn’t laziness; it was fear of being judged."}
  A2 {MoveType:SpecificityPunch, Anchor:"corridor", Proposal:"The corridor had a line of shoes tapping impatiently."}
OracleLocks:
  O1 {MechanismLock:"Because fear rises, therefore hesitation grows.", BoundaryLock:"works only if RETURN follows", LandingLine:"That’s why I hesitated."}
  O2 {MechanismLock:"Specific detail increases clarity.", BoundaryLock:"one spark only", LandingLine:"I knew time was running out."}
OperatorPlan:
  StepsOrParagraphOrSOP:
    - insert SPARK then RETURN
    - end paragraph with “I had to decide…”
FenceEval:
  Decision: ACCEPT
Outcome:
  SelectedCandidate: A1
  PrimaryLeak: BoxFitLeak
  PrescriptionRef: ACTP_05.REPAIR_RECIPES_PSLE.BoxFitLeak

		

12.2 Engineering design review corridor session (Z2 org)

			
Place:USA×Lane:ENG×Zoom:Z2×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_ENG_REVIEW_01
EnvelopeRef: ENV_ENGINEERING_REVIEW_01
TaskType: "Design simplification proposal"
...

13) Checklist (Install + Use)

			
CHECKLIST_CIV2_CORRIDOR_INSTALL_01:
  [ ] Use Place×Lane×Zoom×Role×Type×ID for every record
  [ ] Create/choose an EnvelopeRef (threshold package)
  [ ] Run AVOO chain: ARCH->ORA->OPR->FEN
  [ ] Log a CORRIDOR_SESSION_EVENT_01
  [ ] Enforce OneRepairOnly
  [ ] If Risk/Compliance flags -> REJECT (no heroics)
  [ ] Schedule retest via ChronoHelmAI

		

14) What you now have (in CivOS v2 terms)

A portable runtime object (CORRIDOR_SESSION_EVENT_01) that works at Z0–Z6
A directory install for AVOO roles + lane packs (Universal Architect Academy)
A FenceOS-governed corridor engine that generalizes the “ridiculous combinations” effect into any domain—safely, repeatably, and machine-readable.

ACTP_23 — UAA Lane Pack: MED (Medicine)

Universal Architect Academy · MED Lane Pack (AVOO × FenceOS) — Directory Install (Almost-Code) — v0.1

0) Lane Purpose (MED)

Use corridor engineering to improve:

patient understanding + adherence (language clarity + engagement)
differential diagnosis quality (hypothesis corridor generation)
workflow efficiency (SOP improvement without safety loss)
team communication under load (handover, escalation, check-backs)

Not for:

unapproved treatments
bypassing protocols
making clinical decisions beyond scope

1) Envelope Profile (MED)

“`text id=”2w3bds”
Place:GLOBAL×Lane:MED×Zoom:Z6×Role:FEN×Type:THRESH×ID:ENV_MED_CLINICAL_SAFE_01
ρ NoveltyBudget: [0.15, 0.35]
κ RiskBudget: [0.00, 0.05]
C_min Clarity: 0.90
L_min Compliance:0.98
E_max Error: 0.02
TTC_min: strict (must preserve safety buffer)
Ban:

treatment suggestions outside protocol
ambiguous language that could be misread as instruction
“clever shortcuts” in safety steps
Allow:
analogy/metaphor ONLY if followed by explicit literal return (Oracle lock)
workflow proposals ONLY if accompanied by risk check + supervisor sign-off

			
---
## 2) Role Directory (MED-specific behaviors)

text id=”8wug0v”
Place:GLOBAL×Lane:MED×Zoom:Z6×Role:SYS×Type:DIR×ID:DIR_MED_AVOO_01

ARCH (Medical Architect):

Generates 2 corridor candidates:
- Explanation corridor (patient understanding)
- Hypothesis corridor (differential framing)
- Workflow corridor (process simplification)
Must include anchor (symptom/test/step) and intended audience

ORA (Medical Oracle):

Adds safety meaning locks:
- “What this means literally is…”
- boundary conditions (“not a diagnosis; requires clinician evaluation”)
- mechanism lock (cause→effect) where appropriate
- red flag lock (“seek urgent care if…”)

OPR (Medical Operator):

Converts into SOP communication:
- structured checklist
- teach-back script
- handover script (SBAR style)
- follow-up schedule

FEN (Medical Fence):

Hard reject if any risk/compliance triggers
Truncate+stitch if clarity drops
Enforce “do not cross” boundaries

			
---
## 3) MED Task Types (What the simulator is allowed to do)

text id=”pyg8dw”
Place:GLOBAL×Lane:MED×Zoom:Z6×Role:SYS×Type:NODE×ID:MED_TASK_TYPES_01
AllowedTaskTypes:
MED_T1 PatientExplanation (condition/process explanation, not diagnosis)
MED_T2 SymptomTriageScript (generic, red-flag oriented, not prescriptive treatment)
MED_T3 DifferentialFraming (clinician-only; hypothesis list format; not final diagnosis)
MED_T4 HandoverCommunication (SBAR scripts; clarity under load)
MED_T5 WorkflowImprovementProposal (process only; requires sign-off)
ForbiddenTaskTypes:
MED_F1 PrescriptiveTreatmentPlan (outside clinician supervision)
MED_F2 DosageInstruction (unless explicitly sourced to clinician order)
MED_F3 High-risk procedural advice

			
---
## 4) Corridor Move Library (MED-specific)
### Allowed move types (low-risk corridors)

text id=”olw1f2″
Place:GLOBAL×Lane:MED×Zoom:Z6×Role:ARCH×Type:PACK×ID:MED_CORRIDOR_MOVES_01
Moves:
M1 ExplanationReframe (CM1):
“Not X; but Y” to correct misconception
M2 UnexpectedSpecificity (CM2):
one concrete sign/symptom detail that clarifies meaning
M3 MechanismCompression (CM3):
short cause→effect chain
M4 BoundaryHighlight (CM4):
explicit “when to worry / when to seek help”
M5 TeachBackPrompt:
ask patient to repeat in their own words (Operator support)
M6 DecisionGating:
split into safe steps: observe → test → escalate
Forbidden moves:

“shortcut” that removes safety steps
humour/irony in safety-critical contexts

			
---
## 5) Oracle Locks (MED safety language)

text id=”srt1p7″
Place:GLOBAL×Lane:MED×Zoom:Z6×Role:ORA×Type:RULE×ID:MED_ORACLE_LOCKS_01
Locks:
L1 LiteralReturnLock:
After any analogy/metaphor, add: “Literally, this means…”
L2 ScopeLock:
“This is general information, not a diagnosis.”
L3 RedFlagLock:
“Seek urgent medical care if .”
L4 MechanismLock:
“Because , therefore .”
L5 UncertaintyLock:
“There are multiple possible causes; a clinician can assess.”

			
---
## 6) Operator SOP Patterns (communication scripts)
### 6.1 Patient explanation script (Teach-back)

text id=”1cgwfy”
Place:GLOBAL×Lane:MED×Zoom:Z6×Role:OPR×Type:PACK×ID:MED_SOP_PATIENT_EXPLAIN_01
Script:
1) One-sentence summary (plain)
2) Mechanism (because→therefore) in 2 sentences
3) What to do next (safe, non-prescriptive): monitor / book appointment / follow up
4) Red flags (seek urgent care if…)
5) Teach-back: “Can you tell me in your own words what you’ll watch for?”
Constraints:

No medication/dosage advice
No diagnosis certainty language

### 6.2 Handover script (SBAR-style)

text id=”u5o3ml”
Place:GLOBAL×Lane:MED×Zoom:Z6×Role:OPR×Type:PACK×ID:MED_SOP_HANDOVER_SBAR_01
S: Situation (what is happening now)
B: Background (relevant history)
A: Assessment (current status / concerns)
R: Recommendation (next steps / what to watch)
Fence:

Must include explicit uncertainty and escalation criteria

			
---
## 7) FenceOS Hard Reject Rules (MED)

text id=”u3l7jh”
Place:GLOBAL×Lane:MED×Zoom:Z6×Role:FEN×Type:RULE×ID:FENCE_MED_HARD_REJECT_01
Reject if:

suggests specific treatment/dosage without clinician order
gives procedural instructions that could cause harm
minimizes red flags or discourages professional care
implies certainty of diagnosis from limited info
Truncate+Stitch if:
analogy without literal return lock
jargon reduces clarity (C_min breach)
ambiguity could be misread as instruction

			
---
## 8) Event Template (MED corridor session)

text id=”g34z8a”
Place:×Lane:MED×Zoom:×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_MED_01
TaskType: MED_T1 | MED_T2 | MED_T3 | MED_T4 | MED_T5
EnvelopeRef: ENV_MED_CLINICAL_SAFE_01
ContextBullets: [..]
Candidates:
A1 {MoveType, Anchor, Proposal}
A2 {MoveType, Anchor, Proposal}
OracleLocksApplied:

L1..L5 list
OperatorPlan:
script/SOP text
FenceEval:
Sensors + Flags + Decision + one RepairAction
Outcome:
Final deliverable + retest plan

			
---
## 9) Worked Example (Safe) — Patient Explanation Corridor (No diagnosis)

text id=”x5y0m7″
Place:GLOBAL×Lane:MED×Zoom:Z0×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_MED_DEMO_01
TaskType: MED_T1 PatientExplanation
ContextBullets:

Patient asks why fever happens
Wants simple explanation and when to seek help
Candidates:
A1 MoveType: MechanismCompression
Anchor: “fever”
Proposal: “Fever isn’t the illness; it’s the body’s alarm system.”
A2 MoveType: ContrastReframe
Anchor: “temperature”
Proposal: “It’s not just ‘being hot’; it’s the immune system raising the set point.”
OracleLocksApplied:
L1 LiteralReturnLock (if analogy used)
L3 RedFlagLock
L2 ScopeLock
OperatorPlan (MED_SOP_PATIENT_EXPLAIN_01):
Summary + mechanism + next steps + red flags + teach-back
FenceEval:
Decision: ACCEPT (low risk, high clarity)
Outcome:
Final explanation script, exam-safe tone, includes red flags and teach-back

			
---
## 10) Training Drills (MED lane)

text id=”1l4tna”
Place:GLOBAL×Lane:MED×Zoom:Z6×Role:SYS×Type:PACK×ID:MED_TRAINING_DRILLS_01
S1 Operator Base:

rewrite explanations into 2-sentence plain summaries
S2 Oracle Landing:
add scope locks + red flag locks to 10 explanations
S3 Architect Corridors:
generate 2 corridor candidates per explanation (M1–M4 only)
S4 Fence Discipline:
practice rejecting unsafe suggestions; replace with safe scripts
S5 Transfer:
adapt same explanation for Z0 patient, Z1 family, Z2 team handover
“`

11) How this becomes “Universal Architect Packs for doctors”

It’s exactly your earlier idea—but fenced:

Doctors learn to communicate at corridor level (high fascination + clarity)
They learn hypothesis framing (clinician-only) with explicit uncertainty locks
They learn workflow improvements with sign-off gates
Safety is enforced by hard reject rules + TTC buffer logic

ACTP_24 — UAA Lane Pack: ENG (Engineering)

Universal Architect Academy · ENG Lane Pack (AVOO × FenceOS) — Directory Install (Almost-Code) — v0.1

0) Lane Purpose (ENG)

Use corridor engineering to improve:

design simplification (reduce parts/interfaces without losing function)
reliability (reduce failure modes, increase safety margin)
performance under constraints (cost/weight/power/latency)
team coordination (clear specs, clean handovers, crisp decisions)
verification speed (better test plans + staged rollout)

Not for:

bypassing safety checks
hiding risk / under-testing
shipping unverified “clever” designs into production

1) Envelope Profile (ENG)

			
Place:GLOBAL×Lane:ENG×Zoom:Z6×Role:FEN×Type:THRESH×ID:ENV_ENG_REVIEW_SAFE_01
ρ NoveltyBudget: [0.30, 0.60]        // allow some unorthodox design
κ RiskBudget:    [0.00, 0.15]        // low risk tolerance for deployment
C_min Clarity:   0.85                // spec must be legible
L_min Compliance:0.95                // safety/standards compliance
E_max Error:     0.08                // failure probability proxy
TTC_min: medium/high                 // must preserve rollback buffer
Allow:
  - novel architectures if testable + bounded
  - simplification proposals with explicit failure analysis
  - staged rollouts with rollback plan
Ban:
  - removing safety interlocks without replacements
  - “ship and pray” deployments
  - ambiguous specs / hand-wavy guarantees

		

2) Role Directory (ENG-specific behaviors)

			
Place:GLOBAL×Lane:ENG×Zoom:Z6×Role:SYS×Type:DIR×ID:DIR_ENG_AVOO_01
ARCH (Engineering Architect):
  - Generates 2 corridor candidates:
    * Architecture corridor (simplify interfaces, reduce coupling)
    * Verification corridor (faster tests with higher signal)
    * Reliability corridor (remove failure modes, add margins)
  - Must state: "what changes", "why it helps", "new risks introduced"
ORA (Engineering Oracle):
  - Adds meaning locks:
    * Mechanism lock (cause→effect)
    * Boundary lock (works only if…, breaks if…)
    * Failure trace (what fails first?)
    * Acceptance criteria (measurable)
    * Kill-switch / rollback conditions
OPR (Engineering Operator):
  - Converts into executable SOP:
    * spec (inputs/outputs/interfaces)
    * implementation plan (staged)
    * test plan (unit→integration→soak)
    * rollout plan (canary/gradual) + rollback
FEN (Engineering Fence):
  - Hard reject if safety/compliance unknown or TTC buffer insufficient
  - Truncate+stitch if too complex/unclear
  - Enforce “no deploy without verification + rollback”

		

3) ENG Task Types (Allowed / Forbidden)

			
Place:GLOBAL×Lane:ENG×Zoom:Z6×Role:SYS×Type:NODE×ID:ENG_TASK_TYPES_01
AllowedTaskTypes:
  ENG_T1 DesignReviewProposal (architecture change + tradeoffs)
  ENG_T2 InterfaceSpecLock (API/ICD + contracts)
  ENG_T3 VerificationPlan (test strategy + acceptance criteria)
  ENG_T4 ReliabilityUpgrade (FMEA-lite + mitigations)
  ENG_T5 PerformanceTuningPlan (measure→change→verify)
  ENG_T6 DeploymentPlan (staged rollout + rollback + monitoring)
ForbiddenTaskTypes:
  ENG_F1 DisableSafetyInterlocks (without approved replacement)
  ENG_F2 UnverifiedProductionChange (no test/rollback)
  ENG_F3 AmbiguousSpec (no measurable acceptance)

		

4) Corridor Move Library (ENG-specific)

			
Place:GLOBAL×Lane:ENG×Zoom:Z6×Role:ARCH×Type:PACK×ID:ENG_CORRIDOR_MOVES_01
Moves:
  M1 CouplingReduction:
    reduce cross-module dependencies; replace with narrow interface
  M2 InterfaceCompression:
    fewer parameters/states; explicit invariants
  M3 FailureModeDeletion:
    remove a failure path by design (not by hope)
  M4 BoundaryHighlight:
    declare operating envelope; “works only if…”
  M5 VerificationAcceleration:
    find higher-signal tests; shift-left validation
  M6 StagedDeployment:
    canary + progressive rollout + rollback gates
  M7 ObservabilityFirst:
    add sensors/logs/alerts before big change
  M8 TradeoffReframe:
    “Not optimizing X; optimizing constraint Y” (cost/latency/safety)
Forbidden moves:
  - complexity increase without clarity/test plan
  - removing redundancy without compensation analysis

		

5) Oracle Locks (ENG safety meaning locks)

			
Place:GLOBAL×Lane:ENG×Zoom:Z6×Role:ORA×Type:RULE×ID:ENG_ORACLE_LOCKS_01
Locks:
  L1 MechanismLock:
    "Because <change>, therefore <measurable effect>."
  L2 BoundaryLock:
    "Works only if <conditions>; breaks if <conditions>."
  L3 FailureTrace:
    "First failure mode likely is <X>; detection is <sensor>; mitigation is <Y>."
  L4 AcceptanceCriteriaLock:
    explicit metrics + thresholds (latency, error rate, load, safety margin)
  L5 RollbackLock:
    "Rollback when <trigger>; recovery steps <…>."
  L6 ResponsibilityLock:
    owner roles for build/test/review/ship (who signs off)

		

6) Operator SOP Patterns (ENG executable templates)

6.1 Design Review Template (1 page)

			
Place:GLOBAL×Lane:ENG×Zoom:Z6×Role:OPR×Type:PACK×ID:ENG_SOP_DESIGN_REVIEW_01
Sections:
  1) Summary (what changes, why)
  2) Current state (diagram/contract)
  3) Proposed state (diagram/contract)
  4) MechanismLock (cause→effect)
  5) BoundaryLock (when it works/breaks)
  6) Risk + FailureTrace
  7) Test plan (unit→integration→soak)
  8) Deployment plan (staged) + RollbackLock
  9) Acceptance criteria (metrics)
  10) Sign-offs (ResponsibilityLock)

		

6.2 Verification Plan Template (shift-left)

			
Place:GLOBAL×Lane:ENG×Zoom:Z6×Role:OPR×Type:PACK×ID:ENG_SOP_VERIFICATION_01
Steps:
  - Define invariants + failure modes
  - Map tests to failure modes (coverage)
  - Add golden tests (high-signal)
  - Add soak / stress tests (time)
  - Define acceptance thresholds
  - Define stop-ship triggers

		

6.3 Deployment Plan Template

			
Place:GLOBAL×Lane:ENG×Zoom:Z6×Role:OPR×Type:PACK×ID:ENG_SOP_DEPLOYMENT_01
Stages:
  S0 Observability enabled
  S1 Canary (small %)
  S2 Ramp (progressive)
  S3 Full deploy
Gates:
  - metrics green at each stage
  - rollback triggers defined before S1

		

7) FenceOS Hard Reject Rules (ENG)

			
Place:GLOBAL×Lane:ENG×Zoom:Z6×Role:FEN×Type:RULE×ID:FENCE_ENG_HARD_REJECT_01
Reject if:
  - no acceptance criteria (metrics undefined)
  - no rollback plan (TTC buffer effectively zero)
  - safety/compliance impact unknown
  - verification plan missing or weak relative to risk
  - proposal increases coupling/complexity without clarity improvements
Truncate+Stitch if:
  - spec unclear (C_min breach): force interface contracts + invariants
  - too many devices (over-architecting): keep one corridor move only
  - risk narrative vague: require FailureTrace + sensors

		

8) Event Template (ENG corridor session)

			
Place:<PLACE>×Lane:ENG×Zoom:<Z>×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_ENG_01
TaskType: ENG_T1..ENG_T6
EnvelopeRef: ENV_ENG_REVIEW_SAFE_01
ContextBullets: [..]
Candidates:
  A1 {MoveType, Anchor, Proposal}
  A2 {MoveType, Anchor, Proposal}
OracleLocksApplied: [L1..L6]
OperatorPlan:
  - spec / steps / tests / deploy / rollback / metrics
FenceEval:
  Sensors + Flags + Decision + one RepairAction
Outcome:
  Final deliverable + retest schedule

		

9) Worked Example (Safe) — Interface Simplification + Staged Rollout

			
Place:GLOBAL×Lane:ENG×Zoom:Z2×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_ENG_DEMO_01
TaskType: ENG_T1 DesignReviewProposal
ContextBullets:
  - system has frequent integration bugs at module boundary
  - too many optional flags cause inconsistent states
  - need reduction in failure rate without slowing delivery
Candidates:
  A1 MoveType: InterfaceCompression
     Anchor: "API contract"
     Proposal: "Reduce options to 3 explicit modes + declare invariants."
  A2 MoveType: CouplingReduction
     Anchor: "dependency graph"
     Proposal: "Move shared logic behind a single service boundary."
OracleLocksApplied:
  - L1 MechanismLock: fewer states -> fewer invalid combos -> fewer bugs
  - L2 BoundaryLock: works only if modes cover all use cases; breaks if hidden flags remain
  - L3 FailureTrace: first failure = legacy clients mismatch; detect via version metrics; mitigate via compatibility layer
  - L4 AcceptanceCriteriaLock: error rate ↓, integration test pass rate ↑, latency change within threshold
  - L5 RollbackLock: rollback if error spikes beyond threshold
OperatorPlan:
  - ENG_SOP_DESIGN_REVIEW_01 + ENG_SOP_DEPLOYMENT_01 (canary->ramp)
FenceEval:
  - Decision: ACCEPT (bounded change + clear tests + rollback)
Outcome:
  - SelectedCandidate: A1

		

10) Training Drills (ENG lane)

			
Place:GLOBAL×Lane:ENG×Zoom:Z6×Role:SYS×Type:PACK×ID:ENG_TRAINING_DRILLS_01
S1 Operator Base:
  - write 1-page specs with explicit invariants + acceptance criteria
S2 Oracle Landing:
  - add boundary locks + failure traces to 10 proposals
S3 Architect Corridors:
  - generate 2 corridor candidates per problem (M1–M8), each with stated new risks
S4 Fence Discipline:
  - reject proposals missing rollback/tests; practice truncating to one move
S5 Transfer Across Zoom:
  - Z0: code change checklist
  - Z1: team SOP (PR template)
  - Z2: department review standards
  - Z3+: cross-org reliability policy template

		

11) What this gives you (UAA ENG pack outcome)

Engineers learn to produce fascinating, high-leverage designs with:
explicit mechanism
boundaries
measurable acceptance criteria
staged rollout + rollback
failure-mode thinking
Which is exactly “corridor engineering” — safely.

ACTP_25 — UAA Lane Pack: GOV (Governance)

Universal Architect Academy · GOV Lane Pack (AVOO × FenceOS) — Directory Install (Almost-Code) — v0.1

0) Lane Purpose (GOV)

Use corridor engineering to improve:

policy design and rollout safety (reduce unintended harm)
institutional coordination (reduce ambiguity, increase compliance)
service delivery effectiveness (clear SOP, measurable outcomes)
legitimacy under load (trust, fairness, transparency)
feedback loops (sensing, adjustment, sunset)

Not for:

bypassing oversight
opaque coercion
rights violations
“move fast and break people”

1) Envelope Profile (GOV)

			
Place:GLOBAL×Lane:GOV×Zoom:Z6×Role:FEN×Type:THRESH×ID:ENV_GOV_LEGIT_SAFE_01
ρ NoveltyBudget: [0.20, 0.50]      // innovation allowed, but must be legible
κ RiskBudget:    [0.00, 0.12]      // low tolerance for irreversible harm
C_min Clarity:   0.88              // policy must be understandable & implementable
L_min Compliance:0.97              // legal/rights/ethics compliance
E_max Error:     0.08              // policy failure proxy (unintended harm)
TTC_min: high                      // require rollback/sunset + safeguards
Hard requirements:
  - legality + rights safeguards
  - auditability + public rationale (appropriate to context)
  - equity/fairness checks
  - staged rollout + sunset clause for high-uncertainty changes
Ban:
  - unfalsifiable policy goals (“make society better” without metrics)
  - unbounded enforcement discretion (no guardrails)
  - hidden coercion / non-auditable mechanisms

		

2) Role Directory (GOV-specific behaviors)

			
Place:GLOBAL×Lane:GOV×Zoom:Z6×Role:SYS×Type:DIR×ID:DIR_GOV_AVOO_01
ARCH (Governance Architect):
  - Generates 2 corridor candidates:
    * Policy corridor (simpler rule with clearer incentives)
    * Implementation corridor (reduce friction + failure points)
    * Oversight corridor (increase auditability with minimal burden)
  - Must state:
    "objective", "mechanism", "who is affected", "risks", "reversibility plan"
ORA (Governance Oracle):
  - Adds legitimacy locks:
    * Rights/Legal lock
    * Boundary lock (where policy applies / does not apply)
    * Mechanism lock (cause→effect)
    * Equity lock (who bears cost vs who benefits)
    * Accountability lock (who owns decision + appeals path)
    * Sunset/Review lock (when it expires or must be reviewed)
OPR (Governance Operator):
  - Converts into executable governance:
    * policy spec (plain language + technical annex)
    * agency SOP + training
    * comms plan (public + internal)
    * measurement plan (KPIs + sensors)
    * escalation/appeals workflow
FEN (Governance Fence):
  - Hard reject if legality/rights/auditability not satisfied
  - Truncate+stitch if ambiguous or over-complex
  - Enforce staged rollout + sunset for uncertain interventions

		

3) GOV Task Types (Allowed / Forbidden)

			
Place:GLOBAL×Lane:GOV×Zoom:Z6×Role:SYS×Type:NODE×ID:GOV_TASK_TYPES_01
AllowedTaskTypes:
  GOV_T1 PolicyDesignProposal (rule + mechanism + metrics)
  GOV_T2 ImplementationPlan (SOP + training + capacity)
  GOV_T3 OversightDesign (audit + appeals + accountability)
  GOV_T4 PublicServiceWorkflow (reduce friction, increase reliability)
  GOV_T5 RiskAssessment (unintended consequences + TTC/rollback)
  GOV_T6 StagedRolloutPlan (pilot → expand → evaluate → adjust)
  GOV_T7 MeasurementPlan (sensors + dashboards + thresholds)
ForbiddenTaskTypes:
  GOV_F1 RightsBypass (no due process / no appeal)
  GOV_F2 OpaqueEnforcement (no audit trail / no accountability)
  GOV_F3 UnboundedDiscretion (rules without guardrails)
  GOV_F4 NoRollbackHighImpact (irreversible change without sunset/review)

		

4) Corridor Move Library (GOV-specific)

			
Place:GLOBAL×Lane:GOV×Zoom:Z6×Role:ARCH×Type:PACK×ID:GOV_CORRIDOR_MOVES_01
Moves:
  M1 RuleSimplification:
    reduce ambiguity; fewer exceptions; clearer eligibility/thresholds
  M2 IncentiveAlignment:
    align incentives so desired behavior emerges without heavy enforcement
  M3 DiscretionBounding:
    turn “case-by-case” into guardrailed decision trees + documented reasons
  M4 FeedbackLoopInsertion:
    add sensors + periodic review; close the loop
  M5 StagedRollout:
    pilot with tight scope; evaluate; expand only if safe
  M6 AppealsPathDesign:
    create a clear appeal channel + response SLA + oversight
  M7 BurdenShiftAudit:
    identify who bears admin burden; reduce friction for weakest parties
  M8 TransparencyByDesign:
    publish rationale + metrics + audit summaries (as appropriate)
  M9 FailureModeDeletion:
    remove a common failure mode (e.g., unclear eligibility, delayed decisions)
Forbidden moves:
  - “enforcement-first” without incentives/clarity
  - secrecy as default in low-security contexts
  - metrics that cannot be measured or audited

		

5) Oracle Locks (Legitimacy + Safety Meaning Locks)

			
Place:GLOBAL×Lane:GOV×Zoom:Z6×Role:ORA×Type:RULE×ID:GOV_ORACLE_LOCKS_01
Locks:
  L1 LegalRightsLock:
    list legal basis + rights safeguards + due process (where relevant)
  L2 BoundaryLock:
    define scope: who/where/when applies; explicit exclusions
  L3 MechanismLock:
    "Because <policy lever>, therefore <behavior/system effect>."
  L4 EquityLock:
    distribution check: who benefits vs who pays; mitigation if skewed
  L5 AccountabilityLock:
    owner + audit trail + reporting + “who can override and why”
  L6 AppealsLock:
    appeal route + timelines + independent review criteria
  L7 SunsetReviewLock:
    sunset date OR mandatory review trigger + exit/rollback plan
  L8 MetricLock:
    3–7 KPIs with thresholds; define what “success” means

		

6) Operator SOP Patterns (GOV executable templates)

6.1 Policy Spec Template (Plain + Technical Annex)

			
Place:GLOBAL×Lane:GOV×Zoom:Z6×Role:OPR×Type:PACK×ID:GOV_SOP_POLICY_SPEC_01
Sections:
  1) Plain-language summary (what changes, why)
  2) Eligibility + scope (BoundaryLock)
  3) Mechanism (MechanismLock)
  4) Implementation steps (who does what)
  5) Appeals + accountability (AppealsLock + AccountabilityLock)
  6) Safeguards (LegalRightsLock + EquityLock)
  7) Metrics (MetricLock)
  8) Sunset/review + rollback (SunsetReviewLock)
  9) Annex: decision tree + edge cases + audit fields

		

6.2 Implementation Plan (Agency Readiness)

			
Place:GLOBAL×Lane:GOV×Zoom:Z6×Role:OPR×Type:PACK×ID:GOV_SOP_IMPLEMENTATION_01
Steps:
  - capacity check (staffing, systems, training)
  - SOP + scripts + decision trees
  - comms plan (public guidance + internal memos)
  - pilot scope + escalation
  - monitoring dashboard + weekly review cadence

		

6.3 Oversight + Appeals Workflow

			
Place:GLOBAL×Lane:GOV×Zoom:Z6×Role:OPR×Type:PACK×ID:GOV_SOP_OVERSIGHT_APPEALS_01
Workflow:
  - decision recorded with reasons (audit trail)
  - citizen/stakeholder appeal submission channel
  - SLA for response
  - escalation path to independent review
  - periodic audit sampling + published summary (as appropriate)
Fence:
  - no enforcement action without recorded basis (where required)

		

7) FenceOS Hard Reject Rules (GOV)

			
Place:GLOBAL×Lane:GOV×Zoom:Z6×Role:FEN×Type:RULE×ID:FENCE_GOV_HARD_REJECT_01
Reject if:
  - legality/rights safeguards unspecified or weak (L1 missing)
  - scope/boundaries undefined (L2 missing) -> risk of arbitrary enforcement
  - no appeals/accountability path (L5/L6 missing)
  - no measurable KPIs (L8 missing)
  - high-impact change has no sunset/review/rollback plan (L7 missing)
Truncate+Stitch if:
  - policy text ambiguous (C_min breach): simplify rule + add decision tree
  - too many exceptions: reduce to one clear standard + limited exemptions
  - burden inequity detected: add mitigation or adjust scope

		

8) Event Template (GOV corridor session)

			
Place:<PLACE>×Lane:GOV×Zoom:<Z>×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_GOV_01
TaskType: GOV_T1..GOV_T7
EnvelopeRef: ENV_GOV_LEGIT_SAFE_01
ContextBullets: [..]
Candidates:
  A1 {MoveType, Anchor, Proposal}
  A2 {MoveType, Anchor, Proposal}
OracleLocksApplied: [L1..L8]
OperatorPlan:
  - policy spec / SOP / rollout / oversight / metrics / rollback
FenceEval:
  Sensors + Flags + Decision + one RepairAction
Outcome:
  Final deliverable + review cadence

		

9) Worked Example (Generic, non-country-specific) — Staged Rollout + Appeals Lock

			
Place:GLOBAL×Lane:GOV×Zoom:Z2×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_GOV_DEMO_01
TaskType: GOV_T1 PolicyDesignProposal
ContextBullets:
  - service delays cause citizen frustration and uneven outcomes
  - frontline discretion varies widely -> fairness concerns
  - goal: reduce delays while preserving rights and auditability
Candidates:
  A1 MoveType: DiscretionBounding
     Anchor: "frontline decisions"
     Proposal: "Replace vague discretion with a decision tree + required reason codes."
  A2 MoveType: FeedbackLoopInsertion
     Anchor: "processing time"
     Proposal: "Add weekly dashboard + thresholds triggering extra staffing and review."
OracleLocksApplied:
  L1 LegalRightsLock: due process + documented reasons where decisions impact people
  L2 BoundaryLock: applies only to service X; excludes emergency exceptions list
  L3 MechanismLock: clearer rules -> fewer inconsistent decisions -> fairness ↑
  L4 EquityLock: check burden on vulnerable applicants; add assisted channel
  L5 AccountabilityLock: agency owner + audit sampling plan
  L6 AppealsLock: appeal within 14 days; response SLA 21 days; independent review
  L7 SunsetReviewLock: 6-month pilot + expansion only if KPIs met; rollback plan
  L8 MetricLock: median processing time, variance across regions, appeal overturn rate
OperatorPlan:
  - GOV_SOP_POLICY_SPEC_01 (plain + annex decision tree)
  - GOV_SOP_IMPLEMENTATION_01 (pilot training + comms)
  - GOV_SOP_OVERSIGHT_APPEALS_01 (audit + appeals)
FenceEval:
  Decision: ACCEPT (bounded scope + measurable KPIs + audit/appeals + sunset)
Outcome:
  SelectedCandidate: A1
  ReviewCadence: weekly dashboard + monthly audit report + 6-month review

		

10) Training Drills (GOV lane)

			
Place:GLOBAL×Lane:GOV×Zoom:Z6×Role:SYS×Type:PACK×ID:GOV_TRAINING_DRILLS_01
S1 Operator Base:
  - rewrite policy into plain language + decision tree (10 cases)
S2 Oracle Landing:
  - add L1..L8 locks to 10 proposals (rights, boundaries, metrics, sunset)
S3 Architect Corridors:
  - generate 2 corridor candidates per problem using M1..M9
S4 Fence Discipline:
  - practice rejecting anything missing appeals/metrics/sunset
S5 Transfer Across Zoom:
  - Z0: frontline script
  - Z1: team SOP + training
  - Z2: department policy + dashboard
  - Z3+: cross-region standard + audit regime

		

11) What this gives you (UAA GOV pack outcome)

“Architect-level” governance thinking becomes:
innovative but bounded
mechanism-locked
auditable
rights-safe
reversible
Exactly the same corridor engineering mechanism—just fenced to governance realities.

ACTP_26 — UAA Lane Pack: BIZ (Business / Strategy)

Universal Architect Academy · BIZ Lane Pack (AVOO × FenceOS) — Directory Install (Almost-Code) — v0.1

0) Lane Purpose (BIZ)

Use corridor engineering to improve:

strategy clarity (what you will do vs not do)
go-to-market focus (who exactly, why now, how you win)
pitch performance (fascination + legibility without exaggeration collapse)
execution reliability (milestones, KPIs, resource plan)
risk control (avoid narrative-driven overreach)

Not for:

misleading claims
non-falsifiable “vision only” strategy
“move fast and break trust” tactics

1) Envelope Profile (BIZ)

			
Place:GLOBAL×Lane:BIZ×Zoom:Z6×Role:FEN×Type:THRESH×ID:ENV_BIZ_PITCH_ITERATION_01
ρ NoveltyBudget: [0.45, 0.85]
κ RiskBudget:    [0.00, 0.35]
C_min Clarity:   0.75
L_min Compliance:0.85
E_max Error:     0.25
TTC_min: medium  // must preserve runway/rollback buffer; avoid irreversible brand damage
Allow:
  - bold reframes if anchored to evidence + clear plan
  - aggressive hypotheses if explicitly testable within timebox
Ban:
  - claims with no mechanism, no evidence, no metric
  - “we will dominate” without constraints/assumptions
  - obscuring risk / hiding uncertainty

		

2) Role Directory (BIZ-specific behaviors)

			
Place:GLOBAL×Lane:BIZ×Zoom:Z6×Role:SYS×Type:DIR×ID:DIR_BIZ_AVOO_01
ARCH (Business Architect):
  - Generates 2 corridor candidates:
    * Market reframe corridor (CM1/CM3)
    * Positioning corridor (why us vs alternatives)
    * Offer packaging corridor (simplify offer → higher conversion)
    * Channel corridor (faster test loop)
  - Must state:
    "who", "pain", "why now", "mechanism", "test plan", "risk"
ORA (Business Oracle):
  - Adds meaning locks:
    * Falsifiability lock (what would prove it wrong)
    * KPI lock (leading indicators)
    * Boundary lock (where it won’t work)
    * Assumption lock (critical assumptions explicit)
    * Ethics/compliance lock (no deception)
    * Unit economics lock (how it can sustain)
OPR (Business Operator):
  - Converts into executable plan:
    * 30/60/90-day milestones
    * experiments + success criteria
    * resource plan (people/time/budget)
    * sales/marketing scripts + funnel steps
    * reporting cadence + dashboard
FEN (Business Fence):
  - Hard reject “hype collapse”: abstract claims without locks
  - Truncate+stitch: simplify story, add metrics, add constraints
  - Enforce rollback / kill-switch for experiments

		

3) BIZ Task Types (Allowed / Forbidden)

			
Place:GLOBAL×Lane:BIZ×Zoom:Z6×Role:SYS×Type:NODE×ID:BIZ_TASK_TYPES_01
AllowedTaskTypes:
  BIZ_T1 PitchNarrative (story + thesis + proof + plan)
  BIZ_T2 StrategyOnePager (positioning + priorities + constraints)
  BIZ_T3 GTMExperimentPlan (hypothesis tests + KPIs)
  BIZ_T4 PricingPackaging (offer structure + constraints)
  BIZ_T5 SalesScript (objection handling + proof points)
  BIZ_T6 GrowthLoopDesign (referral/retention mechanism)
  BIZ_T7 RiskRegister (assumptions + failure modes + mitigations)
ForbiddenTaskTypes:
  BIZ_F1 DeceptiveMarketing (false scarcity / fake claims)
  BIZ_F2 UnfalsifiableStrategy (no metrics, no test, no boundaries)
  BIZ_F3 IrreversibleSpendWithoutSignal (large bet without leading indicators)

		

4) Corridor Move Library (BIZ-specific)

			
Place:GLOBAL×Lane:BIZ×Zoom:Z6×Role:ARCH×Type:PACK×ID:BIZ_CORRIDOR_MOVES_01
Moves:
  M1 MarketReframe (CM1):
    "Not X market; Y problem" — re-define category by pain/mechanism
  M2 UnexpectedSpecificity (CM2):
    one concrete metric/story fragment that makes it real (conversion, cycle time)
  M3 MechanismCompression (CM3):
    causal chain: "Because __, therefore __, leads to __"
  M4 BoundaryHighlight (CM4):
    define non-customers + situations where you lose
  M5 OfferSimplification:
    reduce options; clarify promise; shorten decision time
  M6 ChannelTimebox:
    pick one channel; 2-week experiment; success threshold
  M7 SteelmanAlternatives (CM8):
    best alternative explanation; why you still win
  M8 ProofStack:
    "evidence ladder": observation → pilot data → case study → scalable plan
Forbidden:
  - grandiosity without proof stack
  - channel sprawl (too many experiments at once)

		

5) Oracle Locks (Anti-hype meaning locks)

			
Place:GLOBAL×Lane:BIZ×Zoom:Z6×Role:ORA×Type:RULE×ID:BIZ_ORACLE_LOCKS_01
Locks:
  L1 FalsifiabilityLock:
    "If <metric> doesn’t improve by <threshold> in <time>, we are wrong."
  L2 KPI_Lock:
    define leading metrics (weekly) + lagging metrics (monthly)
  L3 AssumptionLock:
    list top 3 assumptions + how to test them
  L4 BoundaryLock:
    "We are NOT for <X>; we fail when <Y>."
  L5 UnitEconomicsLock:
    CAC/LTV or cost-to-serve constraints; break-even condition
  L6 EvidenceLock:
    attach proof stack (even if small): pilot, interviews, benchmarks
  L7 EthicsComplianceLock:
    no deceptive claims; clear disclaimers where needed
  L8 RollbackKillSwitchLock:
    stop-loss: "Stop experiment if <bad metric> crosses <threshold>."

		

6) Operator SOP Patterns (BIZ execution templates)

6.1 Pitch One-Pager (fast)

			
Place:GLOBAL×Lane:BIZ×Zoom:Z6×Role:OPR×Type:PACK×ID:BIZ_SOP_PITCH_ONEPAGER_01
Sections:
  1) One-sentence thesis (category + promise)
  2) Who (ICP) + pain (one concrete story)
  3) Mechanism (because→therefore)
  4) Why now (timing)
  5) Proof stack (what evidence exists)
  6) GTM plan (first channel + 2 experiments)
  7) KPIs + thresholds (L2)
  8) Risks + assumptions (L3)
  9) Unit economics guardrail (L5)
  10) Ask (what you need) + timeline

		

6.2 30/60/90 Plan (Operator plan)

			
Place:GLOBAL×Lane:BIZ×Zoom:Z6×Role:OPR×Type:PACK×ID:BIZ_SOP_3090_01
30 days:
  - 1 channel test
  - 1 ICP segment
  - 1 minimal offer
60 days:
  - double down on winning signal
  - refine pricing/packaging
  - build repeatable sales script
90 days:
  - scale channel
  - improve retention loop
  - tighten unit economics
Gates:
  - defined KPI thresholds at day 14/30/60/90
  - stop-loss rules (L8)

		

6.3 GTM Experiment Template (single experiment)

			
Place:GLOBAL×Lane:BIZ×Zoom:Z6×Role:OPR×Type:PACK×ID:BIZ_SOP_GTM_EXPERIMENT_01
Fields:
  Hypothesis:
  Channel:
  ICP:
  Offer:
  SuccessMetric (leading):
  Threshold:
  Timebox:
  CostCap:
  StopLoss:
  NextAction if win/lose:

		

7) FenceOS Hard Reject Rules (BIZ)

			
Place:GLOBAL×Lane:BIZ×Zoom:Z6×Role:FEN×Type:RULE×ID:FENCE_BIZ_HARD_REJECT_01
Reject if:
  - no falsifiability lock (L1 missing)
  - no KPIs/thresholds (L2 missing)
  - no assumptions listed (L3 missing)
  - no proof stack or evidence claims (L6 missing)
  - claims imply certainty while evidence absent
  - irreversible spend without leading signal gates (violates TTC buffer)
Truncate+Stitch if:
  - story too abstract: add one concrete metric + one real example (M2)
  - too many channels: reduce to one timeboxed experiment (M6)
  - weak mechanism: add because→therefore chain (M3)
  - hype language: replace with boundary + test plan (L4 + L1)

		

8) Event Template (BIZ corridor session)

			
Place:<PLACE>×Lane:BIZ×Zoom:<Z>×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_BIZ_01
TaskType: BIZ_T1..BIZ_T7
EnvelopeRef: ENV_BIZ_PITCH_ITERATION_01
ContextBullets: [..]
Candidates:
  A1 {MoveType, Anchor, Proposal}
  A2 {MoveType, Anchor, Proposal}
OracleLocksApplied: [L1..L8]
OperatorPlan:
  - onepager / 30-60-90 / experiment cards / scripts
FenceEval:
  Sensors + Flags + Decision + one RepairAction
Outcome:
  Final deliverable + review cadence

		

9) Worked Example (Generic) — Anti-Hype Pitch Corridor

			
Place:GLOBAL×Lane:BIZ×Zoom:Z2×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_BIZ_DEMO_01
TaskType: BIZ_T1 PitchNarrative
ContextBullets:
  - many teams waste hours on manual reporting
  - buyers want faster decisions with fewer tools
  - risk: crowded market; need clear differentiation
Candidates:
  A1 MoveType: MarketReframe
     Anchor: "reporting time"
     Proposal: "Not analytics software; decision latency reduction."
  A2 MoveType: OfferSimplification
     Anchor: "buying decision"
     Proposal: "One outcome-based package with one core KPI."
OracleLocksApplied:
  L1 FalsifiabilityLock: "If decision latency doesn't drop 20% in 30 days, we fail."
  L2 KPI_Lock: weekly: activation, time-to-first-value; monthly: retention
  L3 AssumptionLock: data access, stakeholder adoption, baseline measurement availability
  L4 BoundaryLock: not for teams without stable data pipelines
  L5 UnitEconomicsLock: CAC cap, payback period target
  L6 EvidenceLock: 10 interviews + 2 pilot case studies
  L8 RollbackKillSwitchLock: stop if churn > threshold in pilot
OperatorPlan:
  - BIZ_SOP_PITCH_ONEPAGER_01 + BIZ_SOP_GTM_EXPERIMENT_01 (single channel)
FenceEval:
  Decision: ACCEPT (bold but falsifiable + bounded + measurable)
Outcome:
  SelectedCandidate: A1
  Next: 14-day experiment gate + weekly KPI review

		

10) Training Drills (BIZ lane)

			
Place:GLOBAL×Lane:BIZ×Zoom:Z6×Role:SYS×Type:PACK×ID:BIZ_TRAINING_DRILLS_01
S1 Operator Base:
  - write 10 one-page strategies with explicit priorities + constraints
S2 Oracle Landing:
  - add L1..L8 locks to 10 pitches (falsifiability, KPIs, assumptions, boundaries)
S3 Architect Corridors:
  - generate 2 corridor candidates per market problem using M1..M8
S4 Fence Discipline:
  - practice rejecting hype; rewrite into measurable, bounded plans (one fix only)
S5 Transfer Across Zoom:
  - Z0: sales call script
  - Z1: team GTM SOP
  - Z2: department strategy onepager
  - Z3+: portfolio allocation + stop-loss governance

		

11) What this gives you (UAA BIZ pack outcome)

Students/founders can be “architect-level” in business without becoming hype-driven:
fascination through reframes + specificity
truth via falsifiability + KPIs + assumptions
safety via rollback + stop-loss
execution via 30/60/90 plans

ACTP_27 — UAA Lane Pack: FIN (Finance / Allocation / Risk)

Universal Architect Academy · FIN Lane Pack (AVOO × FenceOS) — Directory Install (Almost-Code) — v0.1

(General education / systems design only — not personal investment advice.)

0) Lane Purpose (FIN)

Use corridor engineering to improve:

capital allocation decisions (clear rules + risk budgets)
portfolio construction discipline (diversification + constraints)
risk control (stop-loss governance, exposure limits)
decision hygiene under uncertainty (anti-narrative bias locks)
reporting and accountability (why we did it, what would reverse it)

Not for:

pumping specific assets
“sure-win” claims
leverage without governance
hiding risk (tail risk / liquidity / correlation)

1) Envelope Profile (FIN)

			
Place:GLOBAL×Lane:FIN×Zoom:Z6×Role:FEN×Type:THRESH×ID:ENV_FIN_RISK_BUDGET_SAFE_01
ρ NoveltyBudget: [0.25, 0.65]      // allow ideas, but never unbounded
κ RiskBudget:    [0.00, 0.20]      // portfolio-level risk cap (context-dependent)
C_min Clarity:   0.88              // decisions must be explainable & auditable
L_min Compliance:0.95              // policy/regulatory/mandate compliance
E_max Error:     0.10              // “blow-up probability” proxy
TTC_min: high                      // must preserve survival buffer (liquidity/exit)
Hard requirements:
  - explicit risk budget (max loss / drawdown / exposure)
  - liquidity/exit constraints (TTC buffer)
  - scenario / stress checks (tail events)
  - stop-loss / de-risk triggers
Ban:
  - thesis with no risk limits
  - narrative-only allocations (no measurable edge)
  - hidden leverage / liquidity traps

		

2) Role Directory (FIN-specific behaviors)

			
Place:GLOBAL×Lane:FIN×Zoom:Z6×Role:SYS×Type:DIR×ID:DIR_FIN_AVOO_01
ARCH (Finance Architect):
  - Generates 2 corridor candidates:
    * Allocation corridor (new weighting / hedge / barbell)
    * Risk corridor (reduce tail exposure / improve convexity)
    * Process corridor (better decision rules / rebalancing)
  - Must state:
    "thesis", "edge source", "risk budget", "what breaks it", "liquidity"
ORA (Finance Oracle):
  - Adds meaning locks:
    * Falsifiability lock (what proves thesis wrong)
    * Risk budget lock (max loss, exposure, drawdown cap)
    * Scenario lock (stress cases)
    * Correlation/Concentration lock (hidden coupling)
    * Liquidity/TTC lock (can we exit before damage?)
    * Governance lock (who can override, why, how recorded)
OPR (Finance Operator):
  - Converts into executable policy:
    * IPS / mandate constraints
    * rebalancing rules
    * position sizing + limits
    * monitoring dashboard + alerts
    * execution checklist (slippage, liquidity, timing)
    * post-mortem template
FEN (Finance Fence):
  - Hard reject if risk budget missing or liquidity unknown
  - Truncate+stitch if complexity hides risk
  - Enforce stop-loss / de-risk triggers and concentration caps

		

3) FIN Task Types (Allowed / Forbidden)

			
Place:GLOBAL×Lane:FIN×Zoom:Z6×Role:SYS×Type:NODE×ID:FIN_TASK_TYPES_01
AllowedTaskTypes:
  FIN_T1 AllocationPolicy (weights + constraints + rebalancing)
  FIN_T2 RiskBudgetDesign (max loss / drawdown / VaR-like proxies)
  FIN_T3 HedgeDesign (when to hedge, how to size, what it protects)
  FIN_T4 StressScenarioPlan (tail events + response playbook)
  FIN_T5 GovernanceRules (stop-loss, escalation, overrides)
  FIN_T6 ReportingDashboardSpec (metrics, triggers, audit)
  FIN_T7 DecisionPostmortem (what we believed, what happened, update rules)
ForbiddenTaskTypes:
  FIN_F1 SpecificAssetPicksAsAdvice (personalized recommendations)
  FIN_F2 UnlimitedLeverageWithoutControls
  FIN_F3 UnboundedIlliquidExposure (no TTC buffer)

		

4) Corridor Move Library (FIN-specific)

			
Place:GLOBAL×Lane:FIN×Zoom:Z6×Role:ARCH×Type:PACK×ID:FIN_CORRIDOR_MOVES_01
Moves:
  M1 RiskBudgetFirst:
    decide risk budget before returns (cap downside first)
  M2 BarbellConstruction:
    combine safe core + small high-upside satellite (bounded)
  M3 ConcentrationAudit:
    reveal hidden concentration via factor/correlation lens
  M4 LiquidityTTCUpgrade:
    increase exit ability; reduce time-to-irreversible-loss
  M5 StopLossGovernance:
    define de-risk triggers (not emotional selling)
  M6 RebalanceDiscipline:
    periodic rule-based rebalance (avoid drift)
  M7 ScenarioSwitching:
    define regime triggers (inflation shock, recession, liquidity crunch)
  M8 EvidenceCompression:
    thesis as measurable signals (not narrative)
Forbidden:
  - “all-in” allocations
  - adding complexity that reduces auditability
  - risk shifting to hidden tail exposures

		

5) Oracle Locks (Anti-narrative + Safety Locks)

			
Place:GLOBAL×Lane:FIN×Zoom:Z6×Role:ORA×Type:RULE×ID:FIN_ORACLE_LOCKS_01
Locks:
  L1 FalsifiabilityLock:
    "If signal <X> fails for <T>, thesis is wrong."
  L2 RiskBudgetLock:
    "Max exposure = __%; max drawdown allowed = __; max loss per position = __."
  L3 LiquidityLock (TTC):
    "Exit within __ days at normal volume without >__% impact."
  L4 CorrelationLock:
    "If correlations rise to __ in stress, treat as concentrated."
  L5 ScenarioLock:
    define 3–5 stress scenarios + expected behavior + action plan
  L6 GovernanceLock:
    who can change rules; override requires written reason + timestamp
  L7 StopLossLock:
    explicit de-risk triggers + staged reduction (not binary panic)
  L8 EvidenceLock:
    data/metrics supporting thesis + what data would contradict it

		

6) Operator SOP Patterns (FIN executable templates)

6.1 Investment Policy Statement / Allocation One-Pager (IPS-lite)

			
Place:GLOBAL×Lane:FIN×Zoom:Z6×Role:OPR×Type:PACK×ID:FIN_SOP_IPS_01
Sections:
  1) Objective (return target optional; risk limits mandatory)
  2) RiskBudgetLock (L2)
  3) Allowed instruments (by category, not specific tickers)
  4) Concentration limits (single position / sector / factor)
  5) Liquidity constraints (L3)
  6) Rebalance rules (schedule + thresholds)
  7) Stop-loss / de-risk triggers (L7)
  8) Scenarios + playbook (L5)
  9) Reporting metrics (weekly/monthly)
  10) Governance (L6) + review cadence

		

6.2 Risk Dashboard Spec

			
Place:GLOBAL×Lane:FIN×Zoom:Z6×Role:OPR×Type:PACK×ID:FIN_SOP_DASHBOARD_01
Metrics:
  - exposure by bucket (core/satellite)
  - concentration (top N share)
  - liquidity score (days-to-exit proxy)
  - drawdown, volatility proxy
  - correlation / factor crowding proxy
  - scenario sensitivity notes
Triggers:
  - breach of exposure caps
  - drawdown threshold crossed
  - liquidity deterioration
  - correlation spike (concentration-in-stress)
Actions:
  - staged de-risk plan (predefined)

		

6.3 Post-Mortem Template (Decision Hygiene)

			
Place:GLOBAL×Lane:FIN×Zoom:Z6×Role:OPR×Type:PACK×ID:FIN_SOP_POSTMORTEM_01
Fields:
  Thesis (1 paragraph)
  Signals used (measurable)
  Risk budget set (numbers)
  What would prove wrong (falsifiers)
  What happened (facts)
  Was loss within expected band?
  Update rule (one change only)

		

7) FenceOS Hard Reject Rules (FIN)

			
Place:GLOBAL×Lane:FIN×Zoom:Z6×Role:FEN×Type:RULE×ID:FENCE_FIN_HARD_REJECT_01
Reject if:
  - risk budget missing (L2 absent)
  - liquidity/TTC unknown or unacceptable (L3 absent)
  - no falsifiability criteria (L1 absent)
  - concentration hidden or unmeasured (L4 absent)
  - no stop-loss/de-risk governance (L7 absent)
  - thesis is narrative only (no EvidenceLock L8)
Truncate+Stitch if:
  - proposal too complex to audit: simplify to one move
  - correlations/hidden coupling not addressed: add CorrelationLock
  - scenario plan missing: add 3 scenarios + actions

		

8) Event Template (FIN corridor session)

			
Place:<PLACE>×Lane:FIN×Zoom:<Z>×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_FIN_01
TaskType: FIN_T1..FIN_T7
EnvelopeRef: ENV_FIN_RISK_BUDGET_SAFE_01
ContextBullets: [..]
Candidates:
  A1 {MoveType, Anchor, Proposal}
  A2 {MoveType, Anchor, Proposal}
OracleLocksApplied: [L1..L8]
OperatorPlan:
  - IPS / dashboard / rebalance / stop-loss / post-mortem
FenceEval:
  Sensors + Flags + Decision + one RepairAction
Outcome:
  Final policy deliverable + review cadence

		

9) Worked Example (Generic) — Risk Budget First + Scenario Locks

			
Place:GLOBAL×Lane:FIN×Zoom:Z2×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_FIN_DEMO_01
TaskType: FIN_T2 RiskBudgetDesign
ContextBullets:
  - portfolio drift increased concentration unintentionally
  - liquidity concerns during stress events
  - goal: maintain survivability while still allowing upside
Candidates:
  A1 MoveType: ConcentrationAudit
     Anchor: "top-5 exposure"
     Proposal: "Set explicit concentration caps + factor stress check."
  A2 MoveType: LiquidityTTCUpgrade
     Anchor: "days-to-exit"
     Proposal: "Increase liquid core allocation and cap illiquid sleeve."
OracleLocksApplied:
  L2 RiskBudgetLock: max drawdown cap + position loss caps
  L3 LiquidityLock: days-to-exit threshold
  L4 CorrelationLock: concentration-in-stress rule
  L5 ScenarioLock: recession, inflation shock, liquidity crunch + actions
  L6 GovernanceLock: overrides require committee sign-off + written reason
  L7 StopLossLock: staged de-risk triggers
OperatorPlan:
  - FIN_SOP_IPS_01 + FIN_SOP_DASHBOARD_01
FenceEval:
  Decision: ACCEPT (bounded, auditable, TTC-safe)
Outcome:
  SelectedCandidate: A2 (with A1 caps added as secondary rule if allowed by one-fix rule in next cycle)

		

(Note: under “one repair only,” you’d implement A2 first, then schedule a later session for A1.)

10) Training Drills (FIN lane)

			
Place:GLOBAL×Lane:FIN×Zoom:Z6×Role:SYS×Type:PACK×ID:FIN_TRAINING_DRILLS_01
S1 Operator Base:
  - write IPS one-pagers with explicit caps (10 exercises)
S2 Oracle Landing:
  - add falsifiers + scenario locks + liquidity locks to 10 theses
S3 Architect Corridors:
  - generate 2 corridor candidates per allocation problem (M1–M8)
S4 Fence Discipline:
  - practice rejecting narrative-only proposals; convert to measurable, bounded policy
S5 Transfer Across Zoom:
  - Z0: trade execution checklist (slippage/liquidity)
  - Z1: team risk dashboard + weekly review
  - Z2: department allocation governance
  - Z3+: institution-wide risk budget policy template

		

11) What this gives you (UAA FIN pack outcome)

Finance “architecting” becomes a discipline:
upside allowed only inside explicit risk budgets
liquidity/TTC treated as first-class safety buffer
scenarios and stop-loss governance prevent blow-ups
decisions become auditable, falsifiable, and improvable

ACTP_28 — UAA Lane Pack: EDU (Education / Training)

Universal Architect Academy · EDU Lane Pack (AVOO × FenceOS) — Directory Install (Almost-Code) — v0.1

0) Lane Purpose (EDU)

Use corridor engineering to improve:

student capability under load (exam stability, retrieval strength)
curriculum design (scope + sequencing that actually transfers)
teaching execution (repeatable, measurable interventions)
safety (prevent P0 collapses: burnout, confusion, false competence)
regeneration (EducationOS as civilisation pipeline)

Not for:

“one-shot hacks” that don’t transfer
uncontrolled novelty that breaks clarity
widening choice at Operator layer (causes shear + confusion)

1) Envelope Profiles (EDU) — Level-specific thresholds

			
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:FEN×Type:THRESH×ID:ENV_EDU_BASE_01
Fields:
  ρ NoveltyBudget: [0..1]
  κ RiskBudget:    [0..1]     // risk of confusion/burnout/backfire
  C_min Clarity:   0..1
  L_min Protocol:  0..1       // adherence to syllabus/rubric/ethics
  E_max Error:     0..1       // failure probability proxy under load
  TTC_min:         time/buffer // time-to-irreversible-collapse buffer
Rules:
  - Corridor must preserve clarity and transfer.
  - OneRepairOnly enforced.
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:FEN×Type:THRESH×ID:ENV_EDU_PRIMARY_01
Inherits: ENV_EDU_BASE_01
ρ: [0.25, 0.55]
κ: [0.00, 0.10]
C_min: 0.88
L_min: 0.95
E_max: 0.10
TTC_min: high (avoid confusion collapse)
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:FEN×Type:THRESH×ID:ENV_EDU_PSLE_ENG_COMP_01
ρ: [0.40, 0.65]
κ: [0.00, 0.10]
C_min: 0.82
L_min: 0.95
E_max: 0.10
TTC_min: high
Note:
  - This maps directly to ACTP (one spark + return).
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:FEN×Type:THRESH×ID:ENV_EDU_SEC12_01
ρ: [0.45, 0.75]
κ: [0.00, 0.15]
C_min: 0.78
L_min: 0.92
E_max: 0.12
TTC_min: medium/high
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:FEN×Type:THRESH×ID:ENV_EDU_SEC34_01
ρ: [0.50, 0.85]
κ: [0.00, 0.18]
C_min: 0.75
L_min: 0.90
E_max: 0.15
TTC_min: medium/high

		

2) Role Directory (EDU-specific behaviors)

			
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:SYS×Type:DIR×ID:DIR_EDU_AVOO_01
ARCH (Education Architect):
  - Generates 2 corridor candidates:
    * Diagnostic corridor (find true leak fast)
    * Curriculum corridor (sequence change that increases transfer)
    * Instruction corridor (one high-leverage drill)
    * Assessment corridor (retest design that detects stability)
  - Must state:
    "skill target", "leak hypothesis", "why this works", "risk", "retest"
ORA (Education Oracle):
  - Adds learning locks:
    * Definition lock (what counts as correct)
    * Mechanism lock (because→therefore in learning terms)
    * Boundary lock (works only if…, fails if…)
    * Transfer lock (how to verify transfer under variation)
    * Load lock (timed/stress conditions)
    * Anti-false-competence lock (proof requirement)
OPR (Education Operator):
  - Converts into SOP:
    * lesson plan steps
    * drill schedule (10-min daily)
    * rubric + marking
    * retest cadence (day 7/day 14)
    * “rewrite weakest paragraph” loop where relevant
FEN (Education Fence):
  - Hard reject if:
      * unclear definitions/rubrics
      * no retest/transfer check
      * overload risk (burnout, confusion)
  - Truncate+stitch:
      * simplify to ONE drill
      * restore clarity and baseline competence

		

3) EDU Task Types (Allowed / Forbidden)

			
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:SYS×Type:NODE×ID:EDU_TASK_TYPES_01
AllowedTaskTypes:
  EDU_T1 RapidDiagnosis (find primary leak)
  EDU_T2 RepairPrescription (one drill only)
  EDU_T3 LessonSOP (repeatable execution plan)
  EDU_T4 AssessmentDesign (retest + transfer test)
  EDU_T5 LoadTrainingPlan (timed stability)
  EDU_T6 CurriculumSequenceProposal (scope/sequence change)
  EDU_T7 CohortControlPanel (dashboard + thresholds)
  EDU_T8 ParentSupportProtocol (low-effort support tools)
ForbiddenTaskTypes:
  EDU_F1 MultiFixEverythingPlan (breaks OneRepairOnly)
  EDU_F2 NoveltyWithoutClarity (no mechanism/definition lock)
  EDU_F3 TrainingWithoutRetest (no verification loop)

		

4) Corridor Move Library (EDU-specific)

			
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:ARCH×Type:PACK×ID:EDU_CORRIDOR_MOVES_01
Moves:
  M1 LeakIsolation:
    identify ONE primary leak (clarity/landing/boxfit/load/retrieval/transfer)
  M2 MinimalIntervention:
    smallest drill that fixes the leak (10–15 min/day)
  M3 TransferProbe:
    design a near-variant test to confirm transfer (not memorization)
  M4 LoadFence:
    add timed/stress constraint only after baseline stability
  M5 RewriteWeakestUnit:
    fix only the weakest paragraph/question-type/unit each cycle
  M6 CorridorTemplateInjection:
    add one safe template (hook pair / contrast / mechanism lock) with landing
  M7 ChoiceReduction:
    reduce options at Operator layer (fewer methods; one correct routine)
  M8 FeedbackLoopInsertion:
    sensors → thresholds → repair → retest cadence (EducationOS closed loop)
Forbidden:
  - expanding method choices before stability
  - adding “style” before clarity/structure
  - stacking multiple drills simultaneously

		

5) Oracle Locks (EducationOS Learning Locks)

			
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:ORA×Type:RULE×ID:EDU_ORACLE_LOCKS_01
Locks:
  L1 DefinitionLock:
    "What counts as correct is ___" (marking criteria)
  L2 MechanismLock:
    "Because skill X is missing, therefore error Y happens."
  L3 BoundaryLock:
    "Works only if prerequisites A/B exist; fails if student lacks ___."
  L4 TransferLock:
    "Proof = success on 3 variants under different surface forms."
  L5 LoadLock:
    "Proof under time = timed performance stays above threshold."
  L6 AntiFalseCompetenceLock:
    "No promotion without retest + spaced recall."
  L7 RetestCadenceLock:
    "Retest day 7 and day 14; keep log."
  L8 OneRepairOnlyLock:
    "Fix only one leak; everything else is frozen."

		

6) Operator SOP Patterns (EDU executable templates)

6.1 Rapid Diagnosis SOP (5–10 min)

			
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:OPR×Type:PACK×ID:EDU_SOP_DIAGNOSE_01
Inputs:
  - 1–2 student scripts/attempts
Steps:
  1) Identify task type (composition / math / comprehension / etc.)
  2) Mark ONLY these sensors:
     - Clarity/definition adherence
     - Structural role adherence (if writing)
     - Retrieval errors (if content)
     - Time collapse (if timed)
  3) Pick ONE primary leak:
     {ClarityLeak | LandingLeak | BoxFitLeak | RetrievalLeak | LoadLeak | TransferLeak | OverloadLeak | BoredomLeak}
Output:
  - PrimaryLeak
  - One drill prescription
  - Retest plan (day 7/day 14)
Rule:
  - Do not prescribe more than one drill.

		

6.2 Repair SOP (7-day micro-cycle)

			
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:OPR×Type:PACK×ID:EDU_SOP_REPAIR_7DAY_01
Plan:
  Day1–3: drill (10–15 min/day) + 1 micro-output
  Day4–6: drill + 1 near-variant transfer probe
  Day7: retest (same type as baseline)
Outputs:
  - before/after score
  - promote or repeat (OneRepairOnly)

		

6.3 Assessment + Transfer Test SOP

			
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:OPR×Type:PACK×ID:EDU_SOP_TRANSFER_TEST_01
Rules:
  - 3 variants minimum:
      V1 (same surface), V2 (different surface), V3 (timed)
  - Promotion only if passes all 3 above threshold.

		

6.4 Writing-specific plug-in (ACTP integration)

			
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:OPR×Type:PACK×ID:EDU_SOP_WRITING_ACTP_PLUGIN_01
BindsTo:
  - ACTP (one spark + return)
  - RewriteWeakestParagraph loop
Contract:
  - one corridor line per paragraph (PSLE)
  - RETURN immediately after SPARK
  - fix only weakest paragraph per cycle

		

7) FenceOS Hard Reject Rules (EDU)

			
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:FEN×Type:RULE×ID:FENCE_EDU_HARD_REJECT_01
Reject if:
  - no DefinitionLock (L1 missing)
  - no retest cadence (L7 missing)
  - no transfer probe (L4 missing) for “promotion”
  - multi-drill prescription (violates OneRepairOnly)
  - workload exceeds TTC buffer (burnout risk high)
Truncate+Stitch if:
  - plan too complex: reduce to ONE drill + one retest
  - novelty/stylistic upgrades before clarity: revert to Operator baseline
  - confusion rises: enforce anchors, shorter steps, fewer options

		

8) Event Template (EDU corridor session)

			
Place:<PLACE>×Lane:EDU×Zoom:<Z>×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_EDU_01
TaskType: EDU_T1..EDU_T8
EnvelopeRef: ENV_EDU_<LEVEL>_01
ContextBullets: [..]
Candidates:
  A1 {MoveType, TargetSkill, Proposal}
  A2 {MoveType, TargetSkill, Proposal}
OracleLocksApplied: [L1..L8]
OperatorPlan:
  - SOP steps
  - drill prescription
  - retest plan (day 7/day 14)
FenceEval:
  Sensors + Flags + Decision + one RepairAction
Outcome:
  Final plan + next scheduled retest

		

9) Worked Example (Generic) — PSLE Composition Repair (ACTP plug-in)

			
Place:SGP×Lane:EDU×Zoom:Z1×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_EDU_DEMO_PSLE_01
TaskType: EDU_T2 RepairPrescription
EnvelopeRef: ENV_EDU_PSLE_ENG_COMP_01
ContextBullets:
  - student writing is clear but boring; low engagement
  - paragraphs correct but no hook / no quoteable lines
Candidates:
  A1 MoveType: CorridorTemplateInjection
     TargetSkill: "Hook Pair + Return"
     Proposal: "Add 1 Hook Pair in P1 only; keep rest plain."
  A2 MoveType: UnexpectedSpecificity
     TargetSkill: "Specific detail punch"
     Proposal: "Add one specificity line per paragraph + immediate return."
OracleLocksApplied:
  L1 DefinitionLock: PSLE clarity first; one spark per paragraph max
  L4 TransferLock: apply to 3 themes, not one story only
  L7 RetestCadenceLock: day 7 and day 14
  L8 OneRepairOnlyLock: pick only one move
OperatorPlan:
  - EDU_SOP_REPAIR_7DAY_01
  - EDU_SOP_WRITING_ACTP_PLUGIN_01
FenceEval:
  Decision: ACCEPT
Outcome:
  SelectedCandidate: A1
  Prescription: Hook Pair Factory (10 mins/day) + day 7 retest

		

10) Training Drills (EDU lane)

			
Place:GLOBAL×Lane:EDU×Zoom:Z6×Role:SYS×Type:PACK×ID:EDU_TRAINING_DRILLS_01
S1 Operator Base (stability):
  - run SOP for diagnosis + single drill prescription
  - teach “choice reduction”: one routine only
S2 Oracle Landing (learning locks):
  - add DefinitionLock + TransferLock + RetestLock to 10 lesson plans
S3 Architect Corridors (two-candidate generation):
  - produce 2 corridor candidates per student case:
      (fast fix vs deeper fix), both bounded
S4 Fence Discipline:
  - reject multi-fix plans; enforce one repair only; protect TTC buffer
S5 Transfer Across Zoom:
  - Z0: student micro-skill
  - Z1: classroom routine (teacher SOP)
  - Z2: school policy for retest cycles
  - Z3+: national curriculum sequencing proposals with pilots + measurement

		

11) CivOS v2 Bindings (Lane×Zoom×Role)

This pack installs cleanly into your CivOS v2 runtime objects:

Uses CORRIDOR_SESSION_EDU_01 events (loggable, auditable)
Uses envelope refs per level (Primary/PSLE/Sec)
Uses EducationOS closed-loop as the Operator spine
Uses AVOO to generate and fence “high-leverage teaching corridors”

12) What this gives you (UAA EDU outcome)

A universal “Education Architect” training system that:

diagnoses the real leak fast
repairs with minimal, bounded drills
verifies via transfer + retest cadence
prevents collapse by workload fencing
and scales from a single student (Z0) to curriculum design (Z3–Z5)

ACTP_29 — UAA Lane Pack: LANG (Language / Communication)

Universal Architect Academy · LANG Lane Pack (AVOO × FenceOS) — Directory Install (Almost-Code) — v0.1

0) Lane Purpose (LANG)

Use corridor engineering to improve:

writing clarity + memorability (quoteability)
speaking and presentations under load
persuasion (Sec 3–4 rhetoric: mechanisms + counterargument stitching)
teaching language (curriculum-safe templates)
cross-audience communication (child/teen/adult; expert/non-expert)

Not for:

ambiguity games that break meaning
sarcasm/irony without fences (especially with novices)
stacking devices until comprehension collapses

1) Envelope Profiles (LANG) — Age/Context thresholds

			
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:FEN×Type:THRESH×ID:ENV_LANG_BASE_01
Fields:
  ρ NoveltyBudget
  κ RiskBudget (confusion/cringe/backfire)
  C_min ClarityMin
  L_min Protocol (rubric/syllabus/audience constraints)
  E_max Error (misinterpretation probability proxy)
  TTC_min (time-to-irreversible misunderstanding)
Rules:
  - Every SPARK must be stitched within ≤1 sentence.
  - OneRepairOnly enforced.
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:FEN×Type:THRESH×ID:ENV_LANG_PRIMARY_01
ρ: [0.25, 0.50]
κ: [0.00, 0.10]
C_min: 0.88
L_min: 0.95
E_max: 0.10
TTC_min: high
Ban: irony; metaphor chains.
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:FEN×Type:THRESH×ID:ENV_LANG_PSLE_COMP_01
ρ: [0.40, 0.65]
κ: [0.00, 0.10]
C_min: 0.82
L_min: 0.95
E_max: 0.10
TTC_min: high
Lock: one spark per paragraph + immediate RETURN (ACTP).
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:FEN×Type:THRESH×ID:ENV_LANG_SEC12_VOICE_01
ρ: [0.45, 0.75]
κ: [0.00, 0.15]
C_min: 0.78
L_min: 0.92
E_max: 0.12
TTC_min: medium/high
Allow: fenced irony (rare), voice experiments, spike→stitch.
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:FEN×Type:THRESH×ID:ENV_LANG_SEC34_RHETORIC_01
ρ: [0.50, 0.85]
κ: [0.00, 0.18]
C_min: 0.75
L_min: 0.90
E_max: 0.15
TTC_min: medium/high
Require: mechanism locks + counterargument stitch + explicit thesis return.

		

2) Role Directory (LANG-specific behaviors)

			
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:SYS×Type:DIR×ID:DIR_LANG_AVOO_01
ARCH (Language Architect):
  - Generates 2 corridor candidates:
    * hook / image / contrast / specificity corridor
    * rhythm / pacing corridor
    * rhetorical ladder (Sec34)
  - Must include:
    audience type, anchor noun(s), device type, intended emotional effect
ORA (Language Oracle):
  - Adds meaning locks:
    * RETURN truth (plain)
    * ANCHOR explicit nouns
    * MECHANISM lock (cause→effect) for arguments
    * BOUNDARY lock (where it fails / misreads)
    * IRONY fence (if allowed)
    * Definition lock (what is meant by key terms)
OPR (Language Operator):
  - Deploys safely:
    * structure templates (5-box, claim-evidence, etc.)
    * clause-length control
    * transitions / sequencing
    * timed delivery scripts (speaking)
    * checklists + rewrite-only-one-unit loop
FEN (Language Fence):
  - Rejects:
    missing anchors, missing landing, device stacking, ambiguity games
  - Truncates + stitches:
    reduce novelty, restore clarity, add RETURN, retest once

		

3) LANG Task Types (Allowed / Forbidden)

			
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:SYS×Type:NODE×ID:LANG_TASK_TYPES_01
AllowedTaskTypes:
  LANG_T1 CorridorLineCreation (SPARK+STITCH)
  LANG_T2 CompositionStructure (PSLE 5-Box / Sec narratives)
  LANG_T3 VoiceLockTraining (Sec12)
  LANG_T4 ArgumentCompiler (Sec34)
  LANG_T5 PresentationScript (spoken pacing + landing)
  LANG_T6 EditingRepairLoop (rewrite weakest unit only)
  LANG_T7 VocabularyBindUpgrade (phrase bank → usable corridors)
  LANG_T8 AudienceAdaptation (same meaning, different audience)
ForbiddenTaskTypes:
  LANG_F1 AmbiguityGames (meaning flip without explicit locks)
  LANG_F2 UnfencedIronyForNovices
  LANG_F3 DeviceStackingChains (metaphor pile-ups)

		

4) Corridor Move Library (LANG-specific)

			
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:ARCH×Type:PACK×ID:LANG_CORRIDOR_MOVES_01
Moves:
  M1 HookPair (P1 only for PSLE): SPARK + RETURN
  M2 UnexpectedSpecificity: concrete detail that sharpens meaning
  M3 ContrastFlip: “not X; but Y” + stitch
  M4 BodyDetailEmotion: show emotion with body detail + return
  M5 RhythmTriplet: short–long–short + plain meaning
  M6 RhetoricLadder (Sec34): claim→contrast→image→return
  M7 MechanismCompression: because→therefore chain (argument clarity)
  M8 CounterViewSteelman: best opposing view then return
  M9 PersonaFitShift: adjust tone to match narrator/role
Forbidden:
  - sarcasm without fence
  - metaphor chains (2+ images colliding)
  - abstract hooks without scene anchors

		

5) Oracle Locks (Meaning locks for language)

			
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:ORA×Type:RULE×ID:LANG_ORACLE_LOCKS_01
Locks:
  L1 AnchorLock:
    first clause must include a concrete noun (who/what/where)
  L2 ReturnLock:
    every SPARK is followed by a plain meaning sentence within ≤1 sentence
  L3 BoundaryLock:
    “This works only if…” / “This could be misread when…”
  L4 DefinitionLock:
    define key terms in one sentence (Sec34 especially)
  L5 MechanismLock:
    because→therefore chain (argument)
  L6 IronyFenceLock (only if envelope allows):
    irony line + intent lock + return truth
  L7 QuoteabilityLock:
    memorable line must still be concrete + clear
  L8 OneRepairOnlyLock:
    fix one leak; freeze everything else

		

6) Operator SOP Patterns (LANG executable templates)

6.1 Corridor Line SOP (SPARK→STITCH)

			
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:OPR×Type:PACK×ID:LANG_SOP_CORRIDOR_LINE_01
Steps:
  1) Choose device (M2/M3/M4/M5; PSLE uses M1)
  2) Write SPARK (≤16 words recommended) with AnchorLock
  3) Write STITCH (ReturnLock) immediately
  4) Fence check: no stacking, no abstract drift, clarity in 2 seconds
Output:
  - corridor pair (SPARK+STITCH)

		

6.2 PSLE Composition Plugin (bind to ACTP)

			
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:OPR×Type:PACK×ID:LANG_SOP_PSLE_ACTP_01
BindsTo:
  - ACTP_05..15 (PSLE control tower)
Contract:
  - one spark per paragraph + immediate RETURN
  - rewrite weakest paragraph only

		

6.3 Sec12 Voice Lock SOP

			
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:OPR×Type:PACK×ID:LANG_SOP_SEC12_VOICELOCK_01
Steps:
  1) Declare voice (dry/serious/reflective/humorous)
  2) Write 8 lines with consistent tone/rhythm
  3) Insert 1–2 spikes max; stitch immediately
  4) Fence check: persona fit + no cringe drift
Output:
  - voice-locked paragraph + 1 quote line (optional)

		

6.4 Sec34 Argument Compiler SOP

			
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:OPR×Type:PACK×ID:LANG_SOP_SEC34_ARGUMENT_01
Structure:
  P1 Thesis explicit + scope + thesis return
  P2 Claim + MechanismLock + evidence + return
  P3 Claim + MechanismLock + evidence + return
  P4 CounterStitch (steelman + boundary + return thesis)
  P5 Synthesis + quote line + thesis return
Rules:
  - mechanism locks mandatory
  - evidence must be concrete

		

6.5 Spoken Presentation SOP (talk corridor)

			
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:OPR×Type:PACK×ID:LANG_SOP_PRESENTATION_01
Steps:
  1) 10-second hook (one corridor line + stitch)
  2) 3-point structure (Operator)
  3) After each point: one “return meaning” sentence
  4) Close with 1 quoteable line + explicit takeaway
Fence:
  - avoid ambiguous humour unless fenced

		

7) FenceOS Hard Reject Rules (LANG)

			
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:FEN×Type:RULE×ID:FENCE_LANG_HARD_REJECT_01
Reject if:
  - AnchorLock missing (no concrete noun)
  - ReturnLock missing (no stitch)
  - device stacking (2+ devices in one SPARK)
  - abstract hook with no scene (especially for Primary/PSLE)
  - irony without fence (or irony in PSLE/Primary)
Truncate+Stitch if:
  - SPARK too long or unclear: cut length + add concrete noun
  - meaning could be misread: add BoundaryLock line
  - cringe mismatch: switch to specificity/body-detail and plain truth
OneRepairOnly:
  - apply exactly one repair action, then retest once

		

8) Event Template (LANG corridor session)

			
Place:<PLACE>×Lane:LANG×Zoom:<Z>×Role:AVOO×Type:EVENT×ID:CORRIDOR_SESSION_LANG_01
TaskType: LANG_T1..LANG_T8
EnvelopeRef: ENV_LANG_<CONTEXT>_01
ContextBullets: [..]
Candidates:
  A1 {MoveType, Anchor, Spark}
  A2 {MoveType, Anchor, Spark}
OracleLocksApplied: [L1..L8 subset]
OperatorPlan:
  - structure/SOP + timing + checklist
FenceEval:
  Sensors + Flags + Decision + one RepairAction
Outcome:
  Final deliverable + retest plan

		

9) VocabularyOS Bind Upgrade (LANG ↔ VOC symmetry)

Use vocabulary not as “word lists,” but as corridor-ready binds.

			
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:SYS×Type:EDGE×ID:EDGE_LANG_TO_VOC_01
From: UAA_LANE_LANG_01
To:   VocabularyOS (phrase banks, binds, retrieval loops)
Binding:
  - corridor lines draw from:
      * Anchor nouns (concrete)
      * Contrast operators (not/but/yet/however)
      * Body-detail verbs (trembled, tightened, hovered)
      * Mechanism verbs (because/therefore/leads to)
  - Every new “fancy phrase” must map to:
      * a ReturnLock meaning (plain)
      * a usage context (where it fits)

		

10) Training Drills (LANG lane)

			
Place:GLOBAL×Lane:LANG×Zoom:Z6×Role:SYS×Type:PACK×ID:LANG_TRAINING_DRILLS_01
S1 Operator Base:
  - cadence cut (long → 2 short)
  - anchor-first sentences (10)
S2 Oracle Landing:
  - stitch within 1 sentence (10 spikes)
  - mechanism locks (10 because→therefore chains)
S3 Architect Corridors:
  - generate 2 corridor candidates per task (M2/M3/M5/M6)
  - pick best + stitch
S4 Fence Discipline:
  - reject your own cleverness:
    * remove stacked devices
    * ban irony unless fenced
    * switch to body-detail + return if unclear
S5 Transfer Across Zoom:
  - Z0: single line
  - Z1: paragraph
  - Z2: essay/presentation
  - Z3+: org communication standards

		

11) CivOS v2 Bindings (Lane×Zoom×Role)

This pack installs cleanly into your CivOS v2 runtime:

Uses CORRIDOR_SESSION_LANG_01 events
Uses envelope refs per audience context (Primary/PSLE/Sec)
Uses AVOO chain + FenceOS rules as mandatory execution physics
Binds to EDU lane pack via ACTP plug-ins (composition control tower)

12) What this gives you (UAA LANG outcome)

A unified language training system that:

produces fascination without losing meaning
scales from PSLE composition to Sec 3–4 persuasive essays
turns “ridiculous combinations” into repeatable corridor engineering
remains machine-readable, auditable, and installable across Z0–Z6

LanguageOS · Architect Corridor Engine (LACE) — v0.1

META

Definitions

State variables

Stability bands

Core Mechanism

Architect move (Symmetry-breaking)

Oracle stabilizer (Meaning lock)

Operator stabilizer (Delivery lock)

Stitching requirement (landing)

Output Targets

Sensor Pack — LACE_SENSORS_01

SENSORS

DERIVED

FenceOS Coupling — LACE_FENCE_01

RULES

Simulation Model — LACE_SIM_01

Entities

Update equations (simple discrete-time)

Capacity

Symmetry injection

Clarity

Landing

Emotion activation

Attention

Bind gain (long-run)

Confusion / cringe

Policy Controller — LACE_POLICY_01

Goal

CONTROL LOOP (per utterance)

ACTIONS

DECISION

Test Harness — LACE_TEST_01

Scenarios

Success criteria

How you use this in eduKateSG

VocabularyOS × LanguageOS × AVOO

Architect Corridor Training Protocol (ACTP) — v0.1 (Almost-Code)

META

0) Core Contract

Contract

Measurable outcomes

1) Definitions

Core primitives

Safety bands (default)

2) The 5-Stage Curriculum (8–12 weeks)

Stage 1 — Operator Clarity Lock (Weeks 1–2)

Drills

Stage exit test

Stage 2 — Oracle Landing Patterns (Weeks 3–4)

Oracle stitch template (mandatory)

Drills

Stage exit test

Stage 3 — Architect Permutation Library (Weeks 5–7)

Architect move types (safe set)

Allowed injection policy

Drills

Stage exit test

Stage 4 — Persona Fit + Timing Control (Weeks 8–9)

PersonaFit rules

Timing rules

Drills

Stage exit test

Stage 5 — Exam-Safe Transfer Mode (Weeks 10–12)

Exam-safe constraints

Use cases

Drills

Stage exit test

3) LACE-Aligned Assessment Rubric (LACE_RUBRIC_01)

Score each piece (0–5)

Pass conditions (default)

4) Simulation Log Format (for ChronoHelmAI / LLM-Runnable)

LOG_RECORD (per utterance)

Batch metrics

5) Example Templates (No Real People)

Template Pack: TEMPLATES_ACTP_01

T1 — Hook Pair (Exam-Safe)

T2 — Hyperbole with Landing

T3 — Contrast Flip

T4 — Unexpected Specificity

Template Pack: `TEMPLATES_ACTP_01`

B1 Drill Pack — `ACTP_B1_DRILLS_01`

B2 Drill Pack — `ACTP_B2_DRILLS_01` (PSLE)

B3 Drill Pack — `ACTP_B3_DRILLS_01`

B4 Drill Pack — `ACTP_B4_DRILLS_01`

4) Teacher Marking Sheet (LACE × EducationOS) — `MARKSHEET_ACTP_01`

5) EducationOS Closed-Loop Integration — `EDUOS_LOOP_ACTP_01`

PROMPTS_B1_50 (Primary 3–4) — `ACTP_PROMPTS_B1_50`

PROMPTS_B2_50 (Primary 5–6 / PSLE) — `ACTP_PROMPTS_B2_50`

PROMPTS_B3_50 (Secondary 1–2) — `ACTP_PROMPTS_B3_50`

PROMPTS_B4_50 (Secondary 3–4) — `ACTP_PROMPTS_B4_50`

2) LLM-Runnable Scorer — `SCORER_PROMPT_ACTP_01`

3) Repair Router — `REPAIR_ROUTER_ACTP_01`

4) Student Report Template — `STUDENT_REPORT_ACTP_01`

1) PROMPTS_B3_50 (Secondary 1–2) — `ACTP_PROMPTS_B3_50_EXPANDED`