@unoverse-platform/studio 0.1.111 → 0.1.113

package/README.md

@@ -54,9 +54,8 @@ full client:
   its own; the renderer loads when required, from the universe that owns it.
 - **Publish**: every universe pulls the org's repo; nothing is pushed in. Connect the
   repo on the org page's Source tab, and a push arrives by webhook within seconds, by
-  polling within 5 minutes, or with Sync now. Until your universe runs a release with the Git sync,
-  `unoverse deploy studio` still publishes to your own universe over its API. Lint runs
-  first; nothing leaves your machine until the rules pass.
+  polling within 5 minutes, or with Sync now. The universe lints
+  each commit first and applies nothing that fails.
 
 The universe is somebody's deployment of the Unoverse platform. Yours, your team's, or
 a customer's. Studio never runs one.

package/local/plugin.ts

@@ -364,8 +364,8 @@ export function localStudioHost(): Plugin {
             }
 
             /**
-             * THE WORKSPACE'S OWN UNIVERSE, for the Live preview. unoverse.yaml (written
-             * by `unoverse deploy studio`, committed with the repo) names where this
+             * THE WORKSPACE'S OWN UNIVERSE, for the Live preview. unoverse.yaml (committed
+             * with the repo) names where this
              * workspace ships; failing that, a machine signed in to exactly one universe
              * has answered the question too. This is the "future work" liveUniverseUrl's
              * stub promised: the universe comes from the workspace, never a browser

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unoverse-platform/studio",
-  "version": "0.1.111",
+  "version": "0.1.113",
   "type": "module",
   "description": "Unoverse Studio: the local authoring app. Reads your own rx/ folder, no backend.",
   "scripts": {

package/vendor/base/src/definitions/registry/objects.ts

@@ -96,6 +96,26 @@ export interface ObjectLink {
   alike?: string[];
 }
 
+/**
+ * HOW A NAME IS MATCHED TO A ROW OF THIS OBJECT (docs/unoverse/data/objects/entity-resolution.md,
+ * "How an org declares it", agreed 2026-10-05). The words are the org's; the steps are the
+ * platform's (services/ingestion/pipeline/5-save/matching.ts).
+ */
+export interface ObjectMatching {
+  /** Equal on both rows, compared as words: the same thing. Decides alone. */
+  ids?: string[];
+  /** The fields that hold its names; a mention equal to any of them, as words, is that row. */
+  names: string[];
+  /** One of `names`, a list: where a confirmed name is added. */
+  remember?: string;
+  /** Shown to the judge beside each candidate. */
+  evidence?: string[];
+  /** Filled on both and different, as words: never the same thing. */
+  ruleOut?: string[];
+  /** The node that decides a name the rules leave open (TypeSafeChoice). Absent, an open name goes to review. */
+  judge?: string;
+}
+
 /**
  * A COLUMN OF A DATASET (dataset.md, "the declaration is the schema"). The same words a prop
  * uses, so an author learns one grammar: a name, a type, whether it must be there, and whether
@@ -182,6 +202,8 @@ export interface ObjectDefinition {
   meta?: "open";
   /** The lines it draws between its own rows, by name (README 7; relationships-and-labels.md). */
   links?: Record<string, ObjectLink>;
+  /** How a name is matched to its rows (entity-resolution.md); absent, a line to it compares one field with one field. */
+  matching?: ObjectMatching;
   /** THE TABLE THIS OBJECT OWNS (docs/unoverse/data/objects/dataset.md, PROPOSED 2026-09-18),
    *  from its folder's table.yaml: an object that holds many small facts read together rather
    *  than one row read alone. Absent on every ordinary object, which stays a row. */
@@ -325,6 +347,11 @@ function readFolder(dir: string, name: string, org: string | undefined, seen: st
     for (const f of mine) if (typeof f === "string" && !(f in props)) throw new Error(`object ${name}: link ${ln} names the field "${f}", which the object does not have (${dir})`);
     for (const f of l?.alike ?? []) if (!mine.includes(f)) throw new Error(`object ${name}: link ${ln}: alike names "${f}", which is not one of its ${l?.to ? "match" : "between"} fields (${dir})`);
   }
+  // ITS MATCHING names only its own fields, for the same reason.
+  const matching = (envelope.matching ?? parent?.matching) as ObjectMatching | undefined;
+  for (const f of [...(matching?.ids ?? []), ...(matching?.names ?? []), ...(matching?.evidence ?? []), ...(matching?.ruleOut ?? [])]) {
+    if (!(f in props) && !["title", "description", "source_url", "source_id"].includes(f)) throw new Error(`object ${name}: matching names the field "${f}", which the object does not have (${dir})`);
+  }
   return {
     name,
     ...(org ? { org } : {}),
@@ -338,6 +365,7 @@ function readFolder(dir: string, name: string, org: string | undefined, seen: st
     ...(typeof envelope.element === "string" && envelope.element ? { element: envelope.element } : parent?.element ? { element: parent.element } : {}),
     ...(envelope.meta ? { meta: envelope.meta } : parent?.meta ? { meta: parent.meta } : {}),
     ...(links && Object.keys(links).length ? { links } : {}),
+    ...(envelope.matching ? { matching: envelope.matching as ObjectMatching } : parent?.matching ? { matching: parent.matching } : {}),
     ...(dataset ? { dataset } : {}),
     props,
     ownProps,

package/vendor/base/src/definitions/registry/pipelines.ts

@@ -67,6 +67,12 @@ export interface MakeEntry {
   when?: string;
   /** How many of this object one source makes (owner, 2026-09-13): one, or many. The read asks by it; a part's entry says none. */
   cardinality?: "one" | "many";
+  /**
+   * WRITTEN FROM EVERY SECTION (owner, 2026-10-05): `per: section` writes this object after the
+   * document is cut, one read per stored piece of each named section, instead of in the
+   * document's first read, which sees only its first two pages and its headings.
+   */
+  per?: "section";
   sourceUrl?: string;
   sourceId?: string;
   /** The item's content, each value a reference over `item`, `index`, `config`, `collect`. */
@@ -148,6 +154,7 @@ function readFolder(dir: string, name: string, org: string | undefined): Pipelin
         ...(spec.any === true ? { any: list } : { each: list }),
         ...(spec.cardinality === "one" || spec.cardinality === "many" ? { cardinality: spec.cardinality as "one" | "many" } : {}),
         ...(whenOf(spec) ? { when: whenOf(spec) } : {}),
+        ...(spec.per === "section" ? { per: "section" as const } : {}),
         sourceUrl: typeof raw.sourceUrl === "string" ? raw.sourceUrl : "{{ item.address }}",
         sourceId: typeof raw.sourceId === "string" ? raw.sourceId : "{{ item.universalId }}",
         content: isRecord(raw.content) ? raw.content : {},

package/vendor/base/src/items/collect.ts

@@ -295,7 +295,7 @@ function collectFrom(root: string, project: string, designSystem: string): Colle
   // package envelope their $refs and credential shapes resolve against. The name is the
   // node's `type`, bare: a saved workflow stores that identity and nothing else.
   //
-  // Until 2026-09-05 deploy never looked at nodes at all, so `deploy studio` shipped a
+  // Until 2026-09-05 the collect never looked at nodes at all, so shipping an org sent a
   // developer's components and skills and silently left every node behind. Until
   // 2026-09-08 it looked at a `nodes/` folder beside design/ while every org already
   // kept its nodes INSIDE its project, so the same nodes were left behind again. Org

package/vendor/base/src/lint/objects/rules.mjs

@@ -106,6 +106,19 @@ export function envelopeFindings(name, envelope, file = `${name}.yaml`) {
       for (const k of Object.keys(l)) if (!["type", "between", "order", "when", "alike"].includes(k)) say(`object ${name}: link ${ln}: "${k}" is not a word here`);
     }
   }
+  // HOW A NAME IS MATCHED TO ITS ROWS (entity-resolution.md, "How an org declares it", 2026-10-05).
+  if (envelope.matching != null) {
+    const m = envelope.matching;
+    const fields = (v) => Array.isArray(v) && v.length > 0 && v.every((f) => typeof f === "string" && f);
+    if (!isRecord(m)) refuse(`object ${name}: matching is a record: ids, names, remember, evidence, ruleOut, judge`);
+    else {
+      if (!fields(m.names)) refuse(`object ${name}: matching: names lists the fields that hold this object's names`);
+      for (const k of ["ids", "evidence", "ruleOut"]) if (m[k] != null && !fields(m[k])) refuse(`object ${name}: matching: ${k} is a list of field names`);
+      if (m.remember != null && (typeof m.remember !== "string" || !(m.names ?? []).includes(m.remember))) refuse(`object ${name}: matching: remember names one of names, the list a confirmed name is added to`);
+      if (m.judge != null && (typeof m.judge !== "string" || !/^[A-Z][A-Za-z0-9]*$/.test(m.judge))) refuse(`object ${name}: matching: judge names a node by its type (TypeSafeChoice)`);
+      for (const k of Object.keys(m)) if (!["ids", "names", "remember", "evidence", "ruleOut", "judge"].includes(k)) say(`object ${name}: matching: "${k}" is not a word here`);
+    }
+  }
   return out;
 }
 
@@ -251,6 +264,11 @@ export function rowKeyFindings(name, envelope, props, file = `${name}.yaml`) {
     if (!Array.isArray(list)) continue;
     for (const f of list.flat()) if (typeof f === "string" && !known.has(f) && !known.has(camel(f))) out.push({ file, msg: `object ${name}: ${key} names "${f}", which is not a prop of this object or its base. A row key is a field (README 9a)` });
   }
+  const m = isRecord(envelope.matching) ? envelope.matching : null;
+  if (m) {
+    for (const k of ["ids", "names", "evidence", "ruleOut"]) for (const f of Array.isArray(m[k]) ? m[k] : []) if (typeof f === "string" && !known.has(f)) out.push({ file, msg: `object ${name}: matching: ${k} names "${f}", which is not a prop of this object or its base (entity-resolution.md)` });
+    if (typeof m.remember === "string" && props[m.remember] && props[m.remember].type !== "array") out.push({ file, msg: `object ${name}: matching: remember names "${m.remember}", which is not a list; a confirmed name is added to a list (entity-resolution.md)` });
+  }
   return out;
 }
 
@@ -285,7 +303,7 @@ export const PIPELINE_READ_KEYS = new Set(["each", "sourceUrl", "sourceId", "con
 const DROPPED_MAKE_KEYS = ["partsOf", "by", "under", "when", "from", "any", "index"];
 
 /** What an object may say: under `each`, how many and what it holds; made once per pack, how many and from which rows. */
-const ITEM_OBJECT_KEYS = new Set(["cardinality", "any", "parts", "where"]);
+const ITEM_OBJECT_KEYS = new Set(["cardinality", "any", "parts", "where", "per"]);
 const FIELD = /^[A-Za-z_][A-Za-z0-9_]*$/;
 
 /**
@@ -361,7 +379,8 @@ export function pipelineFindings(name, file, fileName = "pipeline.yaml") {
         }
         if (made.includes(o)) refuse(`pipeline ${name}: ${at}.${o} is made above already; one entry makes an object`);
         const allowed = ITEM_OBJECT_KEYS;
-        for (const k of Object.keys(spec)) if (!allowed.has(k)) refuse(`pipeline ${name}: ${at}.${o}: "${k}" is not a word here; an object says cardinality, any, parts and where (${see})`);
+        for (const k of Object.keys(spec)) if (!allowed.has(k)) refuse(`pipeline ${name}: ${at}.${o}: "${k}" is not a word here; an object says cardinality, any, parts, where and per (${see})`);
+        if ("per" in spec && spec.per !== "section") refuse(`pipeline ${name}: ${at}.${o}: per says section, the only unit an object is written per (${see})`);
         // HOW MANY IS SAID by every object the model writes (owner, 2026-09-13).
         if (spec.cardinality !== "one" && spec.cardinality !== "many") say(`pipeline ${name}: ${at}.${o} says cardinality: one or many, how many of it one row makes (${see})`);
         if ("any" in spec && spec.any !== true) refuse(`pipeline ${name}: ${at}.${o}: any: true is its only value, the item MAY be one`);

package/vendor/base/src/workflow/PlatformMemoryCore.ts

@@ -45,7 +45,7 @@ const MEMORY_SERVICE_URL = process.env.MEMORY_SERVICE_URL || "http://localhost:4
 export const USER_MEMORY_METHODS: Record<string, any> = {
   queryMemory: {
     description:
-      "Search the user's remembered facts by topic (semantic + keyword). Use mid-conversation when a specific topic needs prior context — budget, preferences, past decisions about X, or where an earlier plan got to. Returns claims with certainty scores — weight stronger evidence higher. This is evidence about the user specifically, not a knowledge-base search. (A summary of who the user is was already provided in your context — query only for depth beyond it.)",
+      "Memory about this person: who they are, what they have told you, their preferences, and anything they started and did not finish. Use it only to know who is asking or to pick up their unfinished work. It holds no records, figures or actions, and it never finds a tool. When the person asks you to do something, or asks about their own records, search for it instead. Returns claims with certainty scores; weight stronger evidence higher. (A summary of who the person is was already provided in your context; query only for depth beyond it.)",
     input: {
       type: "object",
       additionalProperties: false,
@@ -133,7 +133,7 @@ export const AGENT_MEMORY_METHODS: Record<string, any> = {
 };
 
 export const USER_MEMORY_INSTRUCTIONS =
-  "User memory is available. A background summary of who this user is (identity + current state) was injected into your context at start — do not re-fetch it. queryMemory(topic) searches deeper when a specific topic needs prior context.";
+  "User memory is about the person: who they are, what they have told you, and what they left unfinished. A summary is already in your context; do not re-fetch it. queryMemory goes deeper on a topic about the person. Memory is never how you get something done: for any task or question about their own records, use search to find the tool, then answer for this person.";
 
 export const AGENT_MEMORY_INSTRUCTIONS =
   "You have persistent goal memory that survives restarts and context resets. On wake: getGoalContext before doing work — it shows the active goal, its ledger (attempts, whether it is met, the criteria still open from the judge's last verdict), AND your recent goals with their progress (done/total). If an earlier goal is unfinished or was closed too soon, resumeGoal reopens it so you continue from where you left off instead of starting over. While working: record decisions, failures, environment facts, and progress with writeNote, and keep updateGoalState accurate after each meaningful step (mark steps '[done] …' as you finish them — don't leave the plan frozen on step 1). On completion: REVIEW first — verify the output meets the locked acceptance criteria, mark the remaining plan steps done and set a closing currentStep via updateGoalState, then archiveGoal with a specific summary. The journal is for future-you — write what re-hydration needs, nothing else.";