run-dmcp 0.6.0 → 0.7.0

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export { timelineDivergences } from "./timeline/checkpoint.js";
 export type { Divergence } from "./timeline/checkpoint.js";
 export { declareIrreversible, irreversibleFactFor, listIrreversibleFacts, } from "./timeline/irreversible.js";
 export type { IrreversibleFact } from "./timeline/irreversible.js";
+export type { SetTransition } from "./timeline/constrained.js";
 export { openingEventId } from "./timeline/provenance.js";
 export type { FactProvenance } from "./timeline/provenance.js";
 export { narrationConstraintAt, contradictions, NARRATION_CONSTRAINT_FORMAT_VERSION, } from "./timeline/narration.js";
@@ -22,7 +23,7 @@ export { writeConstrainedValue, transferConstrainedValue, valueHistory, } from "
 export type { ValueTransition } from "./timeline/constrained.js";
 export { ConstraintViolationError, constraintsFor, conservedConstraintFor } from "./timeline/registry.js";
 export { createResolver, ResolveProtocolError } from "./timeline/resolve.js";
-export type { Mechanic, Resolver, Proposal, Expectation, AdjudicationInput, Adjudication, IntendedChange, IntendedWrite, IntendedTransfer, Outcome, ResolveRefusalReason, } from "./timeline/resolve.js";
+export type { Mechanic, Resolver, Proposal, Expectation, AdjudicationInput, Adjudication, IntendedChange, IntendedWrite, IntendedTransfer, IntendedSet, Outcome, ResolveRefusalReason, } from "./timeline/resolve.js";
 export { createStateRenderer } from "./timeline/render.js";
 export type { RenderVocabulary, VocabularyEntry, StateRenderer, RenderedState, RenderedNoun, UnnamedFact, } from "./timeline/render.js";
 export { createTurnReader } from "./reader/turnReader.js";

package/dist/mcp-server.d.ts

@@ -6,7 +6,7 @@ export declare const SERVER_NAME = "dmcp";
  *  the published package version by src/__tests__/serverVersion.test.ts --
  *  this said "0.3.0" for the whole of 0.4.0, because a release bumps
  *  package.json and nothing was watching this. */
-export declare const SERVER_VERSION = "0.6.0";
+export declare const SERVER_VERSION = "0.7.0";
 /**
  * Build an MCP server with every CORE tool, resource and prompt this engine
  * serves -- entities, facts, events, the timeline, and the entity/property

package/dist/mcp-server.js

@@ -45,7 +45,7 @@ export const SERVER_NAME = "dmcp";
  *  the published package version by src/__tests__/serverVersion.test.ts --
  *  this said "0.3.0" for the whole of 0.4.0, because a release bumps
  *  package.json and nothing was watching this. */
-export const SERVER_VERSION = "0.6.0";
+export const SERVER_VERSION = "0.7.0";
 /**
  * Build an MCP server with every CORE tool, resource and prompt this engine
  * serves -- entities, facts, events, the timeline, and the entity/property

package/dist/timeline/constrained.d.ts

@@ -218,3 +218,42 @@ export declare function transferConstrainedValue(params: {
  * discipline. `limit` applies after ordering, never before.
  */
 export declare function valueHistory(entityId: string, key: string, limit?: number): ValueTransition[];
+/**
+ * One non-numeric column set, as `resolve()`'s `set` intent applies it (issue
+ * #32). A row, never a verdict: what the column held, what it holds now, and
+ * the fact the write opened -- `null` when the value did not move, because an
+ * unchanged value opens no new interval (projection.ts's update trigger).
+ */
+export interface SetTransition {
+    entityId: string;
+    key: string;
+    previousValue: string | number | null;
+    newValue: string | number | null;
+    t: T;
+    factId: string | null;
+}
+/**
+ * Sets one live column of an entity's projected table to `value` (issue #32).
+ * The engine stores what it is handed and never learns what the column means;
+ * the projection triggers version it exactly as they version every other
+ * column write, so nothing here touches `facts` directly.
+ *
+ * The same choke point as numeric writes, and the same checks in the same
+ * voice: the entity and column are resolved against `PROJECTED_TABLES` /
+ * `liveColumns` (never a caller-supplied table name); the column that places
+ * the entity in its game is refused; a key carrying a numeric constraint is
+ * refused, because that value changes by a write where the constraint is
+ * evaluated; `resolve_only` asks the one question it always asks, whether an
+ * adjudication window is open; and a contradicted irreversible fact is
+ * translated into a typed `ConstraintViolationError` with the one hop
+ * attached, by `translateIrreversibleFailure`, never by reading the trigger's
+ * message.
+ *
+ * Not exported from the library: `resolve()` is its only caller, so a
+ * non-numeric consequence reaches storage through a resolution or not at all.
+ */
+export declare function setProjectedValue(params: {
+    entityId: string;
+    key: string;
+    value: string | number | null;
+}): SetTransition;

