feat(architect): Add modifier field to intent decoder, refine prompt

apps/gui/src/components/play/PlayView.tsx

@@ -17,8 +17,10 @@ import type { LLMProviderInstance } from "@omnia/llm";
 
 function IntentTag({
   intent,
+  isSelf,
 }: {
   intent: SimSnapshot["log"][number]["intents"][number];
+  isSelf?: boolean;
 }) {
   const labels: Record<string, string> = {
     monologue: "thought",
@@ -33,9 +35,19 @@ function IntentTag({
     outcome = intent.isValid ? " ✅" : ` ❌ (${intent.reason})`;
   }
 
+  const textToDisplay = (isSelf && intent.selfDescription)
+    ? intent.selfDescription
+    : intent.description;
+
+  const modifiersStr = intent.modifiers && intent.modifiers.length > 0 ? (
+    <span className="intent-modifiers" style={{ fontStyle: "italic", opacity: 0.8, color: "#4b5563", marginLeft: "0.25rem" }}>
+      ({intent.modifiers.join(", ")})
+    </span>
+  ) : null;
+
   return (
     <span className="intent-tag">
-      [{label}] &ldquo;{intent.description}&rdquo;{outcome}
+      [{label}] &ldquo;{textToDisplay}&rdquo;{modifiersStr}{outcome}
       {intent.minutesToAdvance ? ` [+${intent.minutesToAdvance}min]` : ""}
     </span>
   );
@@ -50,6 +62,77 @@ function PromptModal({
 }) {
   const [activeTab, setActiveTab] = useState<"actor" | "decoder">("actor");
 
+  const parseActorPrompt = (systemPrompt: string, userContext: string, inputTokens: number) => {
+    const memoryHeader = "=== YOUR RECENT MEMORY ===";
+    const idx = userContext.indexOf(memoryHeader);
+
+    let worldStr = userContext;
+    let memStr = "";
+
+    if (idx !== -1) {
+      worldStr = userContext.substring(0, idx).trim();
+      memStr = userContext.substring(idx).trim();
+    }
+
+    const sysLen = systemPrompt.length;
+    const worldLen = worldStr.length;
+    const memLen = memStr.length;
+    const totalLen = sysLen + worldLen + memLen;
+
+    if (totalLen === 0) return null;
+
+    const sysPct = (sysLen / totalLen) * 100;
+    const worldPct = (worldLen / totalLen) * 100;
+    const memPct = (memLen / totalLen) * 100;
+
+    const sysTokens = Math.round((sysLen / totalLen) * inputTokens);
+    const worldTokens = Math.round((worldLen / totalLen) * inputTokens);
+    const memTokens = Math.max(0, inputTokens - sysTokens - worldTokens);
+
+    return [
+      { label: "System Prompt", pct: sysPct, tokens: sysTokens, type: "system", content: systemPrompt },
+      { label: "World Info", pct: worldPct, tokens: worldTokens, type: "world", content: worldStr },
+      { label: "Recent Memories", pct: memPct, tokens: memTokens, type: "memories", content: memStr || "(No memories yet.)" },
+    ];
+  };
+
+  const parseDecoderPrompt = (systemPrompt: string, userContext: string, inputTokens: number) => {
+    const proseHeader = "=== NARRATIVE PROSE ===";
+    const idx = userContext.indexOf(proseHeader);
+
+    let worldStr = userContext;
+    let proseStr = "";
+
+    if (idx !== -1) {
+      worldStr = userContext.substring(0, idx).trim();
+      proseStr = userContext.substring(idx).trim();
+    }
+
+    const sysLen = systemPrompt.length;
+    const worldLen = worldStr.length;
+    const proseLen = proseStr.length;
+    const totalLen = sysLen + worldLen + proseLen;
+
+    if (totalLen === 0) return null;
+
+    const sysPct = (sysLen / totalLen) * 100;
+    const worldPct = (worldLen / totalLen) * 100;
+    const prosePct = (proseLen / totalLen) * 100;
+
+    const sysTokens = Math.round((sysLen / totalLen) * inputTokens);
+    const worldTokens = Math.round((worldLen / totalLen) * inputTokens);
+    const proseTokens = Math.max(0, inputTokens - sysTokens - worldTokens);
+
+    return [
+      { label: "System Prompt", pct: sysPct, tokens: sysTokens, type: "system", content: systemPrompt },
+      { label: "Decoder Context", pct: worldPct, tokens: worldTokens, type: "world", content: worldStr },
+      { label: "Narrative Prose", pct: prosePct, tokens: proseTokens, type: "memories", content: proseStr },
+    ];
+  };
+
+  const actorBreakdown = (entry.rawPrompt && entry.usage) ? parseActorPrompt(entry.rawPrompt.systemPrompt, entry.rawPrompt.userContext, entry.usage.inputTokens) : null;
+  const decoderBreakdown = (entry.decoderPrompt && entry.decoderUsage) ? parseDecoderPrompt(entry.decoderPrompt.systemPrompt, entry.decoderPrompt.userContext, entry.decoderUsage.inputTokens) : null;
+
   useEffect(() => {
     if (!entry.rawPrompt && entry.decoderPrompt) {
       setActiveTab("decoder");
@@ -85,50 +168,124 @@ function PromptModal({
           {activeTab === "actor" && entry.rawPrompt && (
             <div className="tab-pane">
               {entry.usage ? (
-                <div className="usage-stats">
-                  <strong>Token Usage:</strong>
-                  <span>Input: <code>{entry.usage.inputTokens}</code></span> &middot;{" "}
-                  <span>Output: <code>{entry.usage.outputTokens}</code></span> &middot;{" "}
-                  <span>Total: <code>{entry.usage.totalTokens}</code></span>
+                <div className="provider-info">
+                  <strong>LLM Instance:</strong> <span>{entry.usage.providerInstanceName || "Default"}</span>
+                  {entry.usage.modelName && (
+                    <span> ({entry.usage.modelName})</span>
+                  )}
                 </div>
               ) : (
-                <div className="usage-stats italic text-gray">
+                <div className="provider-info italic text-gray">
                   No LLM token usage (Player turn used fixed prose).
                 </div>
               )}
 
-              <div className="prompt-field">
-                <h4>System Prompt</h4>
-                <pre>{entry.rawPrompt.systemPrompt}</pre>
-              </div>
+              {actorBreakdown && (
+                <div className="prompt-breakdown-container">
+                  <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center", fontSize: "0.75rem", color: "#6b7280", marginBottom: "0.25rem" }}>
+                    <span style={{ fontWeight: 600 }}>Input Prompt Breakdown</span>
+                    <span>Total Input Tokens: <strong>{entry.usage?.inputTokens}</strong></span>
+                  </div>
+                  <div className="prompt-breakdown-bar">
+                    {actorBreakdown.map((item, idx) => (
+                      <div
+                        key={idx}
+                        className={`bar-section ${item.type}`}
+                        style={{ width: `${item.pct}%` }}
+                        title={`${item.label}: ${item.tokens} tokens (${item.pct.toFixed(1)}%)`}
+                      />
+                    ))}
+                  </div>
+                  <div className="breakdown-accordion">
+                    {actorBreakdown.map((item, idx) => (
+                      <details key={idx} className="breakdown-accordion-item" open={idx === 0}>
+                        <summary className="accordion-header">
+                          <span className={`legend-color ${item.type}`} />
+                          <span className="header-text">
+                            {item.label}: <strong>{item.tokens}</strong> tokens ({item.pct.toFixed(0)}%)
+                          </span>
+                          <span className="accordion-chevron">▼</span>
+                        </summary>
+                        <div className="accordion-content">
+                          <pre>{item.content}</pre>
+                        </div>
+                      </details>
+                    ))}
+                  </div>
+                </div>
+              )}
 
-              <div className="prompt-field">
-                <h4>User Context</h4>
-                <pre>{entry.rawPrompt.userContext}</pre>
-              </div>
+              {entry.usage && (
+                <div className="prompt-output-section" style={{ marginTop: "0.5rem" }}>
+                  <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center", fontSize: "0.75rem", color: "#6b7280", marginBottom: "0.5rem" }}>
+                    <span style={{ fontWeight: 600 }}>LLM Output</span>
+                    <span>Total Output Tokens: <strong>{entry.usage.outputTokens}</strong></span>
+                  </div>
+                  <div className="accordion-content" style={{ border: "1px solid #e5e7eb", borderRadius: "6px" }}>
+                    <pre>{entry.narrativeProse}</pre>
+                  </div>
+                </div>
+              )}
             </div>
           )}
 
           {activeTab === "decoder" && entry.decoderPrompt && (
             <div className="tab-pane">
               {entry.decoderUsage && (
-                <div className="usage-stats">
-                  <strong>Token Usage:</strong>
-                  <span>Input: <code>{entry.decoderUsage.inputTokens}</code></span> &middot;{" "}
-                  <span>Output: <code>{entry.decoderUsage.outputTokens}</code></span> &middot;{" "}
-                  <span>Total: <code>{entry.decoderUsage.totalTokens}</code></span>
+                <div className="provider-info">
+                  <strong>LLM Instance:</strong> <span>{entry.decoderUsage.providerInstanceName || "Default"}</span>
+                  {entry.decoderUsage.modelName && (
+                    <span> ({entry.decoderUsage.modelName})</span>
+                  )}
                 </div>
               )}
 
-              <div className="prompt-field">
-                <h4>System Prompt</h4>
-                <pre>{entry.decoderPrompt.systemPrompt}</pre>
-              </div>
+              {decoderBreakdown && (
+                <div className="prompt-breakdown-container">
+                  <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center", fontSize: "0.75rem", color: "#6b7280", marginBottom: "0.25rem" }}>
+                    <span style={{ fontWeight: 600 }}>Input Prompt Breakdown</span>
+                    <span>Total Input Tokens: <strong>{entry.decoderUsage?.inputTokens}</strong></span>
+                  </div>
+                  <div className="prompt-breakdown-bar">
+                    {decoderBreakdown.map((item, idx) => (
+                      <div
+                        key={idx}
+                        className={`bar-section ${item.type}`}
+                        style={{ width: `${item.pct}%` }}
+                        title={`${item.label}: ${item.tokens} tokens (${item.pct.toFixed(1)}%)`}
+                      />
+                    ))}
+                  </div>
+                  <div className="breakdown-accordion">
+                    {decoderBreakdown.map((item, idx) => (
+                      <details key={idx} className="breakdown-accordion-item" open={idx === 0}>
+                        <summary className="accordion-header">
+                          <span className={`legend-color ${item.type}`} />
+                          <span className="header-text">
+                            {item.label}: <strong>{item.tokens}</strong> tokens ({item.pct.toFixed(0)}%)
+                          </span>
+                          <span className="accordion-chevron">▼</span>
+                        </summary>
+                        <div className="accordion-content">
+                          <pre>{item.content}</pre>
+                        </div>
+                      </details>
+                    ))}
+                  </div>
+                </div>
+              )}
 
-              <div className="prompt-field">
-                <h4>User Context</h4>
-                <pre>{entry.decoderPrompt.userContext}</pre>
-              </div>
+              {entry.decoderUsage && (
+                <div className="prompt-output-section" style={{ marginTop: "0.5rem" }}>
+                  <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center", fontSize: "0.75rem", color: "#6b7280", marginBottom: "0.5rem" }}>
+                    <span style={{ fontWeight: 600 }}>LLM Output</span>
+                    <span>Total Output Tokens: <strong>{entry.decoderUsage.outputTokens}</strong></span>
+                  </div>
+                  <div className="accordion-content" style={{ border: "1px solid #e5e7eb", borderRadius: "6px" }}>
+                    <pre>{JSON.stringify(entry.intents, null, 2)}</pre>
+                  </div>
+                </div>
+              )}
             </div>
           )}
         </div>
@@ -137,12 +294,30 @@ function PromptModal({
   );
 }
 
+function formatSimTime(isoString: string) {
+  try {
+    const d = new Date(isoString);
+    if (isNaN(d.getTime())) return isoString;
+    const yyyy = d.getUTCFullYear();
+    const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
+    const dd = String(d.getUTCDate()).padStart(2, "0");
+    const hh = String(d.getUTCHours()).padStart(2, "0");
+    const min = String(d.getUTCMinutes()).padStart(2, "0");
+    const ss = String(d.getUTCSeconds()).padStart(2, "0");
+    return `${yyyy}-${mm}-${dd} ${hh}:${min}:${ss} UTC`;
+  } catch {
+    return isoString;
+  }
+}
+
 function LogEntryCard({
   entry,
   onShowPrompt,
+  isPlayerCard,
 }: {
   entry: SimSnapshot["log"][number];
   onShowPrompt: (entry: SimSnapshot["log"][number]) => void;
+  isPlayerCard: boolean;
 }) {
   const showMenu = !!(entry.rawPrompt || entry.decoderPrompt);
 
@@ -153,7 +328,7 @@ function LogEntryCard({
           <strong>{entry.entityName}</strong>
           <span className="log-meta">
             Turn {entry.turn} &middot;{" "}
-            {new Date(entry.timestamp).toLocaleTimeString()}
+            {formatSimTime(entry.timestamp)}
           </span>
         </div>
         {showMenu && (
@@ -169,7 +344,7 @@ function LogEntryCard({
       <div className="log-prose">{entry.narrativeProse}</div>
       <div className="log-intents">
         {entry.intents.map((intent, i) => (
-          <IntentTag key={i} intent={intent} />
+          <IntentTag key={i} intent={intent} isSelf={isPlayerCard} />
         ))}
       </div>
     </div>
@@ -185,6 +360,7 @@ export function PlayView() {
   const [selectedEntryForModal, setSelectedEntryForModal] = useState<SimSnapshot["log"][number] | null>(null);
   const logEndRef = useRef<HTMLDivElement>(null);
   const steppingRef = useRef(false);
+  const pauseRequestedRef = useRef(false);
 
   const scrollToBottom = useCallback(() => {
     setTimeout(
@@ -203,10 +379,14 @@ export function PlayView() {
       steppingRef.current = true;
       setLoading(true);
       setError("");
+      pauseRequestedRef.current = false;
 
       try {
         let current = snapshot;
         while (true) {
+          if (pauseRequestedRef.current) {
+            break;
+          }
           const result = await stepSimulation({ simId: id });
           if (!result.ok) {
             setError(result.error);
@@ -276,6 +456,8 @@ export function PlayView() {
       setSnapshot(res.snapshot);
       if (res.snapshot.status === "running") {
         await runSteps(res.snapshot.id);
+      } else {
+        setLoading(false);
       }
     } catch (err) {
       setError(err instanceof Error ? err.message : "Failed to resume session.");
@@ -307,7 +489,6 @@ export function PlayView() {
   const [selectedEntity, setSelectedEntity] = useState("");
 
   const [providerInstances, setProviderInstances] = useState<LLMProviderInstance[]>([]);
-  const [selectedProviderInstance, setSelectedProviderInstance] = useState("");
 
   // Load scenarios and provider instances on mount
   useEffect(() => {
@@ -324,12 +505,6 @@ export function PlayView() {
       try {
         const providersList = await listProviderInstances();
         setProviderInstances(providersList);
-        const active = providersList.find(p => p.isActive);
-        if (active) {
-          setSelectedProviderInstance(active.id);
-        } else if (providersList.length > 0) {
-          setSelectedProviderInstance(providersList[0].id);
-        }
       } catch {
         // ignore
       }
@@ -372,7 +547,6 @@ export function PlayView() {
       const result = await startSimulation({
         scenario: (form.get("scenario") as string) || undefined,
         playEntity: (form.get("playEntity") as string) || undefined,
-        providerInstanceId: selectedProviderInstance || undefined,
       });
 
       if (!result.ok) {
@@ -385,6 +559,8 @@ export function PlayView() {
 
       if (result.snapshot.status === "running") {
         await runSteps(result.snapshot.id);
+      } else {
+        setLoading(false);
       }
     } catch (err) {
       setError(
@@ -491,25 +667,7 @@ export function PlayView() {
                   ))}
                 </select>
               </div>
-              <div className="field">
-                <label htmlFor="llmInstance">LLM Key / Instance</label>
-                <select
-                  id="llmInstance"
-                  value={selectedProviderInstance}
-                  onChange={(e) => setSelectedProviderInstance(e.target.value)}
-                  disabled={providerInstances.length === 0}
-                >
-                  {providerInstances.length === 0 ? (
-                    <option value="">Default (from Env variable)</option>
-                  ) : (
-                    providerInstances.map((p) => (
-                      <option key={p.id} value={p.id}>
-                        {p.name} ({p.providerName}) {p.isActive ? " [Active]" : ""}
-                      </option>
-                    ))
-                  )}
-                </select>
-              </div>
+
               <button type="submit" disabled={loading || providerInstances.length === 0}>
                 {loading ? "Starting..." : "Start Simulation"}
               </button>
@@ -560,15 +718,36 @@ export function PlayView() {
             <div className="sim-info-header">
               <h2>{snapshot.scenarioName}</h2>
               {snapshot.status !== "done" && snapshot.status !== "error" && (
-                <button
-                  className="stop-btn"
-                  onClick={() => {
-                    setSnapshot(null);
-                    setError("");
-                  }}
-                >
-                  Stop
-                </button>
+                <div style={{ display: "flex", gap: "0.5rem" }}>
+                  {snapshot.status === "running" && (
+                    loading ? (
+                      <button
+                        className="pause-btn"
+                        onClick={() => {
+                          pauseRequestedRef.current = true;
+                        }}
+                      >
+                        Pause
+                      </button>
+                    ) : (
+                      <button
+                        className="resume-btn"
+                        onClick={() => runSteps(snapshot.id)}
+                      >
+                        Resume
+                      </button>
+                    )
+                  )}
+                  <button
+                    className="stop-btn"
+                    onClick={() => {
+                      setSnapshot(null);
+                      setError("");
+                    }}
+                  >
+                    Stop
+                  </button>
+                </div>
               )}
             </div>
             <p>{snapshot.scenarioDescription}</p>
@@ -579,13 +758,17 @@ export function PlayView() {
           </div>
 
           <div className="log-container">
-            {snapshot.log.map((entry, i) => (
-              <LogEntryCard
-                key={i}
-                entry={entry}
-                onShowPrompt={setSelectedEntryForModal}
-              />
-            ))}
+            {(() => {
+              const playerEntity = snapshot.entities.find((e) => e.isPlayer);
+              return snapshot.log.map((entry, i) => (
+                <LogEntryCard
+                  key={i}
+                  entry={entry}
+                  onShowPrompt={setSelectedEntryForModal}
+                  isPlayerCard={entry.entityId === playerEntity?.id}
+                />
+              ));
+            })()}
             {loading && (
               <div className="log-processing">
                 <span className="spinner" />
@@ -721,6 +904,18 @@ export function PlayView() {
           padding: 0.25rem 0.75rem;
         }
 
+        .pause-btn {
+          background: #d97706;
+          font-size: 0.75rem;
+          padding: 0.25rem 0.75rem;
+        }
+
+        .resume-btn {
+          background: #059669;
+          font-size: 0.75rem;
+          padding: 0.25rem 0.75rem;
+        }
+
         .sim-info {
           margin-bottom: 1rem;
         }
@@ -959,18 +1154,112 @@ export function PlayView() {
           flex-direction: column;
           gap: 1rem;
         }
-        .usage-stats {
-          background: #eff6ff;
-          border: 1px solid #bfdbfe;
-          color: #1e3a8a;
-          padding: 0.625rem 0.875rem;
+        .provider-info {
+          background: #f9fafb;
+          border: 1px solid #e5e7eb;
+          color: #374151;
+          padding: 0.5rem 0.75rem;
           border-radius: 6px;
           font-size: 0.8125rem;
-          display: flex;
-          gap: 0.5rem;
-          flex-wrap: wrap;
-          align-items: center;
         }
+        .prompt-breakdown-bar {
+          display: flex;
+          height: 24px;
+          width: 100%;
+          border-radius: 4px;
+          overflow: hidden;
+          background: #e5e7eb;
+          margin-top: 0.5rem;
+          margin-bottom: 0.5rem;
+          box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+        }
+        .bar-section {
+          height: 100%;
+          transition: width 0.3s ease;
+        }
+        .bar-section.system {
+          background: #3b82f6;
+        }
+        .bar-section.world {
+          background: #10b981;
+        }
+        .bar-section.memories {
+          background: #f59e0b;
+        }
+        .breakdown-accordion {
+          margin-top: 0.75rem;
+          margin-bottom: 0.75rem;
+        }
+        details.breakdown-accordion-item {
+          border: 1px solid #e5e7eb;
+          border-radius: 6px;
+          margin-bottom: 0.5rem;
+          background: #fff;
+          overflow: hidden;
+        }
+        summary.accordion-header {
+          display: flex;
+          align-items: center;
+          gap: 0.5rem;
+          padding: 0.5rem 0.75rem;
+          background: #f9fafb;
+          cursor: pointer;
+          user-select: none;
+          font-size: 0.8125rem;
+          font-weight: 500;
+        }
+        summary.accordion-header::-webkit-details-marker {
+          display: none;
+        }
+        summary.accordion-header {
+          list-style: none;
+        }
+        .header-text {
+          flex-grow: 1;
+        }
+        .accordion-chevron {
+          font-size: 0.75rem;
+          color: #9ca3af;
+          transition: transform 0.2s ease;
+        }
+        details[open] .accordion-chevron {
+          transform: rotate(180deg);
+        }
+        .accordion-content {
+          padding: 0.75rem;
+          border-top: 1px solid #e5e7eb;
+          background: #fafafa;
+        }
+        .accordion-content pre {
+          margin: 0;
+          padding: 0.5rem;
+          background: #f3f4f6;
+          border: 1px solid #e5e7eb;
+          border-radius: 4px;
+          font-family: monospace;
+          font-size: 0.75rem;
+          white-space: pre-wrap;
+          word-break: break-all;
+          max-height: 250px;
+          overflow-y: auto;
+          color: #1f2937;
+        }
+        .legend-color {
+          width: 10px;
+          height: 10px;
+          border-radius: 2px;
+          display: inline-block;
+        }
+        .legend-color.system {
+          background: #3b82f6;
+        }
+        .legend-color.world {
+          background: #10b981;
+        }
+        .legend-color.memories {
+          background: #f59e0b;
+        }
+
         .usage-stats code {
           background: rgba(37, 99, 235, 0.1);
           color: #1d4ed8;

apps/gui/src/lib/simulation-types.ts

@@ -1,6 +1,8 @@
 export interface IntentInfo {
   type: string;
   description: string;
+  selfDescription?: string;
+  modifiers: string[];
   targetIds: string[];
   isValid?: boolean;
   reason?: string;
@@ -22,6 +24,8 @@ export interface LogEntry {
     inputTokens: number;
     outputTokens: number;
     totalTokens: number;
+    modelName?: string;
+    providerInstanceName?: string;
   };
   decoderPrompt?: {
     systemPrompt: string;
@@ -31,6 +35,8 @@ export interface LogEntry {
     inputTokens: number;
     outputTokens: number;
     totalTokens: number;
+    modelName?: string;
+    providerInstanceName?: string;
   };
 }
 

apps/gui/src/lib/simulation.ts

@@ -119,7 +119,7 @@ class SimulationManager {
     playEntityName?: string,
     providerInstanceId?: string,
   ): Promise<SimSnapshot> {
-    let activeInstance = providerInstanceId
+    const activeInstance = providerInstanceId
       ? ProviderManager.list().find((p) => p.id === providerInstanceId)
       : ProviderManager.getActive();
 
@@ -225,11 +225,12 @@ class SimulationManager {
       const key = inst ? inst.apiKey : (process.env.GOOGLE_API_KEY || "");
       const providerName = inst ? inst.providerName : "google-genai";
       const modelName = inst ? inst.modelName : undefined;
+      const instanceName = inst ? inst.name : undefined;
 
       if (providerName === "google-genai") {
-        return new GeminiProvider(key, modelName);
+        return new GeminiProvider(key, modelName, instanceName);
       } else if (providerName === "openrouter") {
-        return new OpenRouterProvider(key, modelName);
+        return new OpenRouterProvider(key, modelName, instanceName);
       } else {
         return new MockLLMProvider([]);
       }
@@ -384,6 +385,8 @@ class SimulationManager {
         entry.intents.push({
           type: intent.type,
           description: intent.description,
+          selfDescription: intent.selfDescription,
+          modifiers: intent.modifiers || [],
           targetIds: intent.targetIds,
           isValid: outcome.isValid,
           reason: outcome.reason,
@@ -527,6 +530,8 @@ class SimulationManager {
       entry.intents.push({
         type: intent.type,
         description: intent.description,
+        selfDescription: intent.selfDescription,
+        modifiers: intent.modifiers || [],
         targetIds: intent.targetIds,
         isValid: outcome.isValid,
         reason: outcome.reason,
@@ -658,9 +663,9 @@ class SimulationManager {
         }
 
         if (inst.providerName === "google-genai") {
-          return new GeminiProvider(inst.apiKey, inst.modelName);
+          return new GeminiProvider(inst.apiKey, inst.modelName, inst.name);
         } else if (inst.providerName === "openrouter") {
-          return new OpenRouterProvider(inst.apiKey, inst.modelName);
+          return new OpenRouterProvider(inst.apiKey, inst.modelName, inst.name);
         } else {
           return new MockLLMProvider([]);
         }

content/demo/scenarios/talking-room.json

@@ -11,12 +11,6 @@
         "visibility": "PRIVATE",
         "allowedEntities": []
       },
-      {
-        "name": "observation_status",
-        "value": "Active monitoring. Audio and visual feeds online.",
-        "visibility": "PRIVATE",
-        "allowedEntities": []
-      },
       {
         "name": "ambient_sound",
         "value": "A low, barely audible electrical hum.",
@@ -54,6 +48,11 @@
           "visibility": "PRIVATE",
           "allowedEntities": ["7c9b83b3-8cfb-4e89-8d77-626a5757d591"]
         },
+        {
+          "name": "gender",
+          "value": "male",
+          "visibility": "PUBLIC"
+        },
         {
           "name": "appearance",
           "value": "A tall human with short dark hair and alert eyes, standing near the center of the room.",
@@ -96,6 +95,11 @@
           "visibility": "PRIVATE",
           "allowedEntities": ["bf3f29d2-cf11-4b11-9a99-b13c126d400e"]
         },
+        {
+          "name": "gender",
+          "value": "male",
+          "visibility": "PUBLIC"
+        },
         {
           "name": "appearance",
           "value": "A medium-build human with long blonde hair tied back, sitting with their back pressed against the white wall.",

packages/actor/src/actor-prompt-builder.ts

@@ -59,21 +59,22 @@ export class ActorPromptBuilder {
 
   private buildSystemPrompt(): string {
     return `
-You are an actor agent embodying a single character in a narrative simulation. You ARE this character — act immersively, naturally, and in-character at all times. Do not break character, do not reference being an AI or a system, and do not narrate from outside the character's perspective.
+You are an actor agent embodying a single character in a narrative simulation. You ARE this character: act immersively, naturally, and in-character at all times. Do not break character, do not reference being an AI or a system, and do not narrate from outside the character's perspective.
 
 Your output is a short block of narrative prose describing what your character does, says, or thinks next. You may:
-- Speak aloud → this becomes a "dialogue" intent. Other entities can hear it.
-- Perform a physical or logical action → this becomes an "action" intent. It is subject to the world's physics and will be validated by the World Architect.
-- Think internally / reflect / feel → this becomes a "monologue" intent. NO ONE else perceives it. It bypasses all validation and is written straight to your private memory. Use this for inner thoughts, doubts, plans, and feelings that you would not voice aloud.
+- Speak aloud → Other entities can hear it if they are present nearby. (Or nobody will hear it if you are alone)
+- Perform a physical action → It is subject to the world's physics and logic. Do not describe the outcome of your action.
+- Think internally / reflect / feel → this is a "monologue". NO ONE else perceives it. This is what you think internally.
 
 Guidelines:
-- Always write in the first person (e.g., "I do this", "I say", "I think").
-- Only describe your character's own actions, spoken words, and internal reactions. Do NOT narrate or describe the environment, the room, your surroundings, or other characters' actions, as these are managed by the simulation engine.
-- Stay strictly within what your character knows. If an attribute, entity, or fact is not present in your context below, your character does not know it — do not invent it or act on it.
-- Refer to other entities by the subjective names/aliases given in your context, never by raw system IDs.
-- Keep your prose vivid but concise. A single response may contain more than one intent (e.g., you may think, then speak, then act) — write them in natural narrative order.
+- Always write in the first person
+- Only describe your character's own actions, spoken words, and internal reactions. Do NOT narrate or describe the environment or your surroundings, or other characters' actions.
+- Refer to other entities by the subjective names/aliases that you refer to them as.
+- Keep your prose vivid but concise. Write it in natural narrative order.
 - Not every response requires an outward action. It is perfectly valid to only think (a monologue) and do nothing perceivable.
-- Never speak or act on another entity's behalf — you only control your own character.
+- Never speak or act on another entity's behalf. You only control your own character.
+- Stay strictly within what your character knows. Do not invent knowledge that doesn't exist or act on it.
+- You are limited by just your memory. If your memory is limited, then that's all you can remember. If you do make stuff up then that's lying. Which is allowed, but remember that you're lying.
 ".
 `.trim();
   }

packages/architect/tests/architect.test.ts

@@ -22,8 +22,10 @@ describe("Architect & LLMValidator Unit Tests (Tier 1)", () => {
       type: "action",
       originalText: "open the chest and read the scroll",
       description: "Open the chest and read the scroll",
+      selfDescription: "You open the chest and read the scroll.",
       actorId: "alice",
       targetIds: [],
+      modifiers: [],
     };
 
     const result = await architect.validateIntent(world, intent);
@@ -51,8 +53,10 @@ describe("Architect & LLMValidator Unit Tests (Tier 1)", () => {
       type: "action",
       originalText: "unlock the gate and escape",
       description: "Unlock the gate and escape",
+      selfDescription: "You unlock the gate and escape.",
       actorId: "bob",
       targetIds: [],
+      modifiers: [],
     };
 
     const result = await architect.validateIntent(world, intent);
@@ -72,8 +76,10 @@ describe("Architect & LLMValidator Unit Tests (Tier 1)", () => {
       type: "action",
       originalText: "haunt the mansion",
       description: "Haunt the mansion",
+      selfDescription: "You haunt the mansion.",
       actorId: "ghost",
       targetIds: [],
+      modifiers: [],
     };
 
     const result = await architect.validateIntent(world, intent);
@@ -110,8 +116,10 @@ describe("TimeDeltaGenerator & Architect.processIntent Unit Tests (Tier 1)", ()
       type: "action",
       originalText: "pick the lock of the wooden chest",
       description: "Pick the lock of the wooden chest",
+      selfDescription: "You pick the lock of the wooden chest.",
       actorId: "alice",
       targetIds: [],
+      modifiers: [],
     };
 
     const result = await architect.processIntent(world, intent);
@@ -152,8 +160,10 @@ describe("TimeDeltaGenerator & Architect.processIntent Unit Tests (Tier 1)", ()
       type: "action",
       originalText: "run away",
       description: "Run away",
+      selfDescription: "You run away.",
       actorId: "bob",
       targetIds: [],
+      modifiers: [],
     };
 
     const result = await architect.processIntent(world, intent);

packages/intent/src/intent-decoder.ts

@@ -1,6 +1,6 @@
-import { WorldState, serializeObjectiveWorldState } from "@omnia/core";
+import { WorldState } from "@omnia/core";
 import { ILLMProvider } from "@omnia/llm";
-import { IntentSequence, IntentSequenceSchema } from "./intent.js";
+import { IntentSequence, LLMIntentSequenceSchema } from "./intent.js";
 
 export class IntentDecoder {
   constructor(private llmProvider: ILLMProvider) {}
@@ -23,9 +23,15 @@ export class IntentDecoder {
     const actor = worldState.getEntity(actorId);
 
     const aliasEntries = actor ? Array.from(actor.aliases.entries()) : [];
-    const aliasContext = aliasEntries.length > 0
-      ? aliasEntries.map(([targetId, alias]) => `- "${alias}" refers to entity ID: "${targetId}"`).join("\n")
-      : "(No known aliases)";
+    const aliasContext =
+      aliasEntries.length > 0
+        ? aliasEntries
+            .map(
+              ([targetId, alias]) =>
+                `- "${alias}" refers to entity ID: "${targetId}"`,
+            )
+            .join("\n")
+        : "(No known aliases)";
 
     const systemPrompt = `
 You are the Intent Decoder for a narrative simulation engine.
@@ -33,20 +39,16 @@ Your job is to take a block of narrative prose written by an actor agent and dec
 
 For each intent you must:
 1. Classify its type:
-   - "dialogue": Any speech, conversation, or verbal communication directed at another entity.
-   - "action": Any physical or logical action performed in the world (e.g., moving, picking up, opening, looking).
-   - "monologue": An inner thought, reflection, or internal monologue. This is purely internal — not spoken aloud, not perceivable by any other entity, and not a physical action. Use this for any prose depicting the character thinking, reflecting, feeling, or narrating to themselves internally.
+   - "dialogue": if actor speaking, talking, whispering, murmuring, etc
+   - "action": Any physical or logical action performed in the world (e.g., moving, opening, looking).
+   - "monologue": An inner thought, reflection, or internal monologue/self narration.
 2. Extract the original text fragment from the prose that corresponds to this intent.
-3. Write a concise, structured description of the intent (what is being done or said). Include as much detail about the action as possible that was extracted from the narrative prose. Do not make up qualities.
-4. Identify the actorId (the entity performing the intent — this will always be "${actorId}").
-5. Identify targetIds — the entity IDs of the receiving parties. Use the "KNOWN ENTITY IDS" and "ACTOR ALIASES" mapping to resolve any subjective names, descriptions, or nicknames used in the prose to their correct system entity IDs. If no specific target, use an empty array. For "monologue" intents, targetIds must always be an empty array.
-
-Rules:
-- Preserve the chronological order of intents as they appear in the prose.
-- Do NOT merge unrelated actions into a single intent.
-- Dialogue and actions should be separate intents even if they happen in the same sentence.
-- If the prose contains only dialogue, return a single dialogue intent.
-- If the prose contains only a single action, return a single action intent.
+3. Populate "description" and "selfDescription":
+   - "description": No subject or name — a bare third-person verb phrase only (e.g. "clears their throat", "shakes their head slowly")
+   - "selfDescription": The same event from the actor's own perspective, second person, complete sentence starting with "You" (e.g. "You clear your throat.", "You shake your head slowly."). This is shown directly in the actor's own memory — it must never say "the actor" or refer to them in the third person.
+   - In case of a dialogue, the description and self Description only stores the exact words said by the entity. (e.g. "I will do that later", "Are you serious right now?")
+4. Identify targetIds — the entity IDs of the receiving parties. Use the "KNOWN ENTITY IDS" mapping to resolve any subjective names,or aliases used in the prose to their correct system entity IDs. If no specific target, use an empty array.
+5. Identify modifiers — a list of strings representing additional qualities or modifiers extracted from the narrative prose. This includes emotions, tone of voice, speed, manner of action, or statement type (e.g., "question", "anxious", "whispering", "slowly", "quietly", "forcefully"). If no modifiers are present, use an empty array.
 `.trim();
 
     const userContext = `
@@ -58,7 +60,7 @@ The actor refers to other entities using these subjective names/aliases:
 ${aliasContext}
 
 === WORLD STATE ===
-${serializeObjectiveWorldState(worldState)}
+${serializeSimplifiedWorldState(worldState)}
 
 === ACTOR ===
 Actor ID: ${actorId}
@@ -70,7 +72,7 @@ ${narrativeProse}
     const response = await this.llmProvider.generateStructuredResponse({
       systemPrompt,
       userContext,
-      schema: IntentSequenceSchema,
+      schema: LLMIntentSequenceSchema,
     });
 
     if (!response.success || !response.data) {
@@ -79,6 +81,42 @@ ${narrativeProse}
       );
     }
 
-    return response.data;
+    const fullIntents = response.data.intents.map((intent) => ({
+      ...intent,
+      actorId,
+    }));
+
+    return {
+      intents: fullIntents,
+    };
   }
 }
+
+function serializeSimplifiedWorldState(worldState: WorldState): string {
+  const lines: string[] = [];
+
+  lines.push("Locations:");
+  if (worldState.locations.size > 0) {
+    for (const loc of worldState.locations.values()) {
+      const parentId = (loc as { parentId?: string | null }).parentId;
+      const parentStr = parentId ? ` (Parent: ${parentId})` : "";
+      lines.push(`  - Location [ID: ${loc.id}]${parentStr}`);
+    }
+  } else {
+    lines.push("  (No locations)");
+  }
+
+  lines.push("Entities:");
+  if (worldState.entities.size > 0) {
+    for (const entity of worldState.entities.values()) {
+      const locStr = entity.locationId
+        ? ` (Location: ${entity.locationId})`
+        : "";
+      lines.push(`  - Entity [ID: ${entity.id}]${locStr}`);
+    }
+  } else {
+    lines.push("  (No entities)");
+  }
+
+  return lines.join("\n");
+}

packages/intent/src/intent.ts

@@ -14,7 +14,7 @@ export type IntentType = z.infer<typeof IntentTypeSchema>;
 /**
  * A single decoded intent extracted from narrative prose.
  */
-export const IntentSchema = z.object({
+export const LLMIntentSchema = z.object({
   /** The type of intent. */
   type: IntentTypeSchema,
 
@@ -24,8 +24,8 @@ export const IntentSchema = z.object({
   /** A concise, structured description of the intent's action or dialogue. */
   description: z.string(),
 
-  /** The entity ID of the actor performing the intent. */
-  actorId: z.string(),
+  /** The same event from the actor's own perspective (second person, "You"). */
+  selfDescription: z.string(),
 
   /**
    * Entity IDs of the receiving parties (e.g., who is being spoken to,
@@ -33,10 +33,25 @@ export const IntentSchema = z.object({
    * "monologue" intents, since they are not perceivable by anyone.
    */
   targetIds: z.array(z.string()),
+
+  /**
+   * Additional qualities or modifiers extracted from the prose (e.g., emotions,
+   * questions, speed, manner of action like 'quietly', 'whispering', 'anxiously').
+   */
+  modifiers: z.array(z.string()),
+});
+
+export const IntentSchema = LLMIntentSchema.extend({
+  /** The entity ID of the actor performing the intent. */
+  actorId: z.string(),
 });
 
 export type Intent = z.infer<typeof IntentSchema>;
 
+export const LLMIntentSequenceSchema = z.object({
+  intents: z.array(LLMIntentSchema),
+});
+
 /**
  * The full output of the Intent Decoder: an ordered sequence of intents
  * extracted from a single narrative prose block.

packages/intent/tests/intent.test.ts

@@ -15,8 +15,9 @@ describe("IntentDecoder Unit Tests (Tier 1)", () => {
           type: "action",
           originalText: "Alice opened the chest.",
           description: "Open the wooden chest.",
-          actorId: "alice",
+          selfDescription: "You open the wooden chest.",
           targetIds: [],
+          modifiers: [],
         },
       ],
     };
@@ -45,8 +46,9 @@ describe("IntentDecoder Unit Tests (Tier 1)", () => {
           type: "dialogue",
           originalText: '"Do you have the key?" Alice asked Bob.',
           description: "Alice asks Bob if he has the key.",
-          actorId: "alice",
+          selfDescription: "You ask Bob if he has the key.",
           targetIds: ["bob"],
+          modifiers: [],
         },
       ],
     };
@@ -78,15 +80,17 @@ describe("IntentDecoder Unit Tests (Tier 1)", () => {
           type: "dialogue",
           originalText: '"Cover me," Alice whispered to Bob.',
           description: "Alice whispers to Bob requesting cover.",
-          actorId: "alice",
+          selfDescription: "You whisper to Bob requesting cover.",
           targetIds: ["bob"],
+          modifiers: [],
         },
         {
           type: "action",
           originalText: "She crept towards the door and pulled the handle.",
           description: "Creep towards the door and pull the handle.",
-          actorId: "alice",
+          selfDescription: "You creep towards the door and pull the handle.",
           targetIds: [],
+          modifiers: [],
         },
       ],
     };

packages/llm/src/llm.ts

@@ -15,6 +15,8 @@ export interface LLMResponse<T> {
     inputTokens: number;
     outputTokens: number;
     totalTokens: number;
+    modelName?: string;
+    providerInstanceName?: string;
   };
 }
 
@@ -25,6 +27,8 @@ export interface LLMCallRecord {
     inputTokens: number;
     outputTokens: number;
     totalTokens: number;
+    modelName?: string;
+    providerInstanceName?: string;
   };
 }
 

packages/llm/src/providers/google-genai.ts

@@ -12,11 +12,14 @@ export class GeminiProvider implements ILLMProvider {
 
   providerName = "Gemini";
   private model: ChatGoogleGenerativeAI;
+  private modelNameUsed: string;
+  private providerInstanceName?: string;
   lastCalls: LLMCallRecord[] = [];
 
-  constructor(apiKey?: string, modelName?: string) {
+  constructor(apiKey?: string, modelName?: string, providerInstanceName?: string) {
     let key = apiKey;
     let model = modelName;
+    this.providerInstanceName = providerInstanceName;
 
     if (!key) {
       const active = ProviderManager.getActive();
@@ -25,20 +28,27 @@ export class GeminiProvider implements ILLMProvider {
         if (!model) {
           model = active.modelName;
         }
+        if (!this.providerInstanceName) {
+          this.providerInstanceName = active.name;
+        }
       }
     }
 
     if (!key) {
       key = llmConfig.GOOGLE_API_KEY;
+      if (!this.providerInstanceName && key) {
+        this.providerInstanceName = "Environment Variable";
+      }
     }
 
     if (!key) {
       throw new Error("GOOGLE_API_KEY is required to initialize GeminiProvider");
     }
 
+    this.modelNameUsed = model || "gemini-2.5-flash";
     this.model = new ChatGoogleGenerativeAI({
       apiKey: key,
-      model: model || "gemini-2.5-flash",
+      model: this.modelNameUsed,
     });
   }
 
@@ -63,11 +73,13 @@ export class GeminiProvider implements ILLMProvider {
     const parsed = result?.parsed;
     const raw = result?.raw;
 
-    const usage = raw?.usage_metadata ? {
-      inputTokens: raw.usage_metadata.input_tokens || 0,
-      outputTokens: raw.usage_metadata.output_tokens || 0,
-      totalTokens: raw.usage_metadata.total_tokens || 0,
-    } : undefined;
+    const usage = {
+      inputTokens: raw?.usage_metadata?.input_tokens || 0,
+      outputTokens: raw?.usage_metadata?.output_tokens || 0,
+      totalTokens: raw?.usage_metadata?.total_tokens || 0,
+      modelName: this.modelNameUsed,
+      providerInstanceName: this.providerInstanceName || "Default",
+    };
 
     this.lastCalls.push({
       systemPrompt: request.systemPrompt,

packages/llm/src/providers/openrouter.ts

@@ -12,11 +12,14 @@ export class OpenRouterProvider implements ILLMProvider {
 
   providerName = "OpenRouter";
   private model: ChatOpenRouter;
+  private modelNameUsed: string;
+  private providerInstanceName?: string;
   lastCalls: LLMCallRecord[] = [];
 
-  constructor(apiKey?: string, modelName?: string) {
+  constructor(apiKey?: string, modelName?: string, providerInstanceName?: string) {
     let key = apiKey;
     let model = modelName;
+    this.providerInstanceName = providerInstanceName;
 
     if (!key) {
       const active = ProviderManager.getActive();
@@ -25,20 +28,27 @@ export class OpenRouterProvider implements ILLMProvider {
         if (!model) {
           model = active.modelName;
         }
+        if (!this.providerInstanceName) {
+          this.providerInstanceName = active.name;
+        }
       }
     }
 
     if (!key) {
       key = llmConfig.OPENROUTER_API_KEY;
+      if (!this.providerInstanceName && key) {
+        this.providerInstanceName = "Environment Variable";
+      }
     }
 
     if (!key) {
       throw new Error("OPENROUTER_API_KEY is required to initialize OpenRouterProvider");
     }
 
+    this.modelNameUsed = model || "google/gemini-2.5-flash";
     this.model = new ChatOpenRouter({
       apiKey: key,
-      model: model || "google/gemini-2.5-flash",
+      model: this.modelNameUsed,
     });
   }
 
@@ -63,11 +73,13 @@ export class OpenRouterProvider implements ILLMProvider {
     const parsed = result?.parsed;
     const raw = result?.raw;
 
-    const usage = raw?.usage_metadata ? {
-      inputTokens: raw.usage_metadata.input_tokens || 0,
-      outputTokens: raw.usage_metadata.output_tokens || 0,
-      totalTokens: raw.usage_metadata.total_tokens || 0,
-    } : undefined;
+    const usage = {
+      inputTokens: raw?.usage_metadata?.input_tokens || 0,
+      outputTokens: raw?.usage_metadata?.output_tokens || 0,
+      totalTokens: raw?.usage_metadata?.total_tokens || 0,
+      modelName: this.modelNameUsed,
+      providerInstanceName: this.providerInstanceName || "Default",
+    };
 
     this.lastCalls.push({
       systemPrompt: request.systemPrompt,

packages/llm/tests/openrouter.test.ts

@@ -91,6 +91,8 @@ describe("OpenRouterProvider Unit Tests (Tier 1)", () => {
       inputTokens: 10,
       outputTokens: 5,
       totalTokens: 15,
+      modelName: "google/gemini-2.5-flash",
+      providerInstanceName: "Default",
     });
 
     expect(provider.lastCalls.length).toBe(1);
@@ -101,6 +103,8 @@ describe("OpenRouterProvider Unit Tests (Tier 1)", () => {
         inputTokens: 10,
         outputTokens: 5,
         totalTokens: 15,
+        modelName: "google/gemini-2.5-flash",
+        providerInstanceName: "Default",
       },
     });
   });

packages/memory/src/buffer.ts

@@ -25,27 +25,28 @@ export function serializeSubjectiveBufferEntry(
   entry: BufferEntry,
   viewer: Entity,
 ): string {
-  const actorAlias = resolveAlias(viewer, entry.intent.actorId);
+  const isSelf = viewer.id === entry.intent.actorId;
 
-  const targetAliases = entry.intent.targetIds.map((tid) =>
-    resolveAlias(viewer, tid),
-  );
-
-  let details: string;
-  const content = entry.intent.description.trim() || entry.intent.originalText.trim();
-
-  if (entry.intent.type === "dialogue") {
-    details = `spoke to ${targetAliases.join(", ") || "someone"}: "${content}"`;
-  } else if (entry.intent.type === "monologue") {
-    details = `thought: "${content}"`;
-  } else {
-    details = content;
-    if (entry.outcome) {
+  if (isSelf) {
+    let details = (entry.intent.selfDescription || entry.intent.description || entry.intent.originalText).trim();
+    if (details.length > 0) {
+      details = details.charAt(0).toUpperCase() + details.slice(1);
+    }
+    if (entry.intent.type === "action" && entry.outcome) {
       details += ` (Outcome: ${entry.outcome.isValid ? "Succeeded" : `Failed - ${entry.outcome.reason}`})`;
     }
+    return details;
   }
 
-  return `${actorAlias} ${details}`;
+  const actorAlias = resolveAlias(viewer, entry.intent.actorId);
+  const subjectStr = actorAlias.charAt(0).toUpperCase() + actorAlias.slice(1);
+
+  let details = (entry.intent.description || entry.intent.originalText).trim();
+  if (entry.intent.type === "action" && entry.outcome) {
+    details += ` (Outcome: ${entry.outcome.isValid ? "Succeeded" : `Failed - ${entry.outcome.reason}`})`;
+  }
+
+  return `${subjectStr} ${details}`;
 }
 
 export class BufferRepository {

packages/memory/tests/memory.test.ts

@@ -32,14 +32,16 @@ describe("Subjective Buffer Entry Serializer Tests (Tier 1)", () => {
       intent: {
         type: "dialogue",
         originalText: '"Hello there," Bob said to Charlie.',
-        description: "Bob greets Charlie",
+        description: "says, 'Hello there' to the bartender",
+        selfDescription: "You say, 'Hello there' to the bartender.",
         actorId: "bob",
         targetIds: ["charlie"],
+        modifiers: [],
       },
     };
 
     const result = serializeSubjectiveBufferEntry(entry, viewer);
-    expect(result).toBe('the hooded figure spoke to the bartender: "Bob greets Charlie"');
+    expect(result).toBe("The hooded figure says, 'Hello there' to the bartender");
   });
 
   test("serializes action intent with outcome details", () => {
@@ -54,9 +56,11 @@ describe("Subjective Buffer Entry Serializer Tests (Tier 1)", () => {
       intent: {
         type: "action",
         originalText: "Bob tried to break the latch.",
-        description: "Bob attempts to break the lock latch",
+        description: "attempts to break the lock latch",
+        selfDescription: "You attempt to break the lock latch.",
         actorId: "bob",
         targetIds: [],
+        modifiers: [],
       },
       outcome: {
         isValid: false,
@@ -65,7 +69,7 @@ describe("Subjective Buffer Entry Serializer Tests (Tier 1)", () => {
     };
 
     const result = serializeSubjectiveBufferEntry(entry, viewer);
-    expect(result).toBe('the hooded figure Bob attempts to break the lock latch (Outcome: Failed - The lock is made of reinforced steel.)');
+    expect(result).toBe('The hooded figure attempts to break the lock latch (Outcome: Failed - The lock is made of reinforced steel.)');
   });
 
   test("serializes self-reference and unfamiliar actors", () => {
@@ -80,13 +84,15 @@ describe("Subjective Buffer Entry Serializer Tests (Tier 1)", () => {
         type: "action",
         originalText: "I opened the window.",
         description: "open the window",
+        selfDescription: "You open the window.",
         actorId: "alice",
         targetIds: [],
+        modifiers: [],
       },
     };
 
     const resultSelf = serializeSubjectiveBufferEntry(entrySelf, viewer);
-    expect(resultSelf).toBe("you open the window");
+    expect(resultSelf).toBe("You open the window.");
 
     const entryUnfamiliar: BufferEntry = {
       id: "entry-unfamiliar",
@@ -96,14 +102,16 @@ describe("Subjective Buffer Entry Serializer Tests (Tier 1)", () => {
       intent: {
         type: "action",
         originalText: "Someone knocked.",
-        description: "knock on the door",
+        description: "knocks on the door",
+        selfDescription: "You knock on the door.",
         actorId: "stranger-1",
         targetIds: [],
+        modifiers: [],
       },
     };
 
     const resultUnfamiliar = serializeSubjectiveBufferEntry(entryUnfamiliar, viewer);
-    expect(resultUnfamiliar).toBe("an unfamiliar figure knock on the door");
+    expect(resultUnfamiliar).toBe("An unfamiliar figure knocks on the door");
   });
 });
 
@@ -123,8 +131,10 @@ describe("BufferRepository Persistence Tests (Tier 1)", () => {
       type: "action",
       originalText: "Alice picked up a stick.",
       description: "Alice gathers a stick",
+      selfDescription: "You gather a stick.",
       actorId: "alice",
       targetIds: [],
+      modifiers: [],
     };
 
     const entry: BufferEntry = {

packages/scenario/tests/scenario.test.ts

@@ -57,8 +57,10 @@ describe("Scenario Validation & Schema Tests (Tier 1)", () => {
               type: "action",
               originalText: "I entered the foyer.",
               description: "entered the house",
+              selfDescription: "You entered the house.",
               actorId: "investigator",
               targetIds: [],
+              modifiers: [],
             },
           },
         ],

tests/integration/actor-monologue.test.ts

@@ -62,22 +62,28 @@ describe("Actor Agent + Monologue Intent Integration (Tier 2)", () => {
           type: "monologue",
           originalText: "I can't believe Bob hasn't noticed me yet, Alice thought.",
           description: "Alice internally reflects that Bob has not noticed her.",
+          selfDescription: "You internally reflect that Bob has not noticed you.",
           actorId: "alice",
           targetIds: [],
+          modifiers: [],
         },
         {
           type: "dialogue",
           originalText: '"Hey Bob," she called out softly.',
           description: "Alice softly calls out to Bob.",
+          selfDescription: "You softly call out to Bob.",
           actorId: "alice",
           targetIds: ["bob"],
+          modifiers: [],
         },
         {
           type: "action",
           originalText: "She reached for the ledger on the table.",
           description: "Alice reaches for the ledger on the table.",
+          selfDescription: "You reach for the ledger on the table.",
           actorId: "alice",
           targetIds: [],
+          modifiers: [],
         },
       ],
     };

tests/integration/game-loop.test.ts

@@ -33,15 +33,19 @@ describe("Omnia Integration Tests (Tier 2)", () => {
           type: "dialogue",
           originalText: '"Cover me," Alice whispered to Bob.',
           description: "Alice whispers to Bob to cover her.",
+          selfDescription: "You whisper to Bob to cover you.",
           actorId: "alice",
           targetIds: ["bob"],
+          modifiers: [],
         },
         {
           type: "action",
           originalText: "She crept towards the door and pulled the handle.",
           description: "Alice creeps to the door and pulls the handle.",
+          selfDescription: "You creep to the door and pull the handle.",
           actorId: "alice",
           targetIds: [],
+          modifiers: [],
         },
       ],
     };
@@ -108,16 +112,20 @@ describe("Omnia Integration Tests (Tier 2)", () => {
       type: "action" as const,
       originalText: "She tries to unlock the gate with a hairpin.",
       description: "Alice attempts to pick the lock with a hairpin.",
+      selfDescription: "You attempt to pick the lock with a hairpin.",
       actorId: "alice",
       targetIds: [],
+      modifiers: [],
     };
 
     const intent2 = {
       type: "dialogue" as const,
       originalText: '"This is useless," she mutters.',
       description: "Alice mutters to herself.",
+      selfDescription: "You mutter to yourself.",
       actorId: "alice",
       targetIds: [],
+      modifiers: [],
     };
 
     // LLM validation / time delta mock responses: