diff --git a/SCENARIO_EDITOR_PLAN.md b/SCENARIO_EDITOR_PLAN.md
index f50281b7..439026bd 100644
--- a/SCENARIO_EDITOR_PLAN.md
+++ b/SCENARIO_EDITOR_PLAN.md
@@ -132,11 +132,14 @@
 - `apps/scenario-editor/` (from Stage 3)
 
 ### Requirements (Task Checklist)
-- [ ] **4.1** Add objective editor for predicate DSL (`metric`, `all`, `any`, `not`).
-- [ ] **4.2** Add event/action editor for declarative scripts (`atTick`, `everyTicks`, actions union).
-- [ ] **4.3** Add behavior profile assignment UI with closed profile validation.
-- [ ] **4.4** Add authoring-time semantic validation (unknown metric, invalid op/type combos, empty `all/any`, etc.).
-- [ ] **4.5** Integrate edited scripts/objectives into export pipeline.
+- [x] **4.1** Add objective editor for predicate DSL (`metric`, `all`, `any`, `not`).
+- [x] **4.2** Add event/action editor for declarative scripts (`atTick`, `everyTicks`, actions union).
+- [x] **4.3** Add behavior profile assignment UI with closed profile validation.
+- [x] **4.4** Add authoring-time semantic validation (unknown metric, invalid op/type combos, empty `all/any`, etc.).
+- [x] **4.5** Integrate edited scripts/objectives into export pipeline.
+
+Stage 4.3 repair note: behavior profile assignment now uses closed-key selection UI with explicit invalid-key diagnostics tied to the runtime profile registry.
+Stage 4.4 repair note: semantic validators now reject predicate/script kind-field mismatches (invalid type combos) in addition to unknown metrics/operators and empty composite nodes.
 
 ### Good Tests
 - UI-driven serialization tests from form model -> valid script/objective JSON.
