@polycode-projects/the-mechanical-code-talker 2.7.10 → 2.7.12

package/corpus/worlds/manifest.json

@@ -4,7 +4,7 @@
   "counts": {
     "worlds": 2,
     "facts": 527,
-    "rules": 14
+    "rules": 19
   },
   "budgets": {
     "sourceBytesPerWorld": 131072,
@@ -14,8 +14,8 @@
   "sources": [
     {
       "file": "src/ashcombe-hall.jsonl",
-      "bytes": 7481,
-      "sha256": "776634e8f7db704f2895ad1557cdcb79c28e14fe8fd4202ef1d0db9b4358ca91"
+      "bytes": 8352,
+      "sha256": "f141da008edb6abfe025ddf4753fc374ccf44bdf23e3a414741f33f7246a3c9a"
     },
     {
       "file": "src/spider-fly.jsonl",
@@ -31,8 +31,8 @@
     },
     {
       "file": "shards/ashcombe-hall.jsonl.gz",
-      "bytes": 864,
-      "sha256": "468ba9ae859fc63094f5030648f07885e1e0785fb4e18e309cc4e6729c878ebf"
+      "bytes": 948,
+      "sha256": "49bbdf7bd0008c916145e866cd174d334c97ec449bd8ec850d10985468653c25"
     },
     {
       "file": "shards/spider-fly.jsonl.gz",

package/corpus/worlds/src/ashcombe-hall.jsonl

@@ -60,5 +60,10 @@
 {"world":"ashcombe-hall","kind":"rule","name":"give","ruleKind":"action-signature","slots":{"subjectClass":"portable","targetClass":"person"}}
 {"world":"ashcombe-hall","kind":"rule","name":"give","ruleKind":"action-effect","slots":{"predicate":"located-in","subjectRole":"subject","objectRole":"target"}}
 {"world":"ashcombe-hall","kind":"rule","name":"open","ruleKind":"action-signature","slots":{"subjectClass":"adventurer","targetClass":"furniture"}}
+{"world":"ashcombe-hall","kind":"rule","name":"open","ruleKind":"action-precond","slots":{"shape":"fact-value","predicate":"stands-locked-in","role":"target","scope":"any","negate":"true"}}
+{"world":"ashcombe-hall","kind":"rule","name":"open","ruleKind":"action-precond","slots":{"shape":"fact-value","predicate":"is-open","role":"target","scope":"any","value":"true","negate":"true"}}
+{"world":"ashcombe-hall","kind":"rule","name":"open","ruleKind":"action-effect","slots":{"predicate":"is-open","subjectRole":"target","value":"true"}}
 {"world":"ashcombe-hall","kind":"rule","name":"unlock","ruleKind":"action-signature","slots":{"subjectClass":"adventurer","targetClass":"furniture"}}
 {"world":"ashcombe-hall","kind":"rule","name":"close","ruleKind":"action-signature","slots":{"subjectClass":"adventurer","targetClass":"furniture"}}
+{"world":"ashcombe-hall","kind":"rule","name":"close","ruleKind":"action-precond","slots":{"shape":"fact-value","predicate":"is-open","role":"target","scope":"any","value":"true"}}
+{"world":"ashcombe-hall","kind":"rule","name":"close","ruleKind":"action-effect","slots":{"predicate":"is-open","subjectRole":"target","value":"false"}}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "2.7.10",
+  "version": "2.7.12",
   "private": false,
   "type": "module",
   "description": "The Mechanical Code Talker (tmct) — a tolerant, offline, $0 chat surface that guides you toward precision queries about a software repository. ELIZA/PARRY-style but domain-obsessed with code. No model calls; no codebase index of its own.",

package/src/adapters/memory/core.mjs

@@ -1287,10 +1287,18 @@ const RULE_SLOT_SPEC = {
   [RULE_KIND_ACTION_PRECOND]: [
     ["shape", "mgx:ruleActionPrecondShape"], ["predicate", "mgx:ruleActionPrecondPredicate"],
     ["role", "mgx:ruleActionPrecondRole"], ["scope", "mgx:ruleActionPrecondScope"],
+    // value/negate: the "fact-value" shape's literal-match and negation
+    // slots. Optional (RULE_SLOT_OPTIONAL below) — no-incoming/comparator
+    // preconds never set them.
+    ["value", "mgx:ruleActionPrecondValue"], ["negate", "mgx:ruleActionPrecondNegate"],
   ],
   [RULE_KIND_ACTION_EFFECT]: [
     ["predicate", "mgx:ruleActionEffectPredicate"], ["subjectRole", "mgx:ruleActionEffectSubject"],
-    ["objectRole", "mgx:ruleActionEffectObject"],
+    // objectRole/value: exactly one of these two must be set (enforced
+    // below, not by this per-slot spec) — a role-bound effect (Hanoi's
+    // "rest-on") supplies objectRole, a literal datatype effect (Ashcombe's
+    // is-open = "true") supplies value instead.
+    ["objectRole", "mgx:ruleActionEffectObject"], ["value", "mgx:ruleActionEffectValue"],
   ],
   // "the <left> may not be with the <right> without the <guard>" — each slot
   // names a class whose sole member src/domain/domain.mjs resolves at compile time.
@@ -1300,25 +1308,47 @@ const RULE_SLOT_SPEC = {
   ],
 };
 
+// Slots a kind's RULE_SLOT_SPEC lists but does NOT require non-empty — the
+// literal-effect/fact-value extension's slots, added after the original
+// four-kind design. A pre-existing rule never sets them, so it reads back
+// with these keys simply absent (readRuleRows defaults an absent slot to
+// ""), the same "not supplied" signal domain.mjs's compileDomain gives an
+// explicit "" — see optionalTerm there.
+const RULE_SLOT_OPTIONAL = {
+  [RULE_KIND_ACTION_PRECOND]: new Set(["value", "negate"]),
+  [RULE_KIND_ACTION_EFFECT]: new Set(["objectRole", "value"]),
+};
+
 // Content-addressed over (kind, name, ...slots in RULE_SLOT_SPEC order),
 // mirroring factIdFor's NUL-delimited discipline: identical rules upsert,
 // different ones coexist. For 2-slot kinds the joined string is byte-identical
 // to the historical (kind, name, slot1, slot2) template, so pre-existing rule
-// ids never change (pinned by test/adapters/memory-rules-action.test.mjs).
+// ids never change (pinned by test/adapters/memory-rules-action.test.mjs);
+// action-precond/action-effect ids shifted when their optional slots joined
+// the spec above (their own round-trip test asserts dedup behavior, never a
+// specific hash, so this was never a promise for those two kinds).
 const ruleIdFor = (kind, name, slotValues) => `rule:${fnv1aHex([kind, name, ...slotValues].join("\0"))}`;
 
 /** Append one taught RULE — a sibling of appendFact storing a `Rule`
  *  individual, same upsert/provenance/trust/SHACL discipline (neither
  *  pipeline ever checks `individual.class`). `slots` is the matching
- *  per-kind object (RULE_SLOT_SPEC above). Returns { id }. */
+ *  per-kind object (RULE_SLOT_SPEC above); a slot named in RULE_SLOT_OPTIONAL
+ *  may be omitted. Returns { id }. */
 export async function appendRule(dir, { name, kind, slots, provenance = "", createdAt = "" } = {}) {
   const spec = RULE_SLOT_SPEC[kind];
   if (!spec) throw new Error(`a rule kind must be one of ${RULE_KINDS.join(", ")}, got ${JSON.stringify(kind)}`);
   const n = normFactTerm(name);
   if (!n) throw new Error("a rule needs a name");
+  const optional = RULE_SLOT_OPTIONAL[kind] || new Set();
   const slotValues = spec.map(([slotKey]) => normFactTerm(slots?.[slotKey]));
-  if (slotValues.some((v) => !v)) {
-    throw new Error(`a ${kind} rule needs ${spec.map(([slotKey]) => slotKey).join(" + ")}`);
+  const missing = spec.filter(([slotKey], i) => !optional.has(slotKey) && !slotValues[i]);
+  if (missing.length) {
+    throw new Error(`a ${kind} rule needs ${missing.map(([slotKey]) => slotKey).join(" + ")}`);
+  }
+  if (kind === RULE_KIND_ACTION_EFFECT) {
+    const objectRole = slotValues[spec.findIndex(([k]) => k === "objectRole")];
+    const value = slotValues[spec.findIndex(([k]) => k === "value")];
+    if (!objectRole && !value) throw new Error(`a ${kind} rule needs an objectRole or a value`);
   }
   const id = ruleIdFor(kind, n, slotValues);
   const label = labelOf(`${n} = ${kind}(${slotValues.join(", ")})`);
@@ -1336,7 +1366,13 @@ export async function appendRule(dir, { name, kind, slots, provenance = "", crea
         { prop: "rdf:type", key: "type", value: "owl:NamedIndividual" },
         { prop: RULE_NAME_PROP, key: "ruleName", value: n },
         { prop: RULE_KIND_PROP, key: "ruleKind", value: kind },
-        ...spec.map(([slotKey, prop], i) => ({ prop, key: slotKey, value: slotValues[i] })),
+        // An optional slot left empty stores no attribute at all — the same
+        // "never supplied" shape a pre-extension Rule individual already has,
+        // rather than a wasted always-"" one.
+        ...spec
+          .map(([slotKey, prop], i) => ({ prop, key: slotKey, value: slotValues[i], skip: !slotValues[i] && optional.has(slotKey) }))
+          .filter((attr) => !attr.skip)
+          .map(({ skip, ...attr }) => attr),
         { prop: CREATED_AT_PROP, key: "createdAt", value: createdAtVal },
         ...(provs.length ? [{ prop: "mgx:factProvenance", key: "provenance", value: provs.join(" | ") }] : []),
       ],

package/src/adapters/memory/shacl.mjs

@@ -11,9 +11,13 @@ const RULE_KINDS = new Set([
   "action-signature", "action-precond", "action-effect", "action-constraint",
 ]);
 
-// Mirrors core.mjs's own (unexported) RULE_SLOT_SPEC exactly — the single
-// source of truth for the closed rule-kind shapes; kept in sync by hand
-// (both describe the same kinds' slots).
+// Mirrors the REQUIRED subset of core.mjs's own (unexported) RULE_SLOT_SPEC —
+// kept in sync by hand. Two kinds there also carry optional slots
+// (RULE_SLOT_OPTIONAL: action-precond's value/negate, action-effect's
+// objectRole/value) that deliberately do NOT appear here: this gate only
+// checks genuine malformation (the comment above), and "at least one of
+// objectRole/value" is a joint constraint core.mjs's own appendRule already
+// enforces at write time, not a per-slot presence check this shape can express.
 const RULE_SLOT_PROPS = {
   compose2: ["mgx:ruleBase1", "mgx:ruleBase2"],
   filter: ["mgx:ruleBase1", "mgx:ruleFilterProperty"],
@@ -23,9 +27,7 @@ const RULE_SLOT_PROPS = {
     "mgx:ruleActionPrecondShape", "mgx:ruleActionPrecondPredicate",
     "mgx:ruleActionPrecondRole", "mgx:ruleActionPrecondScope",
   ],
-  "action-effect": [
-    "mgx:ruleActionEffectPredicate", "mgx:ruleActionEffectSubject", "mgx:ruleActionEffectObject",
-  ],
+  "action-effect": ["mgx:ruleActionEffectPredicate", "mgx:ruleActionEffectSubject"],
   "action-constraint": [
     "mgx:ruleActionConstraintLeft", "mgx:ruleActionConstraintRight", "mgx:ruleActionConstraintGuard",
   ],

package/src/domain/domain.mjs

@@ -19,6 +19,15 @@ const attachPrefix = (predicate) => {
   return p.includes(":") ? p : `mgx:${p}`;
 };
 
+/** A genuinely-supplied optional slot (a literal precond/effect value): `""`,
+ *  `null` and `undefined` all read as "not supplied", the same signal a
+ *  never-taught slot and a readRuleRows-defaulted `""` both give. */
+const optionalTerm = (value) => {
+  if (value == null) return undefined;
+  const t = normTerm(value);
+  return t === "" ? undefined : t;
+};
+
 const rowSort = (a, b) =>
   a.subject.localeCompare(b.subject) ||
   a.predicate.localeCompare(b.predicate) ||
@@ -55,17 +64,32 @@ export function compileDomain(factRows, ruleRows) {
         targetClass: normTerm(slots.targetClass),
       });
     } else if (rule.kind === "action-precond") {
+      // value/negate are optional: absent in every no-incoming/comparator row
+      // taught so far, so their key is omitted rather than written as "" —
+      // an omitted key keeps a pre-existing precond's JSON.stringify sort
+      // form (and its precondHolds behavior) byte-identical to before this
+      // shape existed. normFactTerm/readRuleRows read a genuinely absent
+      // slot back as "", the same signal an explicit "" would give.
+      const value = optionalTerm(slots.value);
+      const negate = String(slots.negate) === "true" ? true : undefined;
       family.preconds.push({
         shape: normTerm(slots.shape),
         predicate: attachPrefix(slots.predicate),
         role: normTerm(slots.role),
         scope: normTerm(slots.scope),
+        ...(value !== undefined ? { value } : {}),
+        ...(negate !== undefined ? { negate } : {}),
       });
     } else if (rule.kind === "action-effect") {
+      // value is the literal-effect alternative to objectRole (a datatype
+      // write, e.g. mgx:is-open = "true", rather than a role binding) — same
+      // omit-when-absent discipline as the precond fields above.
+      const value = optionalTerm(slots.value);
       family.effects.push({
         predicate: attachPrefix(slots.predicate),
         subjectRole: normTerm(slots.subjectRole),
         objectRole: normTerm(slots.objectRole),
+        ...(value !== undefined ? { value } : {}),
       });
     } else if (rule.kind === "action-constraint") {
       family.constraints.push({
@@ -111,7 +135,11 @@ export function compileDomain(factRows, ruleRows) {
   };
   for (const action of actions) {
     for (const effect of action.effects) {
-      for (const role of [effect.subjectRole, effect.objectRole]) {
+      // A literal-valued effect (effect.value set) has no objectRole to bind
+      // — the literal IS the object, so objectRole (unused, "" when the
+      // teaching row never set it) never enters the class-membership check.
+      const roles = effect.value !== undefined ? [effect.subjectRole] : [effect.subjectRole, effect.objectRole];
+      for (const role of roles) {
         if (role !== "subject" && role !== "target") requireSoleMember(role, `an effect role of "${action.name}"`);
       }
     }
@@ -187,7 +215,13 @@ export function stateKeyFor(state) {
 const precondApplies = (precond, target, domain) =>
   precond.scope === "any" || (domain.classMembers[precond.scope] || []).includes(target);
 
-function precondHolds(precond, subject, target, state, domain) {
+/** A precondition on a fact ABOUT the role term itself (roleTerm as subject),
+ *  as opposed to "no-incoming"'s fact pointing AT the role term (roleTerm as
+ *  object). Datatype/state checks — a lock, an open/closed flag — read this
+ *  way: "does (roleTerm, predicate, value) exist", with `value` an existence
+ *  wildcard when omitted and `negate` flipping the sense ("must NOT exist"
+ *  covers "must not be locked", "must not already be open"). */
+export function precondHolds(precond, subject, target, state, domain) {
   const roleTerm = precond.role === "target" ? target : subject;
   if (precond.shape === "no-incoming") {
     return !state.some((r) => r.predicate === precond.predicate && r.object === roleTerm);
@@ -198,13 +232,21 @@ function precondHolds(precond, subject, target, state, domain) {
     return domain.ordering.some((r) =>
       r.subject === left && r.predicate === precond.predicate && r.object === right);
   }
+  if (precond.shape === "fact-value") {
+    const exists = state.some((r) => r.subject === roleTerm && r.predicate === precond.predicate
+      && (precond.value == null || r.object === precond.value));
+    return precond.negate ? !exists : exists;
+  }
   return false;
 }
 
 /** Ground an effect/constraint role word: "subject"/"target" bind the
  *  grounding pair; any other word is class-bound and binds the class's sole
- *  member — its companion semantics (compileDomain guarantees exactly one). */
-const roleBinding = (role, subject, target, domain) => {
+ *  member — its companion semantics (compileDomain guarantees exactly one).
+ *  Exported so a caller consulting one grounded precond/effect directly,
+ *  rather than running a full movesFromRules search, can still resolve an
+ *  effect's subject/object the same way the planner does. */
+export const roleBinding = (role, subject, target, domain) => {
   if (role === "subject") return subject;
   if (role === "target") return target;
   return (domain.classMembers[role] || [])[0];
@@ -213,12 +255,15 @@ const roleBinding = (role, subject, target, domain) => {
 const positionIn = (rows, term, predicate) =>
   rows.find((r) => r.subject === term && r.predicate === predicate)?.object;
 
-function applyEffects(effects, subject, target, state, domain) {
+export function applyEffects(effects, subject, target, state, domain) {
   let rows = state;
   let changed = false;
   for (const effect of effects) {
     const effSubject = roleBinding(effect.subjectRole, subject, target, domain);
-    const effObject = roleBinding(effect.objectRole, subject, target, domain);
+    // A literal-valued effect (a taught datatype flag) writes its value
+    // directly; a role-valued effect resolves objectRole through the
+    // grounding pair / class-bound member instead.
+    const effObject = effect.value !== undefined ? effect.value : roleBinding(effect.objectRole, subject, target, domain);
     const already = rows.some((r) =>
       r.subject === effSubject && r.predicate === effect.predicate && r.object === effObject);
     if (already) continue;

package/src/domain/grammar/ace.mjs

@@ -502,7 +502,15 @@ const VERB_SYNONYMS = new Map([
 // consumed whole before any shorter prefix inside it gets a chance to match.
 const VERB_SYNONYM_MAX_PREFIX = Math.max(...[...VERB_SYNONYMS.keys()].map((k) => k.split(" ").length));
 
-const VERB_FUZZY_CANDIDATES = [...new Set([...IMPERATIVE_VERBS, ...VERB_SYNONYMS.values()])];
+// Every leading SURFACE word the exact tiers below recognise as the start of
+// a command: a bare IMPERATIVE_VERBS word, or the first token of any
+// VERB_SYNONYMS key (single- or multi-word alike — "pick", "have", "chat" are
+// each only ever a key's own first word, never a key on their own, so they'd
+// otherwise have nothing to fuzzy-repair a typo onto). Corrects the SURFACE
+// word, not the canonical verb, so the existing exact-match tiers below (in
+// particular the multi-word prefix loop) still resolve the rest of the phrase
+// after repair — "hav a look at" -> "have a look at" -> examine, not just "look".
+const VERB_SURFACE_WORDS = [...new Set([...IMPERATIVE_VERBS, ...[...VERB_SYNONYMS.keys()].map((k) => k.split(" ")[0])])];
 const IMPERATIVE_FUZZY_BOUND = 1; // this project's existing distance-1 tolerance elsewhere (interpret/fuzzy.mjs)
 
 // A small, hand-checked exemption (same idiom as this file's own
@@ -513,31 +521,48 @@ const IMPERATIVE_FUZZY_BOUND = 1; // this project's existing distance-1 toleranc
 // Checked against this repo's own WordNet corpus, not guessed.
 const NEVER_FUZZY_VERB = new Set(["walk", "wake", "make"]);
 
-/** Resolve the leading verb token(s) to a canonical, recognised verb: the
- *  2-token VERB_SYNONYMS prefix FIRST (so "talk to"/"look at" resolve as
- *  themselves rather than as the bare exact verbs "talk"/"look" they'd
- *  otherwise short-circuit on, leaving their "to"/"at" stranded in the object
- *  phrase), then an exact IMPERATIVE_VERBS match, then the 1-token
- *  VERB_SYNONYMS form, then a bounded fuzzy typo repair against the same
- *  vocabulary. `consumed` is how many leading tokens the match ate (1, or 2
- *  for a two-word synonym phrase); `corrected` is non-null only for the
- *  fuzzy tier. Null when nothing at all recognises the leading token(s). */
-function resolveImperativeVerb(toks) {
+/** The three deterministic (non-fuzzy) tiers: a 2+-token VERB_SYNONYMS prefix
+ *  FIRST (so "talk to"/"look at" resolve as themselves rather than as the
+ *  bare exact verbs "talk"/"look" they'd otherwise short-circuit on, leaving
+ *  their "to"/"at" stranded in the object phrase), then an exact
+ *  IMPERATIVE_VERBS match, then the 1-token VERB_SYNONYMS form. `consumed` is
+ *  how many leading tokens the match ate. Null when none of the three match. */
+function exactImperativeVerb(toks) {
   const first = toks[0].toLowerCase();
   const lower = toks.map((t) => t.toLowerCase());
   for (let n = Math.min(VERB_SYNONYM_MAX_PREFIX, toks.length); n >= 2; n -= 1) {
     const hit = VERB_SYNONYMS.get(lower.slice(0, n).join(" "));
-    if (hit) return { verb: hit, consumed: n, corrected: null };
+    if (hit) return { verb: hit, consumed: n };
   }
-  if (IMPERATIVE_VERBS.has(first)) return { verb: first, consumed: 1, corrected: null };
+  if (IMPERATIVE_VERBS.has(first)) return { verb: first, consumed: 1 };
   const oneHit = VERB_SYNONYMS.get(first);
-  if (oneHit) return { verb: oneHit, consumed: 1, corrected: null };
-  if (NEVER_FUZZY_VERB.has(first)) return null;
-  const fuzzyHit = fuzzyMatchInSet(first, VERB_FUZZY_CANDIDATES, IMPERATIVE_FUZZY_BOUND);
-  if (fuzzyHit) return { verb: fuzzyHit, consumed: 1, corrected: { from: first, to: fuzzyHit } };
+  if (oneHit) return { verb: oneHit, consumed: 1 };
   return null;
 }
 
+/** Resolve the leading verb token(s) to a canonical, recognised verb: the
+ *  three exact tiers above, failing that a bounded fuzzy TYPO repair
+ *  (distance <= 1, via the existing interpret/fuzzy.mjs matcher) of the
+ *  leading token against every recognised surface word, single- or
+ *  multi-word idiom alike, then the exact tiers retried against the
+ *  corrected token — so a typo'd idiom lead word ("hav a look at") is
+ *  repaired to its real word first ("have a look at") and still resolves the
+ *  whole idiom, not just a bare-verb guess. Only the fuzzy tier is a
+ *  correction of an ERROR rather than a recognised alternate wording, so only
+ *  it is reported back on the command (`corrected`) for the caller to name in
+ *  its response — a synonym executes silently, a typo fix does not. */
+function resolveImperativeVerb(toks) {
+  const exact = exactImperativeVerb(toks);
+  if (exact) return { ...exact, corrected: null };
+  const first = toks[0].toLowerCase();
+  if (NEVER_FUZZY_VERB.has(first)) return null;
+  const fixedFirst = fuzzyMatchInSet(first, VERB_SURFACE_WORDS, IMPERATIVE_FUZZY_BOUND);
+  if (!fixedFirst) return null;
+  const retried = exactImperativeVerb([fixedFirst, ...toks.slice(1)]);
+  if (!retried) return null;
+  return { ...retried, corrected: { from: first, to: fixedFirst } };
+}
+
 /** Resolve one imperative object phrase to its bare lexicon term. */
 function imperativeNP(lexicon, tokens) {
   const np = resolveNP(lexicon, tokens);

package/src/services/adventure.mjs

@@ -12,6 +12,7 @@ import { worldProvenanceTag } from "../domain/worlds-pack.mjs";
 import { parseImperative } from "../domain/grammar/ace.mjs";
 import { createCompletionsGraphAdapter } from "../domain/completions/graph-adapter.mjs";
 import { actionFamilies } from "../domain/router/taught.mjs";
+import { compileDomain, precondHolds, roleBinding } from "../domain/domain.mjs";
 import { getWorldsPackProvider } from "../adapters/corpus/worlds-pack.mjs";
 import { appendFacts, appendRule, loadMemory, normFactTerm, readFactRows, readRuleRows } from "../adapters/memory/core.mjs";
 import { COMPLETIONS_STORE, generateCompletion } from "./completions.mjs";
@@ -78,7 +79,12 @@ async function openAdventure(opening, { planHolder, memoryDir, sessionId, env, c
     world = names[0];
   } else if (!names.includes(world)) {
     // An unknown "play X" is not necessarily an adventure ask at all ("play
-    // chess") — fall through to the ordinary lanes rather than claim it.
+    // spider" is spider-fly's own opener, not a broken adventure request) —
+    // fall through so a sibling game's opener keeps first refusal.
+    // unclaimedAdventureOpening below is chat's LAST-RESORT check: once
+    // every "play X" lane (this one included) has had its turn and none
+    // claimed the line, THAT'S when an unrecognized name gets named and
+    // declined honestly, never silently.
     return null;
   }
 
@@ -125,6 +131,31 @@ async function openAdventure(opening, { planHolder, memoryDir, sessionId, env, c
   };
 }
 
+/** chat's LAST-RESORT check for a named opener no lane claimed — "play
+ *  atlantis" when the pack has worlds but none is called that. Called AFTER
+ *  every other "play X"-shaped lane (spider-fly's own opener among them) has
+ *  already had its chance, so this never steals a name a sibling game
+ *  recognizes as its own (openAdventure's own fallthrough above stays
+ *  silent for exactly that reason). Only once nothing else wanted the line
+ *  does it get named and declined, rather than answered with an unrelated
+ *  generic non-answer. Null when the line isn't a named opener at all, or
+ *  the pack has no worlds (openAdventure's own first pass already gave that
+ *  case its honest missingPackAnswer, before any lane got a turn), or the
+ *  name IS one of the pack's — never re-decides a real hit. */
+export async function unclaimedAdventureOpening(line, { env }) {
+  const opening = matchAdventureOpening(line);
+  if (!opening?.world) return null;
+  const provider = getWorldsPackProvider(env);
+  let names = null;
+  try { names = await provider.list(); } catch { names = null; }
+  if (!names || !names.length || names.includes(opening.world)) return null;
+  return {
+    text: `I don't know a world called "${spokenNameOf(opening.world)}" — the pack has: ${names.map(spokenNameOf).join(", ")}.`,
+    lane: "game-inform",
+    note: `ADVENTURE — last-resort opening decline: "${opening.world}" names no world in the pack (has: ${names.join(", ")}), and no other lane claimed the line either`,
+  };
+}
+
 /** A resumed game's current room: non-null only when earlier @turnN
  *  snapshots exist (the world was already played in this store), folded the
  *  same way every other reader folds them. A fresh world returns null and
@@ -264,8 +295,10 @@ const affordanceSuffix = (actions) => (actions.length ? ` You can: ${actions.joi
 
 /** The effect predicate a family writes (its action-effect row's slot, with
  *  the mgx: prefix rule readers re-attach). Null when the family carries no
- *  effect row — the open/unlock/close families, whose datatype state writes
- *  have no shipped effect shape yet and ride the container logic below. */
+ *  effect row — unlock's family stays signature-only (its instrument match
+ *  needs a third, externally-supplied binding no shipped rule shape covers)
+ *  and rides the hand-written logic below; go/take/drop/give/open/close all
+ *  carry real effect rows and never hit this null. */
 function familyEffectPredicate(family) {
   const effect = (family || []).find((r) => r.kind === "action-effect");
   if (!effect?.slots?.predicate) return null;
@@ -449,6 +482,24 @@ function containerStatusPhrase(object, { state }) {
     : `the ${object} is open. It's empty.`;
 }
 
+/** `object`'s own datatype facts (its placement predicate, its open/closed
+ *  flag), as the tiny {subject,predicate,object} row set a "fact-value"
+ *  precond needs — read from the already-folded CURRENT truth (state.
+ *  placements/state.openness), never raw @turnN rows, so a superseded
+ *  snapshot can never look current. domain.mjs's own stateFromFacts can't
+ *  serve this: it keys "current" off an @stepN suffix (this world writes
+ *  @turnN) and restricts rows to individuals typed into some action's
+ *  SUBJECT class, which "furniture" (the container's own class) never is —
+ *  a container's own facts about itself would silently vanish through it. */
+function containerDatatypeState(state, object) {
+  const rows = [];
+  const place = state.placements.get(object);
+  if (place) rows.push({ subject: object, predicate: place.predicate, object: place.object });
+  const openness = state.openness.get(object);
+  if (openness) rows.push({ subject: object, predicate: OPEN_PREDICATE, object: openness.open ? "true" : "false" });
+  return rows;
+}
+
 async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
   const memory = await loadMemory(memoryDir);
   const rows = readFactRows(memory);
@@ -512,7 +563,8 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
     );
   }
 
-  const families = actionFamilies(readRuleRows(memory));
+  const ruleRows = readRuleRows(memory);
+  const families = actionFamilies(ruleRows);
   const family = families.get(cmd.verb);
   if (!family) {
     return answer(
@@ -619,9 +671,15 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
     );
   }
 
-  // open / unlock / close — the container verbs. Their families are
-  // signature-only (no shipped rule shape for a datatype effect yet), so the
-  // state writes are the closed container vocabulary below.
+  // open / unlock / close — the container verbs. presence and container-ness
+  // stay hand-checked here (visibility gating, not a state precondition);
+  // unlock's instrument match stays fully hand-written below it too — it
+  // needs a third, externally-supplied binding beyond subject/target, which
+  // this retrofit does not attempt. open/close's lock-state and open/closed
+  // checks, and their mgx:is-open write, are now taught "fact-value"
+  // precond/effect rows consulted through domain.mjs below; only the
+  // hidden-contents reveal (a variable-arity effect over a discovered set)
+  // stays hand-written JS, since no shipped rule shape covers that either.
   const presentHere = place && place.predicate !== "mgx:hidden-in" && place.predicate !== "mgx:currently-in" && place.object === here;
   if (!presentHere) {
     return answer(`I don't see a ${object} here.`, noteFor(`${cmd.verb} — ${object} isn't in the ${here}; declined`), { miss: true });
@@ -629,40 +687,50 @@ async function runWorldCommand(cmd, { world, memoryDir, env, graph, cache }) {
   if (!isContainer(rows, object)) {
     return answer(`the ${object} doesn't open.`, noteFor(`${cmd.verb} — no mgx:is-container fact on ${object}; declined by name`), { miss: true });
   }
-  const open = !!state.openness.get(object)?.open;
 
-  if (cmd.verb === "open") {
-    if (place.predicate === "mgx:stands-locked-in") {
-      return answer(`the ${object} is locked.`, noteFor(`open — ${object} stands locked; precondition declined by name`), { miss: true });
+  if (cmd.verb === "open" || cmd.verb === "close") {
+    const domain = compileDomain(rows, ruleRows);
+    const taughtAction = domain.actions.find((a) => a.name === cmd.verb);
+    const effect = taughtAction?.effects.find((e) => e.predicate === OPEN_PREDICATE);
+    if (!effect) {
+      return answer(
+        `this world doesn't teach how ${cmd.verb === "open" ? "opening" : "closing"} changes the ${object}.`,
+        noteFor(`${cmd.verb} — the taught "${cmd.verb}" family carries no ${OPEN_PREDICATE} effect; honest decline`),
+        { miss: true },
+      );
     }
-    if (open) {
-      return answer(`the ${object} is already open.`, noteFor("open — already open; declined"), { miss: true });
+    const factState = containerDatatypeState(state, object);
+    const failed = taughtAction.preconds.find((p) => !precondHolds(p, "player", object, factState, domain));
+    if (failed) {
+      const text = failed.predicate === "mgx:stands-locked-in"
+        ? `the ${object} is locked.`
+        : cmd.verb === "open" ? `the ${object} is already open.` : `the ${object} isn't open.`;
+      return answer(text, noteFor(`${cmd.verb} — the taught "${cmd.verb}" family's ${failed.predicate} precondition declined by name`), { miss: true });
     }
-    const revealed = [...state.placements]
-      .filter(([, p]) => p.predicate === "mgx:hidden-in" && p.object === object)
-      .map(([thing]) => thing)
-      .sort();
-    return commit(
-      [
-        { subject: `${object}@turn${k}`, predicate: "mgx:is-open", object: "true" },
-        ...revealed.map((thing) => ({ subject: `${thing}@turn${k}`, predicate: "mgx:located-in", object })),
-      ],
-      revealed.length
-        ? `you open the ${object} — inside: the ${revealed.join(", the ")}.`
-        : `you open the ${object}. It's empty.`,
-      `open — ${object} opens${revealed.length ? `, revealing ${revealed.join(", ")}` : ""}`,
-      `open the ${object}`,
-    );
-  }
-
-  if (cmd.verb === "close") {
-    if (!open) {
-      return answer(`the ${object} isn't open.`, noteFor("close — not open; declined"), { miss: true });
+    const effSubject = roleBinding(effect.subjectRole, "player", object, domain);
+    const writeIsOpen = { subject: `${effSubject}@turn${k}`, predicate: effect.predicate, object: effect.value };
+
+    if (cmd.verb === "open") {
+      const revealed = [...state.placements]
+        .filter(([, p]) => p.predicate === "mgx:hidden-in" && p.object === object)
+        .map(([thing]) => thing)
+        .sort();
+      return commit(
+        [
+          writeIsOpen,
+          ...revealed.map((thing) => ({ subject: `${thing}@turn${k}`, predicate: "mgx:located-in", object })),
+        ],
+        revealed.length
+          ? `you open the ${object} — inside: the ${revealed.join(", the ")}.`
+          : `you open the ${object}. It's empty.`,
+        `open — ${object} opens${revealed.length ? `, revealing ${revealed.join(", ")}` : ""} via the taught "open" family's effect`,
+        `open the ${object}`,
+      );
     }
     return commit(
-      [{ subject: `${object}@turn${k}`, predicate: "mgx:is-open", object: "false" }],
+      [writeIsOpen],
       `you close the ${object}.`,
-      `close — ${object} closes`,
+      `close — ${object} closes via the taught "close" family's effect`,
       `close the ${object}`,
     );
   }

package/src/services/chat.mjs

@@ -52,7 +52,7 @@ import { CHILD_PACK_NAME, childProvenanceTag } from "../domain/child-pack.mjs";
 import { getChildPackProvider } from "../adapters/corpus/child-pack.mjs";
 import { dialogueActForLane } from "../domain/dialogue-acts.mjs";
 import { relatedForTerm } from "../domain/skos-view.mjs";
-import { adventureTurn } from "./adventure.mjs";
+import { adventureTurn, unclaimedAdventureOpening } from "./adventure.mjs";
 import { spiderFlyTurn } from "./spider-fly-turn.mjs";
 
 // Composition: the chat surface supplies the domain parser's default lemma/POS
@@ -12646,6 +12646,24 @@ export async function runTurn(input, { config, source = defaultSource, graph = n
     }
   }
 
+  // A "play X" naming no world EITHER game lane above claimed — last resort,
+  // checked only once the adventure lane's own fallthrough and spider-fly's
+  // own opener have both passed on the line, so this never outguesses a
+  // sibling game's own recognized phrasing. Honest by name ("I don't know a
+  // world called…") rather than the generic non-answer an unclaimed opener
+  // fell into before.
+  {
+    const unclaimed = await unclaimedAdventureOpening(workingLine, { env });
+    if (unclaimed) {
+      note(trace, `lane: ${unclaimed.note}`);
+      const result = plainTurn(workingLine, unclaimed.text, { via: "game", miss: true, focus });
+      result.lane = unclaimed.lane;
+      const rec = withLast(result, "play the adventure");
+      rec.planState = planHolder.state;
+      return rec;
+    }
+  }
+
   // Conversational layer next (greetings, thanks, help, bye, why/say-more) — these
   // resolve no entity and carry their own preserved `last`. Bypasses withLast (a
   // conversational turn is never finish()'d / never becomes a new `last`), so the

package/src/surfaces/web/memory-ask-browser.bundle.js

@@ -9131,11 +9131,7 @@ ${bodyText}` : graphText, tier });
           "mgx:ruleActionPrecondRole",
           "mgx:ruleActionPrecondScope"
         ],
-        "action-effect": [
-          "mgx:ruleActionEffectPredicate",
-          "mgx:ruleActionEffectSubject",
-          "mgx:ruleActionEffectObject"
-        ],
+        "action-effect": ["mgx:ruleActionEffectPredicate", "mgx:ruleActionEffectSubject"],
         "action-constraint": [
           "mgx:ruleActionConstraintLeft",
           "mgx:ruleActionConstraintRight",
@@ -10088,9 +10084,16 @@ ${bodyText}` : graphText, tier });
     if (!spec) throw new Error(`a rule kind must be one of ${RULE_KINDS2.join(", ")}, got ${JSON.stringify(kind)}`);
     const n = normFactTerm(name);
     if (!n) throw new Error("a rule needs a name");
+    const optional = RULE_SLOT_OPTIONAL[kind] || /* @__PURE__ */ new Set();
     const slotValues = spec.map(([slotKey]) => normFactTerm(slots?.[slotKey]));
-    if (slotValues.some((v) => !v)) {
-      throw new Error(`a ${kind} rule needs ${spec.map(([slotKey]) => slotKey).join(" + ")}`);
+    const missing = spec.filter(([slotKey], i) => !optional.has(slotKey) && !slotValues[i]);
+    if (missing.length) {
+      throw new Error(`a ${kind} rule needs ${missing.map(([slotKey]) => slotKey).join(" + ")}`);
+    }
+    if (kind === RULE_KIND_ACTION_EFFECT) {
+      const objectRole = slotValues[spec.findIndex(([k]) => k === "objectRole")];
+      const value = slotValues[spec.findIndex(([k]) => k === "value")];
+      if (!objectRole && !value) throw new Error(`a ${kind} rule needs an objectRole or a value`);
     }
     const id = ruleIdFor(kind, n, slotValues);
     const label = labelOf(`${n} = ${kind}(${slotValues.join(", ")})`);
@@ -10109,7 +10112,10 @@ ${bodyText}` : graphText, tier });
           { prop: "rdf:type", key: "type", value: "owl:NamedIndividual" },
           { prop: RULE_NAME_PROP, key: "ruleName", value: n },
           { prop: RULE_KIND_PROP, key: "ruleKind", value: kind },
-          ...spec.map(([slotKey, prop], i) => ({ prop, key: slotKey, value: slotValues[i] })),
+          // An optional slot left empty stores no attribute at all — the same
+          // "never supplied" shape a pre-extension Rule individual already has,
+          // rather than a wasted always-"" one.
+          ...spec.map(([slotKey, prop], i) => ({ prop, key: slotKey, value: slotValues[i], skip: !slotValues[i] && optional.has(slotKey) })).filter((attr) => !attr.skip).map(({ skip, ...attr }) => attr),
           { prop: CREATED_AT_PROP, key: "createdAt", value: createdAtVal },
           ...provs.length ? [{ prop: "mgx:factProvenance", key: "provenance", value: provs.join(" | ") }] : []
         ]
@@ -10376,7 +10382,7 @@ ${bodyText}` : graphText, tier });
     }
     return out.sort((a, b) => `${a[0].subject} ${a[0].predicate}`.localeCompare(`${b[0].subject} ${b[0].predicate}`));
   }
-  var MEMORY_DIR_REL, MEMORY_GRAPH_REL, UTTERANCE_CLASS, FACT_CLASS, MEMORY_SESSION_CLASS, SOURCE_CLASS, RULE_CLASS, SAID_IN_SESSION_PROP, IN_REPLY_TO_PROP, DERIVED_FROM_PROP, STATED_BY_PROP, CANONICALISED_FROM_PROP, SOURCE_RELIABILITY_PROP, OPERATOR_SOURCE_ID, TEACH_SOURCE_ID, ROLES, LABEL_CAP, MEMORY_VOCABULARY, memoryGraphFile, BACKEND_MEMORY, BACKEND_SQLITE, SQLITE_DDL, STD_EDGE_KEYS, cloneJson, MEMORY_MANIFEST_REL, DEFAULT_RETENTION, resolveManifestFile, LEGACY_FACT_ID_RE, SYLLOGISE_STATE_REL, SQLITE_SYLLOGISE_STATE_KEY, MEMORY_INDEX, memoryIndexOf, labelOf, nowIso, sourceLabel, PROV_CLASS_BY_SOURCE_TYPE, isSessionScopedSourceId, RULE_KIND_COMPOSE2, RULE_KIND_FILTER, RULE_KIND_RECURSIVE, RULE_KIND_ACTION_SIGNATURE, RULE_KIND_ACTION_PRECOND, RULE_KIND_ACTION_EFFECT, RULE_KIND_ACTION_CONSTRAINT, RULE_KINDS2, RULE_NAME_PROP, RULE_KIND_PROP, RULE_SLOT_SPEC, ruleIdFor, CONTRADICTION_TRUST_FLOOR, HAS_A_PREDICATE, CAPABLE_OF_PREDICATE2, MULTI_VALUED_PREDICATES;
+  var MEMORY_DIR_REL, MEMORY_GRAPH_REL, UTTERANCE_CLASS, FACT_CLASS, MEMORY_SESSION_CLASS, SOURCE_CLASS, RULE_CLASS, SAID_IN_SESSION_PROP, IN_REPLY_TO_PROP, DERIVED_FROM_PROP, STATED_BY_PROP, CANONICALISED_FROM_PROP, SOURCE_RELIABILITY_PROP, OPERATOR_SOURCE_ID, TEACH_SOURCE_ID, ROLES, LABEL_CAP, MEMORY_VOCABULARY, memoryGraphFile, BACKEND_MEMORY, BACKEND_SQLITE, SQLITE_DDL, STD_EDGE_KEYS, cloneJson, MEMORY_MANIFEST_REL, DEFAULT_RETENTION, resolveManifestFile, LEGACY_FACT_ID_RE, SYLLOGISE_STATE_REL, SQLITE_SYLLOGISE_STATE_KEY, MEMORY_INDEX, memoryIndexOf, labelOf, nowIso, sourceLabel, PROV_CLASS_BY_SOURCE_TYPE, isSessionScopedSourceId, RULE_KIND_COMPOSE2, RULE_KIND_FILTER, RULE_KIND_RECURSIVE, RULE_KIND_ACTION_SIGNATURE, RULE_KIND_ACTION_PRECOND, RULE_KIND_ACTION_EFFECT, RULE_KIND_ACTION_CONSTRAINT, RULE_KINDS2, RULE_NAME_PROP, RULE_KIND_PROP, RULE_SLOT_SPEC, RULE_SLOT_OPTIONAL, ruleIdFor, CONTRADICTION_TRUST_FLOOR, HAS_A_PREDICATE, CAPABLE_OF_PREDICATE2, MULTI_VALUED_PREDICATES;
   var init_core = __esm({
     "src/adapters/memory/core.mjs"() {
       init_promises();
@@ -10506,12 +10512,22 @@ CREATE INDEX IF NOT EXISTS edges_by_prop ON edges(prop);
           ["shape", "mgx:ruleActionPrecondShape"],
           ["predicate", "mgx:ruleActionPrecondPredicate"],
           ["role", "mgx:ruleActionPrecondRole"],
-          ["scope", "mgx:ruleActionPrecondScope"]
+          ["scope", "mgx:ruleActionPrecondScope"],
+          // value/negate: the "fact-value" shape's literal-match and negation
+          // slots. Optional (RULE_SLOT_OPTIONAL below) — no-incoming/comparator
+          // preconds never set them.
+          ["value", "mgx:ruleActionPrecondValue"],
+          ["negate", "mgx:ruleActionPrecondNegate"]
         ],
         [RULE_KIND_ACTION_EFFECT]: [
           ["predicate", "mgx:ruleActionEffectPredicate"],
           ["subjectRole", "mgx:ruleActionEffectSubject"],
-          ["objectRole", "mgx:ruleActionEffectObject"]
+          // objectRole/value: exactly one of these two must be set (enforced
+          // below, not by this per-slot spec) — a role-bound effect (Hanoi's
+          // "rest-on") supplies objectRole, a literal datatype effect (Ashcombe's
+          // is-open = "true") supplies value instead.
+          ["objectRole", "mgx:ruleActionEffectObject"],
+          ["value", "mgx:ruleActionEffectValue"]
         ],
         // "the <left> may not be with the <right> without the <guard>" — each slot
         // names a class whose sole member src/domain/domain.mjs resolves at compile time.
@@ -10521,6 +10537,10 @@ CREATE INDEX IF NOT EXISTS edges_by_prop ON edges(prop);
           ["guard", "mgx:ruleActionConstraintGuard"]
         ]
       };
+      RULE_SLOT_OPTIONAL = {
+        [RULE_KIND_ACTION_PRECOND]: /* @__PURE__ */ new Set(["value", "negate"]),
+        [RULE_KIND_ACTION_EFFECT]: /* @__PURE__ */ new Set(["objectRole", "value"])
+      };
       ruleIdFor = (kind, name, slotValues) => `rule:${fnv1aHex([kind, name, ...slotValues].join("\0"))}`;
       CONTRADICTION_TRUST_FLOOR = 0.5;
       HAS_A_PREDICATE = "mgx:hasA";
@@ -21709,7 +21729,7 @@ ${codeblock}`, options);
   });
 
   // src/domain/grammar/ace.mjs
-  var PATTERN_SUB_CLASS_OF, PATTERN_TYPE_ASSERTION, PATTERN_RELATION, PATTERN_SOME_VALUES_FROM, PATTERN_CARDINALITY, PATTERN_DISJOINT_WITH, PATTERN_POSSESSIVE, PATTERN_ADJECTIVE, PATTERN_CAPABILITY, PATTERNS, IMPERATIVE_VERBS, VERB_SYNONYMS, VERB_SYNONYM_MAX_PREFIX, VERB_FUZZY_CANDIDATES;
+  var PATTERN_SUB_CLASS_OF, PATTERN_TYPE_ASSERTION, PATTERN_RELATION, PATTERN_SOME_VALUES_FROM, PATTERN_CARDINALITY, PATTERN_DISJOINT_WITH, PATTERN_POSSESSIVE, PATTERN_ADJECTIVE, PATTERN_CAPABILITY, PATTERNS, IMPERATIVE_VERBS, VERB_SYNONYMS, VERB_SYNONYM_MAX_PREFIX, VERB_SURFACE_WORDS;
   var init_ace2 = __esm({
     "src/domain/grammar/ace.mjs"() {
       init_lexicon();
@@ -21758,7 +21778,7 @@ ${codeblock}`, options);
         ["shut", "close"]
       ]);
       VERB_SYNONYM_MAX_PREFIX = Math.max(...[...VERB_SYNONYMS.keys()].map((k) => k.split(" ").length));
-      VERB_FUZZY_CANDIDATES = [.../* @__PURE__ */ new Set([...IMPERATIVE_VERBS, ...VERB_SYNONYMS.values()])];
+      VERB_SURFACE_WORDS = [.../* @__PURE__ */ new Set([...IMPERATIVE_VERBS, ...[...VERB_SYNONYMS.keys()].map((k) => k.split(" ")[0])])];
     }
   });
 
@@ -22011,6 +22031,14 @@ ${codeblock}`, options);
     }
   });
 
+  // src/domain/domain.mjs
+  var SEP2;
+  var init_domain = __esm({
+    "src/domain/domain.mjs"() {
+      SEP2 = String.fromCharCode(0);
+    }
+  });
+
   // src/adapters/memory/blocks.mjs
   var BLOCKS_DIR_REL;
   var init_blocks = __esm({
@@ -23449,6 +23477,7 @@ ${JSON.stringify(envelope, null, 2)}`;
   init_ace2();
   init_graph_adapter();
   init_taught();
+  init_domain();
 
   // src/adapters/corpus/worlds-pack.mjs
   init_node_fs();