@pascal-app/core 1.0.4 → 1.0.5

package/dist/agent-tools/design-brief.js

@@ -0,0 +1,149 @@
+import { z } from 'zod';
+/** Where a brief says the objects come from. */
+export const DESIGN_BRIEF_SOURCES = ['open', 'catalog', 'brand', 'existing'];
+/** The tools that place a catalog piece, and the ones that make a piece: what a brief opens. */
+export const CATALOG_PLACEMENT_TOOLS = ['place_items', 'furnish_room', 'place_in_room'];
+export const FURNISHING_CREATION_TOOLS = ['add_object', 'place_design'];
+const fact = z.string().min(1).max(200);
+/** The layers of the dressing `beyond` states, with how each reads in a fact. */
+export const BEYOND_LAYERS = [
+    ['textiles', 'textiles'],
+    ['light', 'light'],
+    ['windows', 'windows'],
+    ['walls', 'walls'],
+    ['floor', 'floor'],
+    ['plants', 'plants'],
+    ['objects', 'objects'],
+    ['smallFurniture', 'small furniture'],
+];
+/** An open dressing owes at least this many of the layers pieces. */
+export const BEYOND_MIN_LAYERS = 6;
+const layer = (what) => z
+    .union([
+    z.array(z.string().min(1).max(120)).min(1).max(12),
+    z.object({ none: z.string().min(1).max(200) }),
+])
+    .describe(`${what}: a list of pieces, each a short phrase naming the piece (and, for a whole home, the room or rooms), or { "none": "<why>" }.`);
+export const beyondSchema = z
+    .object({
+    textiles: layer('Bedding, throws, cushions'),
+    light: layer('Lamps, pendants, sconces'),
+    windows: layer('Curtains, blinds'),
+    walls: layer('Art, mirrors, shelves of objects'),
+    floor: layer('Rugs'),
+    plants: layer('Plants'),
+    objects: layer('Books, vases, trays, tableware'),
+    smallFurniture: layer('A bench, a chair, a desk, a pouf'),
+})
+    .describe('The dressing of the rooms beyond the pieces the request names, layer by layer. An open dressing is a call to dress the rooms fully; beyond is where that design is stated.');
+/** The pieces a layer names, or none. */
+export const layerPieces = (value) => Array.isArray(value) ? value : [];
+/**
+ * The axes of a request's creative latitude, besides the source (the `source` fields below).
+ * Each is bounded, quoting the person's own words that bound it with the reading in a short
+ * line, or open, with a design statement saying how it is designed. An axis the request does
+ * not touch at all is open.
+ */
+export const BRIEF_AXES = [
+    'action',
+    'size',
+    'pieces',
+    'openings',
+    'style',
+    'materials',
+    'dressing',
+];
+/** An open axis's design statement carries at least this many words. */
+export const AXIS_DESIGN_MIN_WORDS = 3;
+const axis = (what) => z
+    .discriminatedUnion('kind', [
+    z.object({
+        kind: z.literal('bounded'),
+        quote: z
+            .string()
+            .max(300)
+            .describe("The person's own words that bound this axis, copied from the request."),
+        reading: fact.describe('One short line: how those words bound this axis.'),
+        extent: z
+            .enum(['minimum', 'exact'])
+            .optional()
+            .describe('Pieces only: minimum, the named pieces must be there and more may come (the default reading), or exact, the request limits the pieces to those ("only", "nothing else").'),
+    }),
+    z.object({
+        kind: z.literal('open'),
+        design: z
+            .string()
+            .max(600)
+            .describe(`How this axis is designed, at least ${AXIS_DESIGN_MIN_WORDS} words.`),
+    }),
+])
+    .describe(what);
+export const axesSchema = z
+    .object({
+    action: axis('What the request asks to be done: add a lamp, make a bedroom, build a house.').optional(),
+    size: axis('Dimensions and extents.').optional(),
+    pieces: axis('The pieces and counts the request names. Usually bounded as a minimum (extent); words such as "only", "nothing else", "just", "seulement", "rien d\'autre" make it exact.').optional(),
+    openings: axis('Counts of windows and doors, when the request gives them: exact counts of the architecture.').optional(),
+    style: axis('Style and form of what is made.').optional(),
+    materials: axis('Materials and finishes.').optional(),
+    dressing: axis('What makes the space lived-in. When open, beyond carries it layer by layer; when bounded, the quote is the words that bound it and beyond may say none everywhere. The pieces the request names, read as a minimum, do not bound it.').optional(),
+})
+    .describe("The request read axis by axis: action, size, pieces, openings, style, materials, dressing, each bounded (the person's words as quote, the reading in a short line) or open (a design statement saying how it is designed). The eighth axis, the source, is the source fields: open, or bounded by sourceQuote. Every axis is stated; an axis the request does not touch is open.");
+export const designBriefTool = {
+    name: 'design_brief',
+    title: 'Write the design brief',
+    description: `The design brief of the request, written once for the whole request (piece by piece when the request invites it): the request read axis by axis (action, size, pieces, openings, style, materials, source, dressing), each axis bounded by the person's own words or open with a design statement, a vision, and where the objects come from. It is recorded as the design record of the turn and answers with what it unlocks. It changes nothing in the scene.
+Furnishings are placed or made after a brief: ${CATALOG_PLACEMENT_TOOLS.join(', ')} (the catalog's) and ${FURNISHING_CREATION_TOOLS.join(', ')} (the agent's own), also inside run_batch. Before one, search_assets and view_assets read the catalog and every other tool works as usual; rooms, walls, openings and finishes are not furnishings.
+Bounded and open, in four readings. "a 4 by 5 m bedroom with a double bed, two nightstands, a wardrobe, one window, one door": action, size, pieces (as a minimum: those pieces must be there, more may come) and openings bounded; style, materials, source and dressing open. "add a lamp next to the sofa": action and dressing bounded by "add a lamp" (one object in a room that exists); style open, its design statement saying how this lamp is designed. "a bedroom with only a bed and a lamp": pieces exact and dressing bounded by "only a bed and a lamp"; style and materials open, the bed and the lamp designed, not defaulted. "Build a house": the action bounded only by "a house"; every other axis open, the dressing included.
+source open: the pieces are made (add_object, place_design), view_assets shows the catalog's pieces for reference, and furnish_room, which places a whole stock set, stays closed. asIs keeps technical equipment only (sanitaryware, kitchen and laundry appliances, heating and similar services): each piece is named with a reason and was shown by view_assets earlier in the same turn (chat) or session (MCP); furniture is made, not kept as it is. source catalog, brand or existing: place_items, furnish_room and place_in_room are open, and the creation tools stay open for what the catalog lacks.
+Naming a piece (a double bed) states its function; its form, size within reason and finish are open unless the request fixes them. The pieces a request names are what the room must contain, not all it may contain: where the dressing axis is open, beyond states that design layer by layer: textiles, light, windows, walls, floor, plants, objects, small furniture, each a list of pieces or { none: why }, at least ${BEYOND_MIN_LAYERS} of the 8 layers naming pieces; where the dressing is bounded (words that limit the pieces or the action, such as "only", "nothing else", "just"), none in every layer is accepted. The pieces the request names, read as a minimum, do not bound the dressing. The answer hands the pieces back as dressing.
+A source other than open is set by the request, not chosen: sourceQuote holds the person's own words that name it, at least two words naming a brand (the brief's brand), the catalog or what is already there ("IKEA furniture only", "que du catalogue", "use my existing furniture"); a request that names no source is open. The chat checks the quote against the person's message of the turn, as it checks every bounded axis's quote; over MCP, where there is no message, a source quote must still name the source and is not compared with a request, and an axis quote is not compared either.
+In the chat a brief lasts for the turn; over MCP it lasts for the session. The next design_brief replaces it. Refused: axis_missing (an axis is absent), axis_quote_not_in_request (a bounded axis's quote is not in the person's message), axis_open_without_design (an open axis without a design statement of at least ${AXIS_DESIGN_MIN_WORDS} words), dressing_bounded_by_minimum (the dressing bounded by words inside a pieces quote read as a minimum), brand_required (source brand without a brand name), source_quote_required (a source other than open without sourceQuote), source_not_named (the quote names no brand, catalog or existing source), source_not_in_request (the quote is not in the person's message), beyond_too_thin (dressing open, fewer than ${BEYOND_MIN_LAYERS} layers naming pieces).`,
+    input: {
+        // Optional in the schema so an absent axis is refused by the operation, with the list,
+        // on every surface, rather than by each surface's own validation error.
+        axes: axesSchema.optional(),
+        source: z
+            .enum(DESIGN_BRIEF_SOURCES)
+            .describe('The source axis: where the objects come from. open: the request names no source. catalog: it asks for the catalog. brand: it names a range (give brand). existing: it names pieces that already exist.'),
+        sourceQuote: z
+            .string()
+            .min(1)
+            .max(300)
+            .optional()
+            .describe('Required with source catalog, brand or existing: the person\'s own words that name it (a brand, the catalog, what is already there), copied from the request ("IKEA furniture only").'),
+        brand: z
+            .string()
+            .min(1)
+            .max(80)
+            .optional()
+            .describe('The range the request names, when source is brand ("IKEA").'),
+        vision: z
+            .string()
+            .min(1)
+            .max(1200)
+            .describe('A few lines: the design intent for what is open (character, forms, materials, how the room is meant to feel).'),
+        beyond: beyondSchema,
+        asIs: z
+            .array(z.object({
+            assetId: z.string().min(1).describe('The catalog id of the piece, from search_assets.'),
+            reason: fact.describe('One line: why this piece stands as it is.'),
+        }))
+            .max(24)
+            .optional()
+            .describe('With source open: technical equipment placed unchanged (place_items, place_in_room), each piece shown by view_assets first, each with its reason. Sanitaryware, kitchen and laundry appliances, heating and similar services; furniture is made.'),
+    },
+};
+/**
+ * The brief as a session keeps it. Reading is tolerant, writing is strict: a record stored before
+ * `beyond` existed still reads (only the tool's input requires it), and a brief stored as
+ * `fixed`/`open` lists, before the axes, still reads with them, so an older brief never costs
+ * the session its checkpoints.
+ */
+export const DesignBriefRecord = z.object({
+    ...designBriefTool.input,
+    fixed: z.array(fact).min(1).max(24).optional(),
+    open: z.array(fact).max(24).optional(),
+    // A brief stored before the dressing had layers holds a string: it still reads.
+    beyond: z.union([designBriefTool.input.beyond, z.string()]).optional(),
+});

package/dist/agent-tools/designs.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+export declare const validateDesignTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        design: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+    };
+};
+export declare const placeDesignTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        design: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        hostId: z.ZodString;
+        position: z.ZodArray<z.ZodNumber>;
+        rotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        side: z.ZodOptional<z.ZodEnum<{
+            back: "back";
+            front: "front";
+        }>>;
+        surfaceId: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        name: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+    };
+};
+//# sourceMappingURL=designs.d.ts.map

package/dist/agent-tools/designs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"designs.d.ts","sourceRoot":"","sources":["../../src/agent-tools/designs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkBvB,eAAO,MAAM,kBAAkB;;;;;;;;;QAMd,YAAY;;CAC5B,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;CAyC3B,CAAA"}

package/dist/agent-tools/designs.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { measurement } from './measurement.js';
+import { NodeId } from './node-id.js';
+const design = z
+    .union([z.string(), z.record(z.string(), z.unknown())])
+    .describe('The design (procedural recipe, version 1 or 2) as an object, or as a JSON string for clients that cannot send recursive objects. Schema: pascal://schema/design.');
+const parameters = z
+    .record(z.string(), z.number())
+    .optional()
+    .describe('Parameter values to measure at, by parameter id. Defaults otherwise.');
+// A list of three, not a tuple: a tuple's list-form schema is refused by some clients.
+const point3 = z.array(z.number()).length(3);
+export const validateDesignTool = {
+    name: 'validate_design',
+    title: 'Validate design',
+    description: 'Check a design (procedural item recipe) without changing the scene. Returns `valid`, coded `diagnostics` with paths (errors block placement, warnings flag floating or unbalanced parts), the parameter `sweep`, and `measurements` at the given parameters: bounds, per-part bounds and instances, true triangle counts, draw groups per slot, datum contact and connected components. It is the authority: some rules are not expressible in pascal://schema/design. Repair and re-validate until `valid` is true. Version 2 designs validate fully but carry a design_version_not_enabled warning: placement accepts version 1 only until the next release.',
+    input: { design, parameters },
+    annotations: { readOnlyHint: true },
+};
+export const placeDesignTool = {
+    name: 'place_design',
+    title: 'Place design',
+    description: 'Create one instance of a design (procedural item recipe, object or JSON string) in the scene. The design must pass validate_design. Its mounting picks the host: floor designs go on a level (or a slab or zone of it) or on a named surface of a placed design; wall-side designs on a straight wall face; ceiling designs under a ceiling. Only creates: refusals carry a code (invalid_design with diagnostics, design_version_not_enabled for version 2 designs until the next release, design_too_large above 24 KiB, invalid_placement, node_exists, host_not_found, wrong_host, unknown_surface, does_not_fit) and change nothing.',
+    input: {
+        design,
+        hostId: NodeId.describe('Floor designs: a level, or a slab or zone on it, or a placed design with surfaceId. Wall-side designs: a straight wall. Ceiling designs: a ceiling.'),
+        position: point3.describe('Metres. Floor: level-local [x, y, z], y above the floor. Wall-side: [along, height, offset] of the mounting reference from the wall start. Ceiling: plan [x, 0, z] of the reference. Surface: [x, 0, z] in the surface frame.'),
+        rotation: measurement('angle', 'rad', {
+            description: 'Yaw. Not for wall-side designs; use side to face the other way.',
+        }).optional(),
+        side: z
+            .enum(['front', 'back'])
+            .optional()
+            .describe("Wall face for wall-side designs: front is the +normal side, normal (−Δz, Δx) of start→end. The wall's frontSide and backSide say which face is exterior (a facade light goes on that one)."),
+        surfaceId: z
+            .string()
+            .optional()
+            .describe('Named surface of the host design to rest on (see validate_design measurements.surfaces).'),
+        parameters,
+        slots: z
+            .record(z.string(), z.string())
+            .optional()
+            .describe('Slot id to "#rrggbb" or a scene:/library: material reference.'),
+        name: z.string().optional(),
+        id: z
+            .string()
+            .optional()
+            .describe('Optional new id ("procedural-item_…"). Refused if it exists: this tool only creates.'),
+    },
+};

package/dist/agent-tools/fences.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export declare const addFenceTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        levelId: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodString>;
+        points: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+        closed: z.ZodOptional<z.ZodBoolean>;
+        height: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        style: z.ZodOptional<z.ZodEnum<{
+            guard: "guard";
+            horizontal: "horizontal";
+            picket: "picket";
+            privacy: "privacy";
+            rail: "rail";
+            slat: "slat";
+        }>>;
+        baseStyle: z.ZodOptional<z.ZodEnum<{
+            floating: "floating";
+            grounded: "grounded";
+            raised: "raised";
+        }>>;
+        materialPreset: z.ZodOptional<z.ZodString>;
+    };
+};
+//# sourceMappingURL=fences.d.ts.map

package/dist/agent-tools/fences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fences.d.ts","sourceRoot":"","sources":["../../src/agent-tools/fences.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;CAiCxB,CAAA"}

package/dist/agent-tools/fences.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { FenceBaseStyle, FenceStyle } from '../schema/nodes/fence-types.js';
+import { levelTarget } from './levels.js';
+import { measurement } from './measurement.js';
+export const addFenceTool = {
+    name: 'add_fence',
+    title: 'Add fence',
+    description: "Add a fence along points on a level: one fence per side, a whole run or a lot's boundary (closed) in one call. Privacy (solid panels) by default; picket for a picket fence, slat for vertical slats, rail for open rails, horizontal for cladding boards, guard for a deck's barrier. Fences stand on the level, as the editor's fence tool puts them. Refused with a code: a side shorter than 10 cm (fence_too_short), a roof level (roof_level).",
+    input: {
+        points: z
+            .array(z.array(z.number()).length(2))
+            .min(2)
+            .max(64)
+            .describe('[x, z] points in level coordinates (metres), the fence running through them in order.'),
+        closed: z
+            .boolean()
+            .optional()
+            .describe("Close the run back to the first point, as a lot's boundary."),
+        height: measurement('length', 'm', {
+            positive: true,
+            description: 'Fence height (default 1.8 m).',
+        }).optional(),
+        style: FenceStyle.optional().describe('slat | rail | privacy | horizontal | guard | picket (default privacy).'),
+        baseStyle: FenceBaseStyle.optional().describe('grounded (default: a kickboard on the ground), floating (the panel held off the ground on its posts) or raised (a bottom rail held above the ground, the posts to the ground: a deck guard).'),
+        materialPreset: z
+            .string()
+            .optional()
+            .describe('A library material (library:<id>), found with search_materials.'),
+        ...levelTarget,
+    },
+};

package/dist/agent-tools/find-by-type.d.ts

@@ -1,11 +1,18 @@
 import { z } from 'zod';
+/** Results a call lists when it names no limit; past it they are counted, not listed. */
+export declare const FIND_BY_TYPE_LIMIT = 200;
 export declare const findByTypeTool: {
     name: string;
     title: string;
     description: string;
     input: {
-        type: z.ZodString;
+        type: z.ZodOptional<z.ZodString>;
         levelId: z.ZodOptional<z.ZodString>;
+        parentId: z.ZodOptional<z.ZodString>;
+        zoneId: z.ZodOptional<z.ZodString>;
+        sourceId: z.ZodOptional<z.ZodString>;
+        sourceIdPrefix: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
     };
 };
 //# sourceMappingURL=find-by-type.d.ts.map

package/dist/agent-tools/find-by-type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find-by-type.d.ts","sourceRoot":"","sources":["../../src/agent-tools/find-by-type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,cAAc;;;;;;;;CAY1B,CAAA"}
+{"version":3,"file":"find-by-type.d.ts","sourceRoot":"","sources":["../../src/agent-tools/find-by-type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,yFAAyF;AACzF,eAAO,MAAM,kBAAkB,MAAM,CAAA;AAErC,eAAO,MAAM,cAAc;IACzB,IAAI;IACJ,KAAK;IACL,WAAW;IACX,KAAK;QACH,IAAI;QAOJ,OAAO;QACP,QAAQ;QAGR,MAAM;QAGN,QAAQ;QAOR,cAAc;QAKd,KAAK;;CASR,CAAA"}

package/dist/agent-tools/find-by-type.js

@@ -1,14 +1,35 @@
 import { z } from 'zod';
 import { NodeId } from './node-id.js';
+/** Results a call lists when it names no limit; past it they are counted, not listed. */
+export const FIND_BY_TYPE_LIMIT = 200;
 export const findByTypeTool = {
     name: 'find_by_type',
     title: 'Find by type',
-    description: "Find everything of one type in the scene, wherever it lives: nodes of that kind (column, door, window, wall, stair…), items of that category, lights (any item that emits light), and typed parts inside scripted objects, windows and doors (a porch's columns, a window's grille). Parts are read-only: they come back with their object's id, the part id and, for objects directly on a level, its bounds in level coordinates; edit them through their object.",
+    description: `Find everything of one type in the scene, wherever it lives: nodes of that kind (column, door, window, wall, stair, imported-mesh, a plugin's kind…), items of that category, lights (any item that emits light), and typed parts inside scripted objects, windows and doors (a porch's columns, a window's grille). Narrow it to a level, a parent, a zone or an importer's source ids; without a type, every node the other filters match. A word that names nothing (no node kind, nor an item category or part type in this scene) is refused with the kinds the scene holds. Each result gives the node's id, name, kind, level and parent, with its metadata and provenance when it has them (one over 1 KB is named in omitted instead); get_node reads a node whole. Parts are read-only: they come back with their object's id, the part id and, for objects directly on a level, its bounds in level coordinates; edit them through their object. count says how many match; past limit (${FIND_BY_TYPE_LIMIT} unless asked) the rest are left out of results, with truncated: narrow the call or raise limit.`,
     input: {
         type: z
             .string()
             .min(1)
-            .describe('What to find, one word: light, column, door, window, beam, panel, railing, trim…'),
+            .optional()
+            .describe('What to find, one word: a node kind (wall, slab, imported-mesh, fixture:bench), an item category, light, or a part type (column, beam, panel, railing, trim…). Omit it to find every node the other filters match.'),
         levelId: NodeId.optional().describe('Only this level. Default: every level.'),
+        parentId: NodeId.optional().describe("Only the nodes directly under this one: a wall's doors and windows, a roof's segments, a level's walls."),
+        zoneId: NodeId.optional().describe("Only what stands in this zone: on the zone's level, its plan point inside the zone's outline and outside its holes (a wall's midpoint, a polygon's centroid, a door or window where its wall puts it, a block or mesh by the middle of its geometry, a part with bounds by their middle)."),
+        sourceId: z
+            .string()
+            .min(1)
+            .optional()
+            .describe('Only the nodes an importer recorded under this source id (provenance.refs[].id, or legacy metadata.sourceIds), exactly. Characters outside printable ASCII also match their percent-encoded form.'),
+        sourceIdPrefix: z
+            .string()
+            .min(1)
+            .optional()
+            .describe('Only the nodes with a source id starting with this.'),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe(`How many results to list at most. Default ${FIND_BY_TYPE_LIMIT}; count still says how many match.`),
     },
 };

package/dist/agent-tools/furnish-room.d.ts

@@ -1,26 +1,28 @@
 import { z } from 'zod';
-export declare const FURNISHED_ROOM_TYPES: readonly ["bedroom", "kitchen", "bathroom", "living", "dining", "hallway", "entry", "laundry", "storage"];
+export declare const FURNISHED_ROOM_TYPES: readonly ['bedroom', 'kitchen', 'bathroom', 'living', 'dining', 'hallway', 'entry', 'laundry', 'storage'];
+/** The fixed set of each room type, as agent-operations/furnish-room.ts lays it out (a test holds them together). */
+export declare const FURNISH_ROOM_SETS = "bedroom: double-bed (a side of 3.2 m or more) or single-bed, two bedside-table, dresser (10 m\u00B2 or more), closet (13 m\u00B2 or more); kitchen: kitchen (back wall of 2.6 m or more) or kitchen-counter, stove (back wall of 3.5 m or more), fridge; bathroom: toilet, bathroom-sink, bathtub (6.5 m\u00B2 or more) or shower-square; living: sofa, coffee-table, livingroom-chair, tv-stand; dining: dining-table, two dining-chair (four when both sides are 3 m or more); laundry: washing-machine, drying-rack; entry and hallway: coat-rack (both sides 1.4 m or more); storage: closet.";
 export declare const furnishRoomTool: {
     name: string;
     title: string;
     description: string;
     input: {
+        levelId: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodString>;
+        zoneId: z.ZodOptional<z.ZodString>;
         polygon: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNumber>>>;
         roomType: z.ZodEnum<{
-            entry: "entry";
-            bedroom: "bedroom";
-            kitchen: "kitchen";
             bathroom: "bathroom";
-            living: "living";
+            bedroom: "bedroom";
             dining: "dining";
+            entry: "entry";
             hallway: "hallway";
+            kitchen: "kitchen";
             laundry: "laundry";
+            living: "living";
             storage: "storage";
         }>;
         doorWallIndex: z.ZodOptional<z.ZodNumber>;
-        levelId: z.ZodOptional<z.ZodString>;
-        level: z.ZodOptional<z.ZodString>;
-        zoneId: z.ZodOptional<z.ZodString>;
     };
 };
 //# sourceMappingURL=furnish-room.d.ts.map

package/dist/agent-tools/furnish-room.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"furnish-room.d.ts","sourceRoot":"","sources":["../../src/agent-tools/furnish-room.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,oBAAoB,2GAUvB,CAAA;AAEV,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;CAyB3B,CAAA"}
+{"version":3,"file":"furnish-room.d.ts","sourceRoot":"","sources":["../../src/agent-tools/furnish-room.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,oBAAoB,YAC/B,SAAS,EACT,SAAS,EACT,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,OAAO,EACP,SAAS,EACT,SAAS,CACD,CAAA;AAEV,qHAAqH;AACrH,eAAO,MAAM,iBAAiB,skBACwhB,CAAA;AAEtjB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;CAwB3B,CAAA"}

package/dist/agent-tools/furnish-room.js

@@ -12,10 +12,12 @@ export const FURNISHED_ROOM_TYPES = [
     'laundry',
     'storage',
 ];
+/** The fixed set of each room type, as agent-operations/furnish-room.ts lays it out (a test holds them together). */
+export const FURNISH_ROOM_SETS = 'bedroom: double-bed (a side of 3.2 m or more) or single-bed, two bedside-table, dresser (10 m² or more), closet (13 m² or more); kitchen: kitchen (back wall of 2.6 m or more) or kitchen-counter, stove (back wall of 3.5 m or more), fridge; bathroom: toilet, bathroom-sink, bathtub (6.5 m² or more) or shower-square; living: sofa, coffee-table, livingroom-chair, tv-stand; dining: dining-table, two dining-chair (four when both sides are 3 m or more); laundry: washing-machine, drying-rack; entry and hallway: coat-rack (both sides 1.4 m or more); storage: closet.';
 export const furnishRoomTool = {
     name: 'furnish_room',
     title: 'Furnish room',
-    description: "Furnish a room for its type from the host's item catalog: the bed, sofa, counters or toilet against the wall facing the door, the rest along a side wall, each set off its wall by its own depth. Name the room by zoneId (its level and outline come with it), or give its polygon and level. The door wall is the edge a door of the room stands on, else doorWallIndex, else edge 0. Nothing lands in a door's clear zone or on another item: a piece that does not fit is nudged, else skipped, and skipped says why. Items stand on the room's level.",
+    description: `Place the catalog's fixed furniture set for a room type: one set per type, not matched to a style. The bed, sofa, counters or toilet go against the wall facing the door, the rest along a side wall, each set off its wall by its own depth. Name the room by zoneId (its level and outline come with it), or give its polygon and level. The door wall is the edge a door of the room stands on, else doorWallIndex, else edge 0. Nothing lands in a door's clear zone or on another item: a piece that does not fit is nudged, else skipped, and skipped says why. Items stand on the room's level. The set per room type: ${FURNISH_ROOM_SETS} The result lists each piece placed with its size and id, and each piece skipped with its reason. view_scene with interior { zoneId } shows the room from inside, at a person's height.`,
     input: {
         zoneId: NodeId.optional().describe('The room: zoneId from create_room, or an id from get_zones.'),
         ...levelTarget,