package/dist/timeline/constrained.js

@@ -669,3 +669,81 @@ export function valueHistory(entityId, key, limit) {
     const limited = limit !== undefined ? ranked.slice(0, limit) : ranked;
     return limited.map((r) => r.transition);
 }
+/** The numeric members of the constraint family. A key carrying one of them
+ *  changes by a write (`writeConstrainedValue`), where the constraint is
+ *  evaluated; a `set` would step round it. */
+const NUMERIC_CONSTRAINT_KINDS = new Set(["monotonic", "bounded", "conserved"]);
+function openFactId(db, entityId, key) {
+    const row = db
+        .prepare(`SELECT id FROM facts WHERE entity_id = ? AND key = ? AND valid_to_t IS NULL ORDER BY valid_from_t DESC, id DESC LIMIT 1`)
+        .get(entityId, key);
+    return row?.id ?? null;
+}
+/**
+ * Sets one live column of an entity's projected table to `value` (issue #32).
+ * The engine stores what it is handed and never learns what the column means;
+ * the projection triggers version it exactly as they version every other
+ * column write, so nothing here touches `facts` directly.
+ *
+ * The same choke point as numeric writes, and the same checks in the same
+ * voice: the entity and column are resolved against `PROJECTED_TABLES` /
+ * `liveColumns` (never a caller-supplied table name); the column that places
+ * the entity in its game is refused; a key carrying a numeric constraint is
+ * refused, because that value changes by a write where the constraint is
+ * evaluated; `resolve_only` asks the one question it always asks, whether an
+ * adjudication window is open; and a contradicted irreversible fact is
+ * translated into a typed `ConstraintViolationError` with the one hop
+ * attached, by `translateIrreversibleFailure`, never by reading the trigger's
+ * message.
+ *
+ * Not exported from the library: `resolve()` is its only caller, so a
+ * non-numeric consequence reaches storage through a resolution or not at all.
+ */
+export function setProjectedValue(params) {
+    const resolved = resolveProjection(params.entityId, params.key);
+    const db = getDatabase();
+    const projected = PROJECTED_TABLES.find((p) => p.table === resolved.table);
+    if (projected && projected.gameIdColumn === params.key) {
+        throw new Error(`timeline: '${params.key}' places entity '${params.entityId}' in its game and cannot be set -- ` +
+            `an entity does not move between games`);
+    }
+    for (const constraint of constraintsFor(params.entityId, params.key)) {
+        if (NUMERIC_CONSTRAINT_KINDS.has(constraint.kind)) {
+            throw new ConstraintViolationError(constraint.kind, params.entityId, `Entity '${params.entityId}' is ${constraint.kind}-constrained for key '${params.key}', which a set does not ` +
+                `evaluate; this value changes by a write, where the constraint is checked.`);
+        }
+        if (constraint.kind === "resolve_only" && !adjudicationOpen()) {
+            throw new ConstraintViolationError("resolve_only", params.entityId, `Entity '${params.entityId}' is resolve_only-constrained for key '${params.key}'; direct writes are refused. ` +
+                `This value can only change through the adjudicating call that opens the resolution window.`);
+        }
+    }
+    const row = db.prepare(`SELECT ${resolved.key} AS value FROM ${resolved.table} WHERE id = ?`).get(resolved.entityId);
+    if (!row) {
+        throw new Error(`timeline: no live row in '${resolved.table}' for entity '${resolved.entityId}' -- ` +
+            `it may have been destroyed since it was last confirmed to exist`);
+    }
+    try {
+        return withTransaction(() => {
+            const before = openFactId(db, resolved.entityId, resolved.key);
+            db.prepare(`UPDATE ${resolved.table} SET ${resolved.key} = ? WHERE id = ?`).run(params.value, resolved.entityId);
+            const after = openFactId(db, resolved.entityId, resolved.key);
+            const story = currentStoryTime(resolved.gameId);
+            if (!story) {
+                throw new Error(`timeline: game '${resolved.gameId}' has no timeline clock -- a set has no t to attach to`);
+            }
+            return {
+                entityId: resolved.entityId,
+                key: resolved.key,
+                previousValue: row.value,
+                newValue: params.value,
+                t: story.t,
+                factId: after !== before ? after : null,
+            };
+        });
+    }
+    catch (err) {
+        if (params.value === null)
+            throw err;
+        translateIrreversibleFailure(db, [{ entityId: params.entityId, key: params.key, table: resolved.table, attemptedValue: params.value }], err);
+    }
+}

package/dist/timeline/resolve.d.ts

@@ -1,6 +1,6 @@
 import { type T } from "./t.js";
 import { type NarrationConstraint, type Contradiction } from "./narration.js";