diff --git a/apps/scenario-editor/package.json b/apps/scenario-editor/package.json
index fca6be19..bb4924be 100644
--- a/apps/scenario-editor/package.json
+++ b/apps/scenario-editor/package.json
@@ -14,6 +14,7 @@
   "dependencies": {
     "@city/classicyui": "workspace:*",
     "@city/scenario-core": "workspace:*",
+    "@city/scenario-runtime": "workspace:*",
     "@tanstack/react-router": "1.157.16",
     "react": "19.2.4",
     "react-dom": "19.2.4"
diff --git a/apps/scenario-editor/src/routes/__root.tsx b/apps/scenario-editor/src/routes/__root.tsx
index f68508bc..343164c4 100644
--- a/apps/scenario-editor/src/routes/__root.tsx
+++ b/apps/scenario-editor/src/routes/__root.tsx
@@ -16,7 +16,7 @@ function RootRouteLayout() {
   return (
     <ScenarioEditorStateProvider>
       <div className="editor-shell">
-        <header className="editor-header">Scenario Editor MVP</header>
+        <header className="editor-header">Scenario Editor</header>
         <EditorTopNav />
         <main className="editor-main">
           <Outlet />
@@ -76,5 +76,14 @@ function getScenarioEditorWorkbenchViewLabel(view: ScenarioEditorWorkbenchView):
   if (view === 'map') {
     return 'Map';
   }
+  if (view === 'objective') {
+    return 'Objective';
+  }
+  if (view === 'script') {
+    return 'Scripts';
+  }
+  if (view === 'behavior') {
+    return 'Behavior';
+  }
   return 'Export';
 }
diff --git a/apps/scenario-editor/src/routes/index.tsx b/apps/scenario-editor/src/routes/index.tsx
index c4cb9864..5cae27f6 100644
--- a/apps/scenario-editor/src/routes/index.tsx
+++ b/apps/scenario-editor/src/routes/index.tsx
@@ -10,6 +10,11 @@ import {
   useState,
 } from 'react';
 
+import {
+  getScenarioEditorBehaviorValidationIssue,
+  isScenarioEditorBehaviorProfileKey,
+  SCENARIO_EDITOR_BEHAVIOR_PROFILE_KEYS,
+} from '../state/editor-behavior.ts';
 import {
   buildScenarioEditorStrictExport,
   getScenarioEditorExportFileName,
@@ -26,6 +31,37 @@ import {
   readScenarioEditorMapTileWord,
   type ScenarioEditorMapPoint,
 } from '../state/editor-map.ts';
+import {
+  appendScenarioObjectiveChildPredicate,
+  coerceScenarioObjectivePredicateKind,
+  getScenarioEditorObjectiveValidationIssues,
+  removeScenarioObjectiveChildPredicate,
+  replaceScenarioObjectiveChildPredicate,
+  replaceScenarioObjectiveNotChildPredicate,
+  SCENARIO_EDITOR_OBJECTIVE_COMPARISONS,
+  SCENARIO_EDITOR_OBJECTIVE_METRIC_KEYS,
+  SCENARIO_EDITOR_OBJECTIVE_PREDICATE_KINDS,
+  type ScenarioEditorObjectivePredicate,
+} from '../state/editor-objective.ts';
+import {
+  appendScenarioEditorScriptAction,
+  appendScenarioEditorScriptEvent,
+  coerceScenarioEditorScriptActionKind,
+  coerceScenarioEditorScriptTriggerKind,
+  getScenarioEditorScriptTriggerKind,
+  getScenarioEditorScriptValidationIssues,
+  removeScenarioEditorScriptAction,
+  removeScenarioEditorScriptEvent,
+  replaceScenarioEditorAtTickTrigger,
+  replaceScenarioEditorEveryTicksTrigger,
+  replaceScenarioEditorScriptAction,
+  replaceScenarioEditorScriptEvent,
+  replaceScenarioEditorSendMessageId,
+  SCENARIO_EDITOR_SCRIPT_ACTION_KINDS,
+  SCENARIO_EDITOR_SCRIPT_TRIGGER_KINDS,
+  type ScenarioEditorScriptAction,
+  type ScenarioEditorScriptEvent,
+} from '../state/editor-script.ts';
 import {
   getScenarioEditorMetadataValidationIssues,
   parseScenarioEditorTagsInput,
@@ -57,10 +93,12 @@ export const Route = createFileRoute('/')({
 });
 
 /**
- * Stage 3 workbench route with metadata editing and manual map editing MVP sections.
- * Parity note: metadata `startYear`/`startFunds` map to `LoadScenario` fields in
- * `ref/micropolis/src/sim/s_fileio.c`; map edits mirror `Map[x][y]` writes from
- * `SimCmdTile`/`SimCmdFill` in `ref/micropolis/src/sim/w_sim.c`.
+ * Stage 4 workbench route with metadata/map editing plus objective and script authoring.
+ * Parity note: objective metric leaves map to `DoScenarioScore` checks in
+ * `ref/micropolis/src/sim/s_msg.c`, while logical composition forms are declarative
+ * runtime extensions from `packages/scenario-runtime`; script events map to
+ * `ScenarioDisaster` trigger/action domains in `ref/micropolis/src/sim/s_disast.c`; behavior
+ * profile assignment maps closed `DoShipSprite` variants from `ref/micropolis/src/sim/w_sprite.c`.
  */
 function ScenarioEditorHomeRoute() {
   const { activeView } = useScenarioEditorState();
@@ -71,6 +109,15 @@ function ScenarioEditorHomeRoute() {
   if (activeView === 'map') {
     return <ScenarioMapEditorCard />;
   }
+  if (activeView === 'objective') {
+    return <ScenarioObjectiveEditorCard />;
+  }
+  if (activeView === 'script') {
+    return <ScenarioScriptEditorCard />;
+  }
+  if (activeView === 'behavior') {
+    return <ScenarioBehaviorProfileEditorCard />;
+  }
 
   return <ScenarioExportCard />;
 }
@@ -382,6 +429,619 @@ function ScenarioMapEditorCard() {
   );
 }
 
+/**
+ * Objective authoring card for Stage 4.1 predicate DSL editing.
+ * Parity note: metric leaves mirror `DoScenarioScore` checks in
+ * `ref/micropolis/src/sim/s_msg.c`; logical nodes (`all`/`any`/`not`) are
+ * declarative extensions supported by `packages/scenario-runtime`.
+ */
+function ScenarioObjectiveEditorCard() {
+  const { objective, isDirty } = useScenarioEditorState();
+  const dispatch = useScenarioEditorDispatch();
+  const validationIssues = useMemo(
+    () => getScenarioEditorObjectiveValidationIssues(objective),
+    [objective],
+  );
+  const objectiveJson = useMemo(
+    () => JSON.stringify(objective.enabled ? objective.predicate : null, null, 2),
+    [objective.enabled, objective.predicate],
+  );
+
+  return (
+    <section className="editor-card editor-objective-card" aria-label="Scenario objective editor">
+      <h1>Scenario Objective</h1>
+      <p>
+        Author objective predicates using the Stage 4 DSL. Metric comparisons track classic
+        `DoScenarioScore` fields, while `all`/`any`/`not` allow composed checks.
+      </p>
+
+      <label className="editor-field editor-objective-toggle">
+        <span>Objective Enabled</span>
+        <input
+          checked={objective.enabled}
+          onChange={(event) => {
+            dispatch({ type: 'set-objective-enabled', enabled: event.currentTarget.checked });
+          }}
+          type="checkbox"
+        />
+        <small className="editor-help">
+          Objective predicate drafts are included in strict export when objective authoring is
+          enabled.
+        </small>
+      </label>
+
+      {objective.enabled ? (
+        <ScenarioObjectivePredicateEditor
+          depth={0}
+          onChange={(predicate) => {
+            dispatch({ type: 'replace-objective-predicate', predicate });
+          }}
+          predicate={objective.predicate}
+        />
+      ) : (
+        <p className="editor-help">Objective checks are disabled for this draft.</p>
+      )}
+
+      <dl className="editor-grid">
+        <dt>Dirty State</dt>
+        <dd>{isDirty ? 'dirty' : 'clean'}</dd>
+        <dt>Objective Enabled</dt>
+        <dd>{objective.enabled ? 'yes' : 'no'}</dd>
+        <dt>Root Predicate</dt>
+        <dd>{objective.enabled ? objective.predicate.kind : 'none'}</dd>
+        <dt>Validation</dt>
+        <dd>
+          {!objective.enabled
+            ? 'disabled'
+            : validationIssues.length === 0
+              ? 'valid'
+              : `invalid (${validationIssues.length} issue${
+                  validationIssues.length === 1 ? '' : 's'
+                })`}
+        </dd>
+      </dl>
+
+      {objective.enabled && validationIssues.length > 0 ? (
+        <section aria-label="Objective semantic issues" className="editor-export-issues">
+          <h2>Objective Semantic Issues</h2>
+          <ul>
+            {validationIssues.map((issue, index) => (
+              <li key={`${issue.path}:${issue.message}:${index}`}>
+                <code>{issue.path}</code>: {issue.message}
+              </li>
+            ))}
+          </ul>
+        </section>
+      ) : null}
+
+      <section className="editor-export-preview" aria-label="Objective predicate preview">
+        <h2>Objective Predicate JSON</h2>
+        <textarea readOnly rows={10} value={objectiveJson} />
+      </section>
+    </section>
+  );
+}
+
+/**
+ * Recursive node editor for one objective predicate subtree.
+ * Not from Micropolis C: this is React authoring UI over runtime predicate data.
+ */
+function ScenarioObjectivePredicateEditor(options: {
+  depth: number;
+  onChange: (predicate: ScenarioEditorObjectivePredicate) => void;
+  predicate: ScenarioEditorObjectivePredicate;
+}) {
+  const { depth, onChange, predicate } = options;
+  const nodeLabel = `Predicate depth ${depth}`;
+
+  return (
+    <fieldset className="editor-objective-node">
+      <legend>{nodeLabel}</legend>
+      <label className="editor-field">
+        <span>Kind</span>
+        <select
+          onChange={(event) => {
+            onChange(
+              coerceScenarioObjectivePredicateKind(
+                predicate,
+                event.currentTarget.value as ScenarioEditorObjectivePredicate['kind'],
+              ),
+            );
+          }}
+          value={predicate.kind}
+        >
+          {SCENARIO_EDITOR_OBJECTIVE_PREDICATE_KINDS.map((kind) => (
+            <option key={kind} value={kind}>
+              {getScenarioObjectivePredicateKindLabel(kind)}
+            </option>
+          ))}
+        </select>
+      </label>
+
+      {predicate.kind === 'metric' ? (
+        <div className="editor-objective-metric-grid">
+          <label className="editor-field">
+            <span>Metric</span>
+            <select
+              onChange={(event) => {
+                onChange({
+                  ...predicate,
+                  metric: event.currentTarget
+                    .value as (typeof SCENARIO_EDITOR_OBJECTIVE_METRIC_KEYS)[number],
+                });
+              }}
+              value={predicate.metric}
+            >
+              {SCENARIO_EDITOR_OBJECTIVE_METRIC_KEYS.map((metric) => (
+                <option key={metric} value={metric}>
+                  {getScenarioObjectiveMetricLabel(metric)}
+                </option>
+              ))}
+            </select>
+          </label>
+
+          <label className="editor-field">
+            <span>Operator</span>
+            <select
+              onChange={(event) => {
+                onChange({
+                  ...predicate,
+                  op: event.currentTarget
+                    .value as (typeof SCENARIO_EDITOR_OBJECTIVE_COMPARISONS)[number],
+                });
+              }}
+              value={predicate.op}
+            >
+              {SCENARIO_EDITOR_OBJECTIVE_COMPARISONS.map((comparison) => (
+                <option key={comparison} value={comparison}>
+                  {getScenarioObjectiveComparisonLabel(comparison)}
+                </option>
+              ))}
+            </select>
+          </label>
+
+          <label className="editor-field">
+            <span>Value</span>
+            <input
+              onChange={(event) => {
+                onChange({
+                  ...predicate,
+                  value: parseIntegerInput(event.currentTarget.value, predicate.value),
+                });
+              }}
+              type="number"
+              value={predicate.value}
+            />
+          </label>
+        </div>
+      ) : null}
+
+      {predicate.kind === 'all' || predicate.kind === 'any' ? (
+        <div className="editor-objective-children">
+          {predicate.predicates.map((childPredicate, index) => (
+            <div className="editor-objective-child-row" key={index}>
+              <ScenarioObjectivePredicateEditor
+                depth={depth + 1}
+                onChange={(child) => {
+                  onChange(replaceScenarioObjectiveChildPredicate(predicate, index, child));
+                }}
+                predicate={childPredicate}
+              />
+              <button
+                className="editor-objective-remove"
+                onClick={() => {
+                  onChange(removeScenarioObjectiveChildPredicate(predicate, index));
+                }}
+                type="button"
+              >
+                Remove Child
+              </button>
+            </div>
+          ))}
+          <button
+            className="editor-objective-add"
+            onClick={() => {
+              onChange(appendScenarioObjectiveChildPredicate(predicate));
+            }}
+            type="button"
+          >
+            Add Child Predicate
+          </button>
+        </div>
+      ) : null}
+
+      {predicate.kind === 'not' ? (
+        <div className="editor-objective-children">
+          <ScenarioObjectivePredicateEditor
+            depth={depth + 1}
+            onChange={(child) => {
+              onChange(replaceScenarioObjectiveNotChildPredicate(predicate, child));
+            }}
+            predicate={predicate.predicate}
+          />
+        </div>
+      ) : null}
+    </fieldset>
+  );
+}
+
+/**
+ * Event/action authoring card for Stage 4.2 declarative script editing.
+ * Parity note: trigger patterns (`atTick`, `everyTicks`) mirror `ScenarioDisaster`
+ * timing checks in `ref/micropolis/src/sim/s_disast.c`, while this React form is
+ * editor-only UI over `scenario-runtime` action unions.
+ */
+function ScenarioScriptEditorCard() {
+  const { script, isDirty } = useScenarioEditorState();
+  const dispatch = useScenarioEditorDispatch();
+  const validationIssues = useMemo(() => getScenarioEditorScriptValidationIssues(script), [script]);
+  const scriptJson = useMemo(
+    () => JSON.stringify(script.enabled ? script.events : [], null, 2),
+    [script.enabled, script.events],
+  );
+
+  const replaceEvents = (events: readonly ScenarioEditorScriptEvent[]) => {
+    dispatch({ type: 'replace-script-events', events });
+  };
+
+  return (
+    <section className="editor-card editor-script-card" aria-label="Scenario script editor">
+      <h1>Scenario Scripts</h1>
+      <p>
+        Author declarative event scripts with one-shot (`atTick`) and interval (`everyTicks`)
+        triggers plus runtime action unions for disasters/messages.
+      </p>
+
+      <label className="editor-field editor-script-toggle">
+        <span>Scripts Enabled</span>
+        <input
+          checked={script.enabled}
+          onChange={(event) => {
+            dispatch({ type: 'set-script-enabled', enabled: event.currentTarget.checked });
+          }}
+          type="checkbox"
+        />
+        <small className="editor-help">
+          Script event/action drafts are included in strict export when script authoring is enabled.
+        </small>
+      </label>
+
+      {script.enabled ? (
+        <div className="editor-script-events">
+          {script.events.map((event, eventIndex) => (
+            <ScenarioScriptEventEditor
+              event={event}
+              index={eventIndex}
+              key={eventIndex}
+              onChange={(nextEvent) => {
+                replaceEvents(
+                  replaceScenarioEditorScriptEvent(script.events, eventIndex, nextEvent),
+                );
+              }}
+              onRemove={() => {
+                replaceEvents(removeScenarioEditorScriptEvent(script.events, eventIndex));
+              }}
+            />
+          ))}
+          <button
+            className="editor-script-add"
+            onClick={() => {
+              replaceEvents(appendScenarioEditorScriptEvent(script.events));
+            }}
+            type="button"
+          >
+            Add Script Event
+          </button>
+        </div>
+      ) : (
+        <p className="editor-help">Scripted event actions are disabled for this draft.</p>
+      )}
+
+      <dl className="editor-grid">
+        <dt>Dirty State</dt>
+        <dd>{isDirty ? 'dirty' : 'clean'}</dd>
+        <dt>Scripts Enabled</dt>
+        <dd>{script.enabled ? 'yes' : 'no'}</dd>
+        <dt>Event Rows</dt>
+        <dd>{script.events.length}</dd>
+        <dt>Validation</dt>
+        <dd>
+          {!script.enabled
+            ? 'disabled'
+            : validationIssues.length === 0
+              ? 'valid'
+              : `invalid (${validationIssues.length} issue${
+                  validationIssues.length === 1 ? '' : 's'
+                })`}
+        </dd>
+      </dl>
+
+      {script.enabled && validationIssues.length > 0 ? (
+        <section aria-label="Script semantic issues" className="editor-export-issues">
+          <h2>Script Semantic Issues</h2>
+          <ul>
+            {validationIssues.map((issue, index) => (
+              <li key={`${issue.path}:${issue.message}:${index}`}>
+                <code>{issue.path}</code>: {issue.message}
+              </li>
+            ))}
+          </ul>
+        </section>
+      ) : null}
+
+      <section className="editor-export-preview" aria-label="Script event preview">
+        <h2>Script Event JSON</h2>
+        <textarea readOnly rows={12} value={scriptJson} />
+      </section>
+    </section>
+  );
+}
+
+/**
+ * One event row editor for Stage 4.2 script authoring.
+ * Not from Micropolis C: this is React form wiring around declarative runtime event drafts.
+ */
+function ScenarioScriptEventEditor(options: {
+  event: ScenarioEditorScriptEvent;
+  index: number;
+  onChange: (event: ScenarioEditorScriptEvent) => void;
+  onRemove: () => void;
+}) {
+  const { event, index, onChange, onRemove } = options;
+  const triggerKind = getScenarioEditorScriptTriggerKind(event.trigger);
+
+  return (
+    <fieldset className="editor-script-event">
+      <legend>{`Event ${index + 1}`}</legend>
+      <div className="editor-script-event-grid">
+        <label className="editor-field">
+          <span>Trigger</span>
+          <select
+            onChange={(changeEvent) => {
+              onChange(
+                coerceScenarioEditorScriptTriggerKind(
+                  event,
+                  changeEvent.currentTarget
+                    .value as (typeof SCENARIO_EDITOR_SCRIPT_TRIGGER_KINDS)[number],
+                ),
+              );
+            }}
+            value={triggerKind}
+          >
+            {SCENARIO_EDITOR_SCRIPT_TRIGGER_KINDS.map((kind) => (
+              <option key={kind} value={kind}>
+                {getScenarioScriptTriggerKindLabel(kind)}
+              </option>
+            ))}
+          </select>
+        </label>
+
+        {triggerKind === 'atTick' ? (
+          <label className="editor-field">
+            <span>atTick</span>
+            <input
+              min={0}
+              onChange={(changeEvent) => {
+                onChange(
+                  replaceScenarioEditorAtTickTrigger(
+                    event,
+                    parseIntegerInput(
+                      changeEvent.currentTarget.value,
+                      'atTick' in event.trigger ? event.trigger.atTick : 0,
+                    ),
+                  ),
+                );
+              }}
+              type="number"
+              value={'atTick' in event.trigger ? event.trigger.atTick : 0}
+            />
+          </label>
+        ) : (
+          <label className="editor-field">
+            <span>everyTicks</span>
+            <input
+              min={1}
+              onChange={(changeEvent) => {
+                onChange(
+                  replaceScenarioEditorEveryTicksTrigger(
+                    event,
+                    parseIntegerInput(
+                      changeEvent.currentTarget.value,
+                      'everyTicks' in event.trigger ? event.trigger.everyTicks : 1,
+                    ),
+                  ),
+                );
+              }}
+              type="number"
+              value={'everyTicks' in event.trigger ? event.trigger.everyTicks : 1}
+            />
+          </label>
+        )}
+      </div>
+
+      <div className="editor-script-actions">
+        <h3>Actions</h3>
+        {event.actions.map((action, actionIndex) => (
+          <div className="editor-script-action-row" key={`${index}:${actionIndex}`}>
+            <label className="editor-field">
+              <span>Action</span>
+              <select
+                onChange={(changeEvent) => {
+                  onChange(
+                    replaceScenarioEditorScriptAction(
+                      event,
+                      actionIndex,
+                      coerceScenarioEditorScriptActionKind(
+                        action,
+                        changeEvent.currentTarget.value as ScenarioEditorScriptAction['kind'],
+                      ),
+                    ),
+                  );
+                }}
+                value={action.kind}
+              >
+                {SCENARIO_EDITOR_SCRIPT_ACTION_KINDS.map((kind) => (
+                  <option key={kind} value={kind}>
+                    {getScenarioScriptActionKindLabel(kind)}
+                  </option>
+                ))}
+              </select>
+            </label>
+
+            {action.kind === 'send-message' ? (
+              <label className="editor-field">
+                <span>messageId</span>
+                <input
+                  onChange={(changeEvent) => {
+                    onChange(
+                      replaceScenarioEditorScriptAction(
+                        event,
+                        actionIndex,
+                        replaceScenarioEditorSendMessageId(
+                          action,
+                          parseIntegerInput(changeEvent.currentTarget.value, action.messageId),
+                        ),
+                      ),
+                    );
+                  }}
+                  type="number"
+                  value={action.messageId}
+                />
+              </label>
+            ) : null}
+
+            <button
+              className="editor-script-remove"
+              onClick={() => {
+                onChange(removeScenarioEditorScriptAction(event, actionIndex));
+              }}
+              type="button"
+            >
+              Remove Action
+            </button>
+          </div>
+        ))}
+        <button
+          className="editor-script-add"
+          onClick={() => {
+            onChange(appendScenarioEditorScriptAction(event));
+          }}
+          type="button"
+        >
+          Add Action
+        </button>
+      </div>
+
+      <button className="editor-script-remove" onClick={onRemove} type="button">
+        Remove Event
+      </button>
+    </fieldset>
+  );
+}
+
+/**
+ * Behavior-profile assignment card for Stage 4.3 closed-profile authoring.
+ * Parity note: profile keys map to closed `ScenarioID` behavior variants in `DoShipSprite`
+ * (`ref/micropolis/src/sim/w_sprite.c`), with declarative selection via
+ * `packages/scenario-runtime/src/behavior-profiles.ts`.
+ */
+function ScenarioBehaviorProfileEditorCard() {
+  const { behavior, isDirty } = useScenarioEditorState();
+  const dispatch = useScenarioEditorDispatch();
+  const validationIssue = getScenarioEditorBehaviorValidationIssue(behavior);
+  const normalizedProfileKey = behavior.profileKey.trim();
+  const hasClosedProfileKey = isScenarioEditorBehaviorProfileKey(normalizedProfileKey);
+  const selectedProfileKey = hasClosedProfileKey ? normalizedProfileKey : behavior.profileKey;
+  const behaviorJson = useMemo(
+    () =>
+      JSON.stringify(
+        behavior.enabled ? { behaviorProfileKey: behavior.profileKey } : null,
+        null,
+        2,
+      ),
+    [behavior.enabled, behavior.profileKey],
+  );
+
+  return (
+    <section
+      className="editor-card editor-behavior-card"
+      aria-label="Scenario behavior profile editor"
+    >
+      <h1>Scenario Behavior Profile</h1>
+      <p>
+        Assign one closed runtime behavior profile key. This preserves deterministic parity by
+        allowing only registered profile variants.
+      </p>
+
+      <label className="editor-field editor-behavior-toggle">
+        <span>Behavior Profile Assignment Enabled</span>
+        <input
+          checked={behavior.enabled}
+          onChange={(event) => {
+            dispatch({ type: 'set-behavior-enabled', enabled: event.currentTarget.checked });
+          }}
+          type="checkbox"
+        />
+        <small className="editor-help">
+          This Stage 4.3 draft editor captures profile assignment only; export integration lands in
+          Stage 4.5.
+        </small>
+      </label>
+
+      {behavior.enabled ? (
+        <label className="editor-field">
+          <span>Behavior Profile Key</span>
+          <select
+            aria-invalid={validationIssue !== undefined}
+            onChange={(event) => {
+              dispatch({
+                type: 'set-behavior-profile-key',
+                profileKey: event.currentTarget.value,
+              });
+            }}
+            value={selectedProfileKey}
+          >
+            {hasClosedProfileKey ? null : (
+              <option value={selectedProfileKey}>
+                {`Unrecognized key: ${behavior.profileKey || '(empty)'}`}
+              </option>
+            )}
+            {SCENARIO_EDITOR_BEHAVIOR_PROFILE_KEYS.map((profileKey) => (
+              <option key={profileKey} value={profileKey}>
+                {getScenarioBehaviorProfileLabel(profileKey)}
+              </option>
+            ))}
+          </select>
+          <small className="editor-help">
+            Closed profile keys only: {SCENARIO_EDITOR_BEHAVIOR_PROFILE_KEYS.join(', ')}.
+          </small>
+          {validationIssue !== undefined ? (
+            <small className="editor-error">{validationIssue}</small>
+          ) : null}
+        </label>
+      ) : (
+        <p className="editor-help">Behavior profile override is disabled for this draft.</p>
+      )}
+
+      <dl className="editor-grid">
+        <dt>Dirty State</dt>
+        <dd>{isDirty ? 'dirty' : 'clean'}</dd>
+        <dt>Assignment Enabled</dt>
+        <dd>{behavior.enabled ? 'yes' : 'no'}</dd>
+        <dt>Profile Key</dt>
+        <dd>{behavior.enabled ? behavior.profileKey : 'none'}</dd>
+        <dt>Validation</dt>
+        <dd>{validationIssue === undefined ? 'valid' : 'invalid'}</dd>
+      </dl>
+
+      <section className="editor-export-preview" aria-label="Behavior profile preview">
+        <h2>Behavior Assignment JSON</h2>
+        <textarea readOnly rows={6} value={behaviorJson} />
+      </section>
+    </section>
+  );
+}
+
 /**
  * Strict JSON export + open/import card for Stage 3.4/3.5.
  * Reuses Stage 0 schema/map canonicalization checks derived from Micropolis map
@@ -389,7 +1049,7 @@ function ScenarioMapEditorCard() {
  * file-picker UX are editor-only browser workflow glue.
  */
 function ScenarioExportCard() {
-  const { bundle, isDirty } = useScenarioEditorState();
+  const { bundle, isDirty, objective, script } = useScenarioEditorState();
   const dispatch = useScenarioEditorDispatch();
   const openFileInputRef = useRef<HTMLInputElement | null>(null);
   const [lastOpenResult, setLastOpenResult] = useState<ScenarioEditorOpenResult | null>(null);
@@ -397,7 +1057,7 @@ function ScenarioExportCard() {
   const exportFileName = getScenarioEditorExportFileName(bundle.key);
 
   const handleExport = () => {
-    const result = buildScenarioEditorStrictExport(bundle);
+    const result = buildScenarioEditorStrictExport(bundle, { objective, script });
     setLastResult(result);
 
     if (!result.ok) {
@@ -472,7 +1132,8 @@ function ScenarioExportCard() {
       <h1>Export Scenario Bundle</h1>
       <p>
         Open an existing bundle JSON for iterative edits, then run strict schema/lint checks and
-        export canonical `ScenarioBundleV1` JSON with map payload compiled to `city-file-bytes`.
+        export canonical `ScenarioBundleV1` JSON with map payload compiled to `city-file-bytes` plus
+        authored Stage 4 objective/script payloads when enabled.
       </p>
 
       <div className="editor-export-actions">
@@ -577,8 +1238,8 @@ function triggerScenarioBundleJsonDownload(fileName: string, jsonText: string) {
 
 /**
  * Parse integer form input with deterministic fallback.
- * Parity note: integers mirror C-style whole-number scenario fields, while fallback behavior
- * is editor-specific UI handling.
+ * Parity note: integers mirror C-style whole-number scenario/objective fields, while fallback
+ * behavior is editor-specific UI handling.
  */
 function parseIntegerInput(rawValue: string, fallback: number): number {
   if (rawValue.trim().length === 0) {
@@ -588,6 +1249,127 @@ function parseIntegerInput(rawValue: string, fallback: number): number {
   return Number.isNaN(parsed) ? fallback : parsed;
 }
 
+/**
+ * Render label text for one objective predicate kind.
+ * Not from Micropolis C: UI-only display names for runtime predicate kinds.
+ */
+function getScenarioObjectivePredicateKindLabel(
+  kind: ScenarioEditorObjectivePredicate['kind'],
+): string {
+  if (kind === 'metric') {
+    return 'Metric';
+  }
+  if (kind === 'all') {
+    return 'All';
+  }
+  if (kind === 'any') {
+    return 'Any';
+  }
+  return 'Not';
+}
+
+/**
+ * Render label text for one objective metric key.
+ * Mirrors metric domains from `DoScenarioScore` in `ref/micropolis/src/sim/s_msg.c`.
+ */
+function getScenarioObjectiveMetricLabel(
+  metric: (typeof SCENARIO_EDITOR_OBJECTIVE_METRIC_KEYS)[number],
+): string {
+  if (metric === 'city-class') {
+    return 'City Class';
+  }
+  if (metric === 'traffic-average') {
+    return 'Traffic Average';
+  }
+  if (metric === 'city-score') {
+    return 'City Score';
+  }
+  return 'Crime Average';
+}
+
+/**
+ * Render label text for one objective comparison operator.
+ * Mirrors relational operator semantics used by `DoScenarioScore` in
+ * `ref/micropolis/src/sim/s_msg.c`.
+ */
+function getScenarioObjectiveComparisonLabel(
+  comparison: (typeof SCENARIO_EDITOR_OBJECTIVE_COMPARISONS)[number],
+): string {
+  if (comparison === 'gt') {
+    return '>';
+  }
+  if (comparison === 'gte') {
+    return '>=';
+  }
+  if (comparison === 'lt') {
+    return '<';
+  }
+  if (comparison === 'lte') {
+    return '<=';
+  }
+  if (comparison === 'eq') {
+    return '=';
+  }
+  return '!=';
+}
+
+/**
+ * Render label text for one script trigger selector value.
+ * Mirrors `ScenarioDisaster` trigger styles in `ref/micropolis/src/sim/s_disast.c`.
+ */
+function getScenarioScriptTriggerKindLabel(
+  kind: (typeof SCENARIO_EDITOR_SCRIPT_TRIGGER_KINDS)[number],
+): string {
+  if (kind === 'atTick') {
+    return 'At Tick';
+  }
+  return 'Every Ticks';
+}
+
+/**
+ * Render label text for one script action kind.
+ * Mirrors action side-effect categories represented by `ScenarioRuntimeAction`.
+ */
+function getScenarioScriptActionKindLabel(
+  kind: (typeof SCENARIO_EDITOR_SCRIPT_ACTION_KINDS)[number],
+): string {
+  if (kind === 'make-earthquake') {
+    return 'Make Earthquake';
+  }
+  if (kind === 'drop-fire-bombs') {
+    return 'Drop Fire Bombs';
+  }
+  if (kind === 'make-monster') {
+    return 'Make Monster';
+  }
+  if (kind === 'make-meltdown') {
+    return 'Make Meltdown';
+  }
+  if (kind === 'make-flood') {
+    return 'Make Flood';
+  }
+  if (kind === 'send-message') {
+    return 'Send Message';
+  }
+  return 'Lose Game';
+}
+
+/**
+ * Render label text for one closed behavior-profile key.
+ * Mirrors runtime profile keyspace from `packages/scenario-runtime` registry.
+ */
+function getScenarioBehaviorProfileLabel(
+  profileKey: (typeof SCENARIO_EDITOR_BEHAVIOR_PROFILE_KEYS)[number],
+): string {
+  if (profileKey === 'classic/default') {
+    return 'Classic Default';
+  }
+  if (profileKey === 'classic/sf-ship-honk') {
+    return 'Classic SF Ship Honk';
+  }
+  return profileKey;
+}
+
 /**
  * Convert canvas pointer coordinates to fixed map tile coordinates.
  * Mirrors Micropolis bounds guards (`0 <= x < WORLD_X`, `0 <= y < WORLD_Y`) from
diff --git a/apps/scenario-editor/src/state/editor-behavior.test.ts b/apps/scenario-editor/src/state/editor-behavior.test.ts
new file mode 100644
index 00000000..4b19f3c6
--- /dev/null
+++ b/apps/scenario-editor/src/state/editor-behavior.test.ts
@@ -0,0 +1,72 @@
+import { describe, expect, test } from 'vitest';
+
+import {
+  createScenarioEditorInitialBehaviorDraft,
+  getScenarioEditorBehaviorValidationIssue,
+  isScenarioEditorBehaviorProfileKey,
+  SCENARIO_EDITOR_BEHAVIOR_PROFILE_KEYS,
+} from './editor-behavior.ts';
+
+/**
+ * Stage 4.3 behavior-profile authoring tests.
+ * Parity anchor: profile keys map to closed `DoShipSprite` behavior variants from
+ * `ref/micropolis/src/sim/w_sprite.c` via `packages/scenario-runtime`.
+ */
+describe('scenario editor behavior profile drafting', () => {
+  test('exposes the closed runtime behavior profile key list', () => {
+    expect(SCENARIO_EDITOR_BEHAVIOR_PROFILE_KEYS).toEqual([
+      'classic/default',
+      'classic/sf-ship-honk',
+    ]);
+  });
+
+  test('creates initial behavior draft disabled with default profile key', () => {
+    const draft = createScenarioEditorInitialBehaviorDraft();
+
+    expect(draft).toEqual({
+      enabled: false,
+      profileKey: 'classic/default',
+    });
+  });
+
+  test('validates enabled profile assignment against closed registry', () => {
+    expect(
+      getScenarioEditorBehaviorValidationIssue({
+        enabled: true,
+        profileKey: 'classic/sf-ship-honk',
+      }),
+    ).toBeUndefined();
+
+    const issue = getScenarioEditorBehaviorValidationIssue({
+      enabled: true,
+      profileKey: 'classic/not-registered',
+    });
+    expect(issue).toContain('closed registered keys');
+    expect(issue).toContain('classic/default');
+    expect(issue).toContain('classic/sf-ship-honk');
+  });
+
+  test('accepts whitespace-padded closed keys by trimming before validation', () => {
+    expect(
+      getScenarioEditorBehaviorValidationIssue({
+        enabled: true,
+        profileKey: '  classic/default  ',
+      }),
+    ).toBeUndefined();
+  });
+
+  test('skips validation while profile assignment is disabled', () => {
+    expect(
+      getScenarioEditorBehaviorValidationIssue({
+        enabled: false,
+        profileKey: 'classic/not-registered',
+      }),
+    ).toBeUndefined();
+  });
+
+  test('exposes a closed-key type guard for behavior profile UI state', () => {
+    expect(isScenarioEditorBehaviorProfileKey('classic/default')).toBe(true);
+    expect(isScenarioEditorBehaviorProfileKey('classic/sf-ship-honk')).toBe(true);
+    expect(isScenarioEditorBehaviorProfileKey('classic/not-registered')).toBe(false);
+  });
+});
diff --git a/apps/scenario-editor/src/state/editor-behavior.ts b/apps/scenario-editor/src/state/editor-behavior.ts
new file mode 100644
index 00000000..8c968b6e
--- /dev/null
+++ b/apps/scenario-editor/src/state/editor-behavior.ts
@@ -0,0 +1,74 @@
+import {
+  DEFAULT_SCENARIO_BEHAVIOR_PROFILE_KEY,
+  SCENARIO_BEHAVIOR_PROFILES,
+  type ScenarioBehaviorProfileKey,
+} from '@city/scenario-runtime';
+
+/**
+ * Closed behavior-profile keys exposed by Stage 4.3 authoring UI.
+ * Mirrors the runtime registry from `packages/scenario-runtime/src/behavior-profiles.ts`,
+ * which ports `ScenarioID`-based behavior variants from `DoShipSprite` in
+ * `ref/micropolis/src/sim/w_sprite.c` to a declarative closed keyspace.
+ */
+export const SCENARIO_EDITOR_BEHAVIOR_PROFILE_KEYS: readonly ScenarioBehaviorProfileKey[] =
+  SCENARIO_BEHAVIOR_PROFILES.map((profile) => profile.key);
+const SCENARIO_EDITOR_BEHAVIOR_PROFILE_KEY_SET = new Set<ScenarioBehaviorProfileKey>(
+  SCENARIO_EDITOR_BEHAVIOR_PROFILE_KEYS,
+);
+
+/**
+ * Stage 4.3 behavior-profile assignment draft state for the scenario editor.
+ * Parity note: Micropolis C did not expose behavior-profile authoring UI; this is an editor-only
+ * draft model for selecting closed runtime variants equivalent to C `ScenarioID` branches.
+ */
+export interface ScenarioEditorBehaviorDraft {
+  readonly enabled: boolean;
+  readonly profileKey: string;
+}
+
+/**
+ * Type guard for closed Stage 4.3 behavior-profile keys.
+ * Mirrors the runtime closed registry from `packages/scenario-runtime/src/behavior-profiles.ts`,
+ * which ports `DoShipSprite` scenario-id branches in `ref/micropolis/src/sim/w_sprite.c`.
+ */
+export function isScenarioEditorBehaviorProfileKey(
+  profileKey: string,
+): profileKey is ScenarioBehaviorProfileKey {
+  return SCENARIO_EDITOR_BEHAVIOR_PROFILE_KEY_SET.has(profileKey as ScenarioBehaviorProfileKey);
+}
+
+/**
+ * Creates initial Stage 4.3 behavior-profile draft state for a new editor session.
+ * Uses the closed runtime default profile, which mirrors non-San-Francisco behavior in
+ * `DoShipSprite` from `ref/micropolis/src/sim/w_sprite.c`.
+ */
+export function createScenarioEditorInitialBehaviorDraft(): ScenarioEditorBehaviorDraft {
+  return {
+    enabled: false,
+    profileKey: DEFAULT_SCENARIO_BEHAVIOR_PROFILE_KEY,
+  };
+}
+
+/**
+ * Returns a validation issue when an enabled behavior assignment is not in the closed registry.
+ * Mapping note: closed validation preserves deterministic parity by rejecting arbitrary runtime
+ * hooks and allowing only registered keys from `SCENARIO_BEHAVIOR_PROFILES`.
+ */
+export function getScenarioEditorBehaviorValidationIssue(
+  draft: ScenarioEditorBehaviorDraft,
+): string | undefined {
+  if (!draft.enabled) {
+    return undefined;
+  }
+
+  const normalizedProfileKey = draft.profileKey.trim();
+  if (isScenarioEditorBehaviorProfileKey(normalizedProfileKey)) {
+    return undefined;
+  }
+
+  const closedKeys = SCENARIO_EDITOR_BEHAVIOR_PROFILE_KEYS.join(', ');
+  if (normalizedProfileKey.length === 0) {
+    return `behavior profile key is required and must match one of the closed registered keys: ${closedKeys}`;
+  }
+  return `behavior profile key must match one of the closed registered keys: ${closedKeys}`;
+}
diff --git a/apps/scenario-editor/src/state/editor-export.test.ts b/apps/scenario-editor/src/state/editor-export.test.ts
index 790a05be..eb1b91c0 100644
--- a/apps/scenario-editor/src/state/editor-export.test.ts
+++ b/apps/scenario-editor/src/state/editor-export.test.ts
@@ -70,6 +70,93 @@ describe('scenario editor strict export', () => {
       message: 'duplicate tag "harbor" (already used at tags.0)',
     });
   });
+
+  test('integrates authored objective/script drafts into strict export output', () => {
+    const bundle = createScenarioEditorInitialBundle();
+    const result = buildScenarioEditorStrictExport(bundle, {
+      objective: {
+        enabled: true,
+        predicate: {
+          kind: 'metric',
+          metric: 'traffic-average',
+          op: 'lt',
+          // Magic number source: Bern objective threshold `TrafficAverage < 80`
+          // from `DoScenarioScore` in `ref/micropolis/src/sim/s_msg.c`.
+          value: 80,
+        },
+      },
+      script: {
+        enabled: true,
+        events: [
+          {
+            // Magic number source: Rio flood cadence checks `wait % 24 == 0`
+            // in `ScenarioDisaster` (`ref/micropolis/src/sim/s_disast.c`).
+            trigger: { everyTicks: 24 },
+            actions: [
+              { kind: 'make-flood' },
+              {
+                kind: 'send-message',
+                // Magic number source: scenario failure message id `-200`
+                // from `DoScenarioScore` in `ref/micropolis/src/sim/s_msg.c`.
+                messageId: -200,
+              },
+            ],
+          },
+        ],
+      },
+    });
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) {
+      throw new Error('Expected strict export to succeed with authored drafts');
+    }
+
+    expect(result.canonicalBundle.objective).toEqual({
+      kind: 'metric',
+      metric: 'traffic-average',
+      op: 'lt',
+      value: 80,
+    });
+    expect(result.canonicalBundle.script).toEqual([
+      {
+        trigger: { everyTicks: 24 },
+        actions: [{ kind: 'make-flood' }, { kind: 'send-message', messageId: -200 }],
+      },
+    ]);
+  });
+
+  test('fails export when authored objective/script drafts violate semantic rules', () => {
+    const bundle = createScenarioEditorInitialBundle();
+    const result = buildScenarioEditorStrictExport(bundle, {
+      objective: {
+        enabled: true,
+        predicate: {
+          kind: 'all',
+          predicates: [],
+        },
+      },
+      script: {
+        enabled: true,
+        events: [],
+      },
+    });
+
+    expect(result.ok).toBe(false);
+    if (result.ok) {
+      throw new Error('Expected strict export to fail on semantic issues');
+    }
+
+    expect(result.issues).toContainEqual({
+      source: 'lint',
+      path: 'objective.predicate.predicates',
+      message: 'all predicate must include at least one child predicate',
+    });
+    expect(result.issues).toContainEqual({
+      source: 'lint',
+      path: 'script.events',
+      message: 'script must include at least one event',
+    });
+  });
 });
 
 describe('scenario editor export file naming', () => {
diff --git a/apps/scenario-editor/src/state/editor-export.ts b/apps/scenario-editor/src/state/editor-export.ts
index a17d3e6e..118c0bd9 100644
--- a/apps/scenario-editor/src/state/editor-export.ts
+++ b/apps/scenario-editor/src/state/editor-export.ts
@@ -4,6 +4,15 @@ import {
   writeScenarioBundleV1CityFileBytes,
 } from '@city/scenario-core';
 
+import {
+  getScenarioEditorObjectiveValidationIssues,
+  type ScenarioEditorObjectiveDraft,
+} from './editor-objective.ts';
+import {
+  getScenarioEditorScriptValidationIssues,
+  type ScenarioEditorScriptDraft,
+} from './editor-script.ts';
+
 /**
  * One strict-export diagnostic emitted by Stage 3.4 authoring checks.
  * Reuses Stage 0 schema validation for fields that map to `LoadScenario`/`saveFile`
@@ -34,6 +43,17 @@ export type ScenarioEditorStrictExportResult =
       readonly ok: false;
     };
 
+/**
+ * Optional Stage 4 authoring drafts compiled into strict-export bundle payloads.
+ * Mapping note: objective predicates and script trigger/action rows map to
+ * `DoScenarioScore`/`ScenarioDisaster` domains from
+ * `ref/micropolis/src/sim/s_msg.c` and `ref/micropolis/src/sim/s_disast.c`.
+ */
+export interface ScenarioEditorStrictExportDraftInputs {
+  readonly objective?: ScenarioEditorObjectiveDraft;
+  readonly script?: ScenarioEditorScriptDraft;
+}
+
 /**
  * Build strict export JSON for one editor bundle.
  * Applies Stage 0 schema validation, authoring lints, and canonical map compilation
@@ -42,8 +62,18 @@ export type ScenarioEditorStrictExportResult =
  */
 export function buildScenarioEditorStrictExport(
   bundle: ScenarioBundleV1,
+  draftInputs: ScenarioEditorStrictExportDraftInputs = {},
 ): ScenarioEditorStrictExportResult {
-  const parsedBundle = scenarioBundleV1Schema.safeParse(bundle);
+  const draftLintIssues = lintScenarioEditorDraftInputs(draftInputs);
+  if (draftLintIssues.length > 0) {
+    return {
+      ok: false,
+      issues: draftLintIssues,
+    };
+  }
+
+  const exportBundle = applyScenarioEditorDraftsToBundle(bundle, draftInputs);
+  const parsedBundle = scenarioBundleV1Schema.safeParse(exportBundle);
   if (!parsedBundle.success) {
     return {
       ok: false,
@@ -122,9 +152,110 @@ function lintScenarioBundleForStrictExport(
     firstIndexByTag.set(tag, index);
   }
 
+  if (bundle.objective !== undefined) {
+    const objectiveIssues = getScenarioEditorObjectiveValidationIssues({
+      enabled: true,
+      predicate: bundle.objective,
+    });
+    for (const issue of objectiveIssues) {
+      issues.push({
+        source: 'lint',
+        path: issue.path,
+        message: issue.message,
+      });
+    }
+  }
+
+  if (bundle.script !== undefined) {
+    const scriptIssues = getScenarioEditorScriptValidationIssues({
+      enabled: true,
+      events: bundle.script,
+    });
+    for (const issue of scriptIssues) {
+      issues.push({
+        source: 'lint',
+        path: issue.path,
+        message: issue.message,
+      });
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Runs Stage 4 semantic validators against in-memory objective/script drafts.
+ * Mapping note: this surfaces authoring diagnostics for predicate/event rows before
+ * schema validation/canonicalization in strict export.
+ */
+function lintScenarioEditorDraftInputs(
+  draftInputs: ScenarioEditorStrictExportDraftInputs,
+): readonly ScenarioEditorExportIssue[] {
+  const issues: ScenarioEditorExportIssue[] = [];
+
+  if (draftInputs.objective !== undefined) {
+    const objectiveIssues = getScenarioEditorObjectiveValidationIssues(draftInputs.objective);
+    for (const issue of objectiveIssues) {
+      issues.push({
+        source: 'lint',
+        path: issue.path,
+        message: issue.message,
+      });
+    }
+  }
+
+  if (draftInputs.script !== undefined) {
+    const scriptIssues = getScenarioEditorScriptValidationIssues(draftInputs.script);
+    for (const issue of scriptIssues) {
+      issues.push({
+        source: 'lint',
+        path: issue.path,
+        message: issue.message,
+      });
+    }
+  }
+
   return issues;
 }
 
+/**
+ * Applies optional Stage 4 objective/script drafts to a bundle before strict export.
+ * Mapping note: objective/script payloads are persisted as authored JSON contract
+ * data while map serialization still mirrors `saveFile` behavior from
+ * `ref/micropolis/src/sim/s_fileio.c`.
+ */
+function applyScenarioEditorDraftsToBundle(
+  bundle: ScenarioBundleV1,
+  draftInputs: ScenarioEditorStrictExportDraftInputs,
+): ScenarioBundleV1 {
+  let nextBundle = bundle;
+
+  if (draftInputs.objective !== undefined) {
+    const { objective: _ignoredObjective, ...bundleWithoutObjective } = nextBundle;
+    nextBundle = draftInputs.objective.enabled
+      ? {
+          ...bundleWithoutObjective,
+          objective: draftInputs.objective.predicate,
+        }
+      : bundleWithoutObjective;
+  }
+
+  if (draftInputs.script !== undefined) {
+    const { script: _ignoredScript, ...bundleWithoutScript } = nextBundle;
+    nextBundle = draftInputs.script.enabled
+      ? {
+          ...bundleWithoutScript,
+          script: draftInputs.script.events.map((event) => ({
+            trigger: { ...event.trigger },
+            actions: event.actions.map((action) => ({ ...action })),
+          })),
+        }
+      : bundleWithoutScript;
+  }
+
+  return nextBundle;
+}
+
 /**
  * Convert schema parser diagnostics into strict-export issue rows.
  * Reuses Zod issue paths/messages from `scenarioBundleV1Schema` as user-facing
diff --git a/apps/scenario-editor/src/state/editor-import.test.ts b/apps/scenario-editor/src/state/editor-import.test.ts
index 1ea8e27e..9b1dd10c 100644
--- a/apps/scenario-editor/src/state/editor-import.test.ts
+++ b/apps/scenario-editor/src/state/editor-import.test.ts
@@ -15,7 +15,30 @@ import { createScenarioEditorInitialBundle } from './editor-state.tsx';
  */
 describe('scenario editor bundle import', () => {
   test('opens strict-export JSON and normalizes map payload for editing', () => {
-    const strictExport = buildScenarioEditorStrictExport(createScenarioEditorInitialBundle());
+    const strictExport = buildScenarioEditorStrictExport(createScenarioEditorInitialBundle(), {
+      objective: {
+        enabled: true,
+        predicate: {
+          kind: 'metric',
+          metric: 'city-score',
+          op: 'gt',
+          // Magic number source: Tokyo/Boston/Rio objective threshold `CityScore > 500`
+          // from `DoScenarioScore` in `ref/micropolis/src/sim/s_msg.c`.
+          value: 500,
+        },
+      },
+      script: {
+        enabled: true,
+        events: [
+          {
+            // Magic number source: Rio flood cadence checks `wait % 24 == 0`
+            // in `ScenarioDisaster` (`ref/micropolis/src/sim/s_disast.c`).
+            trigger: { everyTicks: 24 },
+            actions: [{ kind: 'make-flood' }],
+          },
+        ],
+      },
+    });
     expect(strictExport.ok).toBe(true);
     if (!strictExport.ok) {
       throw new Error('Expected strict export fixture to be valid');
@@ -37,6 +60,18 @@ describe('scenario editor bundle import', () => {
     expect(openResult.bundle.map.width).toBe(120);
     expect(openResult.bundle.map.height).toBe(100);
     expect(openResult.bundle.map.tileWords).toHaveLength(12000);
+    expect(openResult.bundle.objective).toEqual({
+      kind: 'metric',
+      metric: 'city-score',
+      op: 'gt',
+      value: 500,
+    });
+    expect(openResult.bundle.script).toEqual([
+      {
+        trigger: { everyTicks: 24 },
+        actions: [{ kind: 'make-flood' }],
+      },
+    ]);
   });
 
   test('reports a JSON issue for malformed document text', () => {
diff --git a/apps/scenario-editor/src/state/editor-objective.test.ts b/apps/scenario-editor/src/state/editor-objective.test.ts
new file mode 100644
index 00000000..71c80152
--- /dev/null
+++ b/apps/scenario-editor/src/state/editor-objective.test.ts
@@ -0,0 +1,300 @@
+import { describe, expect, test } from 'vitest';
+
+import {
+  appendScenarioObjectiveChildPredicate,
+  coerceScenarioObjectivePredicateKind,
+  createScenarioEditorDefaultObjectivePredicate,
+  createScenarioEditorInitialObjectiveDraft,
+  createScenarioEditorObjectiveDraftFromBundle,
+  getScenarioEditorObjectiveValidationIssues,
+  removeScenarioObjectiveChildPredicate,
+  replaceScenarioObjectiveChildPredicate,
+  replaceScenarioObjectiveNotChildPredicate,
+} from './editor-objective.ts';
+
+/**
+ * Stage 4.1 objective DSL authoring tests.
+ * Parity anchor:
+ * - Metric leaves map to `DoScenarioScore` comparisons in `ref/micropolis/src/sim/s_msg.c`.
+ * - Logical composition nodes are declarative runtime extensions layered on top of those checks.
+ */
+describe('scenario editor objective predicate drafting', () => {
+  test('creates a default C-parity metric predicate template', () => {
+    const predicate = createScenarioEditorDefaultObjectivePredicate();
+
+    // Magic number source: Tokyo/Boston/Rio objective threshold `CityScore > 500`
+    // in `DoScenarioScore` from `ref/micropolis/src/sim/s_msg.c`.
+    expect(predicate).toEqual({
+      kind: 'metric',
+      metric: 'city-score',
+      op: 'gt',
+      value: 500,
+    });
+  });
+
+  test('creates initial objective draft in disabled state', () => {
+    const objective = createScenarioEditorInitialObjectiveDraft();
+
+    expect(objective.enabled).toBe(false);
+    expect(objective.predicate.kind).toBe('metric');
+  });
+
+  test('hydrates enabled objective draft state from imported bundle payloads', () => {
+    const objective = createScenarioEditorObjectiveDraftFromBundle({
+      objective: {
+        kind: 'metric',
+        metric: 'traffic-average',
+        op: 'lt',
+        // Magic number source: Bern objective threshold `TrafficAverage < 80`
+        // from `DoScenarioScore` in `ref/micropolis/src/sim/s_msg.c`.
+        value: 80,
+      },
+    });
+
+    expect(objective.enabled).toBe(true);
+    expect(objective.predicate).toEqual({
+      kind: 'metric',
+      metric: 'traffic-average',
+      op: 'lt',
+      value: 80,
+    });
+  });
+
+  test('coerces metric predicates to list and negation forms', () => {
+    const metricPredicate = {
+      kind: 'metric',
+      metric: 'city-class',
+      op: 'gte',
+      value: 4,
+    } as const;
+
+    const asAll = coerceScenarioObjectivePredicateKind(metricPredicate, 'all');
+    expect(asAll).toEqual({
+      kind: 'all',
+      predicates: [metricPredicate],
+    });
+
+    const asNot = coerceScenarioObjectivePredicateKind(metricPredicate, 'not');
+    expect(asNot).toEqual({
+      kind: 'not',
+      predicate: metricPredicate,
+    });
+  });
+
+  test('coerces list predicates to not using the first child', () => {
+    const predicate = {
+      kind: 'all',
+      predicates: [
+        {
+          kind: 'metric',
+          metric: 'city-score',
+          op: 'gt',
+          value: 500,
+        },
+        {
+          kind: 'metric',
+          metric: 'traffic-average',
+          op: 'lt',
+          value: 80,
+        },
+      ],
+    } as const;
+
+    const asNot = coerceScenarioObjectivePredicateKind(predicate, 'not');
+    expect(asNot).toEqual({
+      kind: 'not',
+      predicate: predicate.predicates[0],
+    });
+  });
+
+  test('appends, replaces, and removes list children immutably', () => {
+    const initial = {
+      kind: 'any',
+      predicates: [
+        {
+          kind: 'metric',
+          metric: 'city-score',
+          op: 'gt',
+          value: 500,
+        },
+      ],
+    } as const;
+
+    const appended = appendScenarioObjectiveChildPredicate(initial, {
+      kind: 'metric',
+      metric: 'crime-average',
+      op: 'lt',
+      value: 60,
+    });
+    expect(appended.kind).toBe('any');
+    if (appended.kind !== 'any') {
+      throw new Error('Expected any predicate');
+    }
+    expect(appended.predicates).toHaveLength(2);
+
+    const replaced = replaceScenarioObjectiveChildPredicate(appended, 1, {
+      kind: 'metric',
+      metric: 'traffic-average',
+      op: 'lt',
+      value: 80,
+    });
+    expect(replaced.kind).toBe('any');
+    if (replaced.kind !== 'any') {
+      throw new Error('Expected any predicate');
+    }
+    expect(replaced.predicates[1]).toEqual({
+      kind: 'metric',
+      metric: 'traffic-average',
+      op: 'lt',
+      value: 80,
+    });
+
+    const removed = removeScenarioObjectiveChildPredicate(replaced, 1);
+    expect(removed.kind).toBe('any');
+    if (removed.kind !== 'any') {
+      throw new Error('Expected any predicate');
+    }
+    expect(removed.predicates).toHaveLength(1);
+  });
+
+  test('does not remove the final child from list predicates', () => {
+    const initial = {
+      kind: 'all',
+      predicates: [{ kind: 'metric', metric: 'city-score', op: 'gt', value: 500 }],
+    } as const;
+
+    const removed = removeScenarioObjectiveChildPredicate(initial, 0);
+    expect(removed).toBe(initial);
+  });
+
+  test('replaces the child on not predicates', () => {
+    const initial = {
+      kind: 'not',
+      predicate: { kind: 'metric', metric: 'city-score', op: 'gt', value: 500 },
+    } as const;
+    const updated = replaceScenarioObjectiveNotChildPredicate(initial, {
+      kind: 'metric',
+      metric: 'city-class',
+      op: 'gte',
+      value: 4,
+    });
+
+    expect(updated).toEqual({
+      kind: 'not',
+      predicate: { kind: 'metric', metric: 'city-class', op: 'gte', value: 4 },
+    });
+  });
+
+  test('validates enabled objective drafts and accepts C-parity metric leaves', () => {
+    const issues = getScenarioEditorObjectiveValidationIssues({
+      enabled: true,
+      predicate: createScenarioEditorDefaultObjectivePredicate(),
+    });
+
+    expect(issues).toEqual([]);
+  });
+
+  test('reports semantic validation issues for malformed predicate trees', () => {
+    const issues = getScenarioEditorObjectiveValidationIssues({
+      enabled: true,
+      predicate: {
+        kind: 'all',
+        predicates: [
+          {
+            kind: 'metric',
+            metric: 'unknown-metric',
+            op: 'gt',
+            value: 500,
+          },
+          {
+            kind: 'metric',
+            metric: 'city-score',
+            op: 'unknown-op',
+            value: 500,
+          },
+          {
+            kind: 'metric',
+            metric: 'city-score',
+            op: 'gt',
+            value: Number.NaN,
+          },
+          {
+            kind: 'any',
+            predicates: [],
+          },
+        ],
+      } as unknown as ReturnType<typeof createScenarioEditorDefaultObjectivePredicate>,
+    });
+
+    expect(issues).toEqual([
+      {
+        path: 'objective.predicate.predicates.0.metric',
+        message: 'metric must be one of: city-class, traffic-average, city-score, crime-average',
+      },
+      {
+        path: 'objective.predicate.predicates.1.op',
+        message: 'comparison op must be one of: gt, gte, lt, lte, eq, neq',
+      },
+      {
+        path: 'objective.predicate.predicates.2.value',
+        message: 'metric predicate value must be a finite integer',
+      },
+      {
+        path: 'objective.predicate.predicates.3.predicates',
+        message: 'any predicate must include at least one child predicate',
+      },
+    ]);
+  });
+
+  test('reports invalid kind/field combinations in predicate nodes', () => {
+    const issues = getScenarioEditorObjectiveValidationIssues({
+      enabled: true,
+      predicate: {
+        kind: 'not',
+        metric: 'city-score',
+        op: 'gt',
+        value: 500,
+        predicates: [],
+        predicate: {
+          kind: 'metric',
+          metric: 'city-score',
+          op: 'gt',
+          value: 500,
+        },
+      } as unknown as ReturnType<typeof createScenarioEditorDefaultObjectivePredicate>,
+    });
+
+    expect(issues).toEqual([
+      {
+        path: 'objective.predicate.metric',
+        message: 'metric field is only valid for metric predicates',
+      },
+      {
+        path: 'objective.predicate.op',
+        message: 'comparison op is only valid for metric predicates',
+      },
+      {
+        path: 'objective.predicate.value',
+        message: 'value field is only valid for metric predicates',
+      },
+      {
+        path: 'objective.predicate.predicates',
+        message: 'predicates array is only valid for all/any predicates',
+      },
+    ]);
+  });
+
+  test('skips semantic validation while objective authoring is disabled', () => {
+    const issues = getScenarioEditorObjectiveValidationIssues({
+      enabled: false,
+      predicate: {
+        kind: 'metric',
+        metric: 'unknown-metric',
+        op: 'unknown-op',
+        value: Number.NaN,
+      } as unknown as ReturnType<typeof createScenarioEditorDefaultObjectivePredicate>,
+    });
+
+    expect(issues).toEqual([]);
+  });
+});
diff --git a/apps/scenario-editor/src/state/editor-objective.ts b/apps/scenario-editor/src/state/editor-objective.ts
new file mode 100644
index 00000000..732be4ad
--- /dev/null
+++ b/apps/scenario-editor/src/state/editor-objective.ts
@@ -0,0 +1,458 @@
+import type { ScenarioBundleV1 } from '@city/scenario-core';
+import type {
+  ScenarioObjectiveComparison,
+  ScenarioObjectiveMetricKey,
+  ScenarioObjectivePredicate,
+} from '@city/scenario-runtime';
+
+export type ScenarioEditorObjectivePredicate = ScenarioObjectivePredicate;
+
+/**
+ * Predicate kinds supported by Stage 4 objective authoring.
+ * Mirrors declarative predicate node kinds from `ScenarioObjectivePredicate` in
+ * `packages/scenario-runtime/src/runtime-state.ts`, which ports classic
+ * `DoScenarioScore` comparisons from `ref/micropolis/src/sim/s_msg.c` and extends
+ * them with composable logical nodes.
+ */
+export const SCENARIO_EDITOR_OBJECTIVE_PREDICATE_KINDS = [
+  'metric',
+  'all',
+  'any',
+  'not',
+] as const satisfies readonly ScenarioObjectivePredicate['kind'][];
+
+/**
+ * Metric keys available in the Stage 4 objective editor.
+ * Mirrors the metrics consumed by `DoScenarioScore` in
+ * `ref/micropolis/src/sim/s_msg.c` through the runtime adapter.
+ */
+export const SCENARIO_EDITOR_OBJECTIVE_METRIC_KEYS = [
+  'city-class',
+  'traffic-average',
+  'city-score',
+  'crime-average',
+] as const satisfies readonly ScenarioObjectiveMetricKey[];
+
+/**
+ * Comparison operators available in the Stage 4 objective editor.
+ * Mirrors C relational checks used by `DoScenarioScore` in
+ * `ref/micropolis/src/sim/s_msg.c`, represented as runtime predicate operators.
+ */
+export const SCENARIO_EDITOR_OBJECTIVE_COMPARISONS = [
+  'gt',
+  'gte',
+  'lt',
+  'lte',
+  'eq',
+  'neq',
+] as const satisfies readonly ScenarioObjectiveComparison[];
+const SCENARIO_EDITOR_OBJECTIVE_PREDICATE_KIND_SET = new Set<ScenarioObjectivePredicate['kind']>(
+  SCENARIO_EDITOR_OBJECTIVE_PREDICATE_KINDS,
+);
+const SCENARIO_EDITOR_OBJECTIVE_METRIC_KEY_SET = new Set<ScenarioObjectiveMetricKey>(
+  SCENARIO_EDITOR_OBJECTIVE_METRIC_KEYS,
+);
+const SCENARIO_EDITOR_OBJECTIVE_COMPARISON_SET = new Set<ScenarioObjectiveComparison>(
+  SCENARIO_EDITOR_OBJECTIVE_COMPARISONS,
+);
+
+/**
+ * Stage 4 editor draft model for optional objective authoring.
+ * Parity note: classic Micropolis scenarios always had one hardcoded objective
+ * selected by numeric id in `DoScenarioScore`; this editor draft stores a modern
+ * predicate tree and an explicit enabled toggle for author control.
+ */
+export interface ScenarioEditorObjectiveDraft {
+  readonly enabled: boolean;
+  readonly predicate: ScenarioObjectivePredicate;
+}
+
+/**
+ * Authoring-time semantic issue for Stage 4 objective predicate drafts.
+ * Metric/op domains mirror `DoScenarioScore` comparisons in
+ * `ref/micropolis/src/sim/s_msg.c`; additional structural diagnostics
+ * (`all`/`any` emptiness, malformed nodes) are editor-only guardrails.
+ */
+export interface ScenarioEditorObjectiveValidationIssue {
+  readonly message: string;
+  readonly path: string;
+}
+
+/**
+ * Validates Stage 4 objective draft semantics before export integration.
+ * Parity note: metric/op checks preserve the `DoScenarioScore` field/comparison
+ * space from `ref/micropolis/src/sim/s_msg.c`, while composite-node shape checks
+ * are modern authoring-time validation with no direct C UI equivalent.
+ */
+export function getScenarioEditorObjectiveValidationIssues(
+  draft: ScenarioEditorObjectiveDraft,
+): readonly ScenarioEditorObjectiveValidationIssue[] {
+  if (!draft.enabled) {
+    return [];
+  }
+
+  return collectScenarioObjectivePredicateValidationIssues(
+    draft.predicate as unknown,
+    'objective.predicate',
+  );
+}
+
+/**
+ * Creates a default metric predicate for new objective drafts and new branch nodes.
+ * Magic number mapping: `value: 500` mirrors the classic `CityScore > 500` objective
+ * threshold used by Tokyo/Boston/Rio in `DoScenarioScore` in
+ * `ref/micropolis/src/sim/s_msg.c`.
+ */
+export function createScenarioEditorDefaultObjectivePredicate(): ScenarioObjectivePredicate {
+  return {
+    kind: 'metric',
+    metric: 'city-score',
+    op: 'gt',
+    value: 500,
+  };
+}
+
+/**
+ * Creates the initial objective draft state for a new editor session.
+ * Parity note: legacy scenarios did not expose objective authoring UI; Stage 4 starts
+ * disabled by default and seeds a C-parity metric predicate template for opt-in edits.
+ */
+export function createScenarioEditorInitialObjectiveDraft(): ScenarioEditorObjectiveDraft {
+  return {
+    enabled: false,
+    predicate: createScenarioEditorDefaultObjectivePredicate(),
+  };
+}
+
+/**
+ * Creates Stage 4 objective draft state from an imported bundle payload.
+ * Mapping note: imports persisted objective predicates that correspond to
+ * `DoScenarioScore` metric/comparison domains in `ref/micropolis/src/sim/s_msg.c`,
+ * while defaulting to disabled authoring when no objective payload is present.
+ */
+export function createScenarioEditorObjectiveDraftFromBundle(
+  bundle: Pick<ScenarioBundleV1, 'objective'>,
+): ScenarioEditorObjectiveDraft {
+  if (bundle.objective === undefined) {
+    return createScenarioEditorInitialObjectiveDraft();
+  }
+
+  return {
+    enabled: true,
+    predicate: bundle.objective,
+  };
+}
+
+/**
+ * Converts one predicate node to a requested kind while preserving children where possible.
+ * Parity note: `metric` leaves remain `DoScenarioScore`-style comparisons, while
+ * `all`/`any`/`not` are declarative composition layers introduced in scenario-runtime.
+ */
+export function coerceScenarioObjectivePredicateKind(
+  predicate: ScenarioObjectivePredicate,
+  nextKind: ScenarioObjectivePredicate['kind'],
+): ScenarioObjectivePredicate {
+  if (predicate.kind === nextKind) {
+    return predicate;
+  }
+
+  if (nextKind === 'metric') {
+    return createScenarioEditorDefaultObjectivePredicate();
+  }
+
+  if (nextKind === 'all' || nextKind === 'any') {
+    if (predicate.kind === 'not') {
+      return {
+        kind: nextKind,
+        predicates: [predicate.predicate],
+      };
+    }
+    if (predicate.kind === 'metric') {
+      return {
+        kind: nextKind,
+        predicates: [predicate],
+      };
+    }
+    return {
+      kind: nextKind,
+      predicates:
+        predicate.predicates.length > 0
+          ? predicate.predicates
+          : [createScenarioEditorDefaultObjectivePredicate()],
+    };
+  }
+
+  if (predicate.kind === 'all' || predicate.kind === 'any') {
+    const firstChild = predicate.predicates[0];
+    return {
+      kind: 'not',
+      predicate:
+        firstChild === undefined ? createScenarioEditorDefaultObjectivePredicate() : firstChild,
+    };
+  }
+
+  return {
+    kind: 'not',
+    predicate,
+  };
+}
+
+/**
+ * Appends one child predicate to an `all` or `any` node.
+ * Returns the input unchanged for non-list nodes because they do not have list children.
+ */
+export function appendScenarioObjectiveChildPredicate(
+  predicate: ScenarioObjectivePredicate,
+  child: ScenarioObjectivePredicate = createScenarioEditorDefaultObjectivePredicate(),
+): ScenarioObjectivePredicate {
+  if (predicate.kind !== 'all' && predicate.kind !== 'any') {
+    return predicate;
+  }
+
+  return {
+    ...predicate,
+    predicates: [...predicate.predicates, child],
+  };
+}
+
+/**
+ * Replaces one child predicate at index on an `all` or `any` node.
+ * Returns the input unchanged when index is out of range or node kind is not list-based.
+ */
+export function replaceScenarioObjectiveChildPredicate(
+  predicate: ScenarioObjectivePredicate,
+  index: number,
+  child: ScenarioObjectivePredicate,
+): ScenarioObjectivePredicate {
+  if (predicate.kind !== 'all' && predicate.kind !== 'any') {
+    return predicate;
+  }
+  if (!Number.isInteger(index) || index < 0 || index >= predicate.predicates.length) {
+    return predicate;
+  }
+
+  return {
+    ...predicate,
+    predicates: predicate.predicates.map((current, currentIndex) =>
+      currentIndex === index ? child : current,
+    ),
+  };
+}
+
+/**
+ * Removes one child predicate by index from an `all` or `any` node.
+ * Enforces at least one child to prevent invalid empty list nodes during editing.
+ */
+export function removeScenarioObjectiveChildPredicate(
+  predicate: ScenarioObjectivePredicate,
+  index: number,
+): ScenarioObjectivePredicate {
+  if (predicate.kind !== 'all' && predicate.kind !== 'any') {
+    return predicate;
+  }
+  if (!Number.isInteger(index) || index < 0 || index >= predicate.predicates.length) {
+    return predicate;
+  }
+  if (predicate.predicates.length <= 1) {
+    return predicate;
+  }
+
+  return {
+    ...predicate,
+    predicates: predicate.predicates.filter((_, currentIndex) => currentIndex !== index),
+  };
+}
+
+/**
+ * Replaces the single child predicate on a `not` node.
+ * Returns the input unchanged when the node is not a `not` predicate.
+ */
+export function replaceScenarioObjectiveNotChildPredicate(
+  predicate: ScenarioObjectivePredicate,
+  child: ScenarioObjectivePredicate,
+): ScenarioObjectivePredicate {
+  if (predicate.kind !== 'not') {
+    return predicate;
+  }
+
+  return {
+    kind: 'not',
+    predicate: child,
+  };
+}
+
+const collectScenarioObjectivePredicateValidationIssues = (
+  predicate: unknown,
+  path: string,
+): ScenarioEditorObjectiveValidationIssue[] => {
+  const issues: ScenarioEditorObjectiveValidationIssue[] = [];
+  if (!isRecord(predicate)) {
+    issues.push({
+      path,
+      message: 'predicate node must be an object',
+    });
+    return issues;
+  }
+
+  const kind = predicate.kind;
+  if (!isScenarioObjectivePredicateKind(kind)) {
+    issues.push({
+      path: `${path}.kind`,
+      message:
+        'predicate kind must be one of: metric, all, any, not (unknown kind found at authoring time)',
+    });
+    return issues;
+  }
+
+  if (kind === 'metric') {
+    if (Object.prototype.hasOwnProperty.call(predicate, 'predicates')) {
+      issues.push({
+        path: `${path}.predicates`,
+        message: 'predicates array is only valid for all/any predicates',
+      });
+    }
+    if (Object.prototype.hasOwnProperty.call(predicate, 'predicate')) {
+      issues.push({
+        path: `${path}.predicate`,
+        message: 'predicate child is only valid for not predicates',
+      });
+    }
+
+    const metric = predicate.metric;
+    if (!isScenarioObjectiveMetricKey(metric)) {
+      issues.push({
+        path: `${path}.metric`,
+        message: 'metric must be one of: city-class, traffic-average, city-score, crime-average',
+      });
+    }
+
+    const op = predicate.op;
+    if (!isScenarioObjectiveComparison(op)) {
+      issues.push({
+        path: `${path}.op`,
+        message: 'comparison op must be one of: gt, gte, lt, lte, eq, neq',
+      });
+    }
+
+    const value = predicate.value;
+    if (typeof value !== 'number' || !Number.isFinite(value) || !Number.isInteger(value)) {
+      issues.push({
+        path: `${path}.value`,
+        message: 'metric predicate value must be a finite integer',
+      });
+    }
+
+    return issues;
+  }
+
+  if (kind === 'all' || kind === 'any') {
+    if (Object.prototype.hasOwnProperty.call(predicate, 'metric')) {
+      issues.push({
+        path: `${path}.metric`,
+        message: 'metric field is only valid for metric predicates',
+      });
+    }
+    if (Object.prototype.hasOwnProperty.call(predicate, 'op')) {
+      issues.push({
+        path: `${path}.op`,
+        message: 'comparison op is only valid for metric predicates',
+      });
+    }
+    if (Object.prototype.hasOwnProperty.call(predicate, 'value')) {
+      issues.push({
+        path: `${path}.value`,
+        message: 'value field is only valid for metric predicates',
+      });
+    }
+    if (Object.prototype.hasOwnProperty.call(predicate, 'predicate')) {
+      issues.push({
+        path: `${path}.predicate`,
+        message: 'predicate child is only valid for not predicates',
+      });
+    }
+
+    const predicates = predicate.predicates;
+    if (!Array.isArray(predicates)) {
+      issues.push({
+        path: `${path}.predicates`,
+        message: `${kind} predicate requires a predicates array`,
+      });
+      return issues;
+    }
+
+    if (predicates.length === 0) {
+      issues.push({
+        path: `${path}.predicates`,
+        message: `${kind} predicate must include at least one child predicate`,
+      });
+      return issues;
+    }
+
+    for (let index = 0; index < predicates.length; index += 1) {
+      const childPredicate = predicates[index];
+      issues.push(
+        ...collectScenarioObjectivePredicateValidationIssues(
+          childPredicate,
+          `${path}.predicates.${index}`,
+        ),
+      );
+    }
+    return issues;
+  }
+
+  if (Object.prototype.hasOwnProperty.call(predicate, 'metric')) {
+    issues.push({
+      path: `${path}.metric`,
+      message: 'metric field is only valid for metric predicates',
+    });
+  }
+  if (Object.prototype.hasOwnProperty.call(predicate, 'op')) {
+    issues.push({
+      path: `${path}.op`,
+      message: 'comparison op is only valid for metric predicates',
+    });
+  }
+  if (Object.prototype.hasOwnProperty.call(predicate, 'value')) {
+    issues.push({
+      path: `${path}.value`,
+      message: 'value field is only valid for metric predicates',
+    });
+  }
+  if (Object.prototype.hasOwnProperty.call(predicate, 'predicates')) {
+    issues.push({
+      path: `${path}.predicates`,
+      message: 'predicates array is only valid for all/any predicates',
+    });
+  }
+
+  const childPredicate = predicate.predicate;
+  if (childPredicate === undefined) {
+    issues.push({
+      path: `${path}.predicate`,
+      message: 'not predicate requires one child predicate',
+    });
+    return issues;
+  }
+
+  issues.push(
+    ...collectScenarioObjectivePredicateValidationIssues(childPredicate, `${path}.predicate`),
+  );
+  return issues;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const isScenarioObjectivePredicateKind = (
+  value: unknown,
+): value is ScenarioObjectivePredicate['kind'] =>
+  typeof value === 'string' &&
+  SCENARIO_EDITOR_OBJECTIVE_PREDICATE_KIND_SET.has(value as ScenarioObjectivePredicate['kind']);
+
+const isScenarioObjectiveMetricKey = (value: unknown): value is ScenarioObjectiveMetricKey =>
+  typeof value === 'string' &&
+  SCENARIO_EDITOR_OBJECTIVE_METRIC_KEY_SET.has(value as ScenarioObjectiveMetricKey);
+
+const isScenarioObjectiveComparison = (value: unknown): value is ScenarioObjectiveComparison =>
+  typeof value === 'string' &&
+  SCENARIO_EDITOR_OBJECTIVE_COMPARISON_SET.has(value as ScenarioObjectiveComparison);
diff --git a/apps/scenario-editor/src/state/editor-script.test.ts b/apps/scenario-editor/src/state/editor-script.test.ts
new file mode 100644
index 00000000..d559121a
--- /dev/null
+++ b/apps/scenario-editor/src/state/editor-script.test.ts
@@ -0,0 +1,264 @@
+import { describe, expect, test } from 'vitest';
+
+import {
+  appendScenarioEditorScriptAction,
+  appendScenarioEditorScriptEvent,
+  coerceScenarioEditorScriptActionKind,
+  coerceScenarioEditorScriptTriggerKind,
+  createScenarioEditorDefaultScriptEvent,
+  createScenarioEditorInitialScriptDraft,
+  createScenarioEditorScriptDraftFromBundle,
+  getScenarioEditorScriptTriggerKind,
+  getScenarioEditorScriptValidationIssues,
+  removeScenarioEditorScriptAction,
+  removeScenarioEditorScriptEvent,
+  replaceScenarioEditorAtTickTrigger,
+  replaceScenarioEditorEveryTicksTrigger,
+  replaceScenarioEditorScriptAction,
+  replaceScenarioEditorScriptEvent,
+  replaceScenarioEditorSendMessageId,
+} from './editor-script.ts';
+
+/**
+ * Stage 4.2 script authoring tests.
+ * Parity anchor: trigger timing and action domains map to `ScenarioDisaster` in
+ * `ref/micropolis/src/sim/s_disast.c`, represented as declarative editor draft state.
+ */
+describe('scenario editor script drafting', () => {
+  test('creates default event with one-shot atTick trigger and earthquake action', () => {
+    const event = createScenarioEditorDefaultScriptEvent();
+
+    // Magic number source: one-shot scenario disaster triggers compare `wait == 1`
+    // in `ScenarioDisaster` (`ref/micropolis/src/sim/s_disast.c`).
+    expect(event).toEqual({
+      trigger: { atTick: 1 },
+      actions: [{ kind: 'make-earthquake' }],
+    });
+  });
+
+  test('creates initial script draft disabled with one template event', () => {
+    const script = createScenarioEditorInitialScriptDraft();
+
+    expect(script.enabled).toBe(false);
+    expect(script.events).toHaveLength(1);
+    expect(getScenarioEditorScriptTriggerKind(script.events[0]!.trigger)).toBe('atTick');
+  });
+
+  test('hydrates enabled script draft state from imported bundle payloads', () => {
+    const script = createScenarioEditorScriptDraftFromBundle({
+      script: [
+        {
+          // Magic number source: Rio flood cadence checks `wait % 24 == 0`
+          // in `ScenarioDisaster` (`ref/micropolis/src/sim/s_disast.c`).
+          trigger: { everyTicks: 24 },
+          actions: [{ kind: 'make-flood' }],
+        },
+      ],
+    });
+
+    expect(script.enabled).toBe(true);
+    expect(script.events).toEqual([
+      {
+        trigger: { everyTicks: 24 },
+        actions: [{ kind: 'make-flood' }],
+      },
+    ]);
+  });
+
+  test('coerces trigger kinds and preserves/clamps countdown values', () => {
+    const asEveryTicks = coerceScenarioEditorScriptTriggerKind(
+      {
+        trigger: { atTick: 0 },
+        actions: [{ kind: 'make-earthquake' }],
+      },
+      'everyTicks',
+    );
+    // Magic number source: Rio flood cadence uses modulo 24 (`wait % 24 == 0`)
+    // in `ScenarioDisaster` (`ref/micropolis/src/sim/s_disast.c`).
+    expect(asEveryTicks.trigger).toEqual({ everyTicks: 1 });
+
+    const asAtTick = coerceScenarioEditorScriptTriggerKind(
+      {
+        trigger: { everyTicks: 24 },
+        actions: [{ kind: 'make-flood' }],
+      },
+      'atTick',
+    );
+    expect(asAtTick.trigger).toEqual({ atTick: 24 });
+  });
+
+  test('coerces action kinds and supports send-message payload updates', () => {
+    const asSendMessage = coerceScenarioEditorScriptActionKind(
+      { kind: 'make-flood' },
+      'send-message',
+    );
+    expect(asSendMessage).toEqual({ kind: 'send-message', messageId: 0 });
+
+    const updatedMessageId = replaceScenarioEditorSendMessageId(asSendMessage, -200);
+    // Magic number source: scenario failure messaging uses id `-200` in
+    // `DoScenarioScore` (`ref/micropolis/src/sim/s_msg.c`).
+    expect(updatedMessageId).toEqual({ kind: 'send-message', messageId: -200 });
+
+    const asLoseGame = coerceScenarioEditorScriptActionKind(updatedMessageId, 'lose-game');
+    expect(asLoseGame).toEqual({ kind: 'lose-game' });
+  });
+
+  test('appends/replaces/removes event rows immutably', () => {
+    const base = [createScenarioEditorDefaultScriptEvent()];
+    const appended = appendScenarioEditorScriptEvent(base, {
+      trigger: { everyTicks: 24 },
+      actions: [{ kind: 'make-flood' }],
+    });
+    expect(appended).toHaveLength(2);
+
+    const replaced = replaceScenarioEditorScriptEvent(appended, 1, {
+      trigger: { atTick: 48 },
+      actions: [{ kind: 'make-monster' }],
+    });
+    expect(replaced[1]).toEqual({
+      trigger: { atTick: 48 },
+      actions: [{ kind: 'make-monster' }],
+    });
+
+    const removed = removeScenarioEditorScriptEvent(replaced, 1);
+    expect(removed).toHaveLength(1);
+
+    const cannotRemoveLast = removeScenarioEditorScriptEvent(removed, 0);
+    expect(cannotRemoveLast).toBe(removed);
+  });
+
+  test('appends/replaces/removes actions immutably while preserving one action', () => {
+    const event = createScenarioEditorDefaultScriptEvent();
+    const appended = appendScenarioEditorScriptAction(event, { kind: 'make-flood' });
+    expect(appended.actions).toHaveLength(2);
+
+    const replaced = replaceScenarioEditorScriptAction(appended, 1, { kind: 'make-meltdown' });
+    expect(replaced.actions[1]).toEqual({ kind: 'make-meltdown' });
+
+    const removed = removeScenarioEditorScriptAction(replaced, 1);
+    expect(removed.actions).toHaveLength(1);
+
+    const cannotRemoveLast = removeScenarioEditorScriptAction(removed, 0);
+    expect(cannotRemoveLast).toBe(removed);
+  });
+
+  test('normalizes atTick/everyTicks values through direct trigger replacement helpers', () => {
+    const event = createScenarioEditorDefaultScriptEvent();
+    const atTick = replaceScenarioEditorAtTickTrigger(event, -99);
+    expect(atTick.trigger).toEqual({ atTick: 0 });
+
+    const everyTicks = replaceScenarioEditorEveryTicksTrigger(event, 0);
+    expect(everyTicks.trigger).toEqual({ everyTicks: 1 });
+  });
+
+  test('validates enabled script drafts for known trigger/action semantics', () => {
+    const issues = getScenarioEditorScriptValidationIssues({
+      enabled: true,
+      events: [createScenarioEditorDefaultScriptEvent()],
+    });
+
+    expect(issues).toEqual([]);
+  });
+
+  test('reports semantic issues for malformed trigger/action payloads', () => {
+    const malformedEvents = [
+      {
+        trigger: { atTick: 1, everyTicks: 24 },
+        actions: [{ kind: 'lose-game', messageId: -200 }],
+      },
+      {
+        trigger: { everyTicks: 0 },
+        actions: [],
+      },
+      {
+        trigger: { atTick: 2 },
+        actions: [{ kind: 'send-message' }],
+      },
+      {
+        trigger: {},
+        actions: [{ kind: 'unknown-action' }],
+      },
+    ] as unknown as ReturnType<typeof createScenarioEditorInitialScriptDraft>['events'];
+
+    const issues = getScenarioEditorScriptValidationIssues({
+      enabled: true,
+      events: malformedEvents,
+    });
+
+    expect(issues).toEqual([
+      {
+        path: 'script.events.0.trigger',
+        message: 'script trigger must use exactly one of atTick or everyTicks',
+      },
+      {
+        path: 'script.events.0.actions.0.messageId',
+        message: 'messageId payload is only valid for send-message actions',
+      },
+      {
+        path: 'script.events.1.trigger.everyTicks',
+        message: 'everyTicks must be a positive integer',
+      },
+      {
+        path: 'script.events.1.actions',
+        message: 'script event must include at least one action',
+      },
+      {
+        path: 'script.events.2.actions.0.messageId',
+        message: 'send-message actions require integer messageId payloads',
+      },
+      {
+        path: 'script.events.3.trigger',
+        message: 'script trigger kind is unknown; expected atTick or everyTicks',
+      },
+      {
+        path: 'script.events.3.actions.0.kind',
+        message:
+          'action kind is unknown; expected one of: make-earthquake, drop-fire-bombs, make-monster, make-meltdown, make-flood, send-message, lose-game',
+      },
+    ]);
+  });
+
+  test('reports invalid trigger/action payload fields for known kinds', () => {
+    const issues = getScenarioEditorScriptValidationIssues({
+      enabled: true,
+      events: [
+        {
+          trigger: { atTick: 3, offset: 1 },
+          actions: [{ kind: 'make-flood', intensity: 2 }],
+        },
+        {
+          trigger: { everyTicks: 24, phase: 6 },
+          actions: [{ kind: 'send-message', messageId: -200, category: 'system' }],
+        },
+      ] as unknown as ReturnType<typeof createScenarioEditorInitialScriptDraft>['events'],
+    });
+
+    expect(issues).toEqual([
+      {
+        path: 'script.events.0.trigger.offset',
+        message: 'trigger field "offset" is not valid for atTick triggers',
+      },
+      {
+        path: 'script.events.0.actions.0.intensity',
+        message: 'payload field "intensity" is not valid for make-flood actions',
+      },
+      {
+        path: 'script.events.1.trigger.phase',
+        message: 'trigger field "phase" is not valid for everyTicks triggers',
+      },
+      {
+        path: 'script.events.1.actions.0.category',
+        message: 'payload field "category" is not valid for send-message actions',
+      },
+    ]);
+  });
+
+  test('skips semantic validation while script authoring is disabled', () => {
+    const issues = getScenarioEditorScriptValidationIssues({
+      enabled: false,
+      events: [],
+    });
+
+    expect(issues).toEqual([]);
+  });
+});
diff --git a/apps/scenario-editor/src/state/editor-script.ts b/apps/scenario-editor/src/state/editor-script.ts
new file mode 100644
index 00000000..7c3d001e
--- /dev/null
+++ b/apps/scenario-editor/src/state/editor-script.ts
@@ -0,0 +1,617 @@
+import type { ScenarioBundleV1 } from '@city/scenario-core';
+import type { ScenarioRuntimeAction } from '@city/scenario-runtime';
+
+/**
+ * Declarative script trigger union for Stage 4.2 event authoring.
+ * Maps to `ScenarioDisaster` trigger styles in `ref/micropolis/src/sim/s_disast.c`:
+ * - `atTick` mirrors one-shot `wait == 1`-style checks.
+ * - `everyTicks` mirrors periodic `wait % 24 == 0`-style checks.
+ */
+export type ScenarioEditorScriptTrigger =
+  | { readonly atTick: number }
+  | { readonly everyTicks: number };
+
+/**
+ * Trigger selector values exposed by the Stage 4.2 script editor UI.
+ * Not from Micropolis C: this powers modern form-state switching between trigger unions.
+ */
+export const SCENARIO_EDITOR_SCRIPT_TRIGGER_KINDS = ['atTick', 'everyTicks'] as const;
+
+/**
+ * Trigger selector discriminant for Stage 4.2 script editor controls.
+ * Not from Micropolis C: TypeScript convenience type for UI form branching.
+ */
+export type ScenarioEditorScriptTriggerKind = (typeof SCENARIO_EDITOR_SCRIPT_TRIGGER_KINDS)[number];
+
+/**
+ * Declarative script action union exposed by Stage 4.2 authoring UI.
+ * Mirrors `ScenarioRuntimeAction` from `packages/scenario-runtime/src/runtime-state.ts`,
+ * which represents C side effects emitted by `ScenarioDisaster`/`DoScenarioScore`.
+ */
+export type ScenarioEditorScriptAction = ScenarioRuntimeAction;
+
+/**
+ * All action kinds supported by the Stage 4.2 script editor.
+ * Mirrors runtime action kinds mapped from `ScenarioDisaster` in
+ * `ref/micropolis/src/sim/s_disast.c` and objective-failure lose-game flow in
+ * `ref/micropolis/src/sim/s_msg.c`.
+ */
+export const SCENARIO_EDITOR_SCRIPT_ACTION_KINDS = [
+  'make-earthquake',
+  'drop-fire-bombs',
+  'make-monster',
+  'make-meltdown',
+  'make-flood',
+  'send-message',
+  'lose-game',
+] as const satisfies readonly ScenarioEditorScriptAction['kind'][];
+const SCENARIO_EDITOR_SCRIPT_ACTION_KIND_SET = new Set<ScenarioEditorScriptAction['kind']>(
+  SCENARIO_EDITOR_SCRIPT_ACTION_KINDS,
+);
+
+/**
+ * One authored script event row for Stage 4.2.
+ * Parity note: this is editor-side draft state; Stage 4.5 integrates it with export/runtime
+ * event definitions that mirror `ScenarioDisaster` countdown checks.
+ */
+export interface ScenarioEditorScriptEvent {
+  readonly trigger: ScenarioEditorScriptTrigger;
+  readonly actions: readonly ScenarioEditorScriptAction[];
+}
+
+/**
+ * Stage 4.2 editor draft model for optional event/action script authoring.
+ * Parity note: classic scenarios used hardcoded disaster switch branches; this stores
+ * declarative event drafts to replace numeric-id branching in later integration stages.
+ */
+export interface ScenarioEditorScriptDraft {
+  readonly enabled: boolean;
+  readonly events: readonly ScenarioEditorScriptEvent[];
+}
+
+/**
+ * Authoring-time semantic issue for Stage 4 script event drafts.
+ * Trigger/action domains mirror `ScenarioDisaster` and `DoScenarioScore` side effects in
+ * `ref/micropolis/src/sim/s_disast.c` and `ref/micropolis/src/sim/s_msg.c`; shape/payload
+ * diagnostics are editor-only checks before Stage 4.5 export integration.
+ */
+export interface ScenarioEditorScriptValidationIssue {
+  readonly message: string;
+  readonly path: string;
+}
+
+/**
+ * Validates Stage 4 script draft semantics in authoring state.
+ * Parity note: trigger and action-kind checks preserve C parity domains from
+ * `ScenarioDisaster`/`DoScenarioScore`, while union-shape and payload checks are
+ * editor-time guards with no direct C authoring UI equivalent.
+ */
+export function getScenarioEditorScriptValidationIssues(
+  draft: ScenarioEditorScriptDraft,
+): readonly ScenarioEditorScriptValidationIssue[] {
+  if (!draft.enabled) {
+    return [];
+  }
+
+  const issues: ScenarioEditorScriptValidationIssue[] = [];
+  const events = draft.events as unknown;
+  if (!Array.isArray(events)) {
+    issues.push({
+      path: 'script.events',
+      message: 'script events must be an array',
+    });
+    return issues;
+  }
+  if (events.length === 0) {
+    issues.push({
+      path: 'script.events',
+      message: 'script must include at least one event',
+    });
+    return issues;
+  }
+
+  for (let eventIndex = 0; eventIndex < events.length; eventIndex += 1) {
+    const event = events[eventIndex];
+    issues.push(
+      ...collectScenarioScriptEventValidationIssues(event, `script.events.${eventIndex}`),
+    );
+  }
+
+  return issues;
+}
+
+/**
+ * Creates a default script action template for new event rows.
+ * Uses earthquake because `ScenarioDisaster` triggers earthquake on `wait == 1`
+ * for San Francisco in `ref/micropolis/src/sim/s_disast.c`.
+ */
+export function createScenarioEditorDefaultScriptAction(): ScenarioEditorScriptAction {
+  return {
+    kind: 'make-earthquake',
+  };
+}
+
+/**
+ * Creates a default script event template for new drafts/event rows.
+ * Magic number mapping: `atTick: 1` mirrors one-shot `wait == 1` branches in
+ * `ScenarioDisaster` (`ref/micropolis/src/sim/s_disast.c`).
+ */
+export function createScenarioEditorDefaultScriptEvent(): ScenarioEditorScriptEvent {
+  return {
+    trigger: { atTick: 1 },
+    actions: [createScenarioEditorDefaultScriptAction()],
+  };
+}
+
+/**
+ * Creates initial Stage 4.2 script draft state for a new editor session.
+ * Parity note: script authoring is opt-in (`enabled: false`) because classic scenarios were
+ * pre-authored in C; enabling and export integration are explicit editor workflow steps.
+ */
+export function createScenarioEditorInitialScriptDraft(): ScenarioEditorScriptDraft {
+  return {
+    enabled: false,
+    events: [createScenarioEditorDefaultScriptEvent()],
+  };
+}
+
+/**
+ * Creates Stage 4 script draft state from an imported bundle payload.
+ * Mapping note: imports persisted script trigger/action rows that map to
+ * `ScenarioDisaster`/`DoScenarioScore` side-effect domains in
+ * `ref/micropolis/src/sim/s_disast.c` and `ref/micropolis/src/sim/s_msg.c`,
+ * while defaulting to disabled authoring when no script payload is present.
+ */
+export function createScenarioEditorScriptDraftFromBundle(
+  bundle: Pick<ScenarioBundleV1, 'script'>,
+): ScenarioEditorScriptDraft {
+  if (bundle.script === undefined) {
+    return createScenarioEditorInitialScriptDraft();
+  }
+
+  return {
+    enabled: true,
+    events: bundle.script.map((event) => ({
+      trigger: { ...event.trigger },
+      actions: event.actions.map((action) => ({ ...action })),
+    })),
+  };
+}
+
+/**
+ * Returns trigger kind discriminator for one script trigger union member.
+ * Not from Micropolis C: editor helper for stable form rendering over union state.
+ */
+export function getScenarioEditorScriptTriggerKind(
+  trigger: ScenarioEditorScriptTrigger,
+): ScenarioEditorScriptTriggerKind {
+  return 'atTick' in trigger ? 'atTick' : 'everyTicks';
+}
+
+/**
+ * Coerces one script event trigger to the requested trigger union member.
+ * Preserves existing interval/tick where possible while enforcing integer bounds expected by
+ * runtime countdown checks in `ScenarioDisaster` (`ref/micropolis/src/sim/s_disast.c`).
+ */
+export function coerceScenarioEditorScriptTriggerKind(
+  event: ScenarioEditorScriptEvent,
+  nextKind: ScenarioEditorScriptTriggerKind,
+): ScenarioEditorScriptEvent {
+  if (nextKind === 'atTick') {
+    const nextAtTick =
+      'atTick' in event.trigger
+        ? normalizeNonNegativeInteger(event.trigger.atTick, 1)
+        : normalizeNonNegativeInteger(event.trigger.everyTicks, 1);
+
+    if ('atTick' in event.trigger && event.trigger.atTick === nextAtTick) {
+      return event;
+    }
+
+    return {
+      ...event,
+      trigger: { atTick: nextAtTick },
+    };
+  }
+
+  const nextEveryTicks =
+    'everyTicks' in event.trigger
+      ? normalizePositiveInteger(event.trigger.everyTicks, 24)
+      : normalizePositiveInteger(event.trigger.atTick, 24);
+  if ('everyTicks' in event.trigger && event.trigger.everyTicks === nextEveryTicks) {
+    return event;
+  }
+
+  return {
+    ...event,
+    trigger: { everyTicks: nextEveryTicks },
+  };
+}
+
+/**
+ * Coerces one script action to a requested runtime action kind.
+ * Preserves `send-message.messageId` when available; defaults message id to `0` for new
+ * `send-message` actions because classic scenario event paths did not use this payload directly.
+ */
+export function coerceScenarioEditorScriptActionKind(
+  action: ScenarioEditorScriptAction,
+  nextKind: ScenarioEditorScriptAction['kind'],
+): ScenarioEditorScriptAction {
+  if (action.kind === nextKind) {
+    return action;
+  }
+
+  if (nextKind === 'send-message') {
+    return {
+      kind: 'send-message',
+      messageId: action.kind === 'send-message' ? action.messageId : 0,
+    };
+  }
+
+  return { kind: nextKind };
+}
+
+/**
+ * Appends one script event row to the authored event list.
+ * Not from Micropolis C: immutable editor list helper for Stage 4.2 form updates.
+ */
+export function appendScenarioEditorScriptEvent(
+  events: readonly ScenarioEditorScriptEvent[],
+  event: ScenarioEditorScriptEvent = createScenarioEditorDefaultScriptEvent(),
+): readonly ScenarioEditorScriptEvent[] {
+  return [...events, event];
+}
+
+/**
+ * Replaces one script event row by index.
+ * Returns the input unchanged when index is out of range.
+ */
+export function replaceScenarioEditorScriptEvent(
+  events: readonly ScenarioEditorScriptEvent[],
+  index: number,
+  event: ScenarioEditorScriptEvent,
+): readonly ScenarioEditorScriptEvent[] {
+  if (!Number.isInteger(index) || index < 0 || index >= events.length) {
+    return events;
+  }
+
+  return events.map((current, currentIndex) => (currentIndex === index ? event : current));
+}
+
+/**
+ * Removes one script event row by index while preserving at least one row.
+ * Not from Micropolis C: keeps editor draft form valid during incremental editing.
+ */
+export function removeScenarioEditorScriptEvent(
+  events: readonly ScenarioEditorScriptEvent[],
+  index: number,
+): readonly ScenarioEditorScriptEvent[] {
+  if (!Number.isInteger(index) || index < 0 || index >= events.length || events.length <= 1) {
+    return events;
+  }
+
+  return events.filter((_, currentIndex) => currentIndex !== index);
+}
+
+/**
+ * Appends one action to a script event action list.
+ * Not from Micropolis C: immutable authoring helper for event action arrays.
+ */
+export function appendScenarioEditorScriptAction(
+  event: ScenarioEditorScriptEvent,
+  action: ScenarioEditorScriptAction = createScenarioEditorDefaultScriptAction(),
+): ScenarioEditorScriptEvent {
+  return {
+    ...event,
+    actions: [...event.actions, action],
+  };
+}
+
+/**
+ * Replaces one action on a script event by index.
+ * Returns the input event unchanged when index is out of range.
+ */
+export function replaceScenarioEditorScriptAction(
+  event: ScenarioEditorScriptEvent,
+  index: number,
+  action: ScenarioEditorScriptAction,
+): ScenarioEditorScriptEvent {
+  if (!Number.isInteger(index) || index < 0 || index >= event.actions.length) {
+    return event;
+  }
+
+  return {
+    ...event,
+    actions: event.actions.map((current, currentIndex) =>
+      currentIndex === index ? action : current,
+    ),
+  };
+}
+
+/**
+ * Removes one action from a script event while preserving at least one action row.
+ * Not from Micropolis C: form guard to avoid empty action arrays during editing.
+ */
+export function removeScenarioEditorScriptAction(
+  event: ScenarioEditorScriptEvent,
+  index: number,
+): ScenarioEditorScriptEvent {
+  if (
+    !Number.isInteger(index) ||
+    index < 0 ||
+    index >= event.actions.length ||
+    event.actions.length <= 1
+  ) {
+    return event;
+  }
+
+  return {
+    ...event,
+    actions: event.actions.filter((_, currentIndex) => currentIndex !== index),
+  };
+}
+
+/**
+ * Replaces one script event trigger payload with a normalized `atTick` value.
+ * Enforces non-negative integers, matching runtime countdown-equals domains.
+ */
+export function replaceScenarioEditorAtTickTrigger(
+  event: ScenarioEditorScriptEvent,
+  atTick: number,
+): ScenarioEditorScriptEvent {
+  const nextAtTick = normalizeNonNegativeInteger(atTick, 0);
+  if ('atTick' in event.trigger && event.trigger.atTick === nextAtTick) {
+    return event;
+  }
+  return {
+    ...event,
+    trigger: { atTick: nextAtTick },
+  };
+}
+
+/**
+ * Replaces one script event trigger payload with a normalized `everyTicks` value.
+ * Enforces positive integers because modulo intervals in C disaster checks use `> 0`.
+ */
+export function replaceScenarioEditorEveryTicksTrigger(
+  event: ScenarioEditorScriptEvent,
+  everyTicks: number,
+): ScenarioEditorScriptEvent {
+  const nextEveryTicks = normalizePositiveInteger(everyTicks, 1);
+  if ('everyTicks' in event.trigger && event.trigger.everyTicks === nextEveryTicks) {
+    return event;
+  }
+  return {
+    ...event,
+    trigger: { everyTicks: nextEveryTicks },
+  };
+}
+
+/**
+ * Replaces `send-message.messageId` on one action entry when the action kind supports it.
+ * Returns input action unchanged for non-message action kinds.
+ */
+export function replaceScenarioEditorSendMessageId(
+  action: ScenarioEditorScriptAction,
+  messageId: number,
+): ScenarioEditorScriptAction {
+  if (action.kind !== 'send-message') {
+    return action;
+  }
+
+  return {
+    kind: 'send-message',
+    messageId: normalizeInteger(messageId, action.messageId),
+  };
+}
+
+const normalizeInteger = (value: number, fallback: number): number => {
+  if (!Number.isInteger(value)) {
+    return fallback;
+  }
+  return value;
+};
+
+const normalizeNonNegativeInteger = (value: number, fallback: number): number => {
+  const normalized = normalizeInteger(value, fallback);
+  return normalized < 0 ? 0 : normalized;
+};
+
+const normalizePositiveInteger = (value: number, fallback: number): number => {
+  const normalized = normalizeInteger(value, fallback);
+  return normalized <= 0 ? 1 : normalized;
+};
+
+const collectScenarioScriptEventValidationIssues = (
+  event: unknown,
+  path: string,
+): ScenarioEditorScriptValidationIssue[] => {
+  const issues: ScenarioEditorScriptValidationIssue[] = [];
+  if (!isRecord(event)) {
+    issues.push({
+      path,
+      message: 'script event must be an object',
+    });
+    return issues;
+  }
+
+  issues.push(...collectScenarioScriptTriggerValidationIssues(event.trigger, `${path}.trigger`));
+
+  const actions = event.actions;
+  if (!Array.isArray(actions)) {
+    issues.push({
+      path: `${path}.actions`,
+      message: 'script event actions must be an array',
+    });
+    return issues;
+  }
+  if (actions.length === 0) {
+    issues.push({
+      path: `${path}.actions`,
+      message: 'script event must include at least one action',
+    });
+    return issues;
+  }
+
+  for (let actionIndex = 0; actionIndex < actions.length; actionIndex += 1) {
+    const action = actions[actionIndex];
+    issues.push(
+      ...collectScenarioScriptActionValidationIssues(action, `${path}.actions.${actionIndex}`),
+    );
+  }
+
+  return issues;
+};
+
+const collectScenarioScriptTriggerValidationIssues = (
+  trigger: unknown,
+  path: string,
+): ScenarioEditorScriptValidationIssue[] => {
+  const issues: ScenarioEditorScriptValidationIssue[] = [];
+  if (!isRecord(trigger)) {
+    issues.push({
+      path,
+      message: 'script trigger must be an object',
+    });
+    return issues;
+  }
+
+  const hasAtTick = Object.prototype.hasOwnProperty.call(trigger, 'atTick');
+  const hasEveryTicks = Object.prototype.hasOwnProperty.call(trigger, 'everyTicks');
+  if (hasAtTick && hasEveryTicks) {
+    issues.push({
+      path,
+      message: 'script trigger must use exactly one of atTick or everyTicks',
+    });
+    return issues;
+  }
+  if (!hasAtTick && !hasEveryTicks) {
+    issues.push({
+      path,
+      message: 'script trigger kind is unknown; expected atTick or everyTicks',
+    });
+    return issues;
+  }
+
+  if (hasAtTick) {
+    const triggerKeys = Object.keys(trigger);
+    for (const triggerKey of triggerKeys) {
+      if (triggerKey === 'atTick') {
+        continue;
+      }
+      issues.push({
+        path: `${path}.${triggerKey}`,
+        message: `trigger field "${triggerKey}" is not valid for atTick triggers`,
+      });
+    }
+
+    const atTick = trigger.atTick;
+    if (typeof atTick !== 'number' || !Number.isInteger(atTick) || atTick < 0) {
+      issues.push({
+        path: `${path}.atTick`,
+        message: 'atTick must be a non-negative integer',
+      });
+    }
+    return issues;
+  }
+
+  const triggerKeys = Object.keys(trigger);
+  for (const triggerKey of triggerKeys) {
+    if (triggerKey === 'everyTicks') {
+      continue;
+    }
+    issues.push({
+      path: `${path}.${triggerKey}`,
+      message: `trigger field "${triggerKey}" is not valid for everyTicks triggers`,
+    });
+  }
+
+  const everyTicks = trigger.everyTicks;
+  if (typeof everyTicks !== 'number' || !Number.isInteger(everyTicks) || everyTicks <= 0) {
+    issues.push({
+      path: `${path}.everyTicks`,
+      message: 'everyTicks must be a positive integer',
+    });
+  }
+  return issues;
+};
+
+const collectScenarioScriptActionValidationIssues = (
+  action: unknown,
+  path: string,
+): ScenarioEditorScriptValidationIssue[] => {
+  const issues: ScenarioEditorScriptValidationIssue[] = [];
+  if (!isRecord(action)) {
+    issues.push({
+      path,
+      message: 'script action must be an object',
+    });
+    return issues;
+  }
+
+  const kind = action.kind;
+  if (!isScenarioEditorScriptActionKind(kind)) {
+    issues.push({
+      path: `${path}.kind`,
+      message: `action kind is unknown; expected one of: ${SCENARIO_EDITOR_SCRIPT_ACTION_KINDS.join(', ')}`,
+    });
+    return issues;
+  }
+
+  const hasMessageId = Object.prototype.hasOwnProperty.call(action, 'messageId');
+  const actionKeys = Object.keys(action);
+  if (kind === 'send-message') {
+    for (const actionKey of actionKeys) {
+      if (actionKey === 'kind' || actionKey === 'messageId') {
+        continue;
+      }
+      issues.push({
+        path: `${path}.${actionKey}`,
+        message: `payload field "${actionKey}" is not valid for send-message actions`,
+      });
+    }
+
+    if (!hasMessageId) {
+      issues.push({
+        path: `${path}.messageId`,
+        message: 'send-message actions require integer messageId payloads',
+      });
+      return issues;
+    }
+
+    const messageId = action.messageId;
+    if (typeof messageId !== 'number' || !Number.isInteger(messageId)) {
+      issues.push({
+        path: `${path}.messageId`,
+        message: 'send-message.messageId must be an integer',
+      });
+    }
+    return issues;
+  }
+
+  for (const actionKey of actionKeys) {
+    if (actionKey === 'kind') {
+      continue;
+    }
+    if (actionKey === 'messageId') {
+      issues.push({
+        path: `${path}.messageId`,
+        message: 'messageId payload is only valid for send-message actions',
+      });
+      continue;
+    }
+    issues.push({
+      path: `${path}.${actionKey}`,
+      message: `payload field "${actionKey}" is not valid for ${kind} actions`,
+    });
+  }
+  return issues;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const isScenarioEditorScriptActionKind = (
+  value: unknown,
+): value is ScenarioEditorScriptAction['kind'] =>
+  typeof value === 'string' &&
+  SCENARIO_EDITOR_SCRIPT_ACTION_KIND_SET.has(value as ScenarioEditorScriptAction['kind']);
diff --git a/apps/scenario-editor/src/state/editor-state.test.ts b/apps/scenario-editor/src/state/editor-state.test.ts
index 14566cac..0e76ba1f 100644
--- a/apps/scenario-editor/src/state/editor-state.test.ts
+++ b/apps/scenario-editor/src/state/editor-state.test.ts
@@ -43,15 +43,151 @@ describe('scenario editor state foundation', () => {
     expect(next.isDirty).toBe(false);
   });
 
-  test('limits MVP workbench views to metadata/map/export and defers non-MVP authoring', () => {
-    expect(SCENARIO_EDITOR_MVP_VIEWS).toEqual(['metadata', 'map', 'export']);
+  test('exposes Stage 4 objective/script/behavior views while still deferring ai authoring', () => {
+    expect(SCENARIO_EDITOR_MVP_VIEWS).toEqual([
+      'metadata',
+      'map',
+      'objective',
+      'script',
+      'behavior',
+      'export',
+    ]);
+    expect((SCENARIO_EDITOR_MVP_VIEWS as readonly string[]).includes('script')).toBe(true);
     expect((SCENARIO_EDITOR_MVP_VIEWS as readonly string[]).includes('scripts')).toBe(false);
-    expect((SCENARIO_EDITOR_MVP_VIEWS as readonly string[]).includes('objectives')).toBe(false);
+    expect((SCENARIO_EDITOR_MVP_VIEWS as readonly string[]).includes('objective')).toBe(true);
+    expect((SCENARIO_EDITOR_MVP_VIEWS as readonly string[]).includes('behavior')).toBe(true);
     expect((SCENARIO_EDITOR_MVP_VIEWS as readonly string[]).includes('ai')).toBe(false);
     expect((SCENARIO_EDITOR_MVP_VIEWS as readonly string[]).includes('ai-import')).toBe(false);
     expect((SCENARIO_EDITOR_MVP_VIEWS as readonly string[]).includes('image-import')).toBe(false);
   });
 
+  test('updates objective draft state through reducer actions', () => {
+    const initial = createScenarioEditorInitialState();
+    const enabled = scenarioEditorReducer(initial, {
+      type: 'set-objective-enabled',
+      enabled: true,
+    });
+
+    expect(enabled.objective.enabled).toBe(true);
+    expect(enabled.isDirty).toBe(true);
+
+    const replaced = scenarioEditorReducer(enabled, {
+      type: 'replace-objective-predicate',
+      predicate: {
+        kind: 'metric',
+        metric: 'traffic-average',
+        op: 'lt',
+        // Magic number source: Bern uses `TrafficAverage < 80` in
+        // `DoScenarioScore` from `ref/micropolis/src/sim/s_msg.c`.
+        value: 80,
+      },
+    });
+
+    expect(replaced.objective.predicate).toEqual({
+      kind: 'metric',
+      metric: 'traffic-average',
+      op: 'lt',
+      value: 80,
+    });
+  });
+
+  test('updates script draft state through reducer actions', () => {
+    const initial = createScenarioEditorInitialState();
+    const enabled = scenarioEditorReducer(initial, {
+      type: 'set-script-enabled',
+      enabled: true,
+    });
+
+    expect(enabled.script.enabled).toBe(true);
+    expect(enabled.isDirty).toBe(true);
+
+    const replaced = scenarioEditorReducer(enabled, {
+      type: 'replace-script-events',
+      events: [
+        {
+          // Magic number source: Rio scenario disaster cadence evaluates
+          // `wait % 24 == 0` in `ScenarioDisaster` (`ref/micropolis/src/sim/s_disast.c`).
+          trigger: { everyTicks: 24 },
+          actions: [{ kind: 'make-flood' }],
+        },
+      ],
+    });
+
+    expect(replaced.script.events).toEqual([
+      {
+        trigger: { everyTicks: 24 },
+        actions: [{ kind: 'make-flood' }],
+      },
+    ]);
+  });
+
+  test('updates behavior profile draft state through reducer actions', () => {
+    const initial = createScenarioEditorInitialState();
+    const enabled = scenarioEditorReducer(initial, {
+      type: 'set-behavior-enabled',
+      enabled: true,
+    });
+
+    expect(enabled.behavior.enabled).toBe(true);
+    expect(enabled.isDirty).toBe(true);
+
+    const assigned = scenarioEditorReducer(enabled, {
+      type: 'set-behavior-profile-key',
+      profileKey: 'classic/sf-ship-honk',
+    });
+    expect(assigned.behavior.profileKey).toBe('classic/sf-ship-honk');
+    expect(assigned.isDirty).toBe(true);
+
+    const trimmed = scenarioEditorReducer(assigned, {
+      type: 'set-behavior-profile-key',
+      profileKey: '  classic/default  ',
+    });
+    expect(trimmed.behavior.profileKey).toBe('classic/default');
+    expect(trimmed.isDirty).toBe(true);
+  });
+
+  test('hydrates objective/script drafts from imported bundle payloads on replace-bundle', () => {
+    const initial = createScenarioEditorInitialState();
+    const replaced = scenarioEditorReducer(initial, {
+      type: 'replace-bundle',
+      bundle: {
+        ...createScenarioEditorInitialBundle(),
+        objective: {
+          kind: 'metric',
+          metric: 'traffic-average',
+          op: 'lt',
+          // Magic number source: Bern objective threshold `TrafficAverage < 80`
+          // from `DoScenarioScore` in `ref/micropolis/src/sim/s_msg.c`.
+          value: 80,
+        },
+        script: [
+          {
+            // Magic number source: Rio flood cadence checks `wait % 24 == 0`
+            // in `ScenarioDisaster` (`ref/micropolis/src/sim/s_disast.c`).
+            trigger: { everyTicks: 24 },
+            actions: [{ kind: 'make-flood' }],
+          },
+        ],
+      },
+    });
+
+    expect(replaced.isDirty).toBe(false);
+    expect(replaced.objective.enabled).toBe(true);
+    expect(replaced.objective.predicate).toEqual({
+      kind: 'metric',
+      metric: 'traffic-average',
+      op: 'lt',
+      value: 80,
+    });
+    expect(replaced.script.enabled).toBe(true);
+    expect(replaced.script.events).toEqual([
+      {
+        trigger: { everyTicks: 24 },
+        actions: [{ kind: 'make-flood' }],
+      },
+    ]);
+  });
+
   test('updates metadata fields through reducer patch actions', () => {
     const initial = createScenarioEditorInitialState();
     const next = scenarioEditorReducer(initial, {
diff --git a/apps/scenario-editor/src/state/editor-state.tsx b/apps/scenario-editor/src/state/editor-state.tsx
index b601ef03..f16762c2 100644
--- a/apps/scenario-editor/src/state/editor-state.tsx
+++ b/apps/scenario-editor/src/state/editor-state.tsx
@@ -14,18 +14,41 @@ import {
   useReducer,
 } from 'react';
 
+import {
+  createScenarioEditorInitialBehaviorDraft,
+  type ScenarioEditorBehaviorDraft,
+} from './editor-behavior.ts';
 import { fillScenarioEditorMapTileWord, writeScenarioEditorMapTileWord } from './editor-map.ts';
+import {
+  createScenarioEditorInitialObjectiveDraft,
+  createScenarioEditorObjectiveDraftFromBundle,
+  type ScenarioEditorObjectiveDraft,
+  type ScenarioEditorObjectivePredicate,
+} from './editor-objective.ts';
+import {
+  createScenarioEditorInitialScriptDraft,
+  createScenarioEditorScriptDraftFromBundle,
+  type ScenarioEditorScriptDraft,
+  type ScenarioEditorScriptEvent,
+} from './editor-script.ts';
 
 /**
- * Editor workbench sections for Stage 3 MVP navigation state.
+ * Editor workbench sections for Stage 4 objective/script/behavior authoring navigation state.
  * Not from Micropolis C: this is editor-only UI flow state and has no direct C runtime equivalent.
  */
-export const SCENARIO_EDITOR_MVP_VIEWS = ['metadata', 'map', 'export'] as const;
+export const SCENARIO_EDITOR_MVP_VIEWS = [
+  'metadata',
+  'map',
+  'objective',
+  'script',
+  'behavior',
+  'export',
+] as const;
 
 /**
- * Editor workbench sections for Stage 3 MVP navigation state.
- * Stage-parity note: script/objective authoring is intentionally deferred to Stage 4, and
- * AI/image import tooling is intentionally deferred to Stage 5.
+ * Editor workbench sections for Stage 4 objective/script authoring navigation state.
+ * Stage-parity note: predicate/event authoring and behavior-profile assignment are exposed in
+ * Stage 4.1/4.2/4.3, while AI/image import remains deferred to Stage 5.
  * Not from Micropolis C: this is editor-only UI flow state and has no direct C runtime equivalent.
  */
 export type ScenarioEditorWorkbenchView = (typeof SCENARIO_EDITOR_MVP_VIEWS)[number];
@@ -37,7 +60,10 @@ export type ScenarioEditorWorkbenchView = (typeof SCENARIO_EDITOR_MVP_VIEWS)[num
  */
 export interface ScenarioEditorState {
   readonly activeView: ScenarioEditorWorkbenchView;
+  readonly behavior: ScenarioEditorBehaviorDraft;
   readonly bundle: ScenarioBundleV1;
+  readonly objective: ScenarioEditorObjectiveDraft;
+  readonly script: ScenarioEditorScriptDraft;
   readonly isDirty: boolean;
 }
 
@@ -84,6 +110,12 @@ export type ScenarioEditorAction =
   | { type: 'mark-dirty' }
   | { type: 'fill-map'; tileWord: number }
   | { type: 'paint-map-tile'; x: number; y: number; tileWord: number }
+  | { type: 'set-behavior-enabled'; enabled: boolean }
+  | { type: 'set-behavior-profile-key'; profileKey: string }
+  | { type: 'replace-objective-predicate'; predicate: ScenarioEditorObjectivePredicate }
+  | { type: 'replace-script-events'; events: readonly ScenarioEditorScriptEvent[] }
+  | { type: 'set-objective-enabled'; enabled: boolean }
+  | { type: 'set-script-enabled'; enabled: boolean }
   | { type: 'update-metadata'; metadata: ScenarioEditorMetadataPatch }
   | { type: 'replace-bundle'; bundle: ScenarioBundleV1 }
   | { type: 'set-active-view'; view: ScenarioEditorWorkbenchView };
@@ -127,7 +159,10 @@ export function createScenarioEditorInitialBundle(): ScenarioBundleV1 {
 export function createScenarioEditorInitialState(): ScenarioEditorState {
   return {
     activeView: 'metadata',
+    behavior: createScenarioEditorInitialBehaviorDraft(),
     bundle: createScenarioEditorInitialBundle(),
+    objective: createScenarioEditorInitialObjectiveDraft(),
+    script: createScenarioEditorInitialScriptDraft(),
     isDirty: false,
   };
 }
@@ -174,6 +209,77 @@ export function scenarioEditorReducer(
         isDirty: true,
       };
     }
+    case 'set-behavior-enabled':
+      if (state.behavior.enabled === action.enabled) {
+        return state;
+      }
+      return {
+        ...state,
+        behavior: {
+          ...state.behavior,
+          enabled: action.enabled,
+        },
+        isDirty: true,
+      };
+    case 'set-behavior-profile-key': {
+      const nextProfileKey = action.profileKey.trim();
+      if (state.behavior.profileKey === nextProfileKey) {
+        return state;
+      }
+      return {
+        ...state,
+        behavior: {
+          ...state.behavior,
+          profileKey: nextProfileKey,
+        },
+        isDirty: true,
+      };
+    }
+    case 'replace-objective-predicate':
+      return {
+        ...state,
+        objective: {
+          ...state.objective,
+          predicate: action.predicate,
+        },
+        isDirty: true,
+      };
+    case 'set-objective-enabled':
+      if (state.objective.enabled === action.enabled) {
+        return state;
+      }
+      return {
+        ...state,
+        objective: {
+          ...state.objective,
+          enabled: action.enabled,
+        },
+        isDirty: true,
+      };
+    case 'replace-script-events':
+      if (state.script.events === action.events) {
+        return state;
+      }
+      return {
+        ...state,
+        script: {
+          ...state.script,
+          events: action.events,
+        },
+        isDirty: true,
+      };
+    case 'set-script-enabled':
+      if (state.script.enabled === action.enabled) {
+        return state;
+      }
+      return {
+        ...state,
+        script: {
+          ...state.script,
+          enabled: action.enabled,
+        },
+        isDirty: true,
+      };
     case 'update-metadata':
       return {
         ...state,
@@ -184,6 +290,9 @@ export function scenarioEditorReducer(
       return {
         ...state,
         bundle: action.bundle,
+        behavior: createScenarioEditorInitialBehaviorDraft(),
+        objective: createScenarioEditorObjectiveDraftFromBundle(action.bundle),
+        script: createScenarioEditorScriptDraftFromBundle(action.bundle),
         isDirty: false,
       };
     case 'set-active-view':
diff --git a/apps/scenario-editor/src/styles.css b/apps/scenario-editor/src/styles.css
index cc2ec8e8..7b88382c 100644
--- a/apps/scenario-editor/src/styles.css
+++ b/apps/scenario-editor/src/styles.css
@@ -90,8 +90,10 @@ body,
 }
 
 .editor-field input,
+.editor-field select,
 .editor-field textarea,
-.editor-field-inline input {
+.editor-field-inline input,
+.editor-field-inline select {
   border: 1px solid #8c959f;
   border-radius: 4px;
   padding: 0.45rem 0.55rem;
@@ -233,3 +235,120 @@ body,
   touch-action: none;
   cursor: crosshair;
 }
+
+.editor-objective-card {
+  max-width: 64rem;
+}
+
+.editor-objective-toggle input[type='checkbox'] {
+  justify-self: start;
+}
+
+.editor-objective-node {
+  border: 1px solid #d0d7de;
+  border-radius: 6px;
+  margin: 0.75rem 0;
+  padding: 0.75rem;
+}
+
+.editor-objective-node > legend {
+  padding: 0 0.4rem;
+  color: #57606a;
+}
+
+.editor-objective-metric-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(12rem, 1fr));
+  gap: 0.75rem;
+}
+
+.editor-objective-children {
+  display: grid;
+  gap: 0.75rem;
+}
+
+.editor-objective-child-row {
+  display: grid;
+  gap: 0.5rem;
+}
+
+.editor-objective-add,
+.editor-objective-remove {
+  border: 1px solid #8c959f;
+  background: #f6f8fa;
+  border-radius: 4px;
+  color: inherit;
+  cursor: pointer;
+  font: inherit;
+  padding: 0.35rem 0.6rem;
+  justify-self: start;
+}
+
+.editor-script-card {
+  max-width: 68rem;
+}
+
+.editor-script-toggle input[type='checkbox'] {
+  justify-self: start;
+}
+
+.editor-script-events {
+  display: grid;
+  gap: 0.85rem;
+}
+
+.editor-script-event {
+  border: 1px solid #d0d7de;
+  border-radius: 6px;
+  margin: 0;
+  padding: 0.8rem;
+}
+
+.editor-script-event > legend {
+  padding: 0 0.4rem;
+  color: #57606a;
+}
+
+.editor-script-event-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(12rem, 1fr));
+  gap: 0.75rem;
+}
+
+.editor-script-actions {
+  display: grid;
+  gap: 0.5rem;
+  margin-top: 0.8rem;
+}
+
+.editor-script-actions h3 {
+  margin: 0;
+  font-size: 0.95rem;
+}
+
+.editor-script-action-row {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(12rem, 1fr));
+  gap: 0.5rem 0.75rem;
+  align-items: end;
+}
+
+.editor-script-add,
+.editor-script-remove {
+  border: 1px solid #8c959f;
+  background: #f6f8fa;
+  border-radius: 4px;
+  color: inherit;
+  cursor: pointer;
+  font: inherit;
+  padding: 0.35rem 0.6rem;
+  justify-self: start;
+}
+
+.editor-behavior-card {
+  max-width: 64rem;
+}
+
+.editor-behavior-toggle input[type='checkbox'] {
+  justify-self: start;
+}
diff --git a/packages/scenario-core/src/scenario-bundle-v1.test.ts b/packages/scenario-core/src/scenario-bundle-v1.test.ts
index 6b934b4b..8cd9a996 100644
--- a/packages/scenario-core/src/scenario-bundle-v1.test.ts
+++ b/packages/scenario-core/src/scenario-bundle-v1.test.ts
@@ -175,4 +175,115 @@ describe('scenarioBundleV1Schema', () => {
     expect(missingNamespace.success).toBe(false);
     expect(unknownNamespace.success).toBe(false);
   });
+
+  it('accepts authored objective/script payloads for Stage 4 export integration', () => {
+    const parsed = parseScenarioBundleV1({
+      version: 1,
+      key: 'user/stage4-authoring',
+      name: 'Stage 4 Authoring',
+      description: '',
+      tags: [],
+      start: {
+        startYear: 2000,
+        startFunds: 12000,
+      },
+      map: {
+        kind: 'city-file-bytes',
+        width: SCENARIO_BUNDLE_V1_MAP_WIDTH,
+        height: SCENARIO_BUNDLE_V1_MAP_HEIGHT,
+        cityFileBytes: 'AA==',
+      },
+      objective: {
+        kind: 'all',
+        predicates: [
+          {
+            kind: 'metric',
+            metric: 'traffic-average',
+            op: 'lt',
+            // Magic number source: Bern objective threshold `TrafficAverage < 80`
+            // from `DoScenarioScore` in `ref/micropolis/src/sim/s_msg.c`.
+            value: 80,
+          },
+          {
+            kind: 'not',
+            predicate: {
+              kind: 'metric',
+              metric: 'crime-average',
+              op: 'gt',
+              value: 150,
+            },
+          },
+        ],
+      },
+      script: [
+        {
+          trigger: { everyTicks: 24 },
+          actions: [
+            { kind: 'make-flood' },
+            {
+              kind: 'send-message',
+              // Magic number source: scenario failure message id `-200`
+              // from `DoScenarioScore` in `ref/micropolis/src/sim/s_msg.c`.
+              messageId: -200,
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(parsed.objective?.kind).toBe('all');
+    expect(parsed.script?.[0]?.trigger).toEqual({ everyTicks: 24 });
+  });
+
+  it('rejects malformed objective/script payload shapes', () => {
+    const invalidObjective = scenarioBundleV1Schema.safeParse({
+      version: 1,
+      key: 'user/invalid-objective',
+      name: 'Invalid Objective',
+      description: '',
+      tags: [],
+      start: {
+        startYear: 2000,
+        startFunds: 10000,
+      },
+      map: {
+        kind: 'city-file-bytes',
+        width: SCENARIO_BUNDLE_V1_MAP_WIDTH,
+        height: SCENARIO_BUNDLE_V1_MAP_HEIGHT,
+        cityFileBytes: 'AA==',
+      },
+      objective: {
+        kind: 'metric',
+        metric: 'unknown',
+        op: 'gt',
+        value: 1,
+      },
+    });
+    const invalidScript = scenarioBundleV1Schema.safeParse({
+      version: 1,
+      key: 'user/invalid-script',
+      name: 'Invalid Script',
+      description: '',
+      tags: [],
+      start: {
+        startYear: 2000,
+        startFunds: 10000,
+      },
+      map: {
+        kind: 'city-file-bytes',
+        width: SCENARIO_BUNDLE_V1_MAP_WIDTH,
+        height: SCENARIO_BUNDLE_V1_MAP_HEIGHT,
+        cityFileBytes: 'AA==',
+      },
+      script: [
+        {
+          trigger: { atTick: 1 },
+          actions: [{ kind: 'send-message' }],
+        },
+      ],
+    });
+
+    expect(invalidObjective.success).toBe(false);
+    expect(invalidScript.success).toBe(false);
+  });
 });
diff --git a/packages/scenario-core/src/scenario-bundle-v1.ts b/packages/scenario-core/src/scenario-bundle-v1.ts
index 5288ac12..a9cc611b 100644
--- a/packages/scenario-core/src/scenario-bundle-v1.ts
+++ b/packages/scenario-core/src/scenario-bundle-v1.ts
@@ -2,6 +2,106 @@ import { z } from 'zod';
 
 const SCENARIO_KEY_NAMESPACE_PREFIXES = ['builtin/', 'user/'] as const;
 const MAP_FORM_CONFLICT_ERROR = 'map must include exactly one map form: cityFileBytes or tileWords';
+const SCENARIO_OBJECTIVE_METRIC_KEYS = [
+  'city-class',
+  'traffic-average',
+  'city-score',
+  'crime-average',
+] as const;
+const SCENARIO_OBJECTIVE_COMPARISONS = ['gt', 'gte', 'lt', 'lte', 'eq', 'neq'] as const;
+
+/**
+ * Objective metric key domain persisted in Stage 4 authored bundle objectives.
+ * Mirrors metrics read by `DoScenarioScore` in `ref/micropolis/src/sim/s_msg.c`,
+ * represented as declarative keys for authored scenarios.
+ */
+export type ScenarioObjectiveMetricKeyV1 = (typeof SCENARIO_OBJECTIVE_METRIC_KEYS)[number];
+
+/**
+ * Objective comparison operators persisted in Stage 4 authored objectives.
+ * Mirrors relational checks from `DoScenarioScore` in `ref/micropolis/src/sim/s_msg.c`.
+ */
+export type ScenarioObjectiveComparisonV1 = (typeof SCENARIO_OBJECTIVE_COMPARISONS)[number];
+
+/**
+ * Leaf objective predicate persisted for Stage 4 authored scenarios.
+ * Mirrors one C-style objective comparison from `DoScenarioScore` in
+ * `ref/micropolis/src/sim/s_msg.c`.
+ */
+export interface ScenarioObjectiveMetricPredicateV1 {
+  readonly kind: 'metric';
+  readonly metric: ScenarioObjectiveMetricKeyV1;
+  readonly op: ScenarioObjectiveComparisonV1;
+  readonly value: number;
+}
+
+/**
+ * Conjunction objective predicate persisted for Stage 4 authored scenarios.
+ * Not a direct Micropolis C struct: declarative composition over C-parity metric leaves.
+ */
+export interface ScenarioObjectiveAllPredicateV1 {
+  readonly kind: 'all';
+  readonly predicates: readonly ScenarioObjectivePredicateV1[];
+}
+
+/**
+ * Disjunction objective predicate persisted for Stage 4 authored scenarios.
+ * Not a direct Micropolis C struct: declarative composition over C-parity metric leaves.
+ */
+export interface ScenarioObjectiveAnyPredicateV1 {
+  readonly kind: 'any';
+  readonly predicates: readonly ScenarioObjectivePredicateV1[];
+}
+
+/**
+ * Negation objective predicate persisted for Stage 4 authored scenarios.
+ * Not a direct Micropolis C struct: declarative composition over C-parity metric leaves.
+ */
+export interface ScenarioObjectiveNotPredicateV1 {
+  readonly kind: 'not';
+  readonly predicate: ScenarioObjectivePredicateV1;
+}
+
+/**
+ * Declarative objective predicate tree persisted in Stage 4 bundle exports.
+ * Metric leaves preserve `DoScenarioScore` comparison domains from
+ * `ref/micropolis/src/sim/s_msg.c`; composite nodes are declarative extensions.
+ */
+export type ScenarioObjectivePredicateV1 =
+  | ScenarioObjectiveMetricPredicateV1
+  | ScenarioObjectiveAllPredicateV1
+  | ScenarioObjectiveAnyPredicateV1
+  | ScenarioObjectiveNotPredicateV1;
+
+/**
+ * Stage 4 script trigger union persisted in scenario bundles.
+ * Maps to `ScenarioDisaster` trigger styles from `ref/micropolis/src/sim/s_disast.c`,
+ * represented as authoring-friendly JSON fields.
+ */
+export type ScenarioScriptTriggerV1 = { readonly atTick: number } | { readonly everyTicks: number };
+
+/**
+ * Stage 4 script action union persisted in scenario bundles.
+ * Action kinds mirror disaster/objective side effects from
+ * `ref/micropolis/src/sim/s_disast.c` and `ref/micropolis/src/sim/s_msg.c`.
+ */
+export type ScenarioScriptActionV1 =
+  | { readonly kind: 'make-earthquake' }
+  | { readonly kind: 'drop-fire-bombs' }
+  | { readonly kind: 'make-monster' }
+  | { readonly kind: 'make-meltdown' }
+  | { readonly kind: 'make-flood' }
+  | { readonly kind: 'send-message'; readonly messageId: number }
+  | { readonly kind: 'lose-game' };
+
+/**
+ * One Stage 4 authored script event row persisted in scenario bundles.
+ * This stores authoring trigger/action rows that map to scenario runtime event behavior.
+ */
+export interface ScenarioScriptEventV1 {
+  readonly trigger: ScenarioScriptTriggerV1;
+  readonly actions: readonly ScenarioScriptActionV1[];
+}
 
 /**
  * Canonical scenario bundle version for Stage 0 contracts.
@@ -105,6 +205,114 @@ export const scenarioStartParametersV1Schema = z
   })
   .strict();
 
+/**
+ * Stage 4 objective metric key schema for authored bundle payloads.
+ * Mirrors `DoScenarioScore` metric domains from `ref/micropolis/src/sim/s_msg.c`.
+ */
+export const scenarioObjectiveMetricKeyV1Schema = z.enum(SCENARIO_OBJECTIVE_METRIC_KEYS);
+
+/**
+ * Stage 4 objective comparison schema for authored bundle payloads.
+ * Mirrors `DoScenarioScore` relational operator domains from `ref/micropolis/src/sim/s_msg.c`.
+ */
+export const scenarioObjectiveComparisonV1Schema = z.enum(SCENARIO_OBJECTIVE_COMPARISONS);
+
+/**
+ * Stage 4 objective predicate schema for authored bundle payloads.
+ * Metric leaves are C-parity (`DoScenarioScore`), while `all`/`any`/`not` nodes
+ * are declarative composition layers.
+ */
+export const scenarioObjectivePredicateV1Schema: z.ZodType<ScenarioObjectivePredicateV1> = z.lazy(
+  () =>
+    z.discriminatedUnion('kind', [
+      z
+        .object({
+          kind: z.literal('metric'),
+          metric: scenarioObjectiveMetricKeyV1Schema,
+          op: scenarioObjectiveComparisonV1Schema,
+          value: z.number().int(),
+        })
+        .strict(),
+      z
+        .object({
+          kind: z.literal('all'),
+          predicates: z.array(scenarioObjectivePredicateV1Schema),
+        })
+        .strict(),
+      z
+        .object({
+          kind: z.literal('any'),
+          predicates: z.array(scenarioObjectivePredicateV1Schema),
+        })
+        .strict(),
+      z
+        .object({
+          kind: z.literal('not'),
+          predicate: scenarioObjectivePredicateV1Schema,
+        })
+        .strict(),
+    ]),
+);
+
+/**
+ * Stage 4 script trigger schema for authored bundle payloads.
+ * `atTick` and `everyTicks` mirror one-shot and periodic countdown trigger domains
+ * from `ScenarioDisaster` in `ref/micropolis/src/sim/s_disast.c`.
+ */
+export const scenarioScriptTriggerV1Schema = z.union([
+  z
+    .object({
+      atTick: z.number().int().min(0),
+    })
+    .strict(),
+  z
+    .object({
+      everyTicks: z.number().int().positive(),
+    })
+    .strict(),
+]);
+
+/**
+ * Stage 4 script action schema for authored bundle payloads.
+ * Action kinds mirror declarative runtime side effects mapped from
+ * `ref/micropolis/src/sim/s_disast.c` and `ref/micropolis/src/sim/s_msg.c`.
+ */
+export const scenarioScriptActionV1Schema: z.ZodType<ScenarioScriptActionV1> = z.discriminatedUnion(
+  'kind',
+  [
+    z.object({ kind: z.literal('make-earthquake') }).strict(),
+    z.object({ kind: z.literal('drop-fire-bombs') }).strict(),
+    z.object({ kind: z.literal('make-monster') }).strict(),
+    z.object({ kind: z.literal('make-meltdown') }).strict(),
+    z.object({ kind: z.literal('make-flood') }).strict(),
+    z
+      .object({
+        kind: z.literal('send-message'),
+        messageId: z.number().int(),
+      })
+      .strict(),
+    z.object({ kind: z.literal('lose-game') }).strict(),
+  ],
+);
+
+/**
+ * Stage 4 authored script event schema for bundle payloads.
+ * Trigger/action rows map to scenario disaster/message side-effect domains from
+ * `ref/micropolis/src/sim/s_disast.c` and `ref/micropolis/src/sim/s_msg.c`.
+ */
+export const scenarioScriptEventV1Schema = z
+  .object({
+    trigger: scenarioScriptTriggerV1Schema,
+    actions: z.array(scenarioScriptActionV1Schema).min(1),
+  })
+  .strict();
+
+/**
+ * Stage 4 authored script list schema for bundle payloads.
+ * Requires at least one event row when script authoring is enabled/persisted.
+ */
+export const scenarioScriptV1Schema = z.array(scenarioScriptEventV1Schema).min(1);
+
 /**
  * Canonical Stage 0 scenario bundle contract for JSON interchange.
  * This is a modern contract wrapper around C-parity map/start fields and is not
@@ -129,6 +337,8 @@ export const scenarioBundleV1Schema = z
     tags: z.array(z.string().min(1)),
     start: scenarioStartParametersV1Schema,
     map: scenarioMapV1Schema,
+    objective: scenarioObjectivePredicateV1Schema.optional(),
+    script: scenarioScriptV1Schema.optional(),
   })
   .strict();
 
diff --git a/packages/sim-core/src/systems/scenario-runtime-determinism.test.ts b/packages/sim-core/src/systems/scenario-runtime-determinism.test.ts
index adc9c6a9..2a4efd56 100644
--- a/packages/sim-core/src/systems/scenario-runtime-determinism.test.ts
+++ b/packages/sim-core/src/systems/scenario-runtime-determinism.test.ts
@@ -303,5 +303,5 @@ describe('scenario runtime fixed-seed deterministic parity', () => {
       expect(declarativeRepeat.hookDigest).toBe(declarative.hookDigest);
       expect(declarativeRepeat.finalDigest).toBe(declarative.finalDigest);
     }
-  });
+  }, 10_000);
 });
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index e78a7714..5c66162b 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -72,6 +72,9 @@ importers:
       '@city/scenario-core':
         specifier: workspace:*
         version: link:../../packages/scenario-core
+      '@city/scenario-runtime':
+        specifier: workspace:*
+        version: link:../../packages/scenario-runtime
       '@tanstack/react-router':
         specifier: 1.157.16
         version: 1.157.16(react-dom@19.2.4(react@19.2.4))(react@19.2.4)