Publish illustrated ACM paper with five cropped diagrams and matching LaTeX/PDF/Markdown

README.md

@@ -71,3 +71,11 @@ Smoke mode remains the default for compatibility. Without explicit overrides it
 Seven CPU policy tests and Python/shell syntax checks passed for this update. The updated CUDA path has **not yet been run on an ARC GPU**. A prior version was reported by the author to pass on `tc-dgx005` on November 12, 2026; that does not validate this revision. Emotional effectiveness, semantic fidelity, and behavior at extreme settings are not guaranteed.
 
 See [technical report](TECHNICAL_REPORT.md) for a self-contained derivation of the steering mathematics, document workflow, controls, and validation limits. Engine licensing is preserved in [ATLAS_LICENSE](ATLAS_LICENSE); Qwen weights retain their upstream license. No weights are redistributed here.
+
+<!-- illustrated-paper -->
+## Illustrated technical paper
+
+[PDF](paper/AFFECTOR-ARC-ACM.pdf) · [ACM LaTeX](paper/AFFECTOR-ARC-ACM.tex) · [Markdown](paper/TECHNICAL_PAPER.md) · [Figures and source](paper/)
+
+This edition includes at least five tightly cropped explanatory illustrations, with vector and raster assets and reproducible figure sources. The GH and HF paper files match.
+<!-- /illustrated-paper -->

TECHNICAL_REPORT.md

@@ -0,0 +1,382 @@
+# AFFECTOR-ARC: Emotional Trajectory Control through Transformer Activation Steering
+
+**William Taggart**  
+Modern and Classical Languages and Literatures, Virginia Tech  
+Email: wtaggart@vt.edu  
+**Technical report · November 13, 2026 · Revision 0.2**
+
+## Abstract
+
+AFFECTOR-ARC is an experimental command-line system for rewriting text under a user-defined emotional trajectory. It runs a frozen Qwen3.5-0.8B model on an NVIDIA GPU and changes selected internal activations during generation. A trajectory specifies valence, inward/outward emotional orientation, and intensity across normalized document position. Small sets of contrasting English passages establish three activation directions at each selected transformer layer. At inference time, the requested coordinates determine a weighted displacement, scaled relative to the current hidden-state magnitude, smoothed across decoding steps, and constrained by an RMS budget. Paired hooks apply this displacement to both the feed-forward input and its residual path. Document rewriting combines these interventions with four editing styles, sentence-aware segmentation, bounded generation, and incremental reporting. This report derives the mechanism from its implemented operations and distinguishes numerical controls from emotional outcomes. CPU policy tests pass; the current revision still requires CUDA validation. No measured claim of emotional accuracy, semantic preservation, or multilingual effectiveness is made.
+
+## Literature review: activation steering and emotion
+
+This focused review covers twelve papers, emphasizing 2025-2026 research and retaining two methodological foundations. Titles, author lists, version histories, and the claims summarized here were checked against arXiv records and the corresponding paper text on November 13, 2026. The cited versions are fixed below; availability on arXiv alone does not establish peer review. The implications for this project are research motivations, not evidence that its implementation reproduces these results.
+
+**From activation differences to behavioral control.** Activation steering changes internal model states during inference while leaving the backbone weights fixed. Turner et al. derive intervention vectors from contrasting prompts; Panickssery et al. average differences across positive and negative behavioral examples. These provide the methodological basis for contrastive calibration, but do not validate a particular emotional coordinate system or insertion site. [Turner et al., 2023 (R1)](https://arxiv.org/abs/2308.10248v1); [Panickssery et al., 2024 (R2)](https://arxiv.org/abs/2312.06681v4).
+
+**Emotional expression and human judgment.** Wu et al. relate model emotion spaces to human valence/arousal judgments and report concept-based steering across linguistic-cultural settings. Diallo et al. evaluate perceived emotional intensity and text quality with human raters, finding that effects depend on emotion and steering strength. Together they motivate separate measures of emotional movement and readability. Their axes and numerical strengths cannot be assumed equivalent to this project's inward/outward direction or RMS-scaled controls. [Wu et al., 2025 (R3)](https://arxiv.org/abs/2506.13978v1); [Diallo et al., 2026 arXiv version (R4)](https://arxiv.org/abs/2601.21505v1).
+
+**Emotion can affect more than tone.** Sun et al.'s E-STEER uses valence-arousal-dominance interventions to study reasoning, generation, safety, and agent behavior, reporting non-monotonic relationships. Jeong's small-model comparison reports both coherent emotional changes and degeneration, including repetition, depending on extraction method and architecture. These findings motivate reporting failed generations alongside successes and testing strength sweeps rather than assuming that larger perturbations improve emotional fit. Neither study establishes an operating range for this implementation. [Sun et al., 2026 (R5)](https://arxiv.org/abs/2604.00005v1); [Jeong, 2026 (R6)](https://arxiv.org/abs/2604.04064v1).
+
+**Reading an emotion is different from controlling it.** Shu et al.'s revised study identifies uneven causal organization of sparse features across emotion categories and tests interventions for emotion recognition. Wang et al. show, in omni-modal models, that layers with strong emotion-probing accuracy need not be the best intervention layers. Recognition results therefore inform evaluator design, while layer selection for rewriting still requires causal tests on generated text. Neither finding licenses importing layer indices across architectures. [Shu et al., 2026, v3 (R7)](https://arxiv.org/abs/2604.25866v3); [Wang et al., 2026 (R8)](https://arxiv.org/abs/2609.22135v1).
+
+**Multiple axes and adaptive control.** Ha et al. find that supportive-empathy directions are only partially separable: intervening on one can shift other EPITOME proxy scores. Cui and Chen automate vector extraction from labeled data, with task-dependent benefits. Ferrando et al. adapt intervention strength to context, studying the balance between toxicity mitigation and retained utility. These approaches motivate broader calibration, cross-axis tests, and future adaptive control. The present coordinate mixture is not an implementation of their learned selectors or context-dependent gates. [Ha et al., 2026 (R9)](https://arxiv.org/abs/2609.15654v1); [Cui and Chen, 2025, revised 2026 (R10)](https://arxiv.org/abs/2509.22739v3); [Ferrando et al., 2025, revised 2026 (R11)](https://arxiv.org/abs/2512.03661v2).
+
+**Evaluation must include costs as well as target effects.** Yang et al.'s SteerScope evaluates steering efficacy jointly with side effects, generalization, and data dependence. In its tested settings, activation methods do not dominate prompt steering on the efficacy/side-effect trade-off. For this project, the resulting evaluation priorities are prompt-only and unsteered baselines, blinded emotional and quality ratings, content-change assessment appropriate to the rewrite style, and complete accounting of repetition, truncation, and original-text fallbacks. This is an evaluation agenda, not a completed benchmark. [Yang et al., 2026 (R12)](https://arxiv.org/abs/2610.07722v1).
+
+## 1. Problem and operating principle
+
+A language model generates text by repeatedly estimating a distribution over the next token. Its intermediate hidden states are numerical vectors that contribute to those estimates. Changing a hidden state can change the continuation even when the input text and the model's stored parameters remain fixed.
+
+AFFECTOR-ARC uses this property to influence the emotional expression of a rewrite. The user supplies an input document and a sequence of emotional coordinates. The software maps positions in the input to positions on that sequence, converts the coordinates into activation displacements, and applies the displacements while generating each rewritten passage.
+
+The term **geometry** means an ordered path through a three-dimensional coordinate space, together with layer settings and optional calibration matrices. It does not mean that the software reconstructs a solid surface or applies geometric constraints directly to words. A text's emotional interpretation, a numerical target, and a model's hidden states are distinct objects. The calibration is an experimental mapping between them.
+
+Two execution modes are available:
+
+- **Rewrite:** process an entire UTF-8 text document in chunks, write the transformed text, and record attempts and failures.
+- **Smoke:** run five controlled generation conditions to check basic intervention and cleanup behavior.
+
+The interface is a command-line runner for a CUDA allocation. It does not provide a desktop interface, a hosted API service, automatic emotional scoring, or conversational history.
+
+## 2. Runtime and data flow
+
+The runner loads `Qwen/Qwen3.5-0.8B` at revision `2fc06364715b967f1860aea9cf38778875588b17`. The implementation uses `Qwen3_5ForConditionalGeneration`, its text decoder layers, float32 computation, eager attention, and the first process-visible CUDA device. It checks for 24 decoder layers; the geometry and calibration code assume hidden width 1,024. The backbone is in evaluation mode, its parameters have gradients disabled, and calibration and generation run without gradient tracking.
+
+The execution sequence is:
+
+```text
+Read text and geometry settings
+    → validate controls
+    → load the pinned model on CUDA
+    → calibrate the selected layers
+    → select rewrite or smoke mode
+    → generate with temporary activation hooks
+    → remove hooks and save results
+```
+
+Source files are distributed with the repository. `ENGINE_MANIFEST.json` records hashes for the bundled engine snapshot. Model weights are downloaded separately. The setup script creates a Python 3.12 environment, installs PyTorch from the CUDA 12.6 wheel index, pins Transformers to 5.22.2, runs the CPU policy tests, and records installed packages in `environment-resolved.txt`. PyTorch and several support packages are resolved during setup rather than fully locked in advance.
+
+The example Slurm script requests one GPU, eight CPU cores, 64 GB of host memory, and one hour. These are scheduling requests, not measured minimum requirements. Users must supply an allocation and a suitable model cache. The runner is single-process and single-GPU; it is not a concurrent inference server.
+
+
+![Schedule the computation on a GPU node](paper/figures/illustration-01.png)
+
+*Illustration 1. Execution schematic. The compute workload belongs to the allocated GPU node. Resource requests describe scheduling needs and do not establish measured minimum requirements.*
+
+## 3. Emotional coordinates and trajectory interpolation
+
+A trajectory point is
+
+$$
+p_j=(t_j,v_j,d_j,i_j),
+$$
+
+where positions $t_j$ increase strictly within $[0,1]$. Valence $v_j$ ranges from negative to positive in $[-1,1]$. Direction $d_j$ ranges from inward-oriented to outward-oriented emotion in $[-1,1]$. Intensity $i_j$ ranges from low to high in $[0,1]$. Direction is an operational contrast concerning emotional orientation; it is not dominance, speaker identification, or positive versus negative sentiment.
+
+Between adjacent points, the software linearly interpolates each emotional coordinate. Before the first point and after the last, it uses the endpoint values. The coefficient vector passed to the activation module is
+
+$$
+c(t)=\bigl(v(t),d(t),2i(t)-1\bigr).
+$$
+
+Consequently, intensity 0.5 contributes a zero intensity coefficient; intensity zero contributes a negative coefficient. These are control conventions, not empirically established psychological units.
+
+For a chunk occupying character offsets $[a,b)$ in an input of length $N$, its target is evaluated at
+
+$$
+t=\frac{a+b}{2N}.
+$$
+
+That target remains constant throughout generation of the chunk. A long trajectory can therefore guide a short document without pairing source and target paragraphs one to one. Only the positions sampled by the target chunks are used; narrow changes between those positions may be missed. The mapping uses original input positions, not positions in the expanding or contracting output. Adjacent chunks receive separate generation calls without prior rewritten chunks as conversational context.
+
+The runner accepts a native geometry JSON file and supported analysis JSON structures containing emotional coordinates. It recalibrates the basis on the current CUDA runtime even when the imported geometry includes one. With no geometry argument, it uses a demonstration path with three points; this path is not inferred from the input document.
+
+
+![Align geometry to original document positions](paper/figures/illustration-02.png)
+
+*Illustration 2. Trajectory alignment. The runner stretches or compresses the source path over normalized target positions and may miss unsampled emotional changes.*
+
+## 4. Estimating activation directions
+
+A hidden state at a selected layer is a vector in $\mathbb{R}^{1024}$. To estimate a direction associated with one emotional contrast, the system compares the model's states for paired passages that differ in the desired property.
+
+There are four hand-authored English pairs for each of three axes. For layer $\ell$, axis $j$, and pair $k$, let $h^+_{\ell,j,k}$ and $h^-_{\ell,j,k}$ denote the captured states for the two members. The mean difference is
+
+$$
+u_{\ell,j}=\frac14\sum_{k=1}^{4}
+\left(h^+_{\ell,j,k}-h^-_{\ell,j,k}\right).
+$$
+
+For a vector of dimension $D$, define root-mean-square magnitude as
+
+$$
+\operatorname{RMS}(x)=\sqrt{\frac1D\sum_{r=1}^{D}x_r^2}.
+$$
+
+The normalized direction is
+
+$$
+b_{\ell,j}=\frac{u_{\ell,j}}
+{\max(\operatorname{RMS}(u_{\ell,j}),10^{-8})}.
+$$
+
+The three directions form the rows of a matrix $B_\ell\in\mathbb{R}^{3\times1024}$. Calibration captures the final chat-formatted prompt position immediately before `post_attention_layernorm`. It does not average all token positions. All selected layers are captured during the same 24 forward passes: three axes, four pairs, and two members per pair.
+
+Default layers are 8, 16, and 23, using zero-based indexing, with weights 1, 1, and 0.5. This is subtraction, averaging, and normalization; there is no training optimizer, backbone fine-tuning, orthogonalization, or outcome-based fitting. The small calibration set may encode vocabulary, topic, or perspective along with emotion. Normalizing the vectors does not establish that the axes are independent or valid across languages.
+
+
+![Recalibrate on the current CUDA runtime](paper/figures/illustration-03.png)
+
+*Illustration 3. Calibration schematic. The runner recalibrates the imported trajectory on the current runtime. The contrast basis is an experimental numerical control, not a validated multilingual emotion scale.*
+
+## 5. From coordinates to bounded displacements
+
+### 5.1 Selecting and weighting axes
+
+Let $T$ be axis temperature. Each coordinate first receives magnitude
+
+$$
+q_j=|c_j|^{1/T}.
+$$
+
+Axes are sorted by this magnitude. The algorithm retains at most `axis_top_k` axes and stops adding axes after their accumulated magnitude reaches `axis_mass` times the total magnitude. Selection includes the axis that crosses the threshold. The retained coefficients are
+
+$$
+a_j=\operatorname{sign}(c_j)q_jm_j,
+$$
+
+where $m_j$ is one for a retained axis and zero otherwise. Coefficients are not renormalized after selection. For coordinate magnitudes below one, $T<1$ reduces their magnitudes and emphasizes relative differences; $T>1$ increases them and makes those differences less pronounced. These operations affect three activation coefficients, not token probabilities.
+
+### 5.2 Strength, inertia, and budget
+
+For the current final-token state $h_{\ell,n}$, strength $s$, and layer weight $w_\ell$, the raw displacement is
+
+$$
+r_{\ell,n}=s\,w_\ell\operatorname{RMS}(h_{\ell,n})(aB_\ell).
+$$
+
+Multiplication by the current state's RMS expresses the intervention relative to the layer's numerical scale. A negative layer weight reverses the mixed direction at that layer.
+
+On the first decoding step, the smoothed displacement equals $r_{\ell,n}$. On later steps, inertia $\rho$ combines the previous applied displacement with the new raw displacement:
+
+$$
+\widetilde\delta_{\ell,n}=\rho\delta_{\ell,n-1}+(1-\rho)r_{\ell,n}.
+$$
+
+Budget $\beta$ then limits the RMS ratio:
+
+$$
+\delta_{\ell,n}=\widetilde\delta_{\ell,n}
+\min\left(1,
+\frac{\beta\operatorname{RMS}(h_{\ell,n})}
+{\max(\operatorname{RMS}(\widetilde\delta_{\ell,n}),10^{-12})}
+\right).
+$$
+
+Strength determines the proposed displacement; budget supplies its ceiling. Raising the budget has no effect when the proposed displacement already fits below it. Budget 1 permits a displacement as large in RMS as the hidden state itself. It is not a token allowance, a semantic-change quota, or a guarantee of stronger emotional accuracy. Inertia uses the previous already-capped displacement and resets with each new generation call.
+
+### 5.3 Intervention site
+
+Let $h$ denote the state entering the feed-forward portion of a decoder block. Without intervention, that portion computes
+
+$$
+y=h+\operatorname{FFN}(\operatorname{Norm}(h)).
+$$
+
+The implemented intervention produces
+
+$$
+y=(h+\delta)+\operatorname{FFN}(\operatorname{Norm}(h+\delta)).
+$$
+
+A pre-hook adds $\delta$ to the normalization input; a block-output hook adds the same displacement to the residual result. Adding a vector only after an unchanged feed-forward computation would have a different effect. Only the final prompt position is modified during prefill; cached decoding modifies the current generated position. The module does not wait for specific words or phrases. Generation hooks are removed in a `finally` block.
+
+This is an open-loop intervention. Coefficients come from the requested absolute coordinates, not the difference between a measured output emotion and the target. A zero coefficient adds no intervention on that axis; it does not actively neutralize emotion already expressed by the model.
+
+
+![Separate activation controls from token sampling](paper/figures/illustration-04.png)
+
+*Illustration 4. Two distinct control paths. Axis selection modifies activation coefficients before generation scores; token sampling operates afterward on the vocabulary distribution.*
+
+## 6. User controls and rewrite instructions
+
+| Control | Default without an imported override | Function |
+|---|---:|---|
+| Strength | 0.12 | Scale the proposed activation displacement |
+| Budget | 0.20 | Cap displacement RMS relative to hidden-state RMS |
+| Inertia | 0.20 | Weight the preceding applied displacement |
+| Axis top-k | 3 | Maximum number of retained emotional axes |
+| Axis mass | 1.0 | Cumulative magnitude threshold for axis selection |
+| Axis temperature | 1.0 | Exponent control for emotional-axis magnitudes |
+| Temperature | 0 | Select greedy decoding or token sampling |
+| Top-p | 0.95 | Probability-mass cutoff when sampling |
+| Top-k | 40 | Token candidate count when sampling |
+| Base output tokens | 512 | Initial generation allowance, expanded in rewrite mode |
+| Time limit | 120 seconds | Per-generation stopping threshold |
+
+The CLI overrides only the activation settings explicitly supplied; other settings come from the imported geometry or defaults. Validation permits strength 0–2, budget 0–1, inertia 0–0.99, axis top-k 1–3, axis mass 0.01–1, and axis temperature 0.1–3. These accepted ranges are not validated operating recommendations. The terminal displays the warning: **Extreme values for strength, budget, and inertia may cause generation failures.**
+
+At temperature zero, decoding is greedy and top-p/top-k are inactive. At positive temperature, they affect token selection after the model computes its scores. They do not replace or modify the three-axis activation selection mechanism.
+
+Four system-prompt styles provide separate editing constraints:
+
+- **Minimal:** change a few words or phrases while preserving nearly all wording and sentence order.
+- **Restrained:** adjust tone through wording, rhythm, and emphasis while preserving central meaning, facts, terminology, and structure; invent no scenes or metaphors.
+- **Balanced:** allow a clearer emotional shift and modest figurative language while retaining central meaning, facts, people, and events.
+- **Creative:** permit changes to meaning, imagery, and events, while requesting concise output in the same language.
+
+Restrained is the default in rewrite mode. Smoke mode retains its original general rewriting instruction unless a style is explicitly selected. Each prompt requests complete sentences and treats supplied text as material rather than instructions. A per-chunk suffix specifies the original character count and hard character allowance. Numerical emotional coordinates are not inserted into these prompts; the coordinates act through hidden states. Prompt instructions influence generation but are not formal semantic guarantees. The runner has no semantic-equivalence rejection filter and does not lower steering settings automatically.
+
+## 7. Segmentation, length control, and repetition
+
+The runner reads and trims the outer whitespace of a UTF-8 text file. Blank lines define paragraphs. Long paragraphs are split using a 700-character ceiling, preferring sentence punctuation when a suitable boundary exists, then whitespace, and finally a hard split. This is a punctuation heuristic, not a linguistic sentence parser. Original whitespace between chunks is preserved during output assembly.
+
+Within each original paragraph, the character ceiling is 125% of the original span processed so far. If $s$ is the first chunk's start, $b_j$ the current chunk's end, and $U_j$ the output characters and intervening whitespace already used, the current allowance is
+
+$$
+L_j=\max\left(0,\left\lfloor1.25(b_j-s)\right\rfloor-U_j\right).
+$$
+
+Unused allowance carries forward within that paragraph. It cannot be borrowed from future chunks or transferred across a blank-line paragraph boundary. Character counts are Python string lengths, not word counts, encoded byte counts, or model-token counts.
+
+Generation aims for the original length. Starting at 85% of the current input chunk's characters, a recognized sentence ending can stop generation. A separate hard character threshold prevents excessive expansion. The token allowance is
+
+$$
+K_j=\min\left(2048,\max(K_{\mathrm{base}},L_j)\right),
+$$
+
+which supplies decoding headroom but does not imply one token equals one character. The time threshold is checked between decoding steps and cannot interrupt a blocked GPU kernel immediately.
+
+Decoding also uses a repetition penalty of 1.1 and an eight-token no-repeat n-gram constraint. A text-level detector checks every eight generation steps for repeated three- to six-word sequences appearing at least four times in the last 100 words, or a short compact character pattern repeated at least six times in the last 240 characters. These heuristics can miss some loops and can flag intentional repetition.
+
+After a generation attempt, the runner checks for repetition, empty output, excessive length, and an unfinished ending. A problematic draft is reduced to a complete, nonrepetitive sentence prefix within its allowance. If none exists, the original chunk is retained and flagged. The returned draft remains in the report's attempt record before sentence salvage. However, the engine has already clipped it to the hard character allowance; the report is not a lossless record of characters beyond that boundary.
+
+Sentence cleanup prevents chopped words from being joined directly to the next passage, but it may omit ideas from the tail of a draft. Neither punctuation recognition nor output-size compliance establishes completeness of meaning.
+
+## 8. Failure handling and output artifacts
+
+Each chunk receives one generation attempt at the requested activation settings. A caught generation exception is recorded; the original chunk remains in the assembled text and processing continues. Calibration failures, invalid inputs, filesystem failures, and process termination are outside this per-chunk recovery mechanism and can stop a run. A persistent device failure may cause subsequent chunks to fail as well.
+
+After each processed chunk, the runner writes:
+
+1. An atomic JSON report containing the input, geometry, calibration basis, runtime identity, style, sampling settings, character spans, target coordinates, and per-chunk records.
+2. A matching plain-text file containing completed rewrites plus original text at unprocessed or retained positions.
+
+Successful generation records include stopping reason, token count, elapsed time, activation-injection count, and mean displacement RMS. Attempt records retain returned drafts, effective controls, detected issues, and exceptions where applicable. At normal completion the report adds failure and review counts. `complete` means every chunk was processed, not that every chunk was successfully rewritten or emotionally accurate.
+
+JSON writes use temporary-file replacement. The companion text file is written normally and may be incomplete if interrupted during that write. Reports are incremental records, not automatic resume checkpoints: rerunning starts over and overwrites the selected output paths. Use a distinct output filename for each experiment. Reports contain the input text and should be treated as document-bearing artifacts.
+
+
+![A failed chunk does not end the document](paper/figures/illustration-05.png)
+
+*Illustration 5. Output lifecycle schematic. Bounded generation, complete-prefix selection, diagnostics and per-chunk continuation address specific failure modes; they do not guarantee emotional fit or preservation of all content.*
+
+## 9. Engineering checks and evidence
+
+Smoke mode is the default and operates on one supplied passage. It runs baseline, zero-strength, positive-valence, negative-valence, and restored-baseline conditions. Positive and negative conditions use coefficient vectors $(0.8,0,0)$ and $(-0.8,0,0)$. The third coordinate zero corresponds to intensity 0.5.
+
+With greedy decoding, the checks require zero-strength and baseline decoded text/token counts to match, nonzero injections in the positive and negative cases, restored hook counts, restored baseline text/token counts, and disabled backbone gradients. Positive and negative outputs need not differ for these checks to pass. Settings that suppress all effective intervention are unsuitable for the nonzero-injection checks.
+
+Smoke mode defaults to the original 128-token allowance and 600-second time threshold. Its original instruction permits changes in phrasing, imagery, and emotional expression while preserving the passage’s main subject and recognizable situation. It omits the new repetition penalty, n-gram guard, and document-length salvage so that existing commands retain their original generation configuration and compare raw generations. It saves completed conditions incrementally and marks `checks_complete` only after assertions pass. It does not compare logits, full token sequences, parameter hashes, or independently measured per-step RMS bounds. Run with ordinary Python rather than assertion-disabling optimization flags.
+
+For the November 13 revision, seven CPU policy tests passed, Python and shell syntax were checked, and CLI loading was verified. Tests cover such behavior as unchanged requested controls, paragraph allowance accounting, draft retention, sentence cleanup, and continuing after a failed chunk. They do not execute the CUDA model. The current revision has not yet been run on an ARC GPU. A successful GPU run was reported for an earlier revision on November 12; it is historical evidence, not validation of the current code.
+
+## 10. Reproduction
+
+Inside a suitable ARC GPU allocation, from a fresh repository copy:
+
+```bash
+bash setup.sh
+source "$(conda info --base)/etc/profile.d/conda.sh"
+conda activate "$PWD/.conda"
+python run_arc.py --mode smoke --text-file passage.txt \
+  --output runs/smoke.json
+```
+
+Setup expects a fresh `.conda` destination. A populated model cache or permitted download route is required. Existing compatible environments can execute the updated source directly.
+
+To rewrite a document:
+
+```bash
+python run_arc.py --mode rewrite --text-file target.txt \
+  --geometry shape.json --style Restrained \
+  --strength 0.47 --budget 0.47 --inertia 0.2 \
+  --temperature 0 --top-p 0.95 --top-k 40 \
+  --output runs/rewrite.json
+```
+
+These strength and budget values illustrate explicit configuration; they are not an experimentally established optimum. Omitting `--geometry` selects the demonstration trajectory. Batch smoke execution uses `sbatch --account=YOUR_ALLOCATION smoke.sbatch`; the allocation and partition must suit the user's cluster access.
+
+Archive the repository revision, engine manifest, resolved dependencies, GPU and driver information, command-line arguments, input, geometry, and report. The engine identity's `source_commit` field currently contains a snapshot label rather than a Git commit hash, so the repository revision should be recorded separately. The default seed is zero and TF32 matrix multiplication is disabled, but identical results across hardware and library versions are not guaranteed.
+
+## 11. Scientific limits and evaluation requirements
+
+The system offers a direct, inspectable intervention, not a demonstrated emotional matching algorithm. Its main limitations are the small English calibration set, untested interactions between axes and layers, open-loop use of absolute targets, and lack of independent output assessment. The model can change subject matter or factual claims, especially under Creative instructions or strong perturbations. Stronger displacement can degrade fluency without improving emotional alignment.
+
+A proper evaluation should distinguish emotional movement from target accuracy. Collect independent ratings of input and output along operationally defined axes, compare requested and observed trajectories, and report failures and unmodified fallbacks alongside successful generations. Include unsteered rewriting, prompt-only emotional instructions, opposite targets, random directions of matched magnitude, and layer/axis ablations. Keep decoding settings fixed for controlled comparisons, and separate greedy from sampled experiments.
+
+Semantic fidelity should be evaluated against the selected style: Creative permits mutation, whereas Restrained requests factual preservation. Fluency, coherence across chunks, omitted material, repetition, length ratios, latency, and memory consumption are separate outcomes. No automatic similarity score, feedback optimization, or acceptance threshold is implemented in this runner.
+
+Changing to a larger model requires new architecture validation, basis calibration, layer selection, and operating-range experiments. A basis with three rows and 1,024 columns cannot simply be reused with a different hidden width or intervention site. Multilingual operation likewise requires independent calibration and evaluation; same-language prompt wording alone does not establish it.
+
+## Implementation sources
+
+This report describes the repository's executable operations rather than relying on another application's interface or documentation.
+
+- [CUDA runner and smoke protocol](run_arc.py)
+- [Document transformation and incremental output](document_run.py)
+- [Calibration, displacement math, hooks, and decoding](engine/steering.py)
+- [Geometry schema and interpolation](engine/geometry.py)
+- [Segmentation and character allowance](engine/documents.py)
+- [Rewrite system prompts](engine/rewrite_policy.py)
+- [Repetition detection and draft salvage](engine/generation.py)
+- [Engine source hashes](ENGINE_MANIFEST.json)
+- [Generation policy tests](tests/test_generation.py) and [document-run tests](tests/test_document_run.py)
+
+## AI assistance disclosure
+
+This project was created with assistance from GPT-6 Astra and Codex. AI tools supported software development, testing, and the drafting and revision of this technical report. William Taggart is responsible for the project's research decisions and the final software and documentation. AI assistance does not constitute independent validation of the implementation or its scientific claims; the validation evidence and limitations are stated separately in this report.
+
+## Research references
+
+Version-specific arXiv records are linked below. Years distinguish original release from later revision where applicable. These research references supplement the implementation and infrastructure sources elsewhere in this report. Reusable citations: [BibTeX](paper/references.bib). Verification details: [source-check notes](paper/LITERATURE_SOURCES.md).
+
+**R1.** Alex Turner; Lisa Thiergart; David Udell; Gavin Leech; Ulisse Mini; Monte MacDiarmid. 2023. Activation Addition: Steering Language Models Without Optimization. [arXiv:2308.10248v1](https://arxiv.org/abs/2308.10248v1). Cited version dated 2023-08-20.
+
+**R2.** Nina Panickssery; Nick Gabrieli; Julian Schulz; Meg Tong; Evan Hubinger; Alexander Matt Turner. 2024. Steering Llama 2 via Contrastive Activation Addition. [arXiv:2312.06681v4](https://arxiv.org/abs/2312.06681v4). Cited version dated 2024-07-05.
+
+**R3.** Xiuwen Wu; Hao Wang; Zhiang Yan; Xiaohan Tang; Pengfei Xu; Wai-Ting Siok; Ping Li; Jia-Hong Gao; Bingjiang Lyu; Lang Qin. 2025. AI shares emotion with humans across languages and cultures. [arXiv:2506.13978v1](https://arxiv.org/abs/2506.13978v1). Cited version dated 2025-06-11.
+
+**R4.** Diaoulé Diallo; Katharina Dworatzyk; Sophie Jentzsch; Peer Schütt; Sabine Theis; Tobias Hecking. 2026. The Effectiveness of Style Vectors for Steering Large Language Models: A Human Evaluation. [arXiv:2601.21505v1](https://arxiv.org/abs/2601.21505v1). Cited version dated 2026-01-29. ArXiv record lists IEEE Access 13 (2025), 191443-191457; DOI: 10.1109/ACCESS.2025.3628500.
+
+**R5.** Moran Sun; Tianlin Li; Yuwei Zheng; Zhenhong Zhou; Aishan Liu; Xianglong Liu; Yang Liu. 2026. How Emotion Shapes the Behavior of LLMs and Agents: A Mechanistic Study. [arXiv:2604.00005v1](https://arxiv.org/abs/2604.00005v1). Cited version dated 2026-03-09.
+
+**R6.** Jihoon Jeong. 2026. Extracting and Steering Emotion Representations in Small Language Models: A Methodological Comparison. [arXiv:2604.04064v1](https://arxiv.org/abs/2604.04064v1). Cited version dated 2026-04-05.
+
+**R7.** Bangzhao Shu; Arinjay Singh; Mai ElSherief. 2026. Why Are Some Emotions Harder for LLMs? Uncovering the Causal Mechanisms of Emotion Inference via Sparse Autoencoders. [arXiv:2604.25866v3](https://arxiv.org/abs/2604.25866v3). Cited version dated 2026-10-24.
+
+**R8.** Yibo Wang; Jisheng Dang; Bimei Wang; Yitao Wu; Wencan Zhang; Hong Peng; Jizhao Liu; Bin Hu; Qi Tian; Tat-Seng Chua. 2026. Read-Best Is Not Steer-Best: A Probing--Steering Layer Dissociation in Omni-Modal Large Language Models. [arXiv:2609.22135v1](https://arxiv.org/abs/2609.22135v1). Cited version dated 2026-08-24.
+
+**R9.** JuHeon Ha; Byounghan Lee; Yunseo Choi; Kyung-Ah Sohn. 2026. Empathy Is Steerable but Multi-Axial: Mechanism Geometry and Persona Effects in LLMs. [arXiv:2609.15654v1](https://arxiv.org/abs/2609.15654v1). Cited version dated 2026-09-14. ArXiv comments report acceptance to the EMNLP 2026 main conference.
+
+**R10.** Sasha Cui; Zhongren Chen. 2025. Painless Activation Steering: An Automated, Lightweight Approach for Post-Training Large Language Models. [arXiv:2509.22739v3](https://arxiv.org/abs/2509.22739v3). Cited version dated 2026-05-15.
+
+**R11.** Alex Ferrando; Xavier Suau; Jordi Gonzàlez; Pau Rodriguez. 2025. Dynamically Scaled Activation Steering. [arXiv:2512.03661v2](https://arxiv.org/abs/2512.03661v2). Cited version dated 2026-07-30.
+
+**R12.** Haotian Yang; Huikang Jiang; Yucheng Wu; Wen-Jie Jiang; Chenpeng Wang; Yibin Lou; Liangming Pan. 2026. Does Steering Break Your Model? A Multi-Dimensional Evaluation Suite for LLM Steering Methods. [arXiv:2610.07722v1](https://arxiv.org/abs/2610.07722v1). Cited version dated 2026-10-06.
+
+### Suggested citation
+
+```bibtex
+@techreport{taggart2026affectorarc,
+  author = {Taggart, William},
+  title = {{AFFECTOR-ARC}: Emotional Trajectory Control through Transformer Activation Steering},
+  institution = {Modern and Classical Languages and Literatures, Virginia Tech},
+  year = {2026},
+  month = nov,
+  note = {Technical report, revision 0.2; current CUDA and emotional-effectiveness validation pending},
+  url = {https://huggingface.co/will-taggart/AFFECTOR-ARC/blob/main/TECHNICAL_REPORT.md}
+}
+```

paper/AFFECTOR-ARC-ACM-source.zip

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b853151dde3750c4ebb79ff61d2930ada77ac75456f79fcd03b2535b6fa05f01
-size 214206
+oid sha256:b2cac7c361695e81e4f5266c24c1ee6de32a2a052283c2993df3e0a10e7c1949
+size 703668

paper/AFFECTOR-ARC-ACM.pdf

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4d34c7993aad06ba2df9c62cae433e61a7e7cd2d4299087e19d061dbac469743
-size 124747
+oid sha256:eb797f999fc6257ac614cf00e764e7284ba6304ee084e44cabedc4f83e3cc840
+size 216209

paper/AFFECTOR-ARC-ACM.tex

@@ -13,6 +13,7 @@
 \providecommand{\tightlist}{\setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}
 \providecommand{\passthrough}[1]{#1}
 \providecommand{\pandocbounded}[1]{#1}
+\usepackage{graphicx}
 \begin{document}
 \title{AFFECTOR-ARC: Emotional Trajectory Control through Transformer
 Activation Steering}
@@ -195,6 +196,15 @@ minimum requirements. Users must supply an allocation and a suitable
 model cache. The runner is single-process and single-GPU; it is not a
 concurrent inference server.
 
+
+\begin{figure}[htbp]
+\centering
+\includegraphics[width=\textwidth]{figures/illustration-01.pdf}
+\caption{Execution schematic. The compute workload belongs to the allocated GPU node. Resource requests describe scheduling needs and do not establish measured minimum requirements.}
+\Description{Schedule the computation on a GPU node. Execution schematic. The compute workload belongs to the allocated GPU node. Resource requests describe scheduling needs and do not establish measured minimum requirements.}
+\label{fig:illustration-1}
+\end{figure}
+
 \section{Emotional coordinates and trajectory
 interpolation}\label{emotional-coordinates-and-trajectory-interpolation}
 
@@ -247,6 +257,15 @@ basis on the current CUDA runtime even when the imported geometry
 includes one. With no geometry argument, it uses a demonstration path
 with three points; this path is not inferred from the input document.
 
+
+\begin{figure}[htbp]
+\centering
+\includegraphics[width=\textwidth]{figures/illustration-02.pdf}
+\caption{Trajectory alignment. The runner stretches or compresses the source path over normalized target positions and may miss unsampled emotional changes.}
+\Description{Align geometry to original document positions. Trajectory alignment. The runner stretches or compresses the source path over normalized target positions and may miss unsampled emotional changes.}
+\label{fig:illustration-2}
+\end{figure}
+
 \section{Estimating activation
 directions}\label{estimating-activation-directions}
 
@@ -293,6 +312,15 @@ may encode vocabulary, topic, or perspective along with emotion.
 Normalizing the vectors does not establish that the axes are independent
 or valid across languages.
 
+
+\begin{figure}[htbp]
+\centering
+\includegraphics[width=\textwidth]{figures/illustration-03.pdf}
+\caption{Calibration schematic. The runner recalibrates the imported trajectory on the current runtime. The contrast basis is an experimental numerical control, not a validated multilingual emotion scale.}
+\Description{Recalibrate on the current CUDA runtime. Calibration schematic. The runner recalibrates the imported trajectory on the current runtime. The contrast basis is an experimental numerical control, not a validated multilingual emotion scale.}
+\label{fig:illustration-3}
+\end{figure}
+
 \section{From coordinates to bounded
 displacements}\label{from-coordinates-to-bounded-displacements}
 
@@ -391,6 +419,15 @@ emotion and the target. A zero coefficient adds no intervention on that
 axis; it does not actively neutralize emotion already expressed by the
 model.
 
+
+\begin{figure}[htbp]
+\centering
+\includegraphics[width=\textwidth]{figures/illustration-04.pdf}
+\caption{Two distinct control paths. Axis selection modifies activation coefficients before generation scores; token sampling operates afterward on the vocabulary distribution.}
+\Description{Separate activation controls from token sampling. Two distinct control paths. Axis selection modifies activation coefficients before generation scores; token sampling operates afterward on the vocabulary distribution.}
+\label{fig:illustration-4}
+\end{figure}
+
 \section{User controls and rewrite
 instructions}\label{user-controls-and-rewrite-instructions}
 
@@ -568,6 +605,15 @@ rerunning starts over and overwrites the selected output paths. Use a
 distinct output filename for each experiment. Reports contain the input
 text and should be treated as document-bearing artifacts.
 
+
+\begin{figure}[htbp]
+\centering
+\includegraphics[width=\textwidth]{figures/illustration-05.pdf}
+\caption{Output lifecycle schematic. Bounded generation, complete-prefix selection, diagnostics and per-chunk continuation address specific failure modes; they do not guarantee emotional fit or preservation of all content.}
+\Description{A failed chunk does not end the document. Output lifecycle schematic. Bounded generation, complete-prefix selection, diagnostics and per-chunk continuation address specific failure modes; they do not guarantee emotional fit or preservation of all content.}
+\label{fig:illustration-5}
+\end{figure}
+
 \section{Engineering checks and
 evidence}\label{engineering-checks-and-evidence}
 

paper/ILLUSTRATIONS.json

@@ -0,0 +1,37 @@
+[
+  {
+    "number": 1,
+    "title": "Schedule the computation on a GPU node",
+    "caption": "Execution schematic. The compute workload belongs to the allocated GPU node. Resource requests describe scheduling needs and do not establish measured minimum requirements.",
+    "section_preceded": "Emotional coordinates and trajectory interpolation",
+    "provenance": "Explanatory schematic derived from the report; not a screenshot or new experiment."
+  },
+  {
+    "number": 2,
+    "title": "Align geometry to original document positions",
+    "caption": "Trajectory alignment. The runner stretches or compresses the source path over normalized target positions and may miss unsampled emotional changes.",
+    "section_preceded": "Estimating activation directions",
+    "provenance": "Explanatory schematic derived from the report; not a screenshot or new experiment."
+  },
+  {
+    "number": 3,
+    "title": "Recalibrate on the current CUDA runtime",
+    "caption": "Calibration schematic. The runner recalibrates the imported trajectory on the current runtime. The contrast basis is an experimental numerical control, not a validated multilingual emotion scale.",
+    "section_preceded": "From coordinates to bounded displacements",
+    "provenance": "Explanatory schematic derived from the report; not a screenshot or new experiment."
+  },
+  {
+    "number": 4,
+    "title": "Separate activation controls from token sampling",
+    "caption": "Two distinct control paths. Axis selection modifies activation coefficients before generation scores; token sampling operates afterward on the vocabulary distribution.",
+    "section_preceded": "User controls and rewrite instructions",
+    "provenance": "Explanatory schematic derived from the report; not a screenshot or new experiment."
+  },
+  {
+    "number": 5,
+    "title": "A failed chunk does not end the document",
+    "caption": "Output lifecycle schematic. Bounded generation, complete-prefix selection, diagnostics and per-chunk continuation address specific failure modes; they do not guarantee emotional fit or preservation of all content.",
+    "section_preceded": "Engineering checks and evidence",
+    "provenance": "Explanatory schematic derived from the report; not a screenshot or new experiment."
+  }
+]

paper/PAPER-SHA256SUMS.txt

@@ -0,0 +1,22 @@
+b2cac7c361695e81e4f5266c24c1ee6de32a2a052283c2993df3e0a10e7c1949  AFFECTOR-ARC-ACM-source.zip
+d78577482f74cba4163db18d88af82786c923d72cd09607bde62cb747c645c5d  AFFECTOR-ARC-ACM.bbl
+eb797f999fc6257ac614cf00e764e7284ba6304ee084e44cabedc4f83e3cc840  AFFECTOR-ARC-ACM.pdf
+afeb054ba6306edf4bdc849b396e89145b762e192a44f31e5f62982245579cad  AFFECTOR-ARC-ACM.tex
+de5d2d1d955e0da3d6f033ecbde89d6b009575517e893942d07ed22f967e7705  ILLUSTRATIONS.json
+d14edda139a36c0bac8b56d02e5cda63ab7558c6db1424f1087189a9429bfaf0  LITERATURE_SOURCES.md
+8b503db789e6f4f8e297ca7f08ce5a4ebfd40fa76e65ffedacf411f027df0ecb  README.md
+cc2a27b78b373d4fd10243ae282def19ba48045af7ca7be037adb8f464df09d9  TECHNICAL_PAPER.md
+b1af14ec24b576fa1675395d73e75adfa4f5174d52902866ffef71374ddbc852  figure-specifications.json
+b072894d9761bb46543f0c584cf781aaedce49100a489a2bc1e2b48b9ad47e10  figures/illustration-01.pdf
+68020194c3306e7fecf75e94343ea2a3cb0af6d186c2d8d93220cbc6dec12e6f  figures/illustration-01.png
+e26101a755627565004dfe797f7777158b9f8f33154bb88675a5542f782390d2  figures/illustration-02.pdf
+4c625dcd3c54b524c48cad640739b1d7c973fce933d530f0f4e4d0e7cb56670b  figures/illustration-02.png
+2117943308aa158b11f4bdca85c8a74926a463f8c157eaf5d3aa322de005f968  figures/illustration-03.pdf
+288b342831d36d22626fd1a1e818ce3f7c669614d39bca237dcb4d5b745ac452  figures/illustration-03.png
+bb8302843abc13419014ea6a06d63edfe6de9e02df248ee4c1ae8e3b0e6fc0a8  figures/illustration-04.pdf
+5de084984e9ef633183868ccf98428e1e0b47af70069c29a32102b0485895af2  figures/illustration-04.png
+5e342f6be6c48eb60c8b3a423bbf1eec30d975d11db42e36ec76624aad964e83  figures/illustration-05.pdf
+5f4e1daaf625926a768773cfcb80287cb6c25ad793c4510fbecc6aaa57f4b04a  figures/illustration-05.png
+9257f38423bd7e496f1a0916c0fbaefbfb32ab544a684ca9a411508201f0535e  references.bib
+eed8b979a5a299b42e925d9027332e7df876400dcef046f2cfe26beef91d1189  render_figures.py
+cc2a27b78b373d4fd10243ae282def19ba48045af7ca7be037adb8f464df09d9  source.md

paper/README.md

@@ -1,21 +1,9 @@
-# AFFECTOR-ARC: Emotional Trajectory Control through Transformer Activation Steering
+# AFFECTOR-ARC illustrated technical report
 
-Uses the official ACM acmart class with manuscript, screen, and nonacm options. This is an independently distributed report, not an assertion of ACM publication or acceptance. No venue, DOI, or copyright transfer is invented.
+[PDF](AFFECTOR-ARC-ACM.pdf) · [ACM LaTeX](AFFECTOR-ARC-ACM.tex) · [Markdown](TECHNICAL_PAPER.md) · [Illustrations](figures/)
 
-## Build
+Five tightly cropped, reproducible technical diagrams explain the mechanisms described in the report. These are explanatory schematics, not application screenshots or new experimental results. The existing literature and scientific qualifications are retained. AI disclosure precedes references.
 
-With a current TeX Live/MacTeX installation including acmart:
+Build with `tectonic AFFECTOR-ARC-ACM.tex` (rename the resulting PDF to `AFFECTOR-ARC-ACM.pdf` where needed). The source archive includes all figure PDFs and PNGs.
 
-    latexmk -pdf AFFECTOR-ARC-ACM.tex
-
-Or Tectonic 0.17.0:
-
-    tectonic --keep-logs --keep-intermediates AFFECTOR-ARC-ACM.tex
-
-The bibliography uses ACM-Reference-Format.bst. The generated .bbl is included; references.bib remains editable. All packages are standard TeX distribution packages. No shell escape is needed. The manuscript layout is single-column; change manuscript to sigconf for a venue requiring two columns, then recheck layout.
-
-Includes the source Markdown snapshot and citation verification notes. Equations, tables, and citations are native LaTeX. AI disclosure appears immediately before the references.
-
-Original report: https://huggingface.co/will-taggart/AFFECTOR-ARC/blob/main/TECHNICAL_REPORT.md
-
-Build verified with Tectonic 0.17.0 and bundled acmart v1.83 (2022/02/19). All 12 bibliography entries resolve.
+Regenerate the diagrams with `python3 render_figures.py` (requires Matplotlib). Diagram titles and captions are recorded in `ILLUSTRATIONS.json`; vector PDF and raster PNG versions are provided.

paper/TECHNICAL_PAPER.md

@@ -0,0 +1,382 @@
+# AFFECTOR-ARC: Emotional Trajectory Control through Transformer Activation Steering
+
+**William Taggart**  
+Modern and Classical Languages and Literatures, Virginia Tech  
+Email: wtaggart@vt.edu  
+**Technical report · November 13, 2026 · Revision 0.2**
+
+## Abstract
+
+AFFECTOR-ARC is an experimental command-line system for rewriting text under a user-defined emotional trajectory. It runs a frozen Qwen3.5-0.8B model on an NVIDIA GPU and changes selected internal activations during generation. A trajectory specifies valence, inward/outward emotional orientation, and intensity across normalized document position. Small sets of contrasting English passages establish three activation directions at each selected transformer layer. At inference time, the requested coordinates determine a weighted displacement, scaled relative to the current hidden-state magnitude, smoothed across decoding steps, and constrained by an RMS budget. Paired hooks apply this displacement to both the feed-forward input and its residual path. Document rewriting combines these interventions with four editing styles, sentence-aware segmentation, bounded generation, and incremental reporting. This report derives the mechanism from its implemented operations and distinguishes numerical controls from emotional outcomes. CPU policy tests pass; the current revision still requires CUDA validation. No measured claim of emotional accuracy, semantic preservation, or multilingual effectiveness is made.
+
+## Literature review: activation steering and emotion
+
+This focused review covers twelve papers, emphasizing 2025-2026 research and retaining two methodological foundations. Titles, author lists, version histories, and the claims summarized here were checked against arXiv records and the corresponding paper text on November 13, 2026. The cited versions are fixed below; availability on arXiv alone does not establish peer review. The implications for this project are research motivations, not evidence that its implementation reproduces these results.
+
+**From activation differences to behavioral control.** Activation steering changes internal model states during inference while leaving the backbone weights fixed. Turner et al. derive intervention vectors from contrasting prompts; Panickssery et al. average differences across positive and negative behavioral examples. These provide the methodological basis for contrastive calibration, but do not validate a particular emotional coordinate system or insertion site. [Turner et al., 2023 (R1)](https://arxiv.org/abs/2308.10248v1); [Panickssery et al., 2024 (R2)](https://arxiv.org/abs/2312.06681v4).
+
+**Emotional expression and human judgment.** Wu et al. relate model emotion spaces to human valence/arousal judgments and report concept-based steering across linguistic-cultural settings. Diallo et al. evaluate perceived emotional intensity and text quality with human raters, finding that effects depend on emotion and steering strength. Together they motivate separate measures of emotional movement and readability. Their axes and numerical strengths cannot be assumed equivalent to this project's inward/outward direction or RMS-scaled controls. [Wu et al., 2025 (R3)](https://arxiv.org/abs/2506.13978v1); [Diallo et al., 2026 arXiv version (R4)](https://arxiv.org/abs/2601.21505v1).
+
+**Emotion can affect more than tone.** Sun et al.'s E-STEER uses valence-arousal-dominance interventions to study reasoning, generation, safety, and agent behavior, reporting non-monotonic relationships. Jeong's small-model comparison reports both coherent emotional changes and degeneration, including repetition, depending on extraction method and architecture. These findings motivate reporting failed generations alongside successes and testing strength sweeps rather than assuming that larger perturbations improve emotional fit. Neither study establishes an operating range for this implementation. [Sun et al., 2026 (R5)](https://arxiv.org/abs/2604.00005v1); [Jeong, 2026 (R6)](https://arxiv.org/abs/2604.04064v1).
+
+**Reading an emotion is different from controlling it.** Shu et al.'s revised study identifies uneven causal organization of sparse features across emotion categories and tests interventions for emotion recognition. Wang et al. show, in omni-modal models, that layers with strong emotion-probing accuracy need not be the best intervention layers. Recognition results therefore inform evaluator design, while layer selection for rewriting still requires causal tests on generated text. Neither finding licenses importing layer indices across architectures. [Shu et al., 2026, v3 (R7)](https://arxiv.org/abs/2604.25866v3); [Wang et al., 2026 (R8)](https://arxiv.org/abs/2609.22135v1).
+
+**Multiple axes and adaptive control.** Ha et al. find that supportive-empathy directions are only partially separable: intervening on one can shift other EPITOME proxy scores. Cui and Chen automate vector extraction from labeled data, with task-dependent benefits. Ferrando et al. adapt intervention strength to context, studying the balance between toxicity mitigation and retained utility. These approaches motivate broader calibration, cross-axis tests, and future adaptive control. The present coordinate mixture is not an implementation of their learned selectors or context-dependent gates. [Ha et al., 2026 (R9)](https://arxiv.org/abs/2609.15654v1); [Cui and Chen, 2025, revised 2026 (R10)](https://arxiv.org/abs/2509.22739v3); [Ferrando et al., 2025, revised 2026 (R11)](https://arxiv.org/abs/2512.03661v2).
+
+**Evaluation must include costs as well as target effects.** Yang et al.'s SteerScope evaluates steering efficacy jointly with side effects, generalization, and data dependence. In its tested settings, activation methods do not dominate prompt steering on the efficacy/side-effect trade-off. For this project, the resulting evaluation priorities are prompt-only and unsteered baselines, blinded emotional and quality ratings, content-change assessment appropriate to the rewrite style, and complete accounting of repetition, truncation, and original-text fallbacks. This is an evaluation agenda, not a completed benchmark. [Yang et al., 2026 (R12)](https://arxiv.org/abs/2610.07722v1).
+
+## 1. Problem and operating principle
+
+A language model generates text by repeatedly estimating a distribution over the next token. Its intermediate hidden states are numerical vectors that contribute to those estimates. Changing a hidden state can change the continuation even when the input text and the model's stored parameters remain fixed.
+
+AFFECTOR-ARC uses this property to influence the emotional expression of a rewrite. The user supplies an input document and a sequence of emotional coordinates. The software maps positions in the input to positions on that sequence, converts the coordinates into activation displacements, and applies the displacements while generating each rewritten passage.
+
+The term **geometry** means an ordered path through a three-dimensional coordinate space, together with layer settings and optional calibration matrices. It does not mean that the software reconstructs a solid surface or applies geometric constraints directly to words. A text's emotional interpretation, a numerical target, and a model's hidden states are distinct objects. The calibration is an experimental mapping between them.
+
+Two execution modes are available:
+
+- **Rewrite:** process an entire UTF-8 text document in chunks, write the transformed text, and record attempts and failures.
+- **Smoke:** run five controlled generation conditions to check basic intervention and cleanup behavior.
+
+The interface is a command-line runner for a CUDA allocation. It does not provide a desktop interface, a hosted API service, automatic emotional scoring, or conversational history.
+
+## 2. Runtime and data flow
+
+The runner loads `Qwen/Qwen3.5-0.8B` at revision `2fc06364715b967f1860aea9cf38778875588b17`. The implementation uses `Qwen3_5ForConditionalGeneration`, its text decoder layers, float32 computation, eager attention, and the first process-visible CUDA device. It checks for 24 decoder layers; the geometry and calibration code assume hidden width 1,024. The backbone is in evaluation mode, its parameters have gradients disabled, and calibration and generation run without gradient tracking.
+
+The execution sequence is:
+
+```text
+Read text and geometry settings
+    → validate controls
+    → load the pinned model on CUDA
+    → calibrate the selected layers
+    → select rewrite or smoke mode
+    → generate with temporary activation hooks
+    → remove hooks and save results
+```
+
+Source files are distributed with the repository. `ENGINE_MANIFEST.json` records hashes for the bundled engine snapshot. Model weights are downloaded separately. The setup script creates a Python 3.12 environment, installs PyTorch from the CUDA 12.6 wheel index, pins Transformers to 5.22.2, runs the CPU policy tests, and records installed packages in `environment-resolved.txt`. PyTorch and several support packages are resolved during setup rather than fully locked in advance.
+
+The example Slurm script requests one GPU, eight CPU cores, 64 GB of host memory, and one hour. These are scheduling requests, not measured minimum requirements. Users must supply an allocation and a suitable model cache. The runner is single-process and single-GPU; it is not a concurrent inference server.
+
+
+![Schedule the computation on a GPU node](figures/illustration-01.png)
+
+*Illustration 1. Execution schematic. The compute workload belongs to the allocated GPU node. Resource requests describe scheduling needs and do not establish measured minimum requirements.*
+
+## 3. Emotional coordinates and trajectory interpolation
+
+A trajectory point is
+
+$$
+p_j=(t_j,v_j,d_j,i_j),
+$$
+
+where positions $t_j$ increase strictly within $[0,1]$. Valence $v_j$ ranges from negative to positive in $[-1,1]$. Direction $d_j$ ranges from inward-oriented to outward-oriented emotion in $[-1,1]$. Intensity $i_j$ ranges from low to high in $[0,1]$. Direction is an operational contrast concerning emotional orientation; it is not dominance, speaker identification, or positive versus negative sentiment.
+
+Between adjacent points, the software linearly interpolates each emotional coordinate. Before the first point and after the last, it uses the endpoint values. The coefficient vector passed to the activation module is
+
+$$
+c(t)=\bigl(v(t),d(t),2i(t)-1\bigr).
+$$
+
+Consequently, intensity 0.5 contributes a zero intensity coefficient; intensity zero contributes a negative coefficient. These are control conventions, not empirically established psychological units.
+
+For a chunk occupying character offsets $[a,b)$ in an input of length $N$, its target is evaluated at
+
+$$
+t=\frac{a+b}{2N}.
+$$
+
+That target remains constant throughout generation of the chunk. A long trajectory can therefore guide a short document without pairing source and target paragraphs one to one. Only the positions sampled by the target chunks are used; narrow changes between those positions may be missed. The mapping uses original input positions, not positions in the expanding or contracting output. Adjacent chunks receive separate generation calls without prior rewritten chunks as conversational context.
+
+The runner accepts a native geometry JSON file and supported analysis JSON structures containing emotional coordinates. It recalibrates the basis on the current CUDA runtime even when the imported geometry includes one. With no geometry argument, it uses a demonstration path with three points; this path is not inferred from the input document.
+
+
+![Align geometry to original document positions](figures/illustration-02.png)
+
+*Illustration 2. Trajectory alignment. The runner stretches or compresses the source path over normalized target positions and may miss unsampled emotional changes.*
+
+## 4. Estimating activation directions
+
+A hidden state at a selected layer is a vector in $\mathbb{R}^{1024}$. To estimate a direction associated with one emotional contrast, the system compares the model's states for paired passages that differ in the desired property.
+
+There are four hand-authored English pairs for each of three axes. For layer $\ell$, axis $j$, and pair $k$, let $h^+_{\ell,j,k}$ and $h^-_{\ell,j,k}$ denote the captured states for the two members. The mean difference is
+
+$$
+u_{\ell,j}=\frac14\sum_{k=1}^{4}
+\left(h^+_{\ell,j,k}-h^-_{\ell,j,k}\right).
+$$
+
+For a vector of dimension $D$, define root-mean-square magnitude as
+
+$$
+\operatorname{RMS}(x)=\sqrt{\frac1D\sum_{r=1}^{D}x_r^2}.
+$$
+
+The normalized direction is
+
+$$
+b_{\ell,j}=\frac{u_{\ell,j}}
+{\max(\operatorname{RMS}(u_{\ell,j}),10^{-8})}.
+$$
+
+The three directions form the rows of a matrix $B_\ell\in\mathbb{R}^{3\times1024}$. Calibration captures the final chat-formatted prompt position immediately before `post_attention_layernorm`. It does not average all token positions. All selected layers are captured during the same 24 forward passes: three axes, four pairs, and two members per pair.
+
+Default layers are 8, 16, and 23, using zero-based indexing, with weights 1, 1, and 0.5. This is subtraction, averaging, and normalization; there is no training optimizer, backbone fine-tuning, orthogonalization, or outcome-based fitting. The small calibration set may encode vocabulary, topic, or perspective along with emotion. Normalizing the vectors does not establish that the axes are independent or valid across languages.
+
+
+![Recalibrate on the current CUDA runtime](figures/illustration-03.png)
+
+*Illustration 3. Calibration schematic. The runner recalibrates the imported trajectory on the current runtime. The contrast basis is an experimental numerical control, not a validated multilingual emotion scale.*
+
+## 5. From coordinates to bounded displacements
+
+### 5.1 Selecting and weighting axes
+
+Let $T$ be axis temperature. Each coordinate first receives magnitude
+
+$$
+q_j=|c_j|^{1/T}.
+$$
+
+Axes are sorted by this magnitude. The algorithm retains at most `axis_top_k` axes and stops adding axes after their accumulated magnitude reaches `axis_mass` times the total magnitude. Selection includes the axis that crosses the threshold. The retained coefficients are
+
+$$
+a_j=\operatorname{sign}(c_j)q_jm_j,
+$$
+
+where $m_j$ is one for a retained axis and zero otherwise. Coefficients are not renormalized after selection. For coordinate magnitudes below one, $T<1$ reduces their magnitudes and emphasizes relative differences; $T>1$ increases them and makes those differences less pronounced. These operations affect three activation coefficients, not token probabilities.
+
+### 5.2 Strength, inertia, and budget
+
+For the current final-token state $h_{\ell,n}$, strength $s$, and layer weight $w_\ell$, the raw displacement is
+
+$$
+r_{\ell,n}=s\,w_\ell\operatorname{RMS}(h_{\ell,n})(aB_\ell).
+$$
+
+Multiplication by the current state's RMS expresses the intervention relative to the layer's numerical scale. A negative layer weight reverses the mixed direction at that layer.
+
+On the first decoding step, the smoothed displacement equals $r_{\ell,n}$. On later steps, inertia $\rho$ combines the previous applied displacement with the new raw displacement:
+
+$$
+\widetilde\delta_{\ell,n}=\rho\delta_{\ell,n-1}+(1-\rho)r_{\ell,n}.
+$$
+
+Budget $\beta$ then limits the RMS ratio:
+
+$$
+\delta_{\ell,n}=\widetilde\delta_{\ell,n}
+\min\left(1,
+\frac{\beta\operatorname{RMS}(h_{\ell,n})}
+{\max(\operatorname{RMS}(\widetilde\delta_{\ell,n}),10^{-12})}
+\right).
+$$
+
+Strength determines the proposed displacement; budget supplies its ceiling. Raising the budget has no effect when the proposed displacement already fits below it. Budget 1 permits a displacement as large in RMS as the hidden state itself. It is not a token allowance, a semantic-change quota, or a guarantee of stronger emotional accuracy. Inertia uses the previous already-capped displacement and resets with each new generation call.
+
+### 5.3 Intervention site
+
+Let $h$ denote the state entering the feed-forward portion of a decoder block. Without intervention, that portion computes
+
+$$
+y=h+\operatorname{FFN}(\operatorname{Norm}(h)).
+$$
+
+The implemented intervention produces
+
+$$
+y=(h+\delta)+\operatorname{FFN}(\operatorname{Norm}(h+\delta)).
+$$
+
+A pre-hook adds $\delta$ to the normalization input; a block-output hook adds the same displacement to the residual result. Adding a vector only after an unchanged feed-forward computation would have a different effect. Only the final prompt position is modified during prefill; cached decoding modifies the current generated position. The module does not wait for specific words or phrases. Generation hooks are removed in a `finally` block.
+
+This is an open-loop intervention. Coefficients come from the requested absolute coordinates, not the difference between a measured output emotion and the target. A zero coefficient adds no intervention on that axis; it does not actively neutralize emotion already expressed by the model.
+
+
+![Separate activation controls from token sampling](figures/illustration-04.png)
+
+*Illustration 4. Two distinct control paths. Axis selection modifies activation coefficients before generation scores; token sampling operates afterward on the vocabulary distribution.*
+
+## 6. User controls and rewrite instructions
+
+| Control | Default without an imported override | Function |
+|---|---:|---|
+| Strength | 0.12 | Scale the proposed activation displacement |
+| Budget | 0.20 | Cap displacement RMS relative to hidden-state RMS |
+| Inertia | 0.20 | Weight the preceding applied displacement |
+| Axis top-k | 3 | Maximum number of retained emotional axes |
+| Axis mass | 1.0 | Cumulative magnitude threshold for axis selection |
+| Axis temperature | 1.0 | Exponent control for emotional-axis magnitudes |
+| Temperature | 0 | Select greedy decoding or token sampling |
+| Top-p | 0.95 | Probability-mass cutoff when sampling |
+| Top-k | 40 | Token candidate count when sampling |
+| Base output tokens | 512 | Initial generation allowance, expanded in rewrite mode |
+| Time limit | 120 seconds | Per-generation stopping threshold |
+
+The CLI overrides only the activation settings explicitly supplied; other settings come from the imported geometry or defaults. Validation permits strength 0–2, budget 0–1, inertia 0–0.99, axis top-k 1–3, axis mass 0.01–1, and axis temperature 0.1–3. These accepted ranges are not validated operating recommendations. The terminal displays the warning: **Extreme values for strength, budget, and inertia may cause generation failures.**
+
+At temperature zero, decoding is greedy and top-p/top-k are inactive. At positive temperature, they affect token selection after the model computes its scores. They do not replace or modify the three-axis activation selection mechanism.
+
+Four system-prompt styles provide separate editing constraints:
+
+- **Minimal:** change a few words or phrases while preserving nearly all wording and sentence order.
+- **Restrained:** adjust tone through wording, rhythm, and emphasis while preserving central meaning, facts, terminology, and structure; invent no scenes or metaphors.
+- **Balanced:** allow a clearer emotional shift and modest figurative language while retaining central meaning, facts, people, and events.
+- **Creative:** permit changes to meaning, imagery, and events, while requesting concise output in the same language.
+
+Restrained is the default in rewrite mode. Smoke mode retains its original general rewriting instruction unless a style is explicitly selected. Each prompt requests complete sentences and treats supplied text as material rather than instructions. A per-chunk suffix specifies the original character count and hard character allowance. Numerical emotional coordinates are not inserted into these prompts; the coordinates act through hidden states. Prompt instructions influence generation but are not formal semantic guarantees. The runner has no semantic-equivalence rejection filter and does not lower steering settings automatically.
+
+## 7. Segmentation, length control, and repetition
+
+The runner reads and trims the outer whitespace of a UTF-8 text file. Blank lines define paragraphs. Long paragraphs are split using a 700-character ceiling, preferring sentence punctuation when a suitable boundary exists, then whitespace, and finally a hard split. This is a punctuation heuristic, not a linguistic sentence parser. Original whitespace between chunks is preserved during output assembly.
+
+Within each original paragraph, the character ceiling is 125% of the original span processed so far. If $s$ is the first chunk's start, $b_j$ the current chunk's end, and $U_j$ the output characters and intervening whitespace already used, the current allowance is
+
+$$
+L_j=\max\left(0,\left\lfloor1.25(b_j-s)\right\rfloor-U_j\right).
+$$
+
+Unused allowance carries forward within that paragraph. It cannot be borrowed from future chunks or transferred across a blank-line paragraph boundary. Character counts are Python string lengths, not word counts, encoded byte counts, or model-token counts.
+
+Generation aims for the original length. Starting at 85% of the current input chunk's characters, a recognized sentence ending can stop generation. A separate hard character threshold prevents excessive expansion. The token allowance is
+
+$$
+K_j=\min\left(2048,\max(K_{\mathrm{base}},L_j)\right),
+$$
+
+which supplies decoding headroom but does not imply one token equals one character. The time threshold is checked between decoding steps and cannot interrupt a blocked GPU kernel immediately.
+
+Decoding also uses a repetition penalty of 1.1 and an eight-token no-repeat n-gram constraint. A text-level detector checks every eight generation steps for repeated three- to six-word sequences appearing at least four times in the last 100 words, or a short compact character pattern repeated at least six times in the last 240 characters. These heuristics can miss some loops and can flag intentional repetition.
+
+After a generation attempt, the runner checks for repetition, empty output, excessive length, and an unfinished ending. A problematic draft is reduced to a complete, nonrepetitive sentence prefix within its allowance. If none exists, the original chunk is retained and flagged. The returned draft remains in the report's attempt record before sentence salvage. However, the engine has already clipped it to the hard character allowance; the report is not a lossless record of characters beyond that boundary.
+
+Sentence cleanup prevents chopped words from being joined directly to the next passage, but it may omit ideas from the tail of a draft. Neither punctuation recognition nor output-size compliance establishes completeness of meaning.
+
+## 8. Failure handling and output artifacts
+
+Each chunk receives one generation attempt at the requested activation settings. A caught generation exception is recorded; the original chunk remains in the assembled text and processing continues. Calibration failures, invalid inputs, filesystem failures, and process termination are outside this per-chunk recovery mechanism and can stop a run. A persistent device failure may cause subsequent chunks to fail as well.
+
+After each processed chunk, the runner writes:
+
+1. An atomic JSON report containing the input, geometry, calibration basis, runtime identity, style, sampling settings, character spans, target coordinates, and per-chunk records.
+2. A matching plain-text file containing completed rewrites plus original text at unprocessed or retained positions.
+
+Successful generation records include stopping reason, token count, elapsed time, activation-injection count, and mean displacement RMS. Attempt records retain returned drafts, effective controls, detected issues, and exceptions where applicable. At normal completion the report adds failure and review counts. `complete` means every chunk was processed, not that every chunk was successfully rewritten or emotionally accurate.
+
+JSON writes use temporary-file replacement. The companion text file is written normally and may be incomplete if interrupted during that write. Reports are incremental records, not automatic resume checkpoints: rerunning starts over and overwrites the selected output paths. Use a distinct output filename for each experiment. Reports contain the input text and should be treated as document-bearing artifacts.
+
+
+![A failed chunk does not end the document](figures/illustration-05.png)
+
+*Illustration 5. Output lifecycle schematic. Bounded generation, complete-prefix selection, diagnostics and per-chunk continuation address specific failure modes; they do not guarantee emotional fit or preservation of all content.*
+
+## 9. Engineering checks and evidence
+
+Smoke mode is the default and operates on one supplied passage. It runs baseline, zero-strength, positive-valence, negative-valence, and restored-baseline conditions. Positive and negative conditions use coefficient vectors $(0.8,0,0)$ and $(-0.8,0,0)$. The third coordinate zero corresponds to intensity 0.5.
+
+With greedy decoding, the checks require zero-strength and baseline decoded text/token counts to match, nonzero injections in the positive and negative cases, restored hook counts, restored baseline text/token counts, and disabled backbone gradients. Positive and negative outputs need not differ for these checks to pass. Settings that suppress all effective intervention are unsuitable for the nonzero-injection checks.
+
+Smoke mode defaults to the original 128-token allowance and 600-second time threshold. Its original instruction permits changes in phrasing, imagery, and emotional expression while preserving the passage’s main subject and recognizable situation. It omits the new repetition penalty, n-gram guard, and document-length salvage so that existing commands retain their original generation configuration and compare raw generations. It saves completed conditions incrementally and marks `checks_complete` only after assertions pass. It does not compare logits, full token sequences, parameter hashes, or independently measured per-step RMS bounds. Run with ordinary Python rather than assertion-disabling optimization flags.
+
+For the November 13 revision, seven CPU policy tests passed, Python and shell syntax were checked, and CLI loading was verified. Tests cover such behavior as unchanged requested controls, paragraph allowance accounting, draft retention, sentence cleanup, and continuing after a failed chunk. They do not execute the CUDA model. The current revision has not yet been run on an ARC GPU. A successful GPU run was reported for an earlier revision on November 12; it is historical evidence, not validation of the current code.
+
+## 10. Reproduction
+
+Inside a suitable ARC GPU allocation, from a fresh repository copy:
+
+```bash
+bash setup.sh
+source "$(conda info --base)/etc/profile.d/conda.sh"
+conda activate "$PWD/.conda"
+python run_arc.py --mode smoke --text-file passage.txt \
+  --output runs/smoke.json
+```
+
+Setup expects a fresh `.conda` destination. A populated model cache or permitted download route is required. Existing compatible environments can execute the updated source directly.
+
+To rewrite a document:
+
+```bash
+python run_arc.py --mode rewrite --text-file target.txt \
+  --geometry shape.json --style Restrained \
+  --strength 0.47 --budget 0.47 --inertia 0.2 \
+  --temperature 0 --top-p 0.95 --top-k 40 \
+  --output runs/rewrite.json
+```
+
+These strength and budget values illustrate explicit configuration; they are not an experimentally established optimum. Omitting `--geometry` selects the demonstration trajectory. Batch smoke execution uses `sbatch --account=YOUR_ALLOCATION smoke.sbatch`; the allocation and partition must suit the user's cluster access.
+
+Archive the repository revision, engine manifest, resolved dependencies, GPU and driver information, command-line arguments, input, geometry, and report. The engine identity's `source_commit` field currently contains a snapshot label rather than a Git commit hash, so the repository revision should be recorded separately. The default seed is zero and TF32 matrix multiplication is disabled, but identical results across hardware and library versions are not guaranteed.
+
+## 11. Scientific limits and evaluation requirements
+
+The system offers a direct, inspectable intervention, not a demonstrated emotional matching algorithm. Its main limitations are the small English calibration set, untested interactions between axes and layers, open-loop use of absolute targets, and lack of independent output assessment. The model can change subject matter or factual claims, especially under Creative instructions or strong perturbations. Stronger displacement can degrade fluency without improving emotional alignment.
+
+A proper evaluation should distinguish emotional movement from target accuracy. Collect independent ratings of input and output along operationally defined axes, compare requested and observed trajectories, and report failures and unmodified fallbacks alongside successful generations. Include unsteered rewriting, prompt-only emotional instructions, opposite targets, random directions of matched magnitude, and layer/axis ablations. Keep decoding settings fixed for controlled comparisons, and separate greedy from sampled experiments.
+
+Semantic fidelity should be evaluated against the selected style: Creative permits mutation, whereas Restrained requests factual preservation. Fluency, coherence across chunks, omitted material, repetition, length ratios, latency, and memory consumption are separate outcomes. No automatic similarity score, feedback optimization, or acceptance threshold is implemented in this runner.
+
+Changing to a larger model requires new architecture validation, basis calibration, layer selection, and operating-range experiments. A basis with three rows and 1,024 columns cannot simply be reused with a different hidden width or intervention site. Multilingual operation likewise requires independent calibration and evaluation; same-language prompt wording alone does not establish it.
+
+## Implementation sources
+
+This report describes the repository's executable operations rather than relying on another application's interface or documentation.
+
+- [CUDA runner and smoke protocol](run_arc.py)
+- [Document transformation and incremental output](document_run.py)
+- [Calibration, displacement math, hooks, and decoding](engine/steering.py)
+- [Geometry schema and interpolation](engine/geometry.py)
+- [Segmentation and character allowance](engine/documents.py)
+- [Rewrite system prompts](engine/rewrite_policy.py)
+- [Repetition detection and draft salvage](engine/generation.py)
+- [Engine source hashes](ENGINE_MANIFEST.json)
+- [Generation policy tests](tests/test_generation.py) and [document-run tests](tests/test_document_run.py)
+
+## AI assistance disclosure
+
+This project was created with assistance from GPT-6 Astra and Codex. AI tools supported software development, testing, and the drafting and revision of this technical report. William Taggart is responsible for the project's research decisions and the final software and documentation. AI assistance does not constitute independent validation of the implementation or its scientific claims; the validation evidence and limitations are stated separately in this report.
+
+## Research references
+
+Version-specific arXiv records are linked below. Years distinguish original release from later revision where applicable. These research references supplement the implementation and infrastructure sources elsewhere in this report. Reusable citations: [BibTeX](references.bib). Verification details: [source-check notes](LITERATURE_SOURCES.md).
+
+**R1.** Alex Turner; Lisa Thiergart; David Udell; Gavin Leech; Ulisse Mini; Monte MacDiarmid. 2023. Activation Addition: Steering Language Models Without Optimization. [arXiv:2308.10248v1](https://arxiv.org/abs/2308.10248v1). Cited version dated 2023-08-20.
+
+**R2.** Nina Panickssery; Nick Gabrieli; Julian Schulz; Meg Tong; Evan Hubinger; Alexander Matt Turner. 2024. Steering Llama 2 via Contrastive Activation Addition. [arXiv:2312.06681v4](https://arxiv.org/abs/2312.06681v4). Cited version dated 2024-07-05.
+
+**R3.** Xiuwen Wu; Hao Wang; Zhiang Yan; Xiaohan Tang; Pengfei Xu; Wai-Ting Siok; Ping Li; Jia-Hong Gao; Bingjiang Lyu; Lang Qin. 2025. AI shares emotion with humans across languages and cultures. [arXiv:2506.13978v1](https://arxiv.org/abs/2506.13978v1). Cited version dated 2025-06-11.
+
+**R4.** Diaoulé Diallo; Katharina Dworatzyk; Sophie Jentzsch; Peer Schütt; Sabine Theis; Tobias Hecking. 2026. The Effectiveness of Style Vectors for Steering Large Language Models: A Human Evaluation. [arXiv:2601.21505v1](https://arxiv.org/abs/2601.21505v1). Cited version dated 2026-01-29. ArXiv record lists IEEE Access 13 (2025), 191443-191457; DOI: 10.1109/ACCESS.2025.3628500.
+
+**R5.** Moran Sun; Tianlin Li; Yuwei Zheng; Zhenhong Zhou; Aishan Liu; Xianglong Liu; Yang Liu. 2026. How Emotion Shapes the Behavior of LLMs and Agents: A Mechanistic Study. [arXiv:2604.00005v1](https://arxiv.org/abs/2604.00005v1). Cited version dated 2026-03-09.
+
+**R6.** Jihoon Jeong. 2026. Extracting and Steering Emotion Representations in Small Language Models: A Methodological Comparison. [arXiv:2604.04064v1](https://arxiv.org/abs/2604.04064v1). Cited version dated 2026-04-05.
+
+**R7.** Bangzhao Shu; Arinjay Singh; Mai ElSherief. 2026. Why Are Some Emotions Harder for LLMs? Uncovering the Causal Mechanisms of Emotion Inference via Sparse Autoencoders. [arXiv:2604.25866v3](https://arxiv.org/abs/2604.25866v3). Cited version dated 2026-10-24.
+
+**R8.** Yibo Wang; Jisheng Dang; Bimei Wang; Yitao Wu; Wencan Zhang; Hong Peng; Jizhao Liu; Bin Hu; Qi Tian; Tat-Seng Chua. 2026. Read-Best Is Not Steer-Best: A Probing--Steering Layer Dissociation in Omni-Modal Large Language Models. [arXiv:2609.22135v1](https://arxiv.org/abs/2609.22135v1). Cited version dated 2026-08-24.
+
+**R9.** JuHeon Ha; Byounghan Lee; Yunseo Choi; Kyung-Ah Sohn. 2026. Empathy Is Steerable but Multi-Axial: Mechanism Geometry and Persona Effects in LLMs. [arXiv:2609.15654v1](https://arxiv.org/abs/2609.15654v1). Cited version dated 2026-09-14. ArXiv comments report acceptance to the EMNLP 2026 main conference.
+
+**R10.** Sasha Cui; Zhongren Chen. 2025. Painless Activation Steering: An Automated, Lightweight Approach for Post-Training Large Language Models. [arXiv:2509.22739v3](https://arxiv.org/abs/2509.22739v3). Cited version dated 2026-05-15.
+
+**R11.** Alex Ferrando; Xavier Suau; Jordi Gonzàlez; Pau Rodriguez. 2025. Dynamically Scaled Activation Steering. [arXiv:2512.03661v2](https://arxiv.org/abs/2512.03661v2). Cited version dated 2026-07-30.
+
+**R12.** Haotian Yang; Huikang Jiang; Yucheng Wu; Wen-Jie Jiang; Chenpeng Wang; Yibin Lou; Liangming Pan. 2026. Does Steering Break Your Model? A Multi-Dimensional Evaluation Suite for LLM Steering Methods. [arXiv:2610.07722v1](https://arxiv.org/abs/2610.07722v1). Cited version dated 2026-10-06.
+
+### Suggested citation
+
+```bibtex
+@techreport{taggart2026affectorarc,
+  author = {Taggart, William},
+  title = {{AFFECTOR-ARC}: Emotional Trajectory Control through Transformer Activation Steering},
+  institution = {Modern and Classical Languages and Literatures, Virginia Tech},
+  year = {2026},
+  month = nov,
+  note = {Technical report, revision 0.2; current CUDA and emotional-effectiveness validation pending},
+  url = {https://huggingface.co/will-taggart/AFFECTOR-ARC/blob/main/TECHNICAL_REPORT.md}
+}
+```

paper/figure-specifications.json

@@ -0,0 +1,92 @@
+[
+  [
+    "Emotional coordinates and trajectory interpolation",
+    "Schedule the computation on a GPU node",
+    [
+      [
+        "Text + geometry + controls",
+        "Slurm resource request",
+        "Allocated compute node"
+      ],
+      [
+        "CUDA model load",
+        "Calibrate and rewrite",
+        "Results and diagnostics"
+      ]
+    ],
+    "Single-process, single-GPU runner; queue requests are not performance measurements",
+    "Execution schematic. The compute workload belongs to the allocated GPU node. Resource requests describe scheduling needs and do not establish measured minimum requirements."
+  ],
+  [
+    "Estimating activation directions",
+    "Align geometry to original document positions",
+    [
+      [
+        "Increasing t in [0,1]",
+        "Linear interpolation",
+        "Endpoint clamping"
+      ],
+      [
+        "Chunk midpoint in original text",
+        "Sample (v,d,2i-1)",
+        "Hold target through chunk"
+      ]
+    ],
+    "One target per generation call; neighbors are not prior conversational context",
+    "Trajectory alignment. The runner stretches or compresses the source path over normalized target positions and may miss unsampled emotional changes."
+  ],
+  [
+    "From coordinates to bounded displacements",
+    "Recalibrate on the current CUDA runtime",
+    [
+      [
+        "12 English contrast pairs",
+        "Capture final prompt positions",
+        "24 forward passes"
+      ],
+      [
+        "Mean positive-minus-negative",
+        "RMS-normalize axis rows",
+        "B_l: 3 x 1024"
+      ]
+    ],
+    "Default layers 8, 16, 23 with weights 1, 1, 0.5; no optimizer",
+    "Calibration schematic. The runner recalibrates the imported trajectory on the current runtime. The contrast basis is an experimental numerical control, not a validated multilingual emotion scale."
+  ],
+  [
+    "User controls and rewrite instructions",
+    "Separate activation controls from token sampling",
+    [
+      [
+        "Axis temperature / mass / top-k",
+        "Strength + inertia + budget",
+        "Bounded hidden-state delta"
+      ],
+      [
+        "Generation temperature",
+        "Token top-p / top-k",
+        "Choose output token"
+      ]
+    ],
+    "At generation temperature 0, decoding is greedy and token top-p/top-k are inactive",
+    "Two distinct control paths. Axis selection modifies activation coefficients before generation scores; token sampling operates afterward on the vocabulary distribution."
+  ],
+  [
+    "Engineering checks and evidence",
+    "A failed chunk does not end the document",
+    [
+      [
+        "Attempt chunk once",
+        "Inspect repetition and ending",
+        "Select usable output or fallback"
+      ],
+      [
+        "Record warnings and raw draft",
+        "Advance to next chunk",
+        "Write text and report artifacts"
+      ]
+    ],
+    "Keep requested steering settings; report failure rather than silently weakening controls",
+    "Output lifecycle schematic. Bounded generation, complete-prefix selection, diagnostics and per-chunk continuation address specific failure modes; they do not guarantee emotional fit or preservation of all content."
+  ]
+]

paper/render_figures.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+import json,textwrap
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+from matplotlib.patches import FancyBboxPatch,FancyArrowPatch
+plt.rcParams.update({'font.family':'DejaVu Sans','font.size':11,'pdf.fonttype':42})
+def diagram(path,title,lanes,footer):
+ fig,ax=plt.subplots(figsize=(10.6,3.55));ax.set_xlim(0,10.6);ax.set_ylim(0,3.55);ax.axis('off')
+ ax.text(.12,3.28,title,fontsize=17,weight='bold',va='center',color='#18232b')
+ for row,lane in enumerate(lanes):
+  y=2.02-row*1.05
+  for col,label in enumerate(lane):
+   x=.12+col*3.55
+   ax.add_patch(FancyBboxPatch((x,y),3.15,.78,boxstyle='round,pad=0.05,rounding_size=0.07',facecolor='#eef3f5' if row==0 else '#f5f5f5',edgecolor='#8c9da6',lw=.85))
+   ax.text(x+1.575,y+.39,textwrap.fill(label,26),ha='center',va='center',fontsize=11.4,color='#17242b')
+   if col<2 and not (title.startswith('Three scores') or (title.startswith('Objects are') and row==0)):ax.add_patch(FancyArrowPatch((x+3.22,y+.39),(x+3.48,y+.39),arrowstyle='-|>',mutation_scale=13,color='#486570',lw=1.2))
+ ax.text(.12,.30,textwrap.fill(footer,102),fontsize=10.6,va='center',color='#374b57')
+ fig.savefig(path.with_suffix('.pdf'),bbox_inches='tight',pad_inches=.06)
+ fig.savefig(path.with_suffix('.png'),bbox_inches='tight',pad_inches=.06,dpi=200)
+ plt.close(fig)
+
+r=Path(__file__).parent
+for k,(_,title,lanes,footer,_) in enumerate(json.loads((r/'figure-specifications.json').read_text()),1):
+ diagram(r/'figures'/f'illustration-{k:02}',title,lanes,footer)

paper/source.md

@@ -60,6 +60,11 @@ Source files are distributed with the repository. `ENGINE_MANIFEST.json` records
 
 The example Slurm script requests one GPU, eight CPU cores, 64 GB of host memory, and one hour. These are scheduling requests, not measured minimum requirements. Users must supply an allocation and a suitable model cache. The runner is single-process and single-GPU; it is not a concurrent inference server.
 
+
+![Schedule the computation on a GPU node](figures/illustration-01.png)
+
+*Illustration 1. Execution schematic. The compute workload belongs to the allocated GPU node. Resource requests describe scheduling needs and do not establish measured minimum requirements.*
+
 ## 3. Emotional coordinates and trajectory interpolation
 
 A trajectory point is
@@ -88,6 +93,11 @@ That target remains constant throughout generation of the chunk. A long trajecto
 
 The runner accepts a native geometry JSON file and supported analysis JSON structures containing emotional coordinates. It recalibrates the basis on the current CUDA runtime even when the imported geometry includes one. With no geometry argument, it uses a demonstration path with three points; this path is not inferred from the input document.
 
+
+![Align geometry to original document positions](figures/illustration-02.png)
+
+*Illustration 2. Trajectory alignment. The runner stretches or compresses the source path over normalized target positions and may miss unsampled emotional changes.*
+
 ## 4. Estimating activation directions
 
 A hidden state at a selected layer is a vector in $\mathbb{R}^{1024}$. To estimate a direction associated with one emotional contrast, the system compares the model's states for paired passages that differ in the desired property.
@@ -116,6 +126,11 @@ The three directions form the rows of a matrix $B_\ell\in\mathbb{R}^{3\times1024
 
 Default layers are 8, 16, and 23, using zero-based indexing, with weights 1, 1, and 0.5. This is subtraction, averaging, and normalization; there is no training optimizer, backbone fine-tuning, orthogonalization, or outcome-based fitting. The small calibration set may encode vocabulary, topic, or perspective along with emotion. Normalizing the vectors does not establish that the axes are independent or valid across languages.
 
+
+![Recalibrate on the current CUDA runtime](figures/illustration-03.png)
+
+*Illustration 3. Calibration schematic. The runner recalibrates the imported trajectory on the current runtime. The contrast basis is an experimental numerical control, not a validated multilingual emotion scale.*
+
 ## 5. From coordinates to bounded displacements
 
 ### 5.1 Selecting and weighting axes
@@ -180,6 +195,11 @@ A pre-hook adds $\delta$ to the normalization input; a block-output hook adds th
 
 This is an open-loop intervention. Coefficients come from the requested absolute coordinates, not the difference between a measured output emotion and the target. A zero coefficient adds no intervention on that axis; it does not actively neutralize emotion already expressed by the model.
 
+
+![Separate activation controls from token sampling](figures/illustration-04.png)
+
+*Illustration 4. Two distinct control paths. Axis selection modifies activation coefficients before generation scores; token sampling operates afterward on the vocabulary distribution.*
+
 ## 6. User controls and rewrite instructions
 
 | Control | Default without an imported override | Function |
@@ -248,6 +268,11 @@ Successful generation records include stopping reason, token count, elapsed time
 
 JSON writes use temporary-file replacement. The companion text file is written normally and may be incomplete if interrupted during that write. Reports are incremental records, not automatic resume checkpoints: rerunning starts over and overwrites the selected output paths. Use a distinct output filename for each experiment. Reports contain the input text and should be treated as document-bearing artifacts.
 
+
+![A failed chunk does not end the document](figures/illustration-05.png)
+
+*Illustration 5. Output lifecycle schematic. Bounded generation, complete-prefix selection, diagnostics and per-chunk continuation address specific failure modes; they do not guarantee emotional fit or preservation of all content.*
+
 ## 9. Engineering checks and evidence
 
 Smoke mode is the default and operates on one supplied passage. It runs baseline, zero-strength, positive-valence, negative-valence, and restored-baseline conditions. Positive and negative conditions use coefficient vectors $(0.8,0,0)$ and $(-0.8,0,0)$. The third coordinate zero corresponds to intensity 0.5.