-import { type ValueTransition } from "./constrained.js";
+import { type ValueTransition, type SetTransition } from "./constrained.js";
 /**
  * The inbound half of authority (design §5.2a, GitHub issue #10): propose ->
  * adjudicate -> outcome. The engine enforces the PROTOCOL -- resolution
@@ -71,8 +71,9 @@ import { type ValueTransition } from "./constrained.js";
  *      INSIDE it (adjudication.ts's own doc comment asks for exactly this
  *      nesting, so the window row rolls back with the writes it
  *      authorized). Every change goes through `writeConstrainedValue` /
- *      `transferConstrainedValue` -- the one choke point (root CLAUDE.md
- *      hard rule 7) -- never a direct write. A constraint violation
+ *      `transferConstrainedValue` / `setProjectedValue` (issue #32, a
+ *      non-numeric column) -- the one choke point (root CLAUDE.md hard
+ *      rule 7) -- never a direct write. A constraint violation
  *      anywhere in the list propagates out of the transaction untouched
  *      (never caught and re-labelled here) and rolls back EVERY change the
  *      transaction made, including ones that individually would have
@@ -169,7 +170,17 @@ export interface IntendedTransfer {
         maxValue: number | null;
     };
 }
-export type IntendedChange = IntendedWrite | IntendedTransfer;
+/** One intended set of a non-numeric column on an entity's projected row
+ *  (issue #32) -- a thing changing owner, a character changing place. The
+ *  engine stores `value` and never learns what `key` means; see
+ *  `setProjectedValue` (constrained.ts) for what it refuses. */
+export interface IntendedSet {
+    kind: "set";
+    entityId: string;
+    key: string;
+    value: string | number | null;
+}
+export type IntendedChange = IntendedWrite | IntendedTransfer | IntendedSet;
 /**
  * What a mechanic returns. `changes` are intents, not writes -- `resolve()`
  * applies every one of them through the one choke point (step 5); the
@@ -201,6 +212,9 @@ export interface Outcome {
     t: T;
     result: Record<string, unknown>;
     transitions: ValueTransition[];
+    /** Every `set` this resolution applied, in order (issue #32). Kept apart
+     *  from `transitions`, whose values are numbers. */
+    sets: SetTransition[];
     constraint: NarrationConstraint;
     eventId: string;
 }

package/dist/timeline/resolve.js

@@ -3,7 +3,7 @@ import { getDatabase, withTransaction } from "../db/connection.js";
 import { currentStoryTime } from "./clock.js";
 import { narrationConstraintAt, contradictions } from "./narration.js";
 import { withAdjudicationOpen } from "./adjudication.js";
-import { writeConstrainedValue, transferConstrainedValue } from "./constrained.js";
+import { writeConstrainedValue, transferConstrainedValue, setProjectedValue } from "./constrained.js";
 /**
  * Refused before dispatch, before any write, or (never, by construction --
  * see step 5 above) mid-apply. `reason` is the discriminant a caller
@@ -81,6 +81,9 @@ export function createResolver(params) {
     };
 }
 function applyChange(change) {
+    if (change.kind === "set") {
+        return setProjectedValue({ entityId: change.entityId, key: change.key, value: change.value });
+    }
     if (change.kind === "write") {
         return [
             writeConstrainedValue({
@@ -180,8 +183,13 @@ function resolveProposal(mechanicsByName, proposal) {
     // is never relabelled as a ResolveProtocolError).
     const applied = withTransaction(() => withAdjudicationOpen(gameId, () => {
         const transitions = [];
+        const sets = [];
         for (const change of changes) {
-            transitions.push(...applyChange(change));
+            const applied = applyChange(change);
+            if (Array.isArray(applied))
+                transitions.push(...applied);
+            else
+                sets.push(applied);
         }
         // Re-read the clock AFTER every write has landed, inside this same
         // transaction -- a sequence-axis game advances its own t once per
@@ -206,7 +214,7 @@ function resolveProposal(mechanicsByName, proposal) {
         getDatabase()
             .prepare(`INSERT INTO events (id, game_id, at_t, kind, description, causes) VALUES (?, ?, ?, 'resolution.recorded', ?, ?)`)
             .run(eventId, gameId, postStory.t, adjudication.description ?? null, JSON.stringify(causes));
-        return { transitions, eventId, postT: postStory.t };
+        return { transitions, sets, eventId, postT: postStory.t };
     }));
     // 7. The outcome's constraint, built AFTER the writes landed and the
     // transaction holding them has already committed -- reachable only from a
@@ -220,6 +228,7 @@ function resolveProposal(mechanicsByName, proposal) {
         t,
         result: adjudication.result ?? {},
         transitions: applied.transitions,
+        sets: applied.sets,
         constraint: postConstraint,
         eventId: applied.eventId,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "run-dmcp",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "An MCP server for LLM-run interactive fiction where the server owns what is true - including when it was true. A continuation of DMCP.",
   "license": "MIT",
   "author": "Derek Ferguson",