kalup 0.3.0 → 0.4.0

package/dist/{commands-T4j_GVBD.mjs → commands-CHucC_PV.mjs}

@@ -234,6 +234,20 @@ var ir_1_schema_default = {
 						"properties": { "type": { "const": "object" } }
 					},
 					"then": { "properties": { "definition": { "$ref": "#/$defs/objectDefinition" } } }
+				},
+				{
+					"if": {
+						"required": ["type"],
+						"properties": { "type": { "const": "pipeline" } }
+					},
+					"then": { "properties": { "definition": { "$ref": "#/$defs/pipelineDefinition" } } }
+				},
+				{
+					"if": {
+						"required": ["type"],
+						"properties": { "type": { "const": "stage" } }
+					},
+					"then": { "properties": { "definition": { "$ref": "#/$defs/stageDefinition" } } }
 				}
 			]
 		},
@@ -357,6 +371,43 @@ var ir_1_schema_default = {
 			},
 			"additionalProperties": false
 		},
+		"pipelineDefinition": {
+			"description": "A pipeline. Its stages are resources of their own; stages lists their IDs in display order.",
+			"type": "object",
+			"required": [
+				"label",
+				"displayOrder",
+				"stages"
+			],
+			"properties": {
+				"label": { "type": "string" },
+				"displayOrder": {
+					"type": "integer",
+					"minimum": 0
+				},
+				"stages": {
+					"type": "array",
+					"items": { "type": "string" }
+				}
+			},
+			"additionalProperties": false
+		},
+		"stageDefinition": {
+			"description": "A pipeline stage. Its metadata field depends on the object: probability on deals, ticketState on tickets, state on custom objects.",
+			"type": "object",
+			"required": ["label"],
+			"properties": {
+				"label": { "type": "string" },
+				"probability": {
+					"type": "number",
+					"minimum": 0,
+					"maximum": 1
+				},
+				"ticketState": { "enum": ["OPEN", "CLOSED"] },
+				"state": { "enum": ["OPEN", "CLOSED"] }
+			},
+			"additionalProperties": false
+		},
 		"binding": {
 			"description": "App terms, filled in by the loader. key and codec for properties, export for objects.",
 			"type": "object",
@@ -541,6 +592,14 @@ var ir_1_schema_default = {
 						"object": {
 							"type": "array",
 							"items": { "type": "string" }
+						},
+						"pipeline": {
+							"type": "array",
+							"items": { "type": "string" }
+						},
+						"stage": {
+							"type": "array",
+							"items": { "type": "string" }
 						}
 					},
 					"additionalProperties": false
@@ -628,6 +687,16 @@ var ir_1_schema_default = {
 					"type": "object",
 					"patternProperties": { "^[a-z]+:\\S+$": { "type": "string" } },
 					"additionalProperties": false
+				},
+				"pipelines": {
+					"description": "Whether the object's pipelines list was read. Absent when its pipelines are not in scope.",
+					"type": "object",
+					"required": ["status"],
+					"properties": {
+						"status": { "enum": ["read", "unreadable"] },
+						"missingScope": { "type": "string" }
+					},
+					"additionalProperties": false
 				}
 			},
 			"additionalProperties": false
@@ -1261,6 +1330,44 @@ const RESERVED_PREFIX = /^(hs_|a\d+_)/;
 function reservedPrefix(name) {
 	return RESERVED_PREFIX.exec(name)?.[1];
 }
+/** Every stage metadata field Kalup manages, in the order the writer and the plan list them. */
+const STAGE_FIELDS = [
+	"probability",
+	"ticketState",
+	"state"
+];
+const FIELD_BY_OBJECT = {
+	deals: "probability",
+	tickets: "ticketState"
+};
+/**
+* The standard objects that have pipelines: the pipelines path answered for each on 2026-10-05 (leads with a 403 for a
+* missing scope). Every custom object may have them too.
+*/
+const PIPELINE_OBJECTS = /* @__PURE__ */ new Set([
+	"appointments",
+	"companies",
+	"contacts",
+	"courses",
+	"deals",
+	"leads",
+	"listings",
+	"orders",
+	"services",
+	"tickets"
+]);
+/** Whether an object can have pipelines: one of PIPELINE_OBJECTS, or a custom object. */
+function hasPipelines(object, custom) {
+	return custom || PIPELINE_OBJECTS.has(object);
+}
+/**
+* The metadata field of a stage of `object`, or undefined for an object whose pipelines Kalup reads and compares but
+* does not write: every standard object but deals and tickets. `custom` says whether the object is a custom object.
+*/
+function stageField(object, custom) {
+	if (custom) return "state";
+	return Object.hasOwn(FIELD_BY_OBJECT, object) ? FIELD_BY_OBJECT[object] : void 0;
+}
 const ADDRESS = /^[a-z]+:\S+$/;
 /** Whether `value` is an address: a lowercase type, a colon and a path without whitespace. */
 function isAddress(value) {
@@ -1314,6 +1421,124 @@ const PROPERTY_FIELDS = [
 	"externalOptions",
 	"referencedObjectType"
 ];
+/**
+* The objects whose properties the properties API lists by name. A config key outside this set names a custom object
+* schema. The set is the 2026-09 `crm.schemas.<object>.read` scope list plus the objects that carry their own scopes
+* (products, leads, goals, marketing events, feedback submissions, users).
+*/
+const STANDARD_OBJECTS = /* @__PURE__ */ new Set([
+	"appointments",
+	"calls",
+	"carts",
+	"commerce_payments",
+	"communications",
+	"companies",
+	"contacts",
+	"courses",
+	"deals",
+	"emails",
+	"feedback_submissions",
+	"goals",
+	"invoices",
+	"leads",
+	"line_items",
+	"listings",
+	"marketing_events",
+	"meetings",
+	"notes",
+	"orders",
+	"postal_mail",
+	"products",
+	"projects",
+	"quotes",
+	"services",
+	"subscriptions",
+	"tasks",
+	"tickets",
+	"users"
+]);
+/**
+* The object type ID of each standard object, by config key. Limits Tracking keys its per-object entries by these.
+* Source: "Object type ID values", retrieved 2026-09-24:
+* https://developers.hubspot.com/docs/api-reference/latest/crm/understanding-the-crm
+* A plain record: look a key up with `Object.hasOwn`, so `constructor` finds nothing.
+*/
+const STANDARD_OBJECT_TYPE_IDS = {
+	appointments: "0-421",
+	calls: "0-48",
+	carts: "0-142",
+	commerce_payments: "0-101",
+	communications: "0-18",
+	companies: "0-2",
+	contacts: "0-1",
+	courses: "0-410",
+	deals: "0-3",
+	emails: "0-49",
+	feedback_submissions: "0-19",
+	goals: "0-74",
+	invoices: "0-53",
+	leads: "0-136",
+	line_items: "0-8",
+	listings: "0-420",
+	marketing_events: "0-54",
+	meetings: "0-47",
+	notes: "0-46",
+	orders: "0-123",
+	postal_mail: "0-116",
+	products: "0-7",
+	projects: "0-970",
+	quotes: "0-14",
+	services: "0-162",
+	subscriptions: "0-69",
+	tasks: "0-27",
+	tickets: "0-5",
+	users: "0-115"
+};
+/** One object's pull scope from its settings under `objects` and the property names its object file defines. */
+function scopeOf(scope = {}, defined = []) {
+	return {
+		custom: scope.custom ?? true,
+		defined: new Set(defined),
+		exclude: excluder(scope.exclude),
+		include: new Set(scope.include ?? [])
+	};
+}
+/** The names of the properties the object files define on `object`, references included. */
+function definedOn(ir, object) {
+	const prefix = `property:${object}/`;
+	return Object.keys(ir.resources).filter((address) => address.startsWith(prefix)).map((address) => address.slice(prefix.length));
+}
+/**
+* A portal property is in scope when the object files define it or `include` names it, whatever `custom` and
+* `exclude` say, or when it is custom, `custom` is on and `exclude` does not name it. validate refuses a name both
+* `include` and `exclude` hold.
+*/
+function inScope(scope, property) {
+	const { name } = property;
+	return scope.defined.has(name) || scope.include.has(name) || scope.custom && !property.hubspotDefined && !scope.exclude(name);
+}
+/** The `exclude` patterns of one object as a predicate over internal names. */
+function excluder(patterns = []) {
+	const matchers = patterns.map(addressMatcher);
+	return (name) => matchers.some((matches) => matches(name));
+}
+/**
+* Whether an object's pipelines are in scope: `pipelines: true` under `objects`, or a pipeline or stage of it in the
+* files or in removed.ts. Unlike `custom`, which filters what pull writes while the properties are read anyway, a
+* pipelines list nobody asked for is never read: an upgrade must not widen what a project manages without a line in
+* config saying so.
+*/
+function pipelinesInScope(scope, ir, object) {
+	const ours = (address) => address.startsWith(`pipeline:${object}/`) || address.startsWith(`stage:${object}/`);
+	return scope?.pipelines === true || Object.keys(ir.resources).some(ours) || Object.keys(ir.tombstones).some(ours);
+}
+/** The --only glob as a predicate over addresses. `*` matches any run of characters, `/` included. */
+function addressMatcher(glob) {
+	if (glob === void 0) return () => true;
+	const literals = glob.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+	const pattern = new RegExp(`^${literals.join(".*")}$`);
+	return (address) => pattern.test(address);
+}
 const punct = "{}[]()<>,:;.=&|?!+-*/%~^@#";
 const escapes = {
 	n: "\n",
@@ -1542,8 +1767,8 @@ const CHAIN_FLAGS = [
 const toolOwned = ["@kalup/core", "kalup"];
 const typeLineFix = "write `export type <Name>Data = InferProperties<typeof <Name>.properties> & { id: string }`";
 /**
-* Parses one object file, kalup.config.ts or removed.ts into plain data. Throws IssueError on anything outside
-* the grammar. `kind` is the kind the file must be, when its path decides it; otherwise the content does.
+* Parses one object file, pipeline file, kalup.config.ts or removed.ts into plain data. Throws IssueError on anything
+* outside the grammar. `kind` is the kind the file must be, when its path decides it; otherwise the content does.
 */
 function read(text, file, kind) {
 	const src = (text.charCodeAt(0) === 65279 ? text.slice(1) : text).replace(/\r\n?/g, "\n");
@@ -1574,6 +1799,14 @@ function read(text, file, kind) {
 		},
 		lines: s.lines
 	};
+	if (found === "pipeline") return {
+		kind: "pipeline",
+		data: {
+			...top,
+			...parsePipelineFile(s, imports)
+		},
+		lines: s.lines
+	};
 	return {
 		kind: "object",
 		data: {
@@ -1586,7 +1819,7 @@ function read(text, file, kind) {
 function kindAt(s) {
 	let j = s.i;
 	while (at(s, j).kind === "comment") j += 1;
-	if (!(is(at(s, j), "ident", "export") && is(at(s, j + 1), "ident", "default"))) return "object";
+	if (!(is(at(s, j), "ident", "export") && is(at(s, j + 1), "ident", "default"))) return is(at(s, j + 1), "ident", "const") && is(at(s, j + 4), "ident", "definePipeline") ? "pipeline" : "object";
 	return is(at(s, j + 2), "ident", "defineRemoved") ? "removed" : "config";
 }
 function at(s, i) {
@@ -1795,6 +2028,10 @@ const SETTINGS = {
 		levels: ["object"],
 		example: "'Firm'"
 	},
+	pipelines: {
+		levels: ["object"],
+		example: "true"
+	},
 	protected: {
 		levels: ["target"],
 		example: "true"
@@ -1915,10 +2152,19 @@ const definitionFields = {
 	lifecycle: lifecycle$1
 };
 const definition = shape(definitionFields, [], misplaced("a property definition"));
-const overrideDefinition = shape(definitionFields, [], (key) => ({
+const stageState = oneOf("OPEN", "CLOSED");
+const stageFields$1 = {
+	probability: num,
+	ticketState: stageState,
+	state: stageState
+};
+const overrideDefinition = shape({
+	...definitionFields,
+	...stageFields$1
+}, [], (key) => ({
 	code: "E_OVERRIDE_DEFINITION",
 	message: key === "type" ? "'type' comes from the builder, so it cannot differ per target" : `unknown field '${key}' in a definition override`,
-	fix: "override only label, description, group, fieldType, formField, options, hidden, displayOrder, the display hints, calculationFormula or lifecycle"
+	fix: "override only label, description, group, fieldType, formField, options, hidden, displayOrder, the display hints, calculationFormula or lifecycle, or a stage metadata field"
 }));
 const customFields = {
 	labels: shape({
@@ -1956,7 +2202,8 @@ const config = shape({
 		include: list$1(str),
 		exclude: list$1(str),
 		custom: bool,
-		as: str
+		as: str,
+		pipelines: bool
 	}, [], misplaced())),
 	targets: map(shape({
 		portalId: num,
@@ -2127,6 +2374,75 @@ function parseTypeLine(s, exports, typed) {
 	if (typed.has(ref.value)) fail$1(s, "E_NOT_DATA", nameTok, `'${nameTok.value}' is exported twice`, "remove the duplicate type export");
 	typed.add(ref.value);
 }
+const PIPELINE_FIX = "only imports and `export const <Name> = definePipeline('<object>', {...})` are allowed here";
+const stage = shape({
+	id: str,
+	label: str,
+	...stageFields$1
+}, ["id", "label"]);
+function parsePipelineFile(s, imports) {
+	const exports = [];
+	for (;;) {
+		const cs = takeComments(s);
+		if (at(s, s.i).kind === "eof") {
+			if (!exports.length) fail$1(s, "E_MISSING_EXPORT", at(s, 0), "no definePipeline export in this file", "add `export const <Name> = definePipeline('<object>', {...})`");
+			if (cs[0]) failComment(s, cs[0]);
+			return {
+				imports,
+				exports
+			};
+		}
+		expect(s, "ident", "export", PIPELINE_FIX);
+		expect(s, "ident", "const", PIPELINE_FIX);
+		exports.push(parsePipeline(s, cs, exports));
+	}
+}
+function parsePipeline(s, cs, exports) {
+	const nameTok = next(s);
+	if (nameTok.kind !== "ident") fail$1(s, "E_NOT_DATA", nameTok, `expected an export name but found ${show$3(nameTok)}`, "write export const <Name> = definePipeline(...)");
+	const name = nameTok.value;
+	if (exports.some((x) => x.name === name)) fail$1(s, "E_DUPLICATE_KEY", nameTok, `duplicate export '${name}'`, "rename one of the two exports", name);
+	expect(s, "punct", "=", "write export const <Name> = definePipeline(...)", name);
+	const b = next(s);
+	if (!is(b, "ident", "definePipeline")) fail$1(s, "E_NOT_DATA", b, `'${b.value}' is not definePipeline`, "write definePipeline('<object>', {...})", name);
+	expect(s, "punct", "(", void 0, name);
+	const object = str(s, name);
+	expect(s, "punct", ",", "add the pipeline literal as the second argument", name);
+	s.lines[name] = nameTok.line;
+	const fields = {};
+	const open = peek(s);
+	entries(s, name, false, (key, tok) => {
+		const path = join$2(name, key);
+		if (key === "id" || key === "label") fields[key] = str(s, path);
+		else if (key === "displayOrder") fields.displayOrder = num(s, path);
+		else if (key === "stages") {
+			const stages = [];
+			entries(s, path, true, (k, _t, scs) => {
+				stages.push({
+					key: k,
+					...stage(s, join$2(path, k)),
+					comments: texts(scs)
+				});
+			});
+			fields.stages = stages;
+		} else fail$1(s, "E_NOT_DATA", tok, `unknown field '${key}'`, "use one of id, label, displayOrder, stages", name);
+	});
+	for (const k of [
+		"id",
+		"label",
+		"displayOrder",
+		"stages"
+	]) if (fields[k] === void 0) fail$1(s, "E_NOT_DATA", open, `missing field '${k}'`, `add ${k}`, name);
+	skip(s, ",");
+	expect(s, "punct", ")", void 0, name);
+	skip(s, ";");
+	return {
+		...fields,
+		name,
+		object,
+		comments: texts(cs)
+	};
+}
 function parseConfig(s, imports) {
 	const fix = "write export default defineConfig({...})";
 	expect(s, "ident", "export", fix);
@@ -2209,6 +2525,10 @@ function inDir(at, file) {
 function objectPath(at, object) {
 	return `${at.dir}/objects/${object}.ts`;
 }
+/** The file pull writes an object's new pipelines into: `<dir>/pipelines/<object>.ts`. */
+function pipelinePath(at, object) {
+	return `${at.dir}/pipelines/${object}.ts`;
+}
 /** An object file's path from the barrel, without the extension, such as `./objects/companies`. */
 function barrelPath(at, file) {
 	return `./${file.slice(at.dir.length + 1, -3)}`;
@@ -2218,8 +2538,9 @@ const TRAILING_SEPARATORS = /[\\/]+$/;
 const SEPARATOR = /[\\/]/;
 /**
 * Builds the IR from a map of relative path to text. Reads kalup.config.ts, then in the folder of object files
-* (<dir>/) removed.ts, every <dir>/** /*.ts except index.ts, and blueprints.lock.json, whose provenance it merges into
-* the resources the lock lists. Throws an IssueError, with every issue found, when the files cannot yield one IR.
+* (<dir>/) removed.ts, every <dir>/** /*.ts except index.ts (those under <dir>/pipelines/ as pipeline files), and
+* blueprints.lock.json, whose provenance it merges into the resources the lock lists. Throws an IssueError, with every
+* issue found, when the files cannot yield one IR.
 */
 function loadFiles(files, options = {}) {
 	const issues = [];
@@ -2342,19 +2663,22 @@ function readObjectFiles(files, at, issues) {
 	const out = [];
 	for (const file of Object.keys(files).sort()) {
 		if (!inDir(at, file) || file === at.barrel || file === at.removed) continue;
-		const later = notReadYet(at, file);
-		if (later) {
-			issues.push(unsupported$1(at, file, `this version does not read ${later} yet`));
-			continue;
-		}
+		const pipelines = inPipelines(at, file);
 		try {
-			const result = read(files[file] ?? "", file);
-			if (result.kind === "object") out.push({
-				file,
-				data: result.data,
-				lines: result.lines
-			});
-			else if (result.kind === "config") issues.push(unsupported$1(at, file, `a defineConfig file under ${at.dir}/ is not an object file`));
+			const result = read(files[file] ?? "", file, pipelines ? "pipeline" : void 0);
+			if (result.kind === "object" || result.kind === "pipeline") {
+				if (result.kind === "pipeline" && !pipelines) {
+					const fix = `move it to ${at.dir}/pipelines/`;
+					issues.push(unsupported$1(at, file, `a definePipeline file belongs under ${at.dir}/pipelines/`, fix));
+					continue;
+				}
+				out.push({
+					file,
+					kind: result.kind,
+					data: result.data,
+					lines: result.lines
+				});
+			} else if (result.kind === "config") issues.push(unsupported$1(at, file, `a defineConfig file under ${at.dir}/ is not an object file`));
 			else {
 				const fix = `move its entries to ${at.removed}`;
 				issues.push(unsupported$1(at, file, `a defineRemoved file belongs at ${at.removed}`, fix));
@@ -2366,9 +2690,9 @@ function readObjectFiles(files, at, issues) {
 	}
 	return out;
 }
-/** What a file in the folder of object files holds that this version does not read yet. */
-function notReadYet(at, file) {
-	return file.startsWith(`${at.dir}/pipelines/`) ? "pipelines" : void 0;
+/** Whether a file lies in the pipelines folder, `<dir>/pipelines/`, which holds definePipeline files only. */
+function inPipelines(at, file) {
+	return file.startsWith(`${at.dir}/pipelines/`);
 }
 function unsupported$1(at, file, message, fix = `move ${file} out of ${at.dir}/ until a release reads it`) {
 	return {
@@ -2397,26 +2721,36 @@ function flatten(objectFiles, issues) {
 		resources[address] = resource;
 		sources[address] = source;
 	};
-	for (const { file, data, lines } of objectFiles) for (const e of data.exports) {
-		const at = (configPath) => ({
-			file,
-			line: lines[configPath] ?? 1,
-			configPath
-		});
-		if (e.builder === "defineCustomObject") {
-			const resource = objectResource$1(e, at(e.name), issues);
-			if (resource) add(`object:${e.object}`, resource, at(e.name));
+	for (const { file, kind, data, lines } of objectFiles) {
+		if (kind === "pipeline") {
+			for (const e of data.exports) flattenPipeline(e, (configPath) => ({
+				file,
+				line: lines[configPath] ?? 1,
+				configPath
+			}), add, issues);
+			continue;
 		}
-		for (const group of e.groups) {
-			const resource = {
-				type: "group",
-				managed: true,
-				definition: { label: group.label }
-			};
-			add(`group:${e.object}/${group.name}`, resource, at(`${e.name}.groups.${group.name}`));
+		for (const e of data.exports) {
+			const at = (configPath) => ({
+				file,
+				line: lines[configPath] ?? 1,
+				configPath
+			});
+			if (e.builder === "defineCustomObject") {
+				const resource = objectResource$1(e, at(e.name), issues);
+				if (resource) add(`object:${e.object}`, resource, at(e.name));
+			}
+			for (const group of e.groups) {
+				const resource = {
+					type: "group",
+					managed: true,
+					definition: { label: group.label }
+				};
+				add(`group:${e.object}/${group.name}`, resource, at(`${e.name}.groups.${group.name}`));
+			}
+			flattenProperties(e, at, add, issues);
+			optionsStated.push(...statedOptions(e, (address) => sources[address]?.file === file));
 		}
-		flattenProperties(e, at, add, issues);
-		optionsStated.push(...statedOptions(e, (address) => sources[address]?.file === file));
 	}
 	return {
 		resources,
@@ -2424,6 +2758,51 @@ function flatten(objectFiles, issues) {
 		optionsStated: [...new Set(optionsStated)]
 	};
 }
+/** The address of a pipeline, and of one of its stages. */
+function pipelineAddress(object, id) {
+	return `pipeline:${object}/${id}`;
+}
+function stageAddress(object, pipeline, stage) {
+	return `stage:${object}/${pipeline}/${stage}`;
+}
+function flattenPipeline(e, at, add, issues) {
+	const unaddressable = (id, source) => {
+		const held = isAddress(pipelineAddress(e.object, id)) && !id.includes("/") && !e.object.includes("/");
+		if (!held) issues.push({
+			code: "E_PIPELINE_ID",
+			message: `the ID '${id}' holds whitespace or a slash, so no address can hold it`,
+			...source,
+			fix: "use an ID without whitespace or slashes"
+		});
+		return !held;
+	};
+	if (unaddressable(e.id, at(`${e.name}.id`))) return;
+	add(pipelineAddress(e.object, e.id), {
+		type: "pipeline",
+		managed: true,
+		definition: {
+			label: e.label,
+			displayOrder: e.displayOrder,
+			stages: e.stages.map((s) => s.id)
+		},
+		binding: { export: e.name }
+	}, at(e.name));
+	for (const st of e.stages) {
+		const stage = stageAddress(e.object, e.id, st.id);
+		if (unaddressable(st.id, at(`${e.name}.stages.${st.key}.id`))) continue;
+		add(stage, {
+			type: "stage",
+			managed: true,
+			definition: compact$5({
+				label: st.label,
+				probability: st.probability,
+				ticketState: st.ticketState,
+				state: st.state
+			}),
+			binding: { key: st.key }
+		}, at(`${e.name}.stages.${st.key}`));
+	}
+}
 function statedOptions(e, mine) {
 	return e.properties.filter((p) => p.definition?.lifecycle?.options !== void 0).map((p) => `property:${e.object}/${p.name}`).filter(mine);
 }
@@ -2599,7 +2978,10 @@ function byCodeUnit(a, b) {
 function basename$1(root) {
 	return root.replace(TRAILING_SEPARATORS, "").split(SEPARATOR).pop() ?? "";
 }
-/** The definition fields a target may override, by resource type. */
+/**
+* The definition fields a target may override, by resource type. A stage takes the metadata field of its pipeline's
+* object only, which validate checks.
+*/
 const OVERRIDABLE = {
 	property: [
 		"label",
@@ -2616,7 +2998,14 @@ const OVERRIDABLE = {
 		"textDisplayHint",
 		"calculationFormula"
 	],
-	group: ["label"]
+	group: ["label"],
+	pipeline: ["label", "displayOrder"],
+	stage: [
+		"label",
+		"probability",
+		"ticketState",
+		"state"
+	]
 };
 /** The lifecycle fields a target may override on a property, each on its own. */
 const OVERRIDABLE_LIFECYCLE = [
@@ -2646,10 +3035,18 @@ function effectiveResources(ir, target) {
 */
 function withDefinition(address, resource, override) {
 	const { type, path } = parseAddress(address);
-	if (!(resource.managed && (type === "property" || type === "group"))) return resource;
-	const stated = pick$3(override, OVERRIDABLE[type]);
-	const object = path.slice(0, path.indexOf("/"));
-	const merged = {
+	if (!(resource.managed && Object.hasOwn(OVERRIDABLE, type))) return resource;
+	const fields = OVERRIDABLE[type];
+	const stated = pick$3(override, fields);
+	if (type === "pipeline" || type === "stage") return {
+		...resource,
+		definition: {
+			...resource.definition,
+			...stated
+		}
+	};
+	const object = path.slice(0, path.indexOf("/"));
+	const merged = {
 		...resource.definition,
 		...definitionToIR(object, resource.binding?.codec ?? "string", stated)
 	};
@@ -2673,10 +3070,26 @@ function own$5(record, key) {
 	return Object.hasOwn(record, key) ? record[key] : void 0;
 }
 const CONFIG$2$1 = "kalup.config.ts";
-/** The resource types a tombstone may name in this version. */
-const REMOVABLE$1 = ["property", "group"];
-/** The path of a property or group address: its object and its name. */
-const ON_OBJECT$1 = /^[^\s/]+\/[^\s/]+$/;
+/** The resource types a tombstone may name in this version, and the shape of each one's path. */
+/** The address types a tombstone may name, each with its form and the shape of its path. */
+const REMOVABLE = {
+	property: {
+		form: "property:<object>/<name>",
+		path: /^[^\s/]+\/[^\s/]+$/
+	},
+	group: {
+		form: "group:<object>/<name>",
+		path: /^[^\s/]+\/[^\s/]+$/
+	},
+	pipeline: {
+		form: "pipeline:<object>/<id>",
+		path: /^[^\s/]+\/[^\s/]+$/
+	},
+	stage: {
+		form: "stage:<object>/<pipeline>/<stage>",
+		path: /^[^\s/]+\/[^\s/]+\/[^\s/]+$/
+	}
+};
 /** The definition fields a property can own, the names `lifecycle.ignoreChanges` may use. */
 const DEFINITION_FIELDS = PROPERTY_FIELDS.filter((field) => field !== "type" && field !== "externalOptions" && field !== "referencedObjectType");
 function validate$2(loaded, options = {}) {
@@ -2714,12 +3127,163 @@ function validate$2(loaded, options = {}) {
 		warnings
 	});
 	checkTombstones(loaded, issues);
+	checkPipelines(loaded, issues);
 	return {
 		issues,
 		warnings
 	};
 }
 /**
+* The rules HubSpot keeps for pipelines and stages, observed 2026-10-01 and 2026-10-05: IDs of a length it stores and
+* not held elsewhere (a pipeline ID across the portal, a stage ID across one object's pipelines), at least one stage
+* and on tickets one closed one, labels unique ignoring case (a stage's also ignoring spaces around it), and each
+* stage's metadata field the one its object takes.
+*/
+function checkPipelines(loaded, issues) {
+	const { ir, sources } = loaded;
+	const at = (address, suffix = "") => {
+		const source = sources[address] ?? {
+			file: "",
+			line: 0,
+			configPath: address
+		};
+		return {
+			file: source.file,
+			line: source.line,
+			configPath: source.configPath + suffix
+		};
+	};
+	const pipelineIds = /* @__PURE__ */ new Map();
+	const pipelineLabels = /* @__PURE__ */ new Map();
+	const stageIds = /* @__PURE__ */ new Map();
+	for (const [address, resource] of Object.entries(ir.resources)) {
+		if (resource.type !== "pipeline") continue;
+		const [object = "", id = ""] = parseAddress(address).path.split("/");
+		const d = resource.definition ?? {};
+		if (!hasPipelines(object, !STANDARD_OBJECTS.has(object))) issues.push({
+			code: "E_PIPELINE_FIELD",
+			message: `${address} is a pipeline of ${object}, which has no pipelines`,
+			...at(address),
+			fix: "name an object that has pipelines, such as deals, tickets or a custom object"
+		});
+		const first = pipelineIds.get(id);
+		if (first === void 0) pipelineIds.set(id, address);
+		else issues.push({
+			code: "E_PIPELINE_ID",
+			message: `${address} has the ID of ${first}, and HubSpot keeps pipeline IDs unique across objects`,
+			...at(address, ".id"),
+			fix: "give one of the two another ID"
+		});
+		if (id.length > 36) issues.push(tooLong(address, 36, at(address, ".id")));
+		const label = String(d.label).toLowerCase();
+		const same = pipelineLabels.get(`${object}/${label}`);
+		if (same === void 0) pipelineLabels.set(`${object}/${label}`, address);
+		else issues.push({
+			code: "E_DUPLICATE_LABEL",
+			message: `${same} and ${address} share the label '${d.label}', ignoring case`,
+			...at(address, ".label"),
+			fix: "give one of the two another label"
+		});
+		const order = d.displayOrder;
+		if (!(Number.isInteger(order) && order >= 0)) issues.push({
+			code: "E_PIPELINE_FIELD",
+			message: `displayOrder ${order} of ${address} is not an integer from 0 up`,
+			...at(address, ".displayOrder"),
+			fix: "use 0 or more: HubSpot lists pipelines lowest first"
+		});
+		checkStages(ir, address, object, stageIds, at, issues);
+	}
+}
+function checkStages(ir, pipeline, object, stageIds, at, issues) {
+	const ids = (ir.resources[pipeline]?.definition?.stages ?? []).filter((id) => Object.hasOwn(ir.resources, `stage:${pipeline.slice(9)}/${id}`));
+	if (ids.length === 0) issues.push({
+		code: "E_PIPELINE_STAGES",
+		message: `${pipeline} has no stage, and HubSpot needs one`,
+		...at(pipeline, ".stages"),
+		fix: "add a stage, or run kalup rm on the pipeline"
+	});
+	const field = stageField(object, !STANDARD_OBJECTS.has(object));
+	const labels = /* @__PURE__ */ new Map();
+	let closed = false;
+	for (const id of ids) {
+		const address = `stage:${pipeline.slice(9)}/${id}`;
+		const d = ir.resources[address]?.definition ?? {};
+		const first = stageIds.get(`${object}/${id}`);
+		if (first === void 0) stageIds.set(`${object}/${id}`, address);
+		else issues.push({
+			code: "E_PIPELINE_ID",
+			message: `${address} has the ID of ${first}, and HubSpot keeps stage IDs unique across an object's pipelines`,
+			...at(address, ".id"),
+			fix: "give one of the two another ID, such as the pipeline ID followed by the stage"
+		});
+		if (id.length > 100) issues.push(tooLong(address, 100, at(address, ".id")));
+		const label = String(d.label).trim().toLowerCase();
+		const same = labels.get(label);
+		if (same === void 0) labels.set(label, address);
+		else issues.push({
+			code: "E_DUPLICATE_LABEL",
+			message: `stages ${same} and ${address} share the label '${label}', ignoring case and spaces around it`,
+			...at(address, ".label"),
+			fix: "give one of the two another label"
+		});
+		closed ||= d.ticketState === "CLOSED";
+		for (const rule of stageRules(object, field, d)) issues.push({
+			code: "E_PIPELINE_FIELD",
+			message: rule.message,
+			...at(address, rule.field),
+			fix: rule.fix
+		});
+	}
+	if (field === "ticketState" && ids.length > 0 && !closed) issues.push({
+		code: "E_PIPELINE_STAGES",
+		message: `${pipeline} has no stage with ticketState 'CLOSED', and HubSpot needs one`,
+		...at(pipeline, ".stages"),
+		fix: "mark the stage tickets end in ticketState: 'CLOSED'"
+	});
+}
+const FIELD_OBJECTS = {
+	probability: "deal stages",
+	ticketState: "ticket stages",
+	state: "custom object stages"
+};
+/**
+* What is wrong with one stage's metadata, as config or an override states it: a field its object does not take, a deal
+* stage without a probability (unless `override`, which states only what differs), a probability outside 0..1. Each
+* entry's `field` is the suffix it points at.
+*/
+function stageRules(object, field, d, override = false) {
+	const out = [];
+	for (const name of STAGE_FIELDS) {
+		if (d[name] === void 0 || name === field) continue;
+		const takes = field === void 0 ? `a stage of ${object} takes none: Kalup reads and compares its pipelines and does not write them` : `a stage of ${object} takes ${field}`;
+		out.push({
+			field: `.${name}`,
+			message: `${name} is for ${FIELD_OBJECTS[name]}; ${takes}`,
+			fix: field === void 0 ? `remove ${name}` : `replace ${name} with ${field}`
+		});
+	}
+	const p = d.probability;
+	if (field === "probability" && p === void 0 && !override) out.push({
+		field: "",
+		message: "a deal stage needs a probability, and HubSpot refuses one without",
+		fix: "add probability, from 0 to 1: 0 and 1 make the stage closed"
+	});
+	else if (field === "probability" && p !== void 0 && !(typeof p === "number" && p >= 0 && p <= 1)) out.push({
+		field: ".probability",
+		message: `probability ${p} is not from 0 to 1`,
+		fix: "use a number from 0 to 1"
+	});
+	return out;
+}
+function tooLong(address, max, at) {
+	return {
+		code: "E_PIPELINE_ID",
+		message: `the ID of ${address} is longer than ${max} characters, which HubSpot answers with an error and does not store`,
+		...at,
+		fix: `use an ID of at most ${max} characters`
+	};
+}
+/**
 * The settings under objects and targets.<t>.objects: a name include and exclude both list, a target object objects
 * does not declare, and a target mode that overrides an object's mode the target says nothing more about.
 */
@@ -2753,6 +3317,12 @@ function checkScopes(loaded, { issues, warnings }) {
 }
 function checkExcludes(config, at, issues) {
 	for (const [object, scope] of Object.entries(config.objects)) {
+		if (scope.pipelines === true && !hasPipelines(object, !STANDARD_OBJECTS.has(object))) issues.push({
+			code: "E_SETTING_VALUE",
+			message: `objects.${object}.pipelines is true, and ${object} has no pipelines`,
+			...at(`objects.${object}.pipelines`),
+			fix: `remove pipelines from objects.${object}`
+		});
 		const both = (scope.include ?? []).filter((name) => (scope.exclude ?? []).includes(name));
 		if (both.length > 0) issues.push({
 			code: "E_SETTING_VALUE",
@@ -2884,6 +3454,7 @@ function checkTargets(loaded, requested, { issues, warnings }) {
 			issues,
 			warnings
 		});
+		checkTargetPipelines(loaded, name, overrides, at, issues);
 	}
 	const declared = Object.keys(config.targets);
 	if (config.defaultTarget !== void 0 && !Object.hasOwn(config.targets, config.defaultTarget)) issues.push({
@@ -2900,7 +3471,7 @@ function checkTargets(loaded, requested, { issues, warnings }) {
 	});
 }
 /**
-* Every key of removed.ts is a property or group address on one object, and none is also a resource in config:
+* Every key of removed.ts is a property, group, pipeline or stage address, and none is also a resource in config:
 * removing a resource takes it out of config.
 */
 function checkTombstones(loaded, issues) {
@@ -2911,7 +3482,7 @@ function checkTombstones(loaded, issues) {
 			...removedLines[key] === void 0 ? {} : { line: removedLines[key] },
 			configPath: key
 		};
-		const fix = "write the address of a property or group, such as 'property:companies/legacy_score'";
+		const fix = "write the address of a property, group, pipeline or stage, such as 'property:companies/legacy_score'";
 		if (!isAddress(key)) {
 			issues.push({
 				code: "E_TOMBSTONE_ADDRESS",
@@ -2922,14 +3493,15 @@ function checkTombstones(loaded, issues) {
 			continue;
 		}
 		const { type, path } = parseAddress(key);
-		if (!REMOVABLE$1.includes(type)) issues.push({
+		const shape = Object.hasOwn(REMOVABLE, type) ? REMOVABLE[type] : void 0;
+		if (!shape) issues.push({
 			code: "E_TOMBSTONE_ADDRESS",
-			message: `cannot remove ${key}: this version removes properties and groups only`,
+			message: `cannot remove ${key}: this version removes properties, groups, pipelines and stages only`,
 			...at,
 			fix: `remove ${key} from ${removed}`
 		});
-		else if (!ON_OBJECT$1.test(path)) {
-			const message = `'${key}' is not of the form ${type}:<object>/<name>`;
+		else if (!shape.path.test(path)) {
+			const message = `'${key}' is not of the form ${shape.form}`;
 			issues.push({
 				code: "E_TOMBSTONE_ADDRESS",
 				message,
@@ -3005,8 +3577,15 @@ function checkDefinitions(ir, target, overrides, at, { issues, warnings }) {
 			report("", refused, `remove the definition override for ${address} under targets.${target}.overrides`);
 			continue;
 		}
-		const type = parseAddress(address).type;
+		const { type, path } = parseAddress(address);
 		checkFields(type, d, report);
+		const order = d.displayOrder;
+		if (type === "pipeline" && order !== void 0 && !(Number.isInteger(order) && order >= 0)) report(".displayOrder", `displayOrder ${order} is not an integer from 0 up`, "use 0 or more");
+		if (type === "stage") {
+			const object = path.slice(0, path.indexOf("/"));
+			const field = stageField(object, !STANDARD_OBJECTS.has(object));
+			for (const rule of stageRules(object, field, d, true)) report(rule.field, rule.message, rule.fix);
+		}
 		if (type === "property") {
 			checkEffective(ir, address, resource, d, report);
 			checkEffectiveOptions(address, resource, d, report);
@@ -3014,6 +3593,41 @@ function checkDefinitions(ir, target, overrides, at, { issues, warnings }) {
 		}
 	}
 }
+/**
+* The pipeline rules on the resources one target's definition overrides leave: a label two pipelines or two stages
+* would share, a ticket pipeline left with no closed stage. Only what the shared files do not
+* break already is reported, as E_OVERRIDE_DEFINITION at the first override the message names, else at an override of
+* a stage of the pipeline it names.
+*/
+function checkTargetPipelines(loaded, target, overrides, at, issues) {
+	const touched = Object.keys(overrides).filter((address) => (address.startsWith("pipeline:") || address.startsWith("stage:")) && Object.hasOwn(loaded.ir.resources, address) && overrides[address]?.definition !== void 0);
+	if (touched.length === 0) return;
+	const shared = [];
+	checkPipelines(loaded, shared);
+	const known = new Set(shared.map((issue) => issue.message));
+	const found = [];
+	checkPipelines({
+		...loaded,
+		ir: {
+			...loaded.ir,
+			resources: effectiveResources(loaded.ir, target)
+		}
+	}, found);
+	const spanning = found.filter((i) => SPANNING.has(i.code) && !known.has(i.message));
+	for (const issue of spanning) {
+		const words = issue.message.split(WORD_BREAK);
+		const pipelineOf = (a) => a.startsWith("stage:") ? `pipeline:${a.slice(6, a.lastIndexOf("/"))}` : a;
+		const address = words.find((word) => touched.includes(word)) ?? touched.find((a) => words.includes(pipelineOf(a))) ?? touched[0];
+		issues.push({
+			code: "E_OVERRIDE_DEFINITION",
+			message: `on target ${target}, ${issue.message}`,
+			...located$1(at, `${address}.definition`)(),
+			...issue.fix === void 0 ? {} : { fix: issue.fix }
+		});
+	}
+}
+const SPANNING = /* @__PURE__ */ new Set(["E_DUPLICATE_LABEL", "E_PIPELINE_STAGES"]);
+const WORD_BREAK = /[\s,']+/;
 function located$1(at, path) {
 	return (suffix = "") => {
 		const full = `${path}${suffix}`;
@@ -3038,14 +3652,16 @@ function checkFields(type, d, report) {
 function refusal$1(address, resource) {
 	const { type } = parseAddress(address);
 	if (type === "object") return "a custom object schema cannot take a definition override in this release";
-	if (type !== "property" && type !== "group") return "only a property or a group can take a definition override";
+	if (!Object.hasOwn(OVERRIDABLE, type)) return "only a property, a group, a pipeline or a stage can take a definition override";
 	if (resource.managed) return;
 	const d = resource.definition ?? {};
 	return d.label !== void 0 && d.group !== void 0 && d.fieldType !== void 0 ? "it is .managed(false), so no target owns its definition" : "it is a reference (its shared definition has no label, group and fieldType), so nothing on it can differ per target";
 }
 function notOverridable(type, field) {
 	if (field === "hasUniqueValue" || field === "dataSensitivity") return `${field} is fixed when HubSpot creates the property, so it cannot differ per target`;
-	return type === "group" ? `a group override may set label only, not ${field}` : `${field} cannot differ per target`;
+	if (type === "group") return `a group override may set label only, not ${field}`;
+	if (type === "pipeline") return `a pipeline override may set label and displayOrder only, not ${field}`;
+	return type === "stage" ? `a stage override may set label and its metadata only, not ${field}` : `${field} cannot differ per target`;
 }
 function checkEffective(ir, address, resource, d, report) {
 	const codec = resource.binding?.codec;
@@ -3221,7 +3837,7 @@ function walkUnresolved(value, visit) {
 }
 const SCHEMA = blueprint_1_schema_default;
 /** `<group|property>:<object>/<name>`. */
-const ON_OBJECT$2 = /^(group|property):([^\s/]+)\/([^\s/]+)$/;
+const ON_OBJECT = /^(group|property):([^\s/]+)\/([^\s/]+)$/;
 /** Object keys, group names and property names: lowercase, digits and underscores, a letter first. */
 const NAME = /^[a-z][a-z0-9_]*$/;
 /** The codec each HubSpot type implies when a blueprint's binding names none. */
@@ -3262,7 +3878,7 @@ function rules(blueprint) {
 	const report = (configPath, message) => issues.push(issue(configPath, message));
 	for (const [address, resource] of Object.entries(blueprint.resources)) {
 		const at = `resources.${address}`;
-		const parts = ON_OBJECT$2.exec(address);
+		const parts = ON_OBJECT.exec(address);
 		if (!parts) {
 			report(at, `'${address}' is not of the form group:<object>/<name> or property:<object>/<name>`);
 			continue;
@@ -3287,7 +3903,7 @@ function checkName(report, at, type, name) {
 function checkProperty(report, at, object, resource) {
 	const d = resource.definition;
 	const group = d.group.$ref;
-	const parts = ON_OBJECT$2.exec(group);
+	const parts = ON_OBJECT.exec(group);
 	if (!(parts && parts[1] === "group" && parts[2] === object)) report(`${at}.definition.group`, `the group '${group}' is not a group of ${object}, group:${object}/<name>`);
 	else if (!NAME.test(parts[3])) report(`${at}.definition.group`, `group name '${parts[3]}' is not lowercase letters, digits and underscores starting with a letter`);
 	const options = d.options ?? [];
@@ -3460,6 +4076,79 @@ const registry = {
 			}
 		}
 	},
+	pipeline: {
+		family: "crm.pipelines",
+		version: "2026-09",
+		status: "ga",
+		expires: "2028-03",
+		identity: "natural",
+		auth: "account",
+		delete: "permanent",
+		scopes: {
+			read: ["crm.schemas.{object}.read"],
+			write: ["crm.schemas.{object}.write"]
+		},
+		tier: "any",
+		limitKey: "pipelines",
+		paths: {
+			list: {
+				method: "GET",
+				path: "/crm/pipelines/2026-09/{objectType}",
+				tag: "read"
+			},
+			read: {
+				method: "GET",
+				path: "/crm/pipelines/2026-09/{objectType}/{pipelineId}",
+				tag: "read"
+			},
+			create: {
+				method: "POST",
+				path: "/crm/pipelines/2026-09/{objectType}",
+				tag: "write"
+			},
+			update: {
+				method: "PATCH",
+				path: "/crm/pipelines/2026-09/{objectType}/{pipelineId}",
+				tag: "write"
+			},
+			delete: {
+				method: "DELETE",
+				path: "/crm/pipelines/2026-09/{objectType}/{pipelineId}",
+				tag: "write"
+			}
+		}
+	},
+	stage: {
+		family: "crm.pipelines",
+		version: "2026-09",
+		status: "ga",
+		expires: "2028-03",
+		identity: "natural",
+		auth: "account",
+		delete: "permanent",
+		scopes: {
+			read: ["crm.schemas.{object}.read"],
+			write: ["crm.schemas.{object}.write"]
+		},
+		tier: "any",
+		paths: {
+			create: {
+				method: "POST",
+				path: "/crm/pipelines/2026-09/{objectType}/{pipelineId}/stages",
+				tag: "write"
+			},
+			update: {
+				method: "PATCH",
+				path: "/crm/pipelines/2026-09/{objectType}/{pipelineId}/stages/{stageId}",
+				tag: "write"
+			},
+			delete: {
+				method: "DELETE",
+				path: "/crm/pipelines/2026-09/{objectType}/{pipelineId}/stages/{stageId}",
+				tag: "write"
+			}
+		}
+	},
 	accountInfo: {
 		family: "account-info",
 		version: "2026-09",
@@ -3496,6 +4185,11 @@ const registry = {
 				method: "GET",
 				path: "/crm/limits/2026-09/custom-object-types",
 				tag: "read"
+			},
+			pipelines: {
+				method: "GET",
+				path: "/crm/limits/2026-09/pipelines",
+				tag: "read"
 			}
 		}
 	}
@@ -3507,7 +4201,9 @@ const registry = {
 const NORM_VERSIONS = {
 	property: 1,
 	group: 1,
-	object: 1
+	object: 1,
+	pipeline: 1,
+	stage: 1
 };
 /**
 * Standard objects whose properties and groups read under a scope other than `crm.schemas.<object>.read`, checked
@@ -3607,7 +4303,10 @@ const fallback = {
 	intervalMs: 1e3
 };
 const fallbackWarning = "HubSpot sent no rate-limit headers. Sending at most 8 requests per second.";
-/** The writes milestone 3 sends: properties and property groups. No custom object schema write. */
+/**
+* The writes apply sends: properties, property groups, pipelines and stages. No custom object schema write, and no
+* pipeline or stage PUT, which the registry does not name.
+*/
 const MILESTONE_3_WRITES = [
 	{
 		type: "property",
@@ -3632,6 +4331,30 @@ const MILESTONE_3_WRITES = [
 	{
 		type: "group",
 		path: "delete"
+	},
+	{
+		type: "pipeline",
+		path: "create"
+	},
+	{
+		type: "pipeline",
+		path: "update"
+	},
+	{
+		type: "pipeline",
+		path: "delete"
+	},
+	{
+		type: "stage",
+		path: "create"
+	},
+	{
+		type: "stage",
+		path: "update"
+	},
+	{
+		type: "stage",
+		path: "delete"
 	}
 ];
 /** How many `errors` entries an outcome keeps: a property used in hundreds of places must not balloon it. */
@@ -3833,7 +4556,7 @@ async function exchange(fetch, url, init, timeoutMs, key) {
 				kind: "answered",
 				status: res.status,
 				headers: res.headers,
-				text: scrub$1(await res.text(), key)
+				text: scrub$2(await res.text(), key)
 			};
 		} catch (error) {
 			return {
@@ -3848,16 +4571,16 @@ async function exchange(fetch, url, init, timeoutMs, key) {
 		clearTimeout(timer);
 	}
 }
-function scrub$1(text, key) {
+function scrub$2(text, key) {
 	return key === "" ? text : text.split(key).join("[key]");
 }
 function quote(text, key, max = 120) {
-	return sanitize(scrub$1(scrub$1(sanitize(scrub$1(text, key), Number.POSITIVE_INFINITY), key), sanitize(key, Number.POSITIVE_INFINITY)), max);
+	return sanitize(scrub$2(scrub$2(sanitize(scrub$2(text, key), Number.POSITIVE_INFINITY), key), sanitize(key, Number.POSITIVE_INFINITY)), max);
 }
 function scrubJson(value, key) {
-	if (typeof value === "string") return scrub$1(value, key);
+	if (typeof value === "string") return scrub$2(value, key);
 	if (Array.isArray(value)) return value.map((item) => scrubJson(item, key));
-	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).map(([name, item]) => [scrub$1(name, key), scrubJson(item, key)]));
+	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).map(([name, item]) => [scrub$2(name, key), scrubJson(item, key)]));
 	return value;
 }
 function readStep(answer, attempt, context) {
@@ -4066,119 +4789,241 @@ function portalMidnight(now, timeZone) {
 	return new Date(Date.UTC(part.year ?? 0, (part.month ?? 1) - 1, (part.day ?? 1) + 1) - offset).toISOString();
 }
 /**
-* The objects whose properties the properties API lists by name. A config key outside this set names a custom object
-* schema. The set is the 2026-09 `crm.schemas.<object>.read` scope list plus the objects that carry their own scopes
-* (products, leads, goals, marketing events, feedback submissions, users).
-*/
-const STANDARD_OBJECTS = /* @__PURE__ */ new Set([
-	"appointments",
-	"calls",
-	"carts",
-	"commerce_payments",
-	"communications",
-	"companies",
-	"contacts",
-	"courses",
-	"deals",
-	"emails",
-	"feedback_submissions",
-	"goals",
-	"invoices",
-	"leads",
-	"line_items",
-	"listings",
-	"marketing_events",
-	"meetings",
-	"notes",
-	"orders",
-	"postal_mail",
-	"products",
-	"projects",
-	"quotes",
-	"services",
-	"subscriptions",
-	"tasks",
-	"tickets",
-	"users"
-]);
-/**
-* The object type ID of each standard object, by config key. Limits Tracking keys its per-object entries by these.
-* Source: "Object type ID values", retrieved 2026-09-24:
-* https://developers.hubspot.com/docs/api-reference/latest/crm/understanding-the-crm
-* A plain record: look a key up with `Object.hasOwn`, so `constructor` finds nothing.
+* A portal resource a name override shadows belongs to no address. Where another resource refers to it (a property's
+* group, a name in a custom object schema), the read records `shadowed:<name>`, which no HubSpot internal name and so
+* no config name equals.
 */
-const STANDARD_OBJECT_TYPE_IDS = {
-	appointments: "0-421",
-	calls: "0-48",
-	carts: "0-142",
-	commerce_payments: "0-101",
-	communications: "0-18",
-	companies: "0-2",
-	contacts: "0-1",
-	courses: "0-410",
-	deals: "0-3",
-	emails: "0-49",
-	feedback_submissions: "0-19",
-	goals: "0-74",
-	invoices: "0-53",
-	leads: "0-136",
-	line_items: "0-8",
-	listings: "0-420",
-	marketing_events: "0-54",
-	meetings: "0-47",
-	notes: "0-46",
-	orders: "0-123",
-	postal_mail: "0-116",
-	products: "0-7",
-	projects: "0-970",
-	quotes: "0-14",
-	services: "0-162",
-	subscriptions: "0-69",
-	tasks: "0-27",
-	tickets: "0-5",
-	users: "0-115"
+const SHADOWED = "shadowed:";
+const KINDS$1 = {
+	string: "string",
+	number: "number",
+	bool: "boolean",
+	date: "date",
+	datetime: "datetime",
+	phone_number: "phoneNumber"
 };
-/** One object's pull scope from its settings under `objects` and the property names its object file defines. */
-function scopeOf(scope = {}, defined = []) {
-	return {
-		custom: scope.custom ?? true,
-		defined: new Set(defined),
-		exclude: excluder(scope.exclude),
-		include: new Set(scope.include ?? [])
-	};
+function kindOf$4(type, fieldType) {
+	if (type === "enumeration") return fieldType === "checkbox" ? "multiEnum" : "enum";
+	return Object.hasOwn(KINDS$1, type) ? KINDS$1[type] : void 0;
 }
-/** The names of the properties the object files define on `object`, references included. */
-function definedOn(ir, object) {
-	const prefix = `property:${object}/`;
-	return Object.keys(ir.resources).filter((address) => address.startsWith(prefix)).map((address) => address.slice(prefix.length));
+function builderOf(p, external) {
+	if (isOwner(p)) return "owner";
+	return external ? "string" : kindOf$4(p.type, p.fieldType);
 }
-/**
-* A portal property is in scope when the object files define it or `include` names it, whatever `custom` and
-* `exclude` say, or when it is custom, `custom` is on and `exclude` does not name it. validate refuses a name both
-* `include` and `exclude` hold.
-*/
-function inScope(scope, property) {
-	const { name } = property;
-	return scope.defined.has(name) || scope.include.has(name) || scope.custom && !property.hubspotDefined && !scope.exclude(name);
+function writable(p, kind, external) {
+	return (kind === "owner" || !external) && FIELD_TYPES[kind].includes(p.fieldType);
 }
-/** The `exclude` patterns of one object as a predicate over internal names. */
-function excluder(patterns = []) {
-	const matchers = patterns.map(addressMatcher);
-	return (name) => matchers.some((matches) => matches(name));
+/** A HubSpot user property p.owner writes: an enumeration HubSpot fills with owners, as a select or radio. */
+function isOwner(p) {
+	return p.referencedObjectType === "OWNER" && p.externalOptions === true && p.type === "enumeration" && FIELD_TYPES.owner.includes(p.fieldType);
 }
-/** The --only glob as a predicate over addresses. `*` matches any run of characters, `/` included. */
-function addressMatcher(glob) {
-	if (glob === void 0) return () => true;
-	const literals = glob.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
-	const pattern = new RegExp(`^${literals.join(".*")}$`);
-	return (address) => pattern.test(address);
+/** Why Kalup does not write a property: its options come from HubSpot, or its type and fieldType fit no builder. */
+function unsupportedReason(p) {
+	if (p.referencedObjectType === "OWNER") return `is a HubSpot user property with fieldType ${sanitize(p.fieldType)}`;
+	if (p.externalOptions) return "takes its options from HubSpot (externalOptions)";
+	return `has type ${sanitize(p.type)} and fieldType ${sanitize(p.fieldType)}`;
+}
+/**
+* Live properties in portal order. Archived properties are skipped. An owner property (a select or radio HubSpot fills
+* with users) is `p.owner`. HubSpot fills the options of any other externalOptions property, so it reads as a string: a
+* HubSpot-defined or HubSpot-calculated one is a `p.string` reference, a custom one is unsupported. So is a property
+* whose type no builder carries (object_coordinates, json, anything unknown), or a custom one whose fieldType no builder
+* accepts (a calculation_rollup), each with one warning when `warn` says the project cares about it: a property outside
+* the pull scope and the files is noise. A custom calculation_equation property is managed: HubSpot marks it
+* `calculated`, but its formula is Kalup's to write.
+*/
+function normalizeProperties(object, raw, issues, warn = () => true) {
+	const properties = [];
+	const unsupported = [];
+	for (const p of raw) {
+		if (p.archived) continue;
+		const hubspotDefined = Boolean(p.hubspotDefined);
+		const reference = Boolean(p.hubspotDefined || p.calculated && p.fieldType !== "calculation_equation" || RESERVED_PREFIX.test(p.name));
+		const external = p.externalOptions === true || p.referencedObjectType === "OWNER";
+		const kind = builderOf(p, external);
+		if (kind === void 0 || !(reference || writable(p, kind, external))) {
+			const u = unsupportedOf(p);
+			warnUnsupported(issues, object, u, warn(p));
+			unsupported.push(u);
+			continue;
+		}
+		const options = kind === "enum" || kind === "multiEnum" ? normalizeOptions(p.options ?? []) : void 0;
+		properties.push({
+			name: p.name,
+			...external ? { external: true } : {},
+			hubspotDefined,
+			type: p.type,
+			fieldType: p.fieldType,
+			kind,
+			reference,
+			calculated: Boolean(p.calculated),
+			definition: definitionOf$1(p, reference, options)
+		});
+	}
+	return {
+		properties,
+		unsupported
+	};
+}
+function warnUnsupported(issues, object, u, wanted) {
+	if (wanted) issues.push({
+		code: "W_UNSUPPORTED_TYPE",
+		message: `property:${object}/${sanitize(u.name)} ${unsupportedReason(u)}, which Kalup does not write; read as a p.string reference`
+	});
+}
+function unsupportedOf(p) {
+	return compact$4({
+		name: p.name,
+		label: p.label,
+		group: p.groupName,
+		description: p.description || void 0,
+		type: p.type,
+		fieldType: p.fieldType,
+		options: p.options?.length ? normalizeOptions(p.options) : void 0,
+		hubspotDefined: Boolean(p.hubspotDefined),
+		externalOptions: p.externalOptions === true || void 0,
+		referencedObjectType: p.referencedObjectType
+	});
+}
+/** The portal names of the unarchived properties in each portal group, sorted. */
+function groupMembers(raw) {
+	const members = /* @__PURE__ */ new Map();
+	for (const p of raw.filter((property) => !property.archived)) members.set(p.groupName, [...members.get(p.groupName) ?? [], p.name]);
+	return new Map([...members].map(([group, names]) => [group, names.sort(byCodeUnit)]));
+}
+/** The meta of each unarchived property, by name. */
+function propertyMeta(raw) {
+	return new Map(raw.filter((p) => !p.archived).map((p) => [p.name, metaOf(p)]));
+}
+function metaOf(p) {
+	const text = (value) => typeof value === "string" ? value : void 0;
+	const flag = (value) => typeof value === "boolean" ? value : void 0;
+	const flags = p.modificationMetadata;
+	const modificationMetadata = flags === void 0 ? void 0 : compact$4({
+		archivable: flag(flags.archivable),
+		readOnlyDefinition: flag(flags.readOnlyDefinition),
+		readOnlyOptions: flag(flags.readOnlyOptions),
+		readOnlyValue: flag(flags.readOnlyValue)
+	});
+	const options = p.options?.map((o) => compact$4({
+		value: o.value,
+		displayOrder: typeof o.displayOrder === "number" ? o.displayOrder : void 0
+	}));
+	return compact$4({
+		sensitivity: p.sensitivity,
+		hubspotDefined: flag(p.hubspotDefined),
+		modificationMetadata,
+		createdAt: text(p.createdAt),
+		updatedAt: text(p.updatedAt),
+		options: options?.length ? options : void 0,
+		currencyPropertyName: text(p.currencyPropertyName)
+	});
+}
+function definitionOf$1(p, reference, options) {
+	if (!reference) return compact$4({
+		label: p.label,
+		group: p.groupName,
+		fieldType: p.fieldType,
+		description: p.description || void 0,
+		options: options?.length ? options : void 0,
+		hasUniqueValue: p.hasUniqueValue || void 0,
+		formField: p.formField || void 0,
+		hidden: p.hidden || void 0,
+		displayOrder: typeof p.displayOrder === "number" && p.displayOrder !== -1 ? p.displayOrder : void 0,
+		...displayOf(p),
+		calculationFormula: p.fieldType === "calculation_equation" ? filled(p.calculationFormula) : void 0,
+		dataSensitivity: unlessDefault("dataSensitivity", p.dataSensitivity)
+	});
+	return options?.length ? { options } : void 0;
+}
+function displayOf(p) {
+	const shown = (field) => TYPE_FIELDS[field]?.includes(p.type) === true;
+	return {
+		numberDisplayHint: shown("numberDisplayHint") ? unlessDefault("numberDisplayHint", p.numberDisplayHint) : void 0,
+		showCurrencySymbol: shown("showCurrencySymbol") ? p.showCurrencySymbol || void 0 : void 0,
+		currencyPropertyName: shown("currencyPropertyName") ? filled(p.currencyPropertyName) : void 0,
+		textDisplayHint: shown("textDisplayHint") ? filled(p.textDisplayHint) : void 0
+	};
+}
+function filled(value) {
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function unlessDefault(field, value) {
+	return typeof value === "string" && value !== "" && value !== DEFAULTS.definition[field] ? value : void 0;
+}
+function normalizeOptions(raw) {
+	const order = (o) => o.displayOrder === void 0 || o.displayOrder < 0 ? Number.MAX_SAFE_INTEGER : o.displayOrder;
+	return [...raw].sort((a, b) => order(a) - order(b)).map((o) => compact$4({
+		value: o.value,
+		label: o.label,
+		hidden: o.hidden || void 0,
+		description: o.description || void 0
+	}));
+}
+const STATES = /* @__PURE__ */ new Set(["OPEN", "CLOSED"]);
+/**
+* The unarchived pipelines of `object`, by displayOrder then ID, since pipelines may share a number and the list is not
+* sorted; each one's stages by displayOrder, which HubSpot never stores tied (observed 2026-10-05). A stage keeps the
+* one metadata field its object takes: a deal's probability as a number, a ticket's ticketState, a custom object's
+* state. `isClosed` is HubSpot's own, derived from that field, and is dropped; so is the metadata of a stage on an
+* object whose pipelines Kalup does not write.
+*/
+function normalizePipelines(object, raw, custom) {
+	const field = stageField(object, custom);
+	const ordered = (list) => [...list].sort((a, b) => a.displayOrder - b.displayOrder || byCodeUnit(a.id, b.id));
+	return ordered(raw.filter((p) => !p.archived)).map((p) => ({
+		id: p.id,
+		label: p.label,
+		displayOrder: p.displayOrder,
+		stages: ordered(p.stages.filter((st) => !st.archived)).map((st) => ({
+			id: st.id,
+			label: st.label,
+			...stageMetadata$1(field, st.metadata ?? {})
+		}))
+	}));
+}
+function stageMetadata$1(field, metadata) {
+	const value = field === void 0 ? void 0 : metadata[field];
+	if (field === "probability") {
+		const probability = Number(value);
+		return value !== void 0 && Number.isFinite(probability) ? { probability } : {};
+	}
+	return field !== void 0 && value !== void 0 && STATES.has(value) ? { [field]: value } : {};
+}
+function normalizeGroups(raw) {
+	return { groups: new Map(raw.filter((g) => !g.archived).map((g) => [g.name, g.label])) };
+}
+/** The schema fields the object file carries, the three lists as HubSpot returned them. */
+function normalizeSchema(schema) {
+	return compact$4({
+		labels: compact$4({
+			singular: schema.labels?.singular,
+			plural: schema.labels?.plural
+		}),
+		primaryDisplayProperty: schema.primaryDisplayProperty,
+		requiredProperties: schema.requiredProperties,
+		searchableProperties: schema.searchableProperties,
+		secondaryDisplayProperties: schema.secondaryDisplayProperties
+	});
+}
+function compact$4(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0));
 }
 const SETS$1 = /* @__PURE__ */ new Set(["requiredProperties", "searchableProperties"]);
+/**
+* Fields that are an order of members: a pipeline's stage IDs. Like `options.order`, one compares only the members
+* both sides hold, since a stage is a resource of its own and one only one side holds is that stage's step.
+*/
+const ORDERS = /* @__PURE__ */ new Set(["stages"]);
 /** Every unit desired owns that observed holds, sorted by unit. */
 function classify(base, desired, observed, rules) {
 	const ignored = new Set(rules.ignoreChanges);
 	const units = [];
-	for (const [field, value] of Object.entries(desired.fields)) if (!ignored.has(field) && Object.hasOwn(observed.fields, field)) units.push(compare$1(field, value, observed.fields[field], valueIn(base, field), SETS$1.has(field)));
+	for (const [field, value] of Object.entries(desired.fields)) {
+		if (ignored.has(field) || !Object.hasOwn(observed.fields, field)) continue;
+		if (ORDERS.has(field)) units.push(orderUnit(field, value, observed.fields[field] ?? [], base));
+		else units.push(compare$1(field, value, observed.fields[field], valueIn(base, field), SETS$1.has(field)));
+	}
 	if (desired.options && observed.options && !ignored.has("options")) units.push(...options(desired.options, observed.options, base, rules));
 	return units.sort((a, b) => byCodeUnit(a.unit, b.unit));
 }
@@ -4195,15 +5040,24 @@ function advanceBase(previous, approved, live, units) {
 	const named = (unit) => units === void 0 || units.some((u) => unit === u || unit.startsWith(`${u}.`) || unit.startsWith(`${u}[`));
 	const next = new Map(Object.entries(previous ?? {}));
 	let agreed = false;
-	for (const [field, value] of Object.entries(approved.fields)) if (named(field) && Object.hasOwn(live.fields, field) && same$3(value, live.fields[field], SETS$1.has(field))) {
-		next.set(field, value);
-		agreed = true;
+	for (const [field, value] of Object.entries(approved.fields)) {
+		if (!(named(field) && Object.hasOwn(live.fields, field))) continue;
+		const both = agreedField(field, value, live.fields[field]);
+		if (both !== void 0) {
+			next.set(field, both);
+			agreed = true;
+		}
 	}
 	if (approved.options && live.options) agreed = advanceOptions(next, approved.options, live.options, named) || agreed;
 	if (!agreed && previous === void 0) return;
 	for (const [field, omitted] of Object.entries(DEFAULTS.definition)) if (field !== "options" && !Object.hasOwn(approved.fields, field) && !next.has(field) && Object.hasOwn(live.fields, field) && same$3(live.fields[field], omitted)) next.set(field, omitted);
 	return sortedRecord(next);
 }
+function agreedField(field, approved, live) {
+	if (!ORDERS.has(field)) return same$3(approved, live, SETS$1.has(field)) ? approved : void 0;
+	const [mine, theirs] = commonOrders(approved, live ?? []);
+	return mine.length > 0 && same$3(mine, theirs) ? mine : void 0;
+}
 function advanceOptions(next, approved, live, named) {
 	const wanted = new Map(approved.map((o) => [o.value, o]));
 	const held = new Map(live.map((o) => [o.value, o]));
@@ -4277,6 +5131,16 @@ function options(desired, observed, base, rules) {
 	units.push(compare$1("options.order", order, common(observed, wanted), orderIn(base, order)));
 	return units;
 }
+function orderUnit(field, desired, observed, base) {
+	const [mine, theirs] = commonOrders(desired, observed);
+	const stored = valueIn(base, field);
+	const order = (stored?.value ?? []).filter((member) => mine.includes(member));
+	return compare$1(field, mine, theirs, stored && order.length === mine.length ? { value: order } : void 0);
+}
+/** The members two orders share, each in its own order. */
+function commonOrders(a, b) {
+	return [a.filter((member) => b.includes(member)), b.filter((member) => a.includes(member))];
+}
 function orderIn(base, members) {
 	const stored = valueIn(base, "optionsOrder");
 	if (!stored) return;
@@ -4337,6 +5201,10 @@ function equal(a, b) {
 function sortedRecord(entries) {
 	return Object.fromEntries([...entries].sort(([a], [b]) => byCodeUnit(a, b)));
 }
+/** A count and its noun: `1 write`, `2 writes`. The plural is the noun plus `s` unless `many` gives another. */
+function plural(count, one, many = `${one}s`) {
+	return `${count} ${count === 1 ? one : many}`;
+}
 const PLAN_SCHEMA = {
 	$schema: "https://json-schema.org/draft/2020-12/schema",
 	$id: "https://kalup.dev/schemas/plan-1.schema.json",
@@ -4739,6 +5607,24 @@ const PLAN_SCHEMA = {
 					"description": "Logical form, $ref included, resolved at apply. A create holds the full definition.",
 					"type": "object"
 				},
+				"stages": {
+					"description": "A pipeline create only: the stages it carries, in display order, each with its full definition. HubSpot refuses a pipeline without a stage.",
+					"type": "array",
+					"items": {
+						"type": "object",
+						"required": ["address", "desired"],
+						"properties": {
+							"address": { "$ref": "#/$defs/address" },
+							"desired": { "type": "object" }
+						},
+						"additionalProperties": false
+					}
+				},
+				"stageLabels": {
+					"description": "Display only, never approved: the label of each stage a pipeline step's stage order names, config's else the portal's, so the plan text shows labels and not IDs.",
+					"type": "object",
+					"additionalProperties": { "type": "string" }
+				},
 				"ignoreChanges": {
 					"description": "Create only: set on create, released after.",
 					"type": "array",
@@ -5044,197 +5930,6 @@ function validatePlan(document) {
 		...path ? { configPath: path } : {}
 	}));
 }
-/**
-* A portal resource a name override shadows belongs to no address. Where another resource refers to it (a property's
-* group, a name in a custom object schema), the read records `shadowed:<name>`, which no HubSpot internal name and so
-* no config name equals.
-*/
-const SHADOWED = "shadowed:";
-const KINDS$1 = {
-	string: "string",
-	number: "number",
-	bool: "boolean",
-	date: "date",
-	datetime: "datetime",
-	phone_number: "phoneNumber"
-};
-function kindOf$4(type, fieldType) {
-	if (type === "enumeration") return fieldType === "checkbox" ? "multiEnum" : "enum";
-	return Object.hasOwn(KINDS$1, type) ? KINDS$1[type] : void 0;
-}
-function builderOf(p, external) {
-	if (isOwner(p)) return "owner";
-	return external ? "string" : kindOf$4(p.type, p.fieldType);
-}
-function writable(p, kind, external) {
-	return (kind === "owner" || !external) && FIELD_TYPES[kind].includes(p.fieldType);
-}
-/** A HubSpot user property p.owner writes: an enumeration HubSpot fills with owners, as a select or radio. */
-function isOwner(p) {
-	return p.referencedObjectType === "OWNER" && p.externalOptions === true && p.type === "enumeration" && FIELD_TYPES.owner.includes(p.fieldType);
-}
-/** Why Kalup does not write a property: its options come from HubSpot, or its type and fieldType fit no builder. */
-function unsupportedReason(p) {
-	if (p.referencedObjectType === "OWNER") return `is a HubSpot user property with fieldType ${sanitize(p.fieldType)}`;
-	if (p.externalOptions) return "takes its options from HubSpot (externalOptions)";
-	return `has type ${sanitize(p.type)} and fieldType ${sanitize(p.fieldType)}`;
-}
-/**
-* Live properties in portal order. Archived properties are skipped. An owner property (a select or radio HubSpot fills
-* with users) is `p.owner`. HubSpot fills the options of any other externalOptions property, so it reads as a string: a
-* HubSpot-defined or HubSpot-calculated one is a `p.string` reference, a custom one is unsupported. So is a property
-* whose type no builder carries (object_coordinates, json, anything unknown), or a custom one whose fieldType no builder
-* accepts (a calculation_rollup), each with one warning when `warn` says the project cares about it: a property outside
-* the pull scope and the files is noise. A custom calculation_equation property is managed: HubSpot marks it
-* `calculated`, but its formula is Kalup's to write.
-*/
-function normalizeProperties(object, raw, issues, warn = () => true) {
-	const properties = [];
-	const unsupported = [];
-	for (const p of raw) {
-		if (p.archived) continue;
-		const hubspotDefined = Boolean(p.hubspotDefined);
-		const reference = Boolean(p.hubspotDefined || p.calculated && p.fieldType !== "calculation_equation" || RESERVED_PREFIX.test(p.name));
-		const external = p.externalOptions === true || p.referencedObjectType === "OWNER";
-		const kind = builderOf(p, external);
-		if (kind === void 0 || !(reference || writable(p, kind, external))) {
-			const u = unsupportedOf(p);
-			warnUnsupported(issues, object, u, warn(p));
-			unsupported.push(u);
-			continue;
-		}
-		const options = kind === "enum" || kind === "multiEnum" ? normalizeOptions(p.options ?? []) : void 0;
-		properties.push({
-			name: p.name,
-			...external ? { external: true } : {},
-			hubspotDefined,
-			type: p.type,
-			fieldType: p.fieldType,
-			kind,
-			reference,
-			calculated: Boolean(p.calculated),
-			definition: definitionOf$1(p, reference, options)
-		});
-	}
-	return {
-		properties,
-		unsupported
-	};
-}
-function warnUnsupported(issues, object, u, wanted) {
-	if (wanted) issues.push({
-		code: "W_UNSUPPORTED_TYPE",
-		message: `property:${object}/${sanitize(u.name)} ${unsupportedReason(u)}, which Kalup does not write; read as a p.string reference`
-	});
-}
-function unsupportedOf(p) {
-	return compact$4({
-		name: p.name,
-		label: p.label,
-		group: p.groupName,
-		description: p.description || void 0,
-		type: p.type,
-		fieldType: p.fieldType,
-		options: p.options?.length ? normalizeOptions(p.options) : void 0,
-		hubspotDefined: Boolean(p.hubspotDefined),
-		externalOptions: p.externalOptions === true || void 0,
-		referencedObjectType: p.referencedObjectType
-	});
-}
-/** The portal names of the unarchived properties in each portal group, sorted. */
-function groupMembers(raw) {
-	const members = /* @__PURE__ */ new Map();
-	for (const p of raw.filter((property) => !property.archived)) members.set(p.groupName, [...members.get(p.groupName) ?? [], p.name]);
-	return new Map([...members].map(([group, names]) => [group, names.sort(byCodeUnit)]));
-}
-/** The meta of each unarchived property, by name. */
-function propertyMeta(raw) {
-	return new Map(raw.filter((p) => !p.archived).map((p) => [p.name, metaOf(p)]));
-}
-function metaOf(p) {
-	const text = (value) => typeof value === "string" ? value : void 0;
-	const flag = (value) => typeof value === "boolean" ? value : void 0;
-	const flags = p.modificationMetadata;
-	const modificationMetadata = flags === void 0 ? void 0 : compact$4({
-		archivable: flag(flags.archivable),
-		readOnlyDefinition: flag(flags.readOnlyDefinition),
-		readOnlyOptions: flag(flags.readOnlyOptions),
-		readOnlyValue: flag(flags.readOnlyValue)
-	});
-	const options = p.options?.map((o) => compact$4({
-		value: o.value,
-		displayOrder: typeof o.displayOrder === "number" ? o.displayOrder : void 0
-	}));
-	return compact$4({
-		sensitivity: p.sensitivity,
-		hubspotDefined: flag(p.hubspotDefined),
-		modificationMetadata,
-		createdAt: text(p.createdAt),
-		updatedAt: text(p.updatedAt),
-		options: options?.length ? options : void 0,
-		currencyPropertyName: text(p.currencyPropertyName)
-	});
-}
-function definitionOf$1(p, reference, options) {
-	if (!reference) return compact$4({
-		label: p.label,
-		group: p.groupName,
-		fieldType: p.fieldType,
-		description: p.description || void 0,
-		options: options?.length ? options : void 0,
-		hasUniqueValue: p.hasUniqueValue || void 0,
-		formField: p.formField || void 0,
-		hidden: p.hidden || void 0,
-		displayOrder: typeof p.displayOrder === "number" && p.displayOrder !== -1 ? p.displayOrder : void 0,
-		...displayOf(p),
-		calculationFormula: p.fieldType === "calculation_equation" ? filled(p.calculationFormula) : void 0,
-		dataSensitivity: unlessDefault("dataSensitivity", p.dataSensitivity)
-	});
-	return options?.length ? { options } : void 0;
-}
-function displayOf(p) {
-	const shown = (field) => TYPE_FIELDS[field]?.includes(p.type) === true;
-	return {
-		numberDisplayHint: shown("numberDisplayHint") ? unlessDefault("numberDisplayHint", p.numberDisplayHint) : void 0,
-		showCurrencySymbol: shown("showCurrencySymbol") ? p.showCurrencySymbol || void 0 : void 0,
-		currencyPropertyName: shown("currencyPropertyName") ? filled(p.currencyPropertyName) : void 0,
-		textDisplayHint: shown("textDisplayHint") ? filled(p.textDisplayHint) : void 0
-	};
-}
-function filled(value) {
-	return typeof value === "string" && value !== "" ? value : void 0;
-}
-function unlessDefault(field, value) {
-	return typeof value === "string" && value !== "" && value !== DEFAULTS.definition[field] ? value : void 0;
-}
-function normalizeOptions(raw) {
-	const order = (o) => o.displayOrder === void 0 || o.displayOrder < 0 ? Number.MAX_SAFE_INTEGER : o.displayOrder;
-	return [...raw].sort((a, b) => order(a) - order(b)).map((o) => compact$4({
-		value: o.value,
-		label: o.label,
-		hidden: o.hidden || void 0,
-		description: o.description || void 0
-	}));
-}
-function normalizeGroups(raw) {
-	return { groups: new Map(raw.filter((g) => !g.archived).map((g) => [g.name, g.label])) };
-}
-/** The schema fields the object file carries, the three lists as HubSpot returned them. */
-function normalizeSchema(schema) {
-	return compact$4({
-		labels: compact$4({
-			singular: schema.labels?.singular,
-			plural: schema.labels?.plural
-		}),
-		primaryDisplayProperty: schema.primaryDisplayProperty,
-		requiredProperties: schema.requiredProperties,
-		searchableProperties: schema.searchableProperties,
-		secondaryDisplayProperties: schema.secondaryDisplayProperties
-	});
-}
-function compact$4(value) {
-	return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0));
-}
 const CONFIG$1$1 = "kalup.config.ts";
 /** HubSpot lists only non-sensitive properties unless asked, and takes one sensitivity per request. */
 const SENSITIVITIES$1 = [
@@ -5301,9 +5996,23 @@ async function readPortal(http, loaded, target, issues, options = {}) {
 			name: p.name,
 			hubspotDefined: Boolean(p.hubspotDefined)
 		});
+		const pipelines = await objectPipelines(http, {
+			key,
+			schema,
+			loaded,
+			options
+		}, {
+			renames,
+			excluded,
+			shadowed
+		}, {
+			issues,
+			gaps
+		});
 		objects.push({
 			object: key,
 			objectTypeId: schema?.objectTypeId,
+			...pipelines ? { pipelines } : {},
 			...normalizeGroups(localize(lists.groups, groupNames).filter(kept("group"))),
 			...normalizeProperties(key, properties, issues, wanted),
 			meta: propertyMeta(properties),
@@ -5323,6 +6032,46 @@ async function readPortal(http, loaded, target, issues, options = {}) {
 		unknownIncludes
 	};
 }
+async function objectPipelines(http, { key, schema, loaded, options }, { renames, excluded, shadowed }, { issues, gaps }) {
+	const custom = schema !== void 0;
+	if (!(options.pipelines === true && hasPipelines(key, custom) || pipelinesInScope(loaded.config.objects[key], loaded.ir, key))) return;
+	return await readPipelines(http, key, schema ? schema.objectTypeId : key, issues, gaps, (listed) => localPipelines$1(key, normalizePipelines(key, listed, custom), renames, excluded, shadowed));
+}
+async function readPipelines(http, object, objectType, issues, gaps, local) {
+	const listed = await gap(() => http.request({
+		type: "pipeline",
+		path: "list",
+		params: { objectType }
+	}), issues, gaps, {
+		list: "pipelines",
+		object,
+		scope: readScope(registry.pipeline, objectType)
+	});
+	return listed && local(listed.results);
+}
+function localPipelines$1(object, live, renames, excluded, shadowed) {
+	const where = ` on ${object}`;
+	const pipelines = localNames(renames, `pipeline:${object}/`, live.map((p) => p.id), where);
+	shadowed.push(...pipelines.shadowed);
+	const out = [];
+	for (const p of live) {
+		const id = pipelines.local(p.id);
+		if (pipelines.shadows(p.id) || excluded.has(`pipeline:${object}/${id}`)) continue;
+		const prefix = `stage:${object}/${id}/`;
+		const stages = localNames(renames, prefix, p.stages.map((st) => st.id), where);
+		shadowed.push(...stages.shadowed);
+		const kept = p.stages.filter((st) => !(stages.shadows(st.id) || excluded.has(`${prefix}${stages.local(st.id)}`)));
+		out.push({
+			...p,
+			id,
+			stages: kept.map((st) => ({
+				...st,
+				id: stages.local(st.id)
+			}))
+		});
+	}
+	return out;
+}
 /**
 * One object's archived properties, sorted by name, from the three archived lists merged by name (the first list
 * wins). Portal names: no override applies. Any error propagates.
@@ -5415,6 +6164,10 @@ async function gap(read, issues, gaps, missed) {
 }
 function excludedAddresses(ir, overrides) {
 	const out = new Set(Object.keys(overrides).filter((address) => overrides[address]?.skip === true));
+	for (const address of Object.keys(ir.resources)) {
+		const pipeline = address.startsWith("stage:") ? `pipeline:${address.slice(6, address.lastIndexOf("/"))}` : void 0;
+		if (pipeline !== void 0 && out.has(pipeline)) out.add(address);
+	}
 	for (const [address, resource] of Object.entries(ir.resources)) {
 		const override = Object.hasOwn(overrides, address) ? overrides[address] : void 0;
 		const moved = resource.managed ? override?.definition?.group : void 0;
@@ -5526,7 +6279,7 @@ function sha256$1(text) {
 	return `sha256:${createHash("sha256").update(text).digest("hex")}`;
 }
 function approvalStep(step) {
-	const { address, action, transport, api, labels, baseUnits, desired, ignoreChanges, changes, expect } = step;
+	const { address, action, transport, api, labels, baseUnits, desired, ignoreChanges, changes, expect, stages } = step;
 	return {
 		address,
 		action,
@@ -5535,6 +6288,7 @@ function approvalStep(step) {
 		labels,
 		baseUnits,
 		desired,
+		...stages ? { stages } : {},
 		ignoreChanges,
 		changes: changes?.map(({ unit, op, after }) => ({
 			unit,
@@ -5544,28 +6298,70 @@ function approvalStep(step) {
 		expect
 	};
 }
-const pinWarningDays = 90;
-/** One warning per API family whose pin expires within 90 days. `expires` is a month; its first day counts. */
-function pinWarnings(rows, now = Date.now()) {
-	const out = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const row of rows) {
-		if (row.expires === void 0) continue;
-		const pin = `${row.family} ${row.version}`;
-		const expires = /* @__PURE__ */ new Date(`${row.expires}-01T00:00:00Z`);
-		if (seen.has(pin) || expires.getTime() - now > pinWarningDays * 864e5) continue;
-		seen.add(pin);
-		out.push({
-			code: "W_PIN_EXPIRES",
-			message: `the ${row.family} API pin ${row.version} expires ${row.expires}`,
-			fix: `upgrade ${bin} to a release that pins a newer version`
-		});
-	}
-	return out;
+/**
+* The exact create body for a managed property (POST /crm/properties/{version}/{objectType}) or group. Enum aliases
+* live in the binding, so they never reach HubSpot. An unmanaged resource is never created, so it throws. Object
+* schemas wait for milestone 4.
+*/
+function toCreatePayload(address, resource) {
+	const { type, path } = parseAddress(address);
+	const name = lastSegment(path);
+	if (!resource.managed) throw new Error(`${address} is not managed and is never created`);
+	const { definition } = resource;
+	if (!definition) throw new Error(`${address} has no definition to create from`);
+	if (type === "group") return {
+		name,
+		label: definition.label
+	};
+	if (type === "object") throw new Error(`${address}: the create payload for an object waits for milestone 4`);
+	if (type !== "property") throw new Error(`${address}: no create payload for type "${type}"`);
+	const group = definition.group;
+	if (!group?.$ref) throw new Error(`${address}: definition.group is not a $ref`);
+	const payload = {
+		name,
+		label: definition.label,
+		type: definition.type,
+		fieldType: definition.fieldType,
+		groupName: lastSegment(parseAddress(group.$ref).path)
+	};
+	if ("description" in definition) payload.description = definition.description;
+	if (Array.isArray(definition.options)) payload.options = definition.options.map((option, index) => ({
+		...option,
+		displayOrder: index
+	}));
+	else if (definition.type === "bool" && definition.fieldType === "booleancheckbox") payload.options = BOOLEAN_OPTIONS.map((option) => ({ ...option }));
+	for (const field of CREATE_FIELDS) if (field in definition) payload[field] = definition[field];
+	return payload;
 }
-/** A count and its noun: `1 write`, `2 writes`. The plural is the noun plus `s` unless `many` gives another. */
-function plural(count, one, many = `${one}s`) {
-	return `${count} ${count === 1 ? one : many}`;
+/** The fields a create sends as the definition states them, after name, label, type, fieldType, group and options. */
+const CREATE_FIELDS = [
+	"hasUniqueValue",
+	"formField",
+	"hidden",
+	"displayOrder",
+	"numberDisplayHint",
+	"showCurrencySymbol",
+	"currencyPropertyName",
+	"textDisplayHint",
+	"calculationFormula",
+	"dataSensitivity",
+	"externalOptions",
+	"referencedObjectType"
+];
+/** The two options HubSpot requires on a `bool` property, labelled as HubSpot's UI labels them. */
+const BOOLEAN_OPTIONS = [{
+	label: "Yes",
+	value: "true",
+	displayOrder: 0,
+	hidden: false
+}, {
+	label: "No",
+	value: "false",
+	displayOrder: 1,
+	hidden: false
+}];
+function lastSegment(path) {
+	return path.slice(path.lastIndexOf("/") + 1);
 }
 /** The classes a person settles: config and HubSpot moved apart, or never agreed. */
 const REVERTING = /* @__PURE__ */ new Set([
@@ -5584,12 +6380,24 @@ const FIELD_END = /[.[]/;
 /**
 * What an update may write, by the unit's field, from HubSpot's documented update schema as live runs confirmed it
 * (docs/hubspot.md): a property its label, description, group (sent as groupName), formField, fieldType, options,
-* hidden, displayOrder, number and text display fields and calculation formula; a group its label. A custom object
-* schema is compared and never written in this release.
+* hidden, displayOrder, number and text display fields and calculation formula; a group its label; a pipeline its
+* label, displayOrder and the order of its stages; a stage its label and its metadata field. A custom object schema is
+* compared and never written in this release.
 */
 const WRITABLE = {
 	object: /* @__PURE__ */ new Set(),
 	group: /* @__PURE__ */ new Set(["label"]),
+	pipeline: /* @__PURE__ */ new Set([
+		"label",
+		"displayOrder",
+		"stages"
+	]),
+	stage: /* @__PURE__ */ new Set([
+		"label",
+		"probability",
+		"ticketState",
+		"state"
+	]),
 	property: /* @__PURE__ */ new Set([
 		"label",
 		"description",
@@ -5606,8 +6414,24 @@ const WRITABLE = {
 		"calculationFormula"
 	])
 };
-/** Units whose change rewrites values HubSpot holds on records, which plan does not check: a step that sets one is risky. */
-const REVALUES = /* @__PURE__ */ new Set(["fieldType", "calculationFormula"]);
+/**
+* Units whose change rewrites values HubSpot holds on records, which plan does not check, or changes how existing
+* records count (a stage's probability or closed state moves forecasts and open and closed reports): a step that sets
+* one is risky.
+*/
+const REVALUES = /* @__PURE__ */ new Set([
+	"fieldType",
+	"calculationFormula",
+	"probability",
+	"ticketState",
+	"state"
+]);
+/** An ID made of digits alone: one HubSpot assigned, as to a pipeline or stage made in the HubSpot UI. */
+const ASSIGNED = /^\d+$/;
+/** Whether Kalup writes the pipelines of an object: deals, tickets and custom objects. */
+function writesPipelines(object) {
+	return stageField(object, !STANDARD_OBJECTS.has(object)) !== void 0;
+}
 /**
 * What a classified unit becomes. `converged` agrees; `config-change`, `add` and `remove` are written; `keep` is kept
 * with a note. `drift` and `conflict` are held unless `--take config` selected the unit (`taken`) or the target
@@ -5638,7 +6462,7 @@ function deriveChange(unit, policy, taken) {
 function stepRisk(step, context) {
 	if (step.risk === "blocked" || step.action === "unknown") return "blocked";
 	switch (step.action) {
-		case "create": return context.owner ? "risky" : "safe";
+		case "create": return context.owner || assignedId(step) ? "risky" : "safe";
 		case "delete": return "destructive";
 		case "manual": return "manual";
 		case "release": return "safe";
@@ -5663,6 +6487,15 @@ function stepLabels(step, context) {
 	if ((step.changes ?? []).some((c) => c.op === "remove" && context.takeoverUnits?.has(c.unit))) labels.push("takeover");
 	return labels;
 }
+/**
+* Whether a pipeline or stage create sends an ID HubSpot assigned in another portal, all digits, for itself or a stage
+* it carries: on a portal that holds the same pipeline under other IDs it makes a copy, so it is risky.
+*/
+function assignedId(step) {
+	const type = step.address.slice(0, step.address.indexOf(":"));
+	const ids = [step.address, ...(step.stages ?? []).map((st) => st.address)].map((a) => a.slice(a.lastIndexOf("/") + 1));
+	return step.action === "create" && (type === "pipeline" || type === "stage") && ids.some((id) => ASSIGNED.test(id));
+}
 /** The field a unit belongs to: `options` for an option member, a member's field and `options.order`. */
 function fieldOf(unit) {
 	const at = unit.search(FIELD_END);
@@ -5731,77 +6564,79 @@ function deleteBlock(meta, members) {
 		fix: "move them to another group or delete them first; HubSpot archives a group only once every property in it is archived"
 	};
 }
-function classOf(change, context) {
-	return context.classes?.[change.unit] ?? change.class;
+/**
+* Whether a stage's values leave it closed: a ticket or custom object stage set or created CLOSED. Apply runs such a
+* stage step before the pipeline's other stage steps, so a ticket pipeline always keeps a closed stage.
+*/
+function closesStage(values) {
+	return values?.ticketState === "CLOSED" || values?.state === "CLOSED";
 }
-function revertsByTake(change, context) {
-	const cls = classOf(change, context);
-	return REVERTING.has(cls) && !(context.drift === "overwrite" && cls !== "diverged");
+/**
+* `resources` as the steps `before` a stage delete leave them: each stage those steps create added to its pipeline's
+* order, and each stage field they write set. A delete runs only once every step before it is done, so the stage delete
+* rule counts what they leave.
+*/
+function afterSteps(resources, before) {
+	const out = { ...resources };
+	const at = (address) => Object.hasOwn(out, address) ? out[address] : void 0;
+	for (const step of before) {
+		if (!((step.action === "create" || step.action === "update" || step.action === "adopt") && step.address.startsWith("stage:"))) continue;
+		const pipeline = `pipeline:${step.address.slice(6, step.address.lastIndexOf("/"))}`;
+		const id = step.address.slice(step.address.lastIndexOf("/") + 1);
+		const held = at(pipeline);
+		const stages = held?.definition?.stages ?? [];
+		if (held && !stages.includes(id)) out[pipeline] = {
+			...held,
+			definition: {
+				...held.definition,
+				stages: [...stages, id]
+			}
+		};
+		const written = step.action === "create" ? step.desired ?? {} : Object.fromEntries((step.changes ?? []).map((c) => [c.unit, c.after]));
+		const current = at(step.address);
+		out[step.address] = {
+			type: "stage",
+			managed: true,
+			...current,
+			definition: {
+				...current?.definition,
+				...written
+			}
+		};
+	}
+	return out;
 }
 /**
-* The exact create body for a managed property (POST /crm/properties/{version}/{objectType}) or group. Enum aliases
-* live in the binding, so they never reach HubSpot. An unmanaged resource is never created, so it throws. Object
-* schemas wait for milestone 4.
+* Why a stage cannot be deleted, or undefined when it can: HubSpot refuses to leave a pipeline with no stage, or a
+* ticket pipeline with no closed stage (observed 2026-10-05). `resources` holds the pipeline and its stages as a read
+* found them and the steps before the delete leave them (afterSteps); `gone` the IDs of the stages of that pipeline
+* deleted before this one. `cli` names the command in the fix.
 */
-function toCreatePayload(address, resource) {
-	const { type, path } = parseAddress(address);
-	const name = lastSegment(path);
-	if (!resource.managed) throw new Error(`${address} is not managed and is never created`);
-	const { definition } = resource;
-	if (!definition) throw new Error(`${address} has no definition to create from`);
-	if (type === "group") return {
-		name,
-		label: definition.label
+function stageDeleteRule(resources, stage, gone, cli) {
+	const pipeline = `pipeline:${stage.slice(6, stage.lastIndexOf("/"))}`;
+	const id = stage.slice(stage.lastIndexOf("/") + 1);
+	const at = (address) => Object.hasOwn(resources, address) ? resources[address] : void 0;
+	const ids = (at(pipeline)?.definition?.stages ?? []).filter((other) => other !== id && !gone.has(other));
+	const fix = `run ${cli} rm on ${pipeline} to delete the whole pipeline, or keep the stage: set its tombstone's action to release`;
+	if (ids.length === 0) return {
+		short: "last stage",
+		detail: "it is the last stage of its pipeline, and HubSpot keeps one",
+		fix
 	};
-	if (type === "object") throw new Error(`${address}: the create payload for an object waits for milestone 4`);
-	if (type !== "property") throw new Error(`${address}: no create payload for type "${type}"`);
-	const group = definition.group;
-	if (!group?.$ref) throw new Error(`${address}: definition.group is not a $ref`);
-	const payload = {
-		name,
-		label: definition.label,
-		type: definition.type,
-		fieldType: definition.fieldType,
-		groupName: lastSegment(parseAddress(group.$ref).path)
+	const prefix = `${pipeline.replace("pipeline:", "stage:")}/`;
+	const closed = (other) => at(`${prefix}${other}`)?.definition?.ticketState === "CLOSED";
+	if (at(stage)?.definition?.ticketState === "CLOSED" && !ids.some(closed)) return {
+		short: "last closed stage",
+		detail: "it is the last closed stage of its ticket pipeline, and HubSpot keeps one",
+		fix: "mark another stage ticketState: 'CLOSED' first"
 	};
-	if ("description" in definition) payload.description = definition.description;
-	if (Array.isArray(definition.options)) payload.options = definition.options.map((option, index) => ({
-		...option,
-		displayOrder: index
-	}));
-	else if (definition.type === "bool" && definition.fieldType === "booleancheckbox") payload.options = BOOLEAN_OPTIONS.map((option) => ({ ...option }));
-	for (const field of CREATE_FIELDS) if (field in definition) payload[field] = definition[field];
-	return payload;
 }
-/** The fields a create sends as the definition states them, after name, label, type, fieldType, group and options. */
-const CREATE_FIELDS = [
-	"hasUniqueValue",
-	"formField",
-	"hidden",
-	"displayOrder",
-	"numberDisplayHint",
-	"showCurrencySymbol",
-	"currencyPropertyName",
-	"textDisplayHint",
-	"calculationFormula",
-	"dataSensitivity",
-	"externalOptions",
-	"referencedObjectType"
-];
-/** The two options HubSpot requires on a `bool` property, labelled as HubSpot's UI labels them. */
-const BOOLEAN_OPTIONS = [{
-	label: "Yes",
-	value: "true",
-	displayOrder: 0,
-	hidden: false
-}, {
-	label: "No",
-	value: "false",
-	displayOrder: 1,
-	hidden: false
-}];
-function lastSegment(path) {
-	return path.slice(path.lastIndexOf("/") + 1);
+function classOf(change, context) {
+	return context.classes?.[change.unit] ?? change.class;
+}
+function revertsByTake(change, context) {
+	const cls = classOf(change, context);
+	return REVERTING.has(cls) && !(context.drift === "overwrite" && cls !== "diverged");
 }
 const MEMBER$1 = /^options\[(.*)\](?:\.(label|hidden|description))?$/s;
 /**
@@ -5889,6 +6724,67 @@ function optionsPatch(changes, live, desired = []) {
 		displayOrder
 	}));
 }
+/** A stage's metadata as HubSpot takes it: the field config states, as a string. */
+function stageMetadata(fields) {
+	const out = {};
+	for (const field of STAGE_FIELDS) if (fields[field] !== void 0) out[field] = String(fields[field]);
+	return out;
+}
+/**
+* The create body of a pipeline step: its ID, label and displayOrder, and every stage it carries, in display order,
+* each with its ID, its index as displayOrder and its metadata. HubSpot refuses a pipeline without a stage.
+*/
+function pipelineCreateBody(step, pipelineId) {
+	const desired = step.desired ?? {};
+	return {
+		pipelineId,
+		label: desired.label,
+		displayOrder: desired.displayOrder,
+		stages: (step.stages ?? []).map((st, displayOrder) => ({
+			stageId: st.address.slice(st.address.lastIndexOf("/") + 1),
+			label: st.desired.label,
+			displayOrder,
+			metadata: stageMetadata(st.desired)
+		}))
+	};
+}
+/** The create body of a stage step: its ID, label and metadata, at `displayOrder`, a free slot after every stage. */
+function stageCreateBody(desired, stageId, displayOrder) {
+	return {
+		stageId,
+		label: desired.label,
+		displayOrder,
+		metadata: stageMetadata(desired)
+	};
+}
+/** The PATCH body of a pipeline step: its approved label and displayOrder. Stage order is written stage by stage. */
+function pipelinePatch(changes) {
+	const body = {};
+	for (const change of changes) if (change.unit === "label" || change.unit === "displayOrder") body[change.unit] = change.after;
+	return body;
+}
+/** The PATCH body of a stage step: its approved label, and its metadata field, which HubSpot merges into the rest. */
+function stagePatch(changes) {
+	const body = {};
+	const fields = {};
+	for (const change of changes) if (change.unit === "label") body.label = change.after;
+	else fields[change.unit] = change.after;
+	const metadata = stageMetadata(fields);
+	return Object.keys(metadata).length > 0 ? {
+		...body,
+		metadata
+	} : body;
+}
+/**
+* The stage order a write leaves: every live stage, the approved order's stages in that order, each in a slot one of
+* them holds, so a stage the order leaves out keeps its place among its neighbours. Stages the approved order names and
+* HubSpot does not hold are left out.
+*/
+function stageOrder(live, approved) {
+	const queue = approved.filter((id) => live.includes(id));
+	const placed = new Set(queue);
+	return live.map((id) => placed.has(id) ? queue.shift() : id);
+}
 /** The option values a step's approved changes remove. */
 function removedValues(changes = []) {
 	return changes.filter((c) => c.op === "remove").flatMap((c) => {
@@ -5951,6 +6847,17 @@ const CAPTURED = {
 		"secondaryDisplayProperties"
 	],
 	group: ["label"],
+	pipeline: [
+		"label",
+		"displayOrder",
+		"stages"
+	],
+	stage: [
+		"label",
+		"probability",
+		"ticketState",
+		"state"
+	],
 	property: PROPERTY_FIELDS.filter((field) => field !== "options"),
 	unsupported: [
 		"label",
@@ -5999,10 +6906,36 @@ function objectOf(address) {
 	const { type, path } = parseAddress(address);
 	return type === "object" ? path : path.slice(0, path.indexOf("/"));
 }
+/** The path after the object: a stage's is `<pipeline>/<stage>`; see stageIdOf for its own ID. */
 function nameOf(address) {
 	const { type, path } = parseAddress(address);
 	return type === "object" ? path : path.slice(path.indexOf("/") + 1);
 }
+/** The pipeline a stage address is under, `pipeline:<k>/<p>`. */
+function pipelineOf(stage) {
+	return `pipeline:${stage.slice(6, stage.lastIndexOf("/"))}`;
+}
+/** A pipeline's or stage's own ID: the last segment of its address. */
+function ownId(address) {
+	return address.slice(address.lastIndexOf("/") + 1);
+}
+/** The name a title gives a resource: a stage's own ID, otherwise the name in its address. */
+function shownName(address) {
+	return parseAddress(address).type === "stage" ? ownId(address) : nameOf(address);
+}
+/** Where a title places a resource after its name: its pipeline and object for a stage, its object for the rest. */
+function placeOf(address) {
+	const { type } = parseAddress(address);
+	if (type === "object") return "";
+	return `${type === "stage" ? ` of pipeline ${ownId(pipelineOf(address))}` : ""} on ${objectOf(address)}`;
+}
+/** How a title words a field a step sets: a field whose change rewrites or recounts record values says so. */
+function fieldWords(unit) {
+	if (unit === "stages") return "the stage order";
+	return REVALUES.has(unit) ? `${unit} (the effect on existing values is not checked)` : unit;
+}
+/** What a title adds to the delete of a pipeline or stage: HubSpot purges both (observed 2026-10-01). */
+const PURGED = "; it cannot be restored";
 /**
 * What an update or adopt step writes, in words, as the end of its title: `, set label, relabel option "north", add
 * option "Paused"`. `option` gives an added or removed option's words, `field` a set field's. The units stay in the
@@ -6129,9 +7062,21 @@ const NOT_CAPTURED = {
 		"modificationMetadata",
 		"sensitiveDataCategories",
 		"updatedAt",
-		"updatedUserId"
+		"updatedUserId"
+	],
+	group: ["displayOrder"],
+	pipeline: [
+		"archived",
+		"createdAt",
+		"updatedAt"
+	],
+	stage: [
+		"archived",
+		"createdAt",
+		"isClosed",
+		"updatedAt",
+		"writePermissions"
 	],
-	group: ["displayOrder"],
 	object: [
 		"allowsSensitiveProperties",
 		"associations",
@@ -6148,8 +7093,12 @@ const NOT_CAPTURED = {
 const OBSERVED_TYPES = /* @__PURE__ */ new Set([
 	"object",
 	"group",
-	"property"
+	"property",
+	"pipeline",
+	"stage"
 ]);
+/** The resource types read from an object's pipelines list. */
+const PIPELINE_TYPES = /* @__PURE__ */ new Set(["pipeline", "stage"]);
 const NAME_FIX = "rename it in HubSpot to a name without spaces";
 /**
 * The config IR as the side of a comparison, as target `target` sees it when one is given: its definition overrides
@@ -6189,13 +7138,14 @@ function observePortal(portal, loaded, targetName, issues) {
 				resources,
 				meta
 			}, issues) : unread$2(key, portal),
+			pipelines: live ? pipelineCoverage(live, portal, resources, issues) : void 0,
 			shadowed: nonEmpty([...new Set(portal.shadowed.filter(under).map(nameOf))].sort(byCodeUnit)),
 			excluded: nonEmpty(portal.excluded.filter(under)),
 			renamed: renamed(target.overrides ?? {}, under)
 		});
 	}
 	const coverage = {
-		complete: Object.values(objects).every((o) => o.status !== "unreadable" && o.unaddressable === void 0),
+		complete: Object.values(objects).every((o) => o.status !== "unreadable" && o.unaddressable === void 0 && o.pipelines?.status !== "unreadable"),
 		objects,
 		otherObjects: portal.customObjects === void 0 ? "unknown" : [...portal.otherObjects].sort(byCodeUnit),
 		notCaptured: NOT_CAPTURED
@@ -6230,18 +7180,27 @@ function statusOf(observation, address) {
 	const object = Object.hasOwn(coverage.objects, key) ? coverage.objects[key] : void 0;
 	if (!(object && OBSERVED_TYPES.has(type))) return "not-observed";
 	if (object.status !== "read") return object.status;
+	if (PIPELINE_TYPES.has(type)) return pipelineStatus(object, address, held);
 	if (type === "object") {
 		if (object.unsupportedSchema) return "unsupported";
 		return held ? "present" : "absent";
 	}
 	if (object.excluded?.includes(address)) return "excluded";
 	if (held) return "present";
+	return type === "property" ? propertyStatus(object, address) : "absent";
+}
+function propertyStatus(object, address) {
 	const name = nameOf(address);
-	if (type !== "property") return "absent";
 	if (object.unsupported?.some((u) => u.name === name)) return "unsupported";
 	if (object.unaddressable?.includes(name)) return "unreadable";
 	return !(object.renamed && Object.hasOwn(object.renamed, address)) && object.outOfScope?.includes(name) ? "excluded" : "absent";
 }
+function pipelineStatus(object, address, held) {
+	if (object.pipelines === void 0) return "not-observed";
+	if (object.pipelines.status !== "read") return "unreadable";
+	if (object.excluded?.includes(address)) return "excluded";
+	return held ? "present" : "absent";
+}
 /** The type ID of each custom object the observation saw exist, by config key. */
 function objectTypeIds(observation) {
 	const out = {};
@@ -6323,6 +7282,51 @@ function unsupportedProperty(object, u) {
 		group: { $ref: `group:${object}/${u.group}` }
 	};
 }
+function pipelineCoverage(live, portal, resources, issues) {
+	const { object } = live;
+	if (live.pipelines === void 0) {
+		const gap = portal.gaps.find((g) => g.object === object && g.list === "pipelines");
+		return gap ? {
+			status: "unreadable",
+			missingScope: gap.scope
+		} : void 0;
+	}
+	const held = (id) => isAddress(`pipeline:${object}/${id}`) && !id.includes("/");
+	const leave = (what, id) => issues.push({
+		code: "W_UNADDRESSABLE_NAME",
+		message: `${what} '${sanitize(id)}' on ${object} has an ID no address can hold, so it is not captured`,
+		fix: "leave it out of config; HubSpot never changes a pipeline or stage ID"
+	});
+	for (const p of live.pipelines) {
+		if (!held(p.id)) {
+			leave("pipeline", p.id);
+			continue;
+		}
+		const stages = p.stages.filter((st) => {
+			if (!held(st.id)) leave("stage", st.id);
+			return held(st.id);
+		});
+		const definition = {
+			label: p.label,
+			displayOrder: p.displayOrder,
+			stages: stages.map((st) => st.id)
+		};
+		resources.push([`pipeline:${object}/${p.id}`, {
+			type: "pipeline",
+			managed: true,
+			definition
+		}]);
+		for (const st of stages) {
+			const { id, ...fields } = st;
+			resources.push([`stage:${object}/${p.id}/${id}`, {
+				type: "stage",
+				managed: true,
+				definition: fields
+			}]);
+		}
+	}
+	return { status: "read" };
+}
 function unread$2(key, portal) {
 	if (portal.excluded.includes(`object:${key}`)) return { status: "excluded" };
 	if (portal.absent.includes(key)) return { status: "absent" };
@@ -6342,6 +7346,25 @@ function nonEmpty(list) {
 function compact$3(value) {
 	return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0));
 }
+const pinWarningDays = 90;
+/** One warning per API family whose pin expires within 90 days. `expires` is a month; its first day counts. */
+function pinWarnings(rows, now = Date.now()) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const row of rows) {
+		if (row.expires === void 0) continue;
+		const pin = `${row.family} ${row.version}`;
+		const expires = /* @__PURE__ */ new Date(`${row.expires}-01T00:00:00Z`);
+		if (seen.has(pin) || expires.getTime() - now > pinWarningDays * 864e5) continue;
+		seen.add(pin);
+		out.push({
+			code: "W_PIN_EXPIRES",
+			message: `the ${row.family} API pin ${row.version} expires ${row.expires}`,
+			fix: `upgrade ${bin} to a release that pins a newer version`
+		});
+	}
+	return out;
+}
 /** The account types a target is not protected on unless config says so: test portals, sandboxes, app developers. */
 const UNPROTECTED = /* @__PURE__ */ new Set([
 	"DEVELOPER_TEST",
@@ -6399,6 +7422,30 @@ async function preflight(http, request) {
 			} : overall);
 		}));
 	}
+	if (request.pipelines) {
+		const observed = new Set(Object.values(request.objectTypeIds));
+		limits.push(await reading(registry.pipeline.limitKey, async () => {
+			const body = await http.request({
+				type: "limits",
+				path: "pipelines"
+			});
+			const custom = body?.customObjectTypes;
+			const overall = figures(custom?.overallLimit, custom?.overallUsage);
+			const listed = body?.hubspotDefinedObjectTypes;
+			const byObjectType = (Array.isArray(listed) ? listed : []).flatMap((item) => {
+				const { objectTypeId, limit, usage } = item ?? {};
+				const entry = typeof objectTypeId === "string" && observed.has(objectTypeId) && figures(limit, usage);
+				return entry ? [{
+					objectTypeId,
+					...entry
+				}] : [];
+			}).sort((a, b) => byCodeUnit(a.objectTypeId, b.objectTypeId));
+			return overall && (byObjectType.length > 0 ? {
+				...overall,
+				byObjectType
+			} : overall);
+		}));
+	}
 	return { limits };
 }
 /**
@@ -6414,6 +7461,7 @@ function headroom(limits, creates, objectTypeIds, target) {
 		blocked: {},
 		issues: []
 	};
+	pipelineRoom(out, limits, creates, objectTypeIds, target);
 	const ofType = (type) => creates.filter((address) => parseAddress(address).type === type);
 	const objectTypes = readOf(limits, registry.object.limitKey);
 	if (objectTypes) check$2(out, ofType("object"), objectTypes, "custom objects", target);
@@ -6429,6 +7477,24 @@ function headroom(limits, creates, objectTypeIds, target) {
 	}
 	return out;
 }
+/**
+* The room the pipelines reading leaves for pipeline creates: a standard object's against its own entry, a custom
+* object's against the overall custom object figures. Called by headroom.
+*/
+function pipelineRoom(out, limits, creates, ids, target) {
+	const pipelines = readOf(limits, registry.pipeline.limitKey);
+	if (!pipelines) return;
+	const byObject = /* @__PURE__ */ new Map();
+	for (const address of creates.filter((a) => parseAddress(a).type === "pipeline")) byObject.set(objectOf(address), [...byObject.get(objectOf(address)) ?? [], address]);
+	const custom = [];
+	for (const [key, list] of byObject) {
+		const id = Object.hasOwn(ids, key) ? ids[key] : void 0;
+		const entry = pipelines.byObjectType?.find((e) => e.objectTypeId === id);
+		if (entry) check$2(out, list, entry, `pipelines on ${key}`, target);
+		else if (!(id ?? "").startsWith("0-")) custom.push(...list);
+	}
+	check$2(out, custom, pipelines, "custom object pipelines", target);
+}
 function check$2(out, creates, { limit, usage }, what, target) {
 	const room = limit - usage;
 	if (creates.length === 0 || room >= creates.length) return;
@@ -6620,16 +7686,37 @@ function schemaNames(definition) {
 function own$3(record, key) {
 	return Object.hasOwn(record, key) ? record[key] : void 0;
 }
+function indexPipelines(observation) {
+	const out = {
+		pipelines: /* @__PURE__ */ new Map(),
+		stages: /* @__PURE__ */ new Map()
+	};
+	for (const address of Object.keys(observation.resources)) {
+		const kind = kindOf$3(address);
+		if (kind === "pipeline" || kind === "stage") {
+			const by = out[kind === "pipeline" ? "pipelines" : "stages"];
+			by.set(objectOf(address), [...by.get(objectOf(address)) ?? [], address]);
+		}
+	}
+	return out;
+}
 const CREATED_FIRST = [
 	"label",
 	"group",
 	"fieldType"
 ];
 const CREATE_ONLY = /* @__PURE__ */ new Set(["hasUniqueValue", "dataSensitivity"]);
+const HIDDEN_CREATED = /* @__PURE__ */ new Set([
+	"type",
+	"options",
+	"stages"
+]);
 const KINDS = [
 	"object",
 	"group",
-	"property"
+	"property",
+	"pipeline",
+	"stage"
 ];
 const TRANSPORT = "public-api";
 const SETS = /* @__PURE__ */ new Set(["requiredProperties", "searchableProperties"]);
@@ -6641,9 +7728,13 @@ const PROVENANCE_ACTIONS = /* @__PURE__ */ new Set([
 ]);
 const NOT_COVERED = {
 	object: "Not copied, HubSpot has no API: record page layouts, saved views.",
-	property: "Not copied, HubSpot has no API: conditional property logic, field-level permissions."
+	property: "Not copied, HubSpot has no API: conditional property logic, field-level permissions.",
+	pipeline: "Not copied, HubSpot has no API: stage required properties, conditional stage properties, pipeline automation, pipeline permissions."
 };
 const NO_SCHEMA_WRITES = "custom object schema writes are not supported in this release";
+function noPipelineWrites(object) {
+	return `Kalup reads and compares the pipelines of ${object} and does not write them in this release`;
+}
 const INCOMPLETE_FIX = "give the key the scopes the plan warns about, then plan again";
 const TITLE_MAX$1 = 160;
 const TEXT_MAX$2 = 400;
@@ -6756,6 +7847,7 @@ function planReads(input) {
 		limits: {
 			objectTypes: decided.steps.some((s) => s.action === "create" && s.risk !== "blocked" && kindOf$3(s.address) === "object"),
 			properties: creates.length > 0 || gone.some((g) => g.taken),
+			pipelines: decided.steps.some((s) => s.action === "create" && s.risk !== "blocked" && kindOf$3(s.address) === "pipeline"),
 			objectTypeIds: typeIdsOf(coverage)
 		}
 	};
@@ -6816,11 +7908,13 @@ function stepLines(doc, step, project) {
 	const labels = step.labels?.length ? ` [${step.labels.join(", ")}]` : "";
 	const block = step.blocked ? [`  ${step.blocked.detail}`, ...step.blocked.fix === void 0 ? [] : [`  fix: ${step.blocked.fix}`]] : [];
 	const created = step.action === "create" && step.risk !== "blocked" ? createdLine(step.desired ?? {}) : [];
+	const carriedLines = (step.risk === "blocked" ? [] : step.stages ?? []).map((st) => `  + stage ${show$2(st.desired.label)} (${show$2(ownId(st.address))})${stageFields(st.desired)}`);
 	return [
 		`${step.id} ${step.risk}${labels} ${step.title}`,
 		...created,
-		...(step.changes ?? []).map((c) => `  ${changeLine(c)}`),
-		...(step.held ?? []).map((h) => `  held ${h.unit} ${h.class}: ${heldValues(h)}. ${exits(doc, step, h)}`),
+		...carriedLines,
+		...(step.changes ?? []).map((c) => `  ${c.unit === "stages" ? orderLine(step, c) : changeLine(c)}`),
+		...(step.held ?? []).map((h) => h.unit === "stages" ? `  held stage order ${h.class}: ${heldOrder(step, h)}. ${exits(doc, step, h)}` : `  held ${h.unit} ${h.class}: ${heldValues(h)}. ${exits(doc, step, h)}`),
 		...sharedLine(doc, step, project),
 		...(step.notes ?? []).map((n) => `  note ${n.unit}: ${n.note}`),
 		...block
@@ -6833,6 +7927,26 @@ function changeLine(c) {
 	}
 	return `${c.unit}: ${shown$1(c.before)} -> ${shown$1(c.after)}`;
 }
+function orderLine(step, c) {
+	return `stage order: ${byLabel(step, c.before)} -> ${byLabel(step, c.after)}`;
+}
+function heldOrder(step, h) {
+	const base = Object.hasOwn(h, "base") ? `, last agreed ${byLabel(step, h.base)}` : "";
+	return `config ${byLabel(step, h.config)}, portal ${byLabel(step, h.live)}${base}`;
+}
+function byLabel(step, list) {
+	const labels = step.stageLabels ?? {};
+	const ids = Array.isArray(list) ? list : [];
+	const shared = (label) => Object.values(labels).filter((l) => l === label).length > 1;
+	return ids.map((id) => {
+		const label = own$2(labels, id);
+		if (label === void 0) return show$2(id);
+		return shared(label) ? `${show$2(label)} (${id})` : show$2(label);
+	}).join(", ");
+}
+function stageFields(desired) {
+	return Object.entries(desired).filter(([field]) => field !== "label").map(([field, value]) => `, ${field} ${shown$1(value)}`).join("");
+}
 function heldValues(h) {
 	const base = Object.hasOwn(h, "base") ? `, last agreed ${shown$1(h.base)}` : "";
 	return `config ${shown$1(h.config)}, portal ${shown$1(h.live)}${base}`;
@@ -6840,7 +7954,7 @@ function heldValues(h) {
 function createdLine(desired) {
 	const options = desired.options;
 	const given = (field) => Object.hasOwn(desired, field) && desired[field] !== void 0;
-	const rest = Object.keys(desired).filter((field) => !(CREATED_FIRST.includes(field) || field === "type" || field === "options") && given(field)).sort(byCodeUnit);
+	const rest = Object.keys(desired).filter((field) => !(CREATED_FIRST.includes(field) || HIDDEN_CREATED.has(field)) && given(field)).sort(byCodeUnit);
 	const fields = [...[...CREATED_FIRST.filter(given), ...rest].map((field) => `${field} ${shown$1(desired[field])}${CREATE_ONLY.has(field) ? " (create only)" : ""}`), ...options && options.length > 0 ? [`options ${options.map((o) => show$2(o.label)).join(", ")}`] : []];
 	return fields.length > 0 ? [`  ${fields.join(", ")}`] : [];
 }
@@ -6887,6 +8001,7 @@ function decide$1(input, coverage) {
 		matched: /* @__PURE__ */ new Set(),
 		missing: [],
 		overrides: settings.overrides ?? {},
+		pipelines: indexPipelines(observation),
 		policy: {
 			drift,
 			allowDestroy,
@@ -6954,6 +8069,7 @@ function stepFor(context, address, resource, status) {
 		return blocked(address, actionOf(status), "dependency-blocked", detail, detail);
 	}
 	if (status === "unsupported") return unsupported(context, address);
+	if (status === "absent" && kindOf$3(address) === "stage" && carried(context, address)) return;
 	const owner = ownerOf(context, address);
 	if (status === "absent" && owner.entry && kindOf$3(address) !== "object") return ownedAbsent(context, address, resource, override, owner.entry);
 	const group = missingGroup(context, resource);
@@ -6973,6 +8089,14 @@ function stepFor(context, address, resource, status) {
 function unread$1(context, address, status) {
 	const key = objectOf(address);
 	const object = own$2(context.coverage.objects, key);
+	const kind = kindOf$3(address);
+	if ((kind === "pipeline" || kind === "stage") && object?.status === "read") {
+		const scope = object.pipelines?.missingScope;
+		if (object.pipelines === void 0) return blocked(address, "unknown", "scope", "pipelines not read", `the pipelines of ${key} are not in scope, so the plan did not read them`, `set objects.${key}.pipelines: true`);
+		const detail = `the pipelines list of ${key} answered 403, so what the portal holds there is unknown`;
+		const fix = scope === void 0 ? "check the scopes of the key" : `add the scope ${scope} to the key`;
+		return blocked(address, "unknown", "scope", `the key cannot read the pipelines of ${key}`, detail, fix);
+	}
 	if (object?.status === "read") return blocked(address, "unknown", "unsupported", "its portal group has no address", "the portal has it in a group whose name holds whitespace, which no address can hold, so what it holds is unknown", "rename the group in HubSpot to a name without spaces");
 	if (status === "not-observed") {
 		const detail = `${key} is not under objects in kalup.config.ts, so the plan did not read it`;
@@ -6985,7 +8109,11 @@ function unread$1(context, address, status) {
 }
 function blockedParents(context, address, resource) {
 	if (kindOf$3(address) === "object") return [];
-	return [(resource.definition?.group)?.$ref, `object:${objectOf(address)}`].flatMap((parent) => {
+	return [
+		(resource.definition?.group)?.$ref,
+		kindOf$3(address) === "stage" ? pipelineOf(address) : void 0,
+		`object:${objectOf(address)}`
+	].flatMap((parent) => {
 		const found = parent === void 0 ? void 0 : context.decided.get(parent);
 		return found?.risk === "blocked" ? [found] : [];
 	});
@@ -7010,6 +8138,7 @@ function absent(context, address, resource, override) {
 	const kind = kindOf$3(address);
 	const name = nameOf(address);
 	if (kind === "object") return blocked(address, "create", "unsupported", "schema writes not supported", `the portal has no custom object ${name}, and ${NO_SCHEMA_WRITES}`, `create it in HubSpot, or ${skipFix(address, input.target)}`);
+	if (kind === "pipeline" || kind === "stage") return pipelineCreate(context, address, resource);
 	if (kind === "property" && own$2(input.archivedProperties, objectOf(address))?.some((p) => p.name === name)) {
 		const [detail, fix] = archivedName$1(name);
 		return blocked(address, "create", "unsupported", "archived name", detail, fix);
@@ -7022,6 +8151,100 @@ function absent(context, address, resource, override) {
 		expect: { exists: false }
 	};
 }
+function pipelineCreate(context, address, resource) {
+	const { target } = context.input;
+	const object = objectOf(address);
+	if (!writesPipelines(object)) {
+		const fix = `create it in HubSpot and run ${bin} pull, or ${skipFix(address, target)}`;
+		return blocked(address, "create", "unsupported", "pipelines not written", noPipelineWrites(object), fix);
+	}
+	const stages = kindOf$3(address) === "pipeline" ? carriedStages(context, address) : [];
+	if (kindOf$3(address) === "pipeline" && stages.length === 0) return blocked(address, "create", "override", "every stage skipped", `every stage of ${address} is skipped on target ${target}, and HubSpot refuses a pipeline without one`, `skip ${address} too, or keep one of its stages on target ${target}`);
+	for (const at of [address, ...stages.map((st) => st.address)]) {
+		const holder = idHolder(context, at);
+		if (holder) return blocked(address, "create", "unsupported", "ID taken", `${holder} holds the ID ${ownId(at)} in this portal, and HubSpot keeps ${kindOf$3(at)} IDs unique ${kindOf$3(at) === "pipeline" ? "across objects" : `across the pipelines of ${object}`}`, `give ${at} another ID in config`);
+		if (at !== address && own$2(context.overrides, at)?.name) {
+			const detail = `the pipeline is absent, and ${at} carries a name override, so no stage of that name can exist`;
+			return blocked(address, "create", "override", detail, detail, `correct or remove the name override for ${at} under targets.${target}.overrides`);
+		}
+	}
+	const notes = [
+		...assignedNotes(context, address, stages),
+		...unreadClash(context, address),
+		...firstPipelineNote(context, address)
+	];
+	const what = stages.length > 0 ? ` with ${plural(stages.length, "stage")}` : "";
+	return {
+		...head(address, "create", "safe", `Create ${described(address, resource)}${what}`),
+		desired: resource.definition,
+		...stages.length > 0 ? { stages } : {},
+		...notes.length > 0 ? { notes } : {},
+		expect: { exists: false }
+	};
+}
+/** Whether Kalup writes the pipelines of an object: deals, tickets and custom objects. */
+function carriedStages(context, pipeline) {
+	const { resources } = context.input.loaded.ir;
+	return (own$2(resources, pipeline)?.definition?.stages ?? []).flatMap((id) => {
+		const address = `stage:${pipeline.slice(9)}/${id}`;
+		const stage = own$2(resources, address);
+		return stage?.managed && own$2(context.overrides, address)?.skip !== true ? [{
+			address,
+			desired: stage.definition ?? {}
+		}] : [];
+	});
+}
+function carried(context, stage) {
+	const pipeline = pipelineOf(stage);
+	const step = context.decided.get(pipeline);
+	return step?.action === "create" && step.risk !== "blocked" || context.missing.some((m) => m.address === pipeline);
+}
+function idHolder(context, address) {
+	const id = ownId(address);
+	const object = objectOf(address);
+	const { pipelines, stages } = context.pipelines;
+	if (kindOf$3(address) === "pipeline") return [...pipelines].flatMap(([key, held]) => key === object ? [] : held).find((a) => ownId(a) === id);
+	const pipeline = pipelineOf(address);
+	return (stages.get(object) ?? []).find((a) => pipelineOf(a) !== pipeline && ownId(a) === id);
+}
+function unreadClash(context, address) {
+	const other = {
+		deals: "tickets",
+		tickets: "deals"
+	}[objectOf(address)];
+	if (kindOf$3(address) !== "pipeline" || other === void 0) return [];
+	if (own$2(context.coverage.objects, other)?.pipelines?.status === "read") return [];
+	return [{
+		unit: "id",
+		live: null,
+		note: `HubSpot keeps pipeline IDs unique across deals and tickets, and this plan did not read the pipelines of ${other}: HubSpot refuses the create if ${other === "tickets" ? "a ticket pipeline" : "a deal pipeline"} holds ${ownId(address)}`
+	}];
+}
+function assignedNotes(context, address, stages) {
+	const ids = [address, ...stages.map((st) => st.address)].filter((a) => ASSIGNED.test(ownId(a)));
+	if (ids.length === 0) return [];
+	const { observation, target } = context.input;
+	const pipeline = kindOf$3(address) === "stage" ? pipelineOf(address) : address;
+	const label = String(own$2(observation.resources, pipeline)?.definition?.label ?? own$2(context.input.loaded.ir.resources, pipeline)?.definition?.label);
+	const matching = (context.pipelines.pipelines.get(objectOf(address)) ?? []).filter((a) => String(own$2(observation.resources, a)?.definition?.label).toLowerCase() === label.toLowerCase());
+	const [only] = matching;
+	const match = matching.length === 1 && only ? `; the portal holds a pipeline "${label}" as ${ownId(only)}` : "";
+	return [{
+		unit: "id",
+		live: null,
+		note: sanitize(`HubSpot assigned the ID ${ids.map(ownId).join(", ")} in another portal${match}. If this portal holds the same pipeline under other IDs, add a name override for the pipeline and each stage under targets.${target}.overrides instead of creating a copy`, TEXT_MAX$2)
+	}];
+}
+function firstPipelineNote(context, address) {
+	const object = objectOf(address);
+	const first = kindOf$3(address) === "pipeline" && !STANDARD_OBJECTS.has(object) && !context.pipelines.pipelines.has(object);
+	const note = `the first pipeline on ${object}: HubSpot adds its own properties hs_pipeline and hs_pipeline_stage to the object, and keeps them after the pipeline is gone`;
+	return first ? [{
+		unit: "object",
+		live: null,
+		note
+	}] : [];
+}
 function ownedAbsent(context, address, resource, override, entry) {
 	const { input } = context;
 	const kind = kindOf$3(address);
@@ -7032,7 +8255,7 @@ function ownedAbsent(context, address, resource, override, entry) {
 	});
 	const found = kind === "property" ? archivedOf(input.archivedProperties, objectOf(address), portalName$1(context, address)) : null;
 	const archived = found === null ? null : found !== void 0;
-	const recreatable = kind === "group" || archived === false;
+	const recreatable = kind !== "property" || archived === false;
 	if (!taken) {
 		const flag = targetFlag(input.target);
 		context.missing.push({
@@ -7115,9 +8338,13 @@ function settle$1(context, r) {
 	};
 	for (const u of units) place$1(context, r, u, bins);
 	const { baseUnits, changes, held, notes } = bins;
-	if (bins.refused) return blocked(address, action, "unsupported", "schema writes not supported", `${NO_SCHEMA_WRITES}, so --take config cannot write its units`, "leave it out of --take");
+	if (bins.refused) {
+		const detail = `${readOnlyOf(address)}, so --take config cannot write its units`;
+		return blocked(address, action, "unsupported", kind === "object" ? "schema writes not supported" : "pipelines not written", detail, "leave it out of --take");
+	}
 	const meta = context.input.observation.meta?.[address];
 	reorder(r, changes, meta);
+	if (kind === "pipeline") reorderStages(context, r, changes);
 	const block = writeBlock(kind, units, changes.map((c) => c.unit), meta);
 	if (block) return blocked(address, action, "unsupported", block.short, block.detail, block.fix);
 	const takeover = takeoverUnits(context, r, changes);
@@ -7135,11 +8362,26 @@ function settle$1(context, r) {
 		...held.length > 0 ? { held } : {},
 		...notes.length > 0 ? { notes } : {},
 		...baseUnits.length > 0 ? { baseUnits } : {},
+		...stageLabelsOf(context, address, changes, held),
 		expect: expectOf(kind, changes, observed)
 	}, context.policy, owner.entry, { takeoverUnits: takeover });
 }
+function stageLabelsOf(context, address, changes, held) {
+	const lists = [...changes.filter((c) => c.unit === "stages").flatMap((c) => [c.before, c.after]), ...held.filter((h) => h.unit === "stages").flatMap((h) => [
+		h.config,
+		h.live,
+		h.base
+	])];
+	const ids = [...new Set(lists.flatMap((list) => Array.isArray(list) ? list : []))].sort(byCodeUnit);
+	if (ids.length === 0) return {};
+	const prefix = `${address.replace("pipeline:", "stage:")}/`;
+	const { loaded, observation } = context.input;
+	const label = (id) => own$2(loaded.ir.resources, `${prefix}${id}`)?.definition?.label ?? own$2(observation.resources, `${prefix}${id}`)?.definition?.label;
+	return { stageLabels: Object.fromEntries(ids.map((id) => [id, String(label(id) ?? id)])) };
+}
 function place$1(context, r, u, bins) {
-	const { action, address, kind, owner } = r;
+	const { action, address, owner } = r;
+	const readOnly = readOnlyOf(address);
 	const rewrite = owner.entry?.rewrites && own$2(owner.entry.rewrites, u.unit);
 	if (rewrite && u.class !== "converged" && same$2(u.desired, rewrite.sent) && same$2(u.observed, rewrite.stored)) {
 		const note = `HubSpot stores ${show$2(rewrite.stored)} when sent ${show$2(rewrite.sent)}; change config to match`;
@@ -7155,9 +8397,9 @@ function place$1(context, r, u, bins) {
 	const unwritten = {
 		unit: u.unit,
 		live: u.observed,
-		note: `not written: ${NO_SCHEMA_WRITES}`
+		note: `not written: ${readOnly}`
 	};
-	if (kind === "object" && disposition === "write") {
+	if (readOnly !== void 0 && disposition === "write") {
 		bins.refused ||= taken;
 		if (REVERTING.has(u.class)) {
 			bins.held.push(heldOf(context, address, u, unpulledOf$1(context, r, u)));
@@ -7167,15 +8409,15 @@ function place$1(context, r, u, bins) {
 		disposition = "note";
 	}
 	if (disposition === "none") {
-		if (!(u.unit === "options.order" && u.desired.length === 0) && (action === "adopt" || !(Object.hasOwn(u, "base") && same$2(u.base, u.desired, SETS.has(u.unit))))) bins.baseUnits.push(u.unit);
+		if (!((u.unit === "options.order" || ORDERS.has(u.unit)) && u.desired.length === 0) && (action === "adopt" || !(Object.hasOwn(u, "base") && same$2(u.base, u.desired, SETS.has(u.unit))))) bins.baseUnits.push(u.unit);
 	} else if (disposition === "write") bins.changes.push(changeOf(u));
 	else if (disposition === "hold") hold(context, r, u, bins);
-	else if (kind === "object") bins.notes.push(unwritten);
-	else bins.notes.push({
+	else if (readOnly === void 0) bins.notes.push({
 		unit: u.unit,
 		live: u.observed,
 		note: keepNote(context, address, u, unpulledOf$1(context, r, u))
 	});
+	else bins.notes.push(unwritten);
 }
 function hold(context, r, u, bins) {
 	const unpulled = unpulledOf$1(context, r, u);
@@ -7253,6 +8495,42 @@ function keepNote(context, address, u, unpulled) {
 	if (unpulled === void 0) return keptNote(target, address);
 	return sanitize(`kept; ${unpulled === SHADOWED_NOTE ? shadowedNote(target) : unpulled}`, TEXT_MAX$2);
 }
+function reorderStages(context, r, changes) {
+	const desired = r.owned.stages ?? [];
+	const live = r.observed.definition?.stages ?? [];
+	const prefix = `stage:${r.address.slice(9)}/`;
+	const added = new Set(desired.filter((id) => !live.includes(id) && creatable(context, `${prefix}${id}`)));
+	const after = desired.filter((id) => live.includes(id) || added.has(id));
+	const written = changes.find((c) => c.unit === "stages");
+	if (written) {
+		written.after = after;
+		return;
+	}
+	const order = r.units.find((u) => u.unit === "stages");
+	if (added.size === 0 || order?.class !== "converged") return;
+	const closing = (id) => closesStage(own$2(context.input.loaded.ir.resources, `${prefix}${id}`)?.definition);
+	const created = [...added].sort((a, b) => Number(closing(b)) - Number(closing(a)) || byCodeUnit(a, b));
+	if (!same$2([...after.filter((id) => !added.has(id)), ...created], after)) {
+		changes.push({
+			unit: "stages",
+			class: "add",
+			op: "set",
+			before: order.observed,
+			after
+		});
+		changes.sort((a, b) => byCodeUnit(a.unit, b.unit));
+	}
+}
+function creatable(context, stage) {
+	const resource = own$2(context.input.loaded.ir.resources, stage);
+	const override = own$2(context.overrides, stage);
+	return resource?.managed === true && override?.skip !== true && override?.name === void 0 && statusOf(context.input.observation, stage) === "absent" && writesPipelines(objectOf(stage)) && idHolder(context, stage) === void 0;
+}
+function readOnlyOf(address) {
+	const kind = kindOf$3(address);
+	if (kind === "object") return NO_SCHEMA_WRITES;
+	return (kind === "pipeline" || kind === "stage") && !writesPipelines(objectOf(address)) ? noPipelineWrites(objectOf(address)) : void 0;
+}
 function reorder(r, changes, meta) {
 	const desired = r.owned.options;
 	if (desired === void 0) return;
@@ -7287,7 +8565,11 @@ function expectOf(kind, changes, observed) {
 	if (changes.length === 0) return { exists: true };
 	const live = capturedSpec(observed).fields;
 	const values = {};
-	for (const field of new Set(changes.map((c) => fieldOf(c.unit)))) values[field] = field === "options" ? observed.definition?.options ?? [] : live[field];
+	for (const change of changes) {
+		const field = fieldOf(change.unit);
+		if (field === "options") values.options = observed.definition?.options ?? [];
+		else values[field] = ORDERS.has(field) ? change.before : live[field];
+	}
 	if (kind === "property") {
 		values.type = live.type;
 		values.fieldType = live.fieldType;
@@ -7304,21 +8586,28 @@ function titleOf(r, changes, baseUnits) {
 	return baseUnits.length > 0 ? `Record the agreed values of ${what}` : `No change to ${what}`;
 }
 function writesTitle(changes) {
-	return writesTail(changes, (c) => `"${(c.op === "add" ? c.after : c.before).label}"`, (unit) => unit === "fieldType" || unit === "calculationFormula" ? `${unit} (the effect on existing values is not checked)` : unit);
+	return writesTail(changes, (c) => `"${(c.op === "add" ? c.after : c.before).label}"`, fieldWords);
 }
 function removals(context) {
 	const entries = Object.entries(context.input.loaded.ir.tombstones).sort(([a], [b]) => byCodeUnit(a, b));
 	const releases = [];
 	const deletes = [];
 	const deleted = /* @__PURE__ */ new Map();
-	for (const kind of ["property", "group"]) {
+	for (const kind of [
+		"property",
+		"group",
+		"stage",
+		"pipeline"
+	]) {
 		for (const [address, tombstone] of entries.filter(([a]) => kindOf$3(a) === kind)) {
-			const step = removal(context, address, tombstone, deleted);
+			const covering = kind === "stage" ? own$2(context.input.loaded.ir.tombstones, pipelineOf(address)) : void 0;
+			if (covering?.action === tombstone.action) continue;
+			const step = covering ? uncovered(address, tombstone, pipelineOf(address)) : removal(context, address, tombstone, deleted);
 			if (step?.action === "release") releases.push(step);
 			else if (step) deletes.push(step);
 			countDeleted(context, step, deleted);
 		}
-		for (const address of kind === "property" ? context.takeover.properties : context.takeover.groups) {
+		for (const address of takeoverOf$1(context, kind)) {
 			const step = takeoverDelete(context, address, deleted);
 			deletes.push(step);
 			countDeleted(context, step, deleted);
@@ -7326,9 +8615,17 @@ function removals(context) {
 	}
 	return [...releases, ...deletes];
 }
+function uncovered(address, tombstone, pipeline) {
+	if (tombstone.action === "destroy") return blocked(address, "delete", "not-owned", "pipeline released", `the tombstone of ${pipeline} releases the pipeline with its stages, so Kalup no longer owns this stage to delete it`, `set the action of ${pipeline} to destroy to delete it with its stages, or this stage's to release`);
+	return blocked(address, "release", "unsupported", "pipeline deleted", `the tombstone of ${pipeline} deletes the pipeline with its stages, so this stage cannot be kept`, `set the action of ${pipeline} to release to keep it with its stages, or this stage's to destroy`);
+}
+function takeoverOf$1(context, kind) {
+	if (kind === "property") return context.takeover.properties;
+	return kind === "group" ? context.takeover.groups : [];
+}
 function countDeleted(context, step, deleted) {
 	if (step?.action === "delete" && (step.risk !== "blocked" || step.blocked?.reason === "policy")) {
-		const key = objectOf(step.address);
+		const key = kindOf$3(step.address) === "stage" ? pipelineOf(step.address) : objectOf(step.address);
 		deleted.set(key, /* @__PURE__ */ new Set([...deleted.get(key) ?? [], portalName$1(context, step.address)]));
 	}
 }
@@ -7413,7 +8710,7 @@ function removal(context, address, tombstone, deleted) {
 	return destroy(context, address, entry, deleted);
 }
 function releaseOf(address, tombstone, owner, status) {
-	const plain = `${kindOf$3(address) === "group" ? "property group" : "property"} ${nameOf(address)} on ${objectOf(address)}`;
+	const plain = `${nounOf(address)} ${shownName(address)}${placeOf(address)}`;
 	if (owner.entry && tombstone.action === "release") {
 		let where = "";
 		if (status === "present") where = "; it stays in HubSpot";
@@ -7433,23 +8730,33 @@ function destroy(context, address, entry, deleted) {
 	const observed = input.observation.resources[address];
 	const key = objectOf(address);
 	if (!observed.managed) return blocked(address, "delete", "unsupported", "HubSpot-defined or calculated", "HubSpot-defined or calculated in this portal, so Kalup does not delete it");
+	const readOnly = readOnlyOf(address);
+	if (readOnly !== void 0) return blocked(address, "delete", "unsupported", "not written in this release", readOnly, "change the tombstone's action to release, which stops managing it and leaves it in HubSpot");
 	const name = portalName$1(context, address);
 	const members = kindOf$3(address) === "group" ? {
 		active: own$2(input.observation.members?.[key] ?? {}, name) ?? [],
 		deleted: deleted.get(key) ?? /* @__PURE__ */ new Set()
 	} : void 0;
-	const block = deleteBlock(input.observation.meta?.[address], members);
+	const block = deleteBlock(input.observation.meta?.[address], members) ?? stageDeleteBlock(context, address, deleted);
 	if (block) return blocked(address, "delete", "unsupported", block.short, block.detail, block.fix);
 	if (!policy.allowDestroy) return blocked(address, "delete", "policy", "deletes not allowed", `target ${input.target} does not allow deletes`, `set allowDestroy: true under targets.${input.target} in kalup.config.ts, or change the tombstone's action to release`);
 	const values = baseValues(entry, observed);
+	if (kindOf$3(address) === "pipeline") values.stages = observed.definition?.stages ?? [];
+	const purged = kindOf$3(address) === "pipeline" || kindOf$3(address) === "stage";
 	return finish$1({
-		...head(address, "delete", "destructive", `Archive ${described(address, observed)}`),
+		...head(address, "delete", "destructive", `${purged ? "Delete" : "Archive"} ${described(address, observed)}${purged ? PURGED : ""}`),
 		expect: Object.keys(values).length > 0 ? {
 			exists: true,
 			values
 		} : { exists: true }
 	}, context.policy, entry);
 }
+function stageDeleteBlock(context, address, deleted) {
+	if (kindOf$3(address) !== "stage") return;
+	const gone = deleted.get(pipelineOf(address)) ?? /* @__PURE__ */ new Set();
+	const before = [...context.decided.values()].filter(hasEffect);
+	return stageDeleteRule(afterSteps(context.input.observation.resources, before), address, gone, bin);
+}
 function baseValues(entry, observed) {
 	const live = capturedSpec(observed).fields;
 	const values = {};
@@ -7471,7 +8778,7 @@ function release(address, title, expect) {
 function orphansOf(input, steps) {
 	const { loaded, state, target } = input;
 	const overrides = loaded.config.targets[target]?.overrides ?? {};
-	return Object.entries(state?.resources ?? {}).filter(([address, entry]) => (entry.origin === "created" || entry.origin === "adopted") && !Object.hasOwn(loaded.ir.resources, address) && !Object.hasOwn(loaded.ir.tombstones, address) && !steps.some((s) => s.address === address)).sort(([a], [b]) => byCodeUnit(a, b)).map(([address, entry]) => {
+	return Object.entries(state?.resources ?? {}).filter(([address, entry]) => (entry.origin === "created" || entry.origin === "adopted") && !Object.hasOwn(loaded.ir.resources, address) && !Object.hasOwn(loaded.ir.tombstones, address) && !(kindOf$3(address) === "stage" && Object.hasOwn(loaded.ir.tombstones, pipelineOf(address))) && !steps.some((s) => s.address === address)).sort(([a], [b]) => byCodeUnit(a, b)).map(([address, entry]) => {
 		const name = resolvedName(overrides, address);
 		const rm = `${bin} rm ${shellWord(address)}`;
 		let note = `no longer in config: run ${rm} to delete it in HubSpot, or ${rm} --release to stop managing it`;
@@ -7502,10 +8809,14 @@ function staleNote(context, address, stale) {
 function portalName$1(context, address) {
 	return resolvedName(context.overrides, address);
 }
-/** The portal name an address resolves to on a target: its name override, else its own name. */
+/**
+* The portal name an address resolves to on a target: its name override, else its own name. A stage's is its stage ID;
+* its pipeline's ID is the pipeline address's.
+*/
 function resolvedName(overrides, address) {
 	const override = own$2(overrides, address);
-	return (override?.skip === true ? void 0 : override?.name) ?? nameOf(address);
+	const mine = kindOf$3(address) === "stage" ? ownId(address) : nameOf(address);
+	return (override?.skip === true ? void 0 : override?.name) ?? mine;
 }
 function archivedOf(lists, key, name) {
 	const list = own$2(lists, key);
@@ -7573,10 +8884,8 @@ function head(address, action, risk, title) {
 	};
 }
 function blocked(address, action, reason, short, detail, fix) {
-	const name = nameOf(address);
-	const kind = kindOf$3(address);
 	return {
-		...head(address, action, "blocked", kind === "object" ? `Cannot plan object ${name}: ${short}` : `Cannot plan ${kind} ${name} on ${objectOf(address)}: ${short}`),
+		...head(address, action, "blocked", `Cannot plan ${kindOf$3(address)} ${shownName(address)}${placeOf(address)}: ${short}`),
 		expect: blockedExpect(action),
 		blocked: {
 			reason,
@@ -7597,7 +8906,14 @@ function actionOf(status) {
 function described(address, resource) {
 	const d = resource.definition ?? {};
 	if (kindOf$3(address) === "object") return `custom object "${d.labels.singular}" (${nameOf(address)})`;
-	return `${kindOf$3(address) === "group" ? "property group" : "property"} "${String(d.label)}" (${nameOf(address)}) on ${objectOf(address)}`;
+	return `${nounOf(address)} "${String(d.label)}" (${shownName(address)})${placeOf(address)}`;
+}
+function nounOf(address) {
+	return {
+		group: "property group",
+		property: "property",
+		pipeline: "pipeline"
+	}[kindOf$3(address)] ?? kindOf$3(address);
 }
 function skipFix(address, target) {
 	return `leave it out on this target: add { '${address}': { skip: true } } under targets.${target}.overrides`;
@@ -7626,7 +8942,11 @@ function bindingsFor(open, overrides, idOf) {
 	}
 	return Object.fromEntries([...found].sort(([a], [b]) => byCodeUnit(a, b)));
 }
-/** A step's own address, every $ref it carries, and the object a group or property is on. */
+/**
+* A step's own address, every $ref it carries, the pipeline a stage is under, the stages a pipeline create carries or
+* its stage order names (live and approved), and the object a group, property, pipeline or stage is on. A stage's name
+* override is so a binding of each pipeline step that moves or names the stage: apply moves it by its portal ID.
+*/
 function dependencies(step) {
 	const out = [step.address];
 	collectRefs([
@@ -7634,9 +8954,18 @@ function dependencies(step) {
 		step.changes,
 		step.expect
 	], out);
+	if (kindOf$3(step.address) === "stage") out.push(pipelineOf(step.address));
+	out.push(...(step.stages ?? []).map((st) => st.address));
+	if (kindOf$3(step.address) === "pipeline") out.push(...orderedStages(step));
 	if (kindOf$3(step.address) !== "object") out.push(`object:${objectOf(step.address)}`);
 	return out;
 }
+function orderedStages(step) {
+	const lists = [step.expect.values?.stages, ...(step.changes ?? []).filter((c) => c.unit === "stages").map((c) => c.after)];
+	const prefix = `${step.address.replace("pipeline:", "stage:")}/`;
+	const ids = lists.flatMap((list) => Array.isArray(list) ? list.filter((id) => typeof id === "string") : []);
+	return [...new Set(ids)].map((id) => `${prefix}${id}`);
+}
 function collectRefs(value, out) {
 	if (Array.isArray(value)) {
 		for (const item of value) collectRefs(item, out);
@@ -7666,7 +8995,9 @@ function callsOf(steps, missing, bindings) {
 	const objects = new Set(effects.map((s) => objectOf(s.address)));
 	const archived = /* @__PURE__ */ new Set([...effects.filter((s) => s.action === "create" || s.action === "delete").map((s) => objectOf(s.address)), ...missing.map((m) => objectOf(m.address))]);
 	const schemas = Object.values(bindings).some((b) => b.id !== void 0) ? 1 : 0;
-	return 3 * effects.filter(writes$1).length + 4 * objects.size + 3 * archived.size + schemas + 1;
+	const reorders = effects.flatMap((s) => s.changes ?? []).filter((c) => c.unit === "stages").reduce((sum, c) => sum + 2 * (c.after?.length ?? 0), 0);
+	const pipelines = new Set(effects.filter((s) => kindOf$3(s.address) === "pipeline" || kindOf$3(s.address) === "stage").map((s) => objectOf(s.address)));
+	return 3 * effects.filter(writes$1).length + 4 * objects.size + 3 * archived.size + schemas + 1 + reorders + pipelines.size;
 }
 function countsOf$1(steps) {
 	const counts = {
@@ -7685,11 +9016,12 @@ function countsOf$1(steps) {
 }
 function planCoverage(coverage, steps, excluded, unobserved) {
 	const objects = Object.entries(coverage.objects).sort(([a], [b]) => byCodeUnit(a, b));
+	const scopeOf = (o) => o.status === "unreadable" ? o.missingScope : o.pipelines?.missingScope;
 	return {
 		complete: coverage.complete && !steps.some((s) => s.action === "unknown"),
-		unreadable: [...objects.filter(([, o]) => o.status === "unreadable").map(([object, o]) => o.missingScope === void 0 ? { object } : {
+		unreadable: [...objects.filter(([, o]) => o.status === "unreadable" || o.pipelines?.status === "unreadable").map(([object, o]) => scopeOf(o) === void 0 ? { object } : {
 			object,
-			scope: o.missingScope
+			scope: scopeOf(o)
 		}), ...unobserved.map((object) => ({ object }))].sort((a, b) => byCodeUnit(a.object, b.object)),
 		unsupported: objects.flatMap(([key, o]) => [...(o.unsupported ?? []).map((u) => `property:${key}/${u.name}`), ...o.unsupportedSchema ? [`object:${key}`] : []]).sort(byCodeUnit),
 		excluded
@@ -7775,11 +9107,15 @@ function namesOf(plan, overrides) {
 		const bound = [...renamed].find(([address, name]) => address.startsWith(prefix) && name === portalName);
 		return bound ? bound[0].slice(prefix.length) : portalName;
 	};
+	const portalOf = (address) => renamed.get(address) ?? (kindOf$2(address) === "stage" ? ownId(address) : nameOf(address));
 	return {
-		portalName: (address) => renamed.get(address) ?? nameOf(address),
+		portalName: portalOf,
 		objectType: (key) => own(`object:${key}`)?.id ?? key,
-		localGroup: (key, portalName) => local(`group:${key}/`, portalName),
-		localProperty: (key, portalName) => local(`property:${key}/`, portalName)
+		localGroup: (key, name) => local(`group:${key}/`, name),
+		localProperty: (key, name) => local(`property:${key}/`, name),
+		localPipeline: (key, id) => local(`pipeline:${key}/`, id),
+		localStage: (key, pipeline, id) => local(`stage:${key}/${pipeline}/`, id),
+		pipelineId: (address) => portalOf(kindOf$2(address) === "stage" ? pipelineOf(address) : address)
 	};
 }
 const SENSITIVITIES = [
@@ -7823,8 +9159,60 @@ async function observeForApply(http, plan, overrides) {
 	return out;
 }
 async function observeObject(http, read, observing, key, out) {
+	const effects = observing.plan.steps.filter((s) => hasEffect(s) && objectOf(s.address) === key);
+	const pipelines = effects.filter((s) => PIPELINE_TYPES.has(kindOf$2(s.address)));
+	if (pipelines.length > 0) await observePipelines(read, observing, key, pipelines, out);
+	if (pipelines.length < effects.length) await observeProperties(http, read, observing, key, out);
+}
+async function observePipelines(read, { names }, key, steps, out) {
+	const live = localPipelines(key, normalizePipelines(key, (await read({
+		type: "pipeline",
+		path: "list",
+		params: { objectType: names.objectType(key) }
+	}, `the pipelines list of ${key}`)).results, !STANDARD_OBJECTS.has(key)), names);
+	for (const step of steps) {
+		const pipeline = kindOf$2(step.address) === "stage" ? pipelineOf(step.address) : step.address;
+		Object.assign(out.resources, Object.fromEntries(pipelineResources(live, pipeline)));
+	}
+}
+/** The pipelines of one object under the plan's local pipeline and stage IDs. */
+function localPipelines(key, live, names) {
+	return live.map((p) => {
+		const id = names.localPipeline(key, p.id);
+		return {
+			...p,
+			id,
+			stages: p.stages.map((st) => ({
+				...st,
+				id: names.localStage(key, id, st.id)
+			}))
+		};
+	});
+}
+/** One pipeline, `pipeline:<key>/<id>`, and its stages as resources, as observe captures them. None when absent. */
+function pipelineResources(live, pipeline) {
+	const id = pipeline.slice(pipeline.lastIndexOf("/") + 1);
+	const found = live.find((p) => p.id === id);
+	if (found === void 0) return [];
+	const definition = {
+		label: found.label,
+		displayOrder: found.displayOrder,
+		stages: found.stages.map((st) => st.id)
+	};
+	const prefix = `${pipeline.replace("pipeline:", "stage:")}/`;
+	return [[pipeline, {
+		type: "pipeline",
+		managed: true,
+		definition
+	}], ...found.stages.map(({ id: stage, ...fields }) => [`${prefix}${stage}`, {
+		type: "stage",
+		managed: true,
+		definition: fields
+	}])];
+}
+async function observeProperties(http, read, observing, key, out) {
 	const { plan, names, schemas } = observing;
-	const effects = plan.steps.filter((s) => hasEffect(s) && objectOf(s.address) === key);
+	const effects = plan.steps.filter((s) => hasEffect(s) && objectOf(s.address) === key && !PIPELINE_TYPES.has(kindOf$2(s.address)));
 	const objectType = names.objectType(key);
 	const properties = await listProperties(read, key, objectType);
 	const { groups: live } = normalizeGroups((await read({
@@ -8435,38 +9823,48 @@ function staleUnits(step, observed, observation, portalName = nameOf(step.addres
 	if (expect.values === void 0 || observed === void 0) return [];
 	const live = capturedSpec(observed).fields;
 	return Object.entries(expect.values).filter(([field, value]) => {
-		return stableStringify(field === "options" ? observed.definition?.options ?? [] : live[field]) !== stableStringify(value);
+		let now = field === "options" ? observed.definition?.options ?? [] : live[field];
+		if (step.action !== "delete" && ORDERS.has(field) && Array.isArray(now) && Array.isArray(value)) now = now.filter((member) => value.includes(member));
+		return stableStringify(now) !== stableStringify(value);
 	}).map(([field]) => field).sort(byCodeUnit);
 }
 /**
 * A step's title from its own data, never the plan's: the kind, the label config gives (for a delete, the label it
 * expects to find), the name and the object. With `names`, the portal name follows the name wherever the two differ.
+* `warned` adds the warnings the plan's title carries, for a person about to confirm the step: that a pipeline or stage
+* delete cannot be restored, and that a field change's effect on existing values is not checked.
 */
-function stepTitle(step, names) {
+function stepTitle(step, names, warned = false) {
 	const { address, action } = step;
 	const kind = kindOf$1(address);
-	const own = nameOf(address);
+	const own = shownName(address);
 	const portal = names?.portalName(address);
 	const name = portal === void 0 || portal === own ? own : `${own}, portal name ${portal}`;
-	const noun = {
-		object: "custom object",
-		group: "property group",
-		property: "property"
-	}[kind];
-	const where = kind === "object" ? "" : ` on ${objectOf(address)}`;
+	const noun = NOUNS[kind];
+	const where = placeOf(address);
+	const purged = kind === "pipeline" || kind === "stage";
+	const removes = purged ? "Delete" : "Archive";
+	const carried = (step.stages ?? []).length > 0 ? ` with ${plural((step.stages ?? []).length, "stage")}` : "";
 	const values = step.action === "delete" ? step.expect.values : step.desired;
 	const shown = kind === "object" ? (values?.labels)?.singular : values?.label;
 	const label = typeof shown === "string" ? ` "${shown}"` : "";
 	const what = `${noun}${label} (${name})${where}`;
 	const title = {
-		create: () => `${step.labels?.includes("reverts-ui-edit") ? "Recreate" : "Create"} ${what}`,
-		adopt: () => `Adopt ${what}${writes(step)}`,
-		update: () => (step.changes ?? []).length > 0 ? `Update ${what}${writes(step)}` : `Record the agreed values of ${what}`,
-		delete: () => label ? `Archive ${what}` : `Archive ${noun} ${portal === void 0 || portal === own ? own : `${own} (portal name ${portal})`}${where}`,
+		create: () => `${step.labels?.includes("reverts-ui-edit") ? "Recreate" : "Create"} ${what}${carried}`,
+		adopt: () => `Adopt ${what}${writes(step, warned)}`,
+		update: () => (step.changes ?? []).length > 0 ? `Update ${what}${writes(step, warned)}` : `Record the agreed values of ${what}`,
+		delete: () => `${label ? `${removes} ${what}` : `${removes} ${noun} ${portal === void 0 || portal === own ? own : `${own} (portal name ${portal})`}${where}`}${purged && warned ? PURGED : ""}`,
 		release: () => `Stop managing ${noun} ${own}${where}; nothing changes in HubSpot`
 	}[action];
 	return sanitize(title ? title() : `${action} ${address}`, TITLE_MAX);
 }
+const NOUNS = {
+	object: "custom object",
+	group: "property group",
+	property: "property",
+	pipeline: "pipeline",
+	stage: "stage"
+};
 /** The value config gives a unit in a step's desired values, or undefined when it gives none. */
 function desiredValue(desired, unit) {
 	const member = memberOf(unit);
@@ -8478,6 +9876,8 @@ function desiredValue(desired, unit) {
 function blockOf(plan, step, held, observation) {
 	const { entry, owned } = held;
 	if (kindOf$1(step.address) === "object" && step.action !== "adopt" && step.action !== "update") return "custom object schema writes are not supported in this release";
+	const readOnly = readOnlyPipeline(step);
+	if (readOnly !== void 0) return readOnly;
 	const observed = observation.resources[step.address];
 	const names = namesOf(plan);
 	switch (step.action) {
@@ -8494,6 +9894,11 @@ function blockOf(plan, step, held, observation) {
 		default: return `${sanitize(step.action)} is not a step apply runs`;
 	}
 }
+function readOnlyPipeline(step) {
+	const kind = kindOf$1(step.address);
+	if (!(kind === "pipeline" || kind === "stage") || writesPipelines(objectOf(step.address))) return;
+	return (step.action === "adopt" || step.action === "update" ? (step.changes ?? []).length : 1) > 0 && step.action !== "release" ? `Kalup does not write the pipelines of ${objectOf(step.address)} in this release` : void 0;
+}
 function writeRefusal(step, trusted, observation) {
 	const { owned } = trusted;
 	if (step.action === "adopt" && owned) return "state owns it already";
@@ -8514,12 +9919,20 @@ function deleteRefusal(plan, step, { owner, overrides }, observation) {
 	const observed = observation.resources[step.address];
 	if (observation.unsupported.includes(step.address) || observed?.managed === false) return "its values cannot be checked before the delete";
 	if (takeover && observation.meta[step.address]?.hubspotDefined === true) return "HubSpot defines it, and takeover never archives what HubSpot defines";
+	switch (kindOf$1(step.address)) {
+		case "stage": return stageDeleteRefusal(plan, step, observation);
+		case "pipeline": return;
+		case "group": return groupDeleteRefusal(plan, step, takeover, observation);
+		default: {
+			const named = observation.schemaNamed[objectOf(step.address)] ?? [];
+			const kept = takeover ? keptByRead(overrides, plan.target.name, step.address, observed, named) : void 0;
+			return kept === void 0 ? deleteBlock(observation.meta[step.address])?.detail : `takeover never archives it: ${kept}`;
+		}
+	}
+}
+function groupDeleteRefusal(plan, step, takeover, observation) {
 	const names = namesOf(plan);
 	const key = objectOf(step.address);
-	if (kindOf$1(step.address) !== "group") {
-		const kept = takeover ? keptByRead(overrides, plan.target.name, step.address, observed, observation.schemaNamed[key] ?? []) : void 0;
-		return kept === void 0 ? deleteBlock(observation.meta[step.address])?.detail : `takeover never archives it: ${kept}`;
-	}
 	const name = names.portalName(step.address);
 	if (takeover && (observation.members[key]?.[name] ?? []).length === 0) return "it held no property when apply read it, and HubSpot marks no group as its own, so takeover never archives an empty group";
 	const deleted = new Set(runOrder(plan).filter((s) => s.action === "delete" && kindOf$1(s.address) === "property" && objectOf(s.address) === key).map((s) => names.portalName(s.address)));
@@ -8528,24 +9941,32 @@ function deleteRefusal(plan, step, { owner, overrides }, observation) {
 		deleted
 	})?.detail;
 }
+function stageDeleteRefusal(plan, step, observation) {
+	const order = runOrder(plan);
+	const before = order.slice(0, order.indexOf(step));
+	const prefix = step.address.slice(0, step.address.lastIndexOf("/") + 1);
+	const gone = new Set(before.filter((s) => s.action === "delete" && s.address.startsWith(prefix)).map((s) => s.address.slice(prefix.length)));
+	return stageDeleteRule(afterSteps(observation.resources, before), step.address, gone, bin)?.detail;
+}
 function uncheckedFields(step, owner) {
 	const captured = CAPTURED[kindOf$1(step.address)];
 	const needed = new Set(Object.keys(owner.base ?? {}).flatMap((unit) => {
 		if (unit === "options" || unit === "optionsOrder") return ["options"];
 		return captured.includes(unit) ? [unit] : [];
 	}));
+	if (kindOf$1(step.address) === "pipeline") needed.add("stages");
 	const values = step.expect.values ?? {};
 	const missing = [...needed].filter((field) => !Object.hasOwn(values, field)).sort(byCodeUnit);
 	return step.expect.exists === true ? missing : ["exists", ...missing];
 }
 function recreates(step, observed, observation, portalName) {
 	if (!step.labels?.includes("reverts-ui-edit") || observed !== void 0) return false;
-	if (kindOf$1(step.address) === "group") return true;
+	if (kindOf$1(step.address) !== "property") return true;
 	const archived = observation.archived[objectOf(step.address)];
 	return archived !== void 0 && !archived.some((p) => p.name === portalName);
 }
 function archivedName(step, observation, portalName) {
-	if (kindOf$1(step.address) === "group") return false;
+	if (kindOf$1(step.address) !== "property") return false;
 	return observation?.archived[objectOf(step.address)]?.some((p) => p.name === portalName) === true;
 }
 function classesOf(step, trusted, observation) {
@@ -8616,16 +10037,24 @@ function checkNames(plan, config) {
 }
 function portalResource(address, names) {
 	const kind = kindOf$1(address);
-	return `${kind}:${kind === "object" ? "" : `${names.objectType(objectOf(address))}/`}${names.portalName(address)}`;
+	return `${kind}:${kind === "object" ? "" : `${names.objectType(objectOf(address))}/`}${kind === "stage" ? `${names.pipelineId(address)}/` : ""}${names.portalName(address)}`;
 }
 /**
 * The effect steps in the order apply runs them, from their actions and addresses alone, never the file's order:
-* groups, then properties (a property may name a group the run creates), then releases, then property deletes, then
-* group deletes, so a group is deleted only after the deletes of its properties. Plan order within each phase.
+* groups, then properties (a property may name a group the run creates), then pipeline creates, then the other stage
+* steps (those that close a stage first, since a ticket pipeline keeps a closed stage), then the other pipeline steps
+* (a stage order is written once the pipeline's new stages exist), then releases, then property deletes, then group
+* deletes, so a group is deleted only after the deletes of its properties, then stage deletes, then pipeline deletes.
+* Plan order within each phase.
 */
 function runOrder(plan) {
-	return formulasLast(plan.steps.filter(hasEffect).sort((a, b) => phase(a) - phase(b)));
+	const known = ORDERED.get(plan.steps);
+	if (known) return known;
+	const order = formulasLast(plan.steps.filter(hasEffect).sort((a, b) => phase(a) - phase(b)));
+	ORDERED.set(plan.steps, order);
+	return order;
 }
+const ORDERED = /* @__PURE__ */ new WeakMap();
 const FORMULA_WORDS = /[A-Za-z0-9_]+/g;
 /**
 * A property step that writes a calculation formula runs after every other property step, and after each formula step
@@ -8653,8 +10082,16 @@ function formulasLast(steps) {
 }
 function phase(step) {
 	const kind = kindOf$1(step.address);
-	if (step.action === "release") return 3;
-	if (step.action === "delete") return kind === "group" ? 5 : 4;
+	if (step.action === "release") return 6;
+	if (step.action === "delete") return {
+		object: 7,
+		property: 7,
+		group: 8,
+		stage: 9,
+		pipeline: 10
+	}[kind];
+	if (kind === "pipeline") return step.action === "create" ? 3 : 5;
+	if (kind === "stage") return closesStage(step.desired) ? 4 : 4.5;
 	return {
 		object: 0,
 		group: 1,
@@ -8662,8 +10099,9 @@ function phase(step) {
 	}[kind];
 }
 function disagreement(step) {
-	return (step.changes ?? []).flatMap((change) => {
+	const changed = (step.changes ?? []).flatMap((change) => {
 		if (change.unit === "options.order") return [];
+		if (ORDERS.has(change.unit)) return orderDisagreement(step, change);
 		const member = memberOf(change.unit);
 		const desired = desiredValue(step.desired, change.unit);
 		let fits;
@@ -8672,6 +10110,19 @@ function disagreement(step) {
 		else fits = member?.field !== void 0 || fieldOf(change.unit) === change.unit ? sameValue(change.after, desired) : false;
 		return fits ? [] : [`step ${step.id} changes ${sanitize(change.unit)} to a value its desired values do not hold`];
 	});
+	return [...carriedDisagreement(step), ...changed];
+}
+function orderDisagreement(step, change) {
+	const desired = step.desired?.[change.unit] ?? [];
+	const { after } = change;
+	return Array.isArray(after) && stableStringify(desired.filter((id) => after.includes(id))) === stableStringify(after) ? [] : [`step ${step.id} writes a ${sanitize(change.unit)} order its desired values do not hold`];
+}
+function carriedDisagreement(step) {
+	if (step.stages === void 0) return [];
+	const prefix = `${step.address.replace("pipeline:", "stage:")}/`;
+	const ids = step.stages.map((st) => st.address.slice(prefix.length));
+	const desired = (step.desired?.stages ?? []).filter((id) => ids.includes(id));
+	return step.action === "create" && kindOf$1(step.address) === "pipeline" && step.stages.every((st) => st.address.startsWith(prefix) && !st.address.slice(prefix.length).includes("/")) && stableStringify(desired) === stableStringify(ids) ? [] : [`step ${step.id} carries stages that are not its own pipeline's, in its order`];
 }
 function sameValue(a, b) {
 	return b !== void 0 && stableStringify(a) === stableStringify(b);
@@ -8693,11 +10144,11 @@ function destination(message, fix) {
 function kindOf$1(address) {
 	return parseAddress(address).type;
 }
-function writes(step) {
+function writes(step, warned) {
 	const changes = step.changes ?? [];
 	const live = step.expect.values?.options ?? [];
 	const label = (option, unit) => typeof option?.label === "string" ? `"${option.label}"` : String(memberOf(unit)?.value);
-	return writesTail(changes, (c) => c.op === "add" ? label(c.after, c.unit) : label(Array.isArray(live) ? live.find((o) => o.value === memberOf(c.unit)?.value) : void 0, c.unit));
+	return writesTail(changes, (c) => c.op === "add" ? label(c.after, c.unit) : label(Array.isArray(live) ? live.find((o) => o.value === memberOf(c.unit)?.value) : void 0, c.unit), warned ? fieldWords : (unit) => unit === "stages" ? fieldWords(unit) : unit);
 }
 /** How long a read-back waits before it tells a person watching that it is still waiting, once per step. */
 const PROGRESS_MS = 3e3;
@@ -8874,12 +10325,16 @@ async function runSteps(run) {
 		reports.set(step.id, done.report);
 		run.issues.push(...done.issues ?? []);
 		stop ||= done.stop === true;
-		if (done.entry !== void 0 && !sends) recorded.push([step, done.entry]);
-		else if (done.entry !== void 0 && !saveEntries(run, [[step, done.entry]])) stop = true;
+		const entries = entriesOf(step, done);
+		if (entries.length > 0 && !sends) recorded.push(...entries);
+		else if (entries.length > 0 && !saveEntries(run, entries)) stop = true;
 	}
 	saveEntries(run, recorded);
 	return reports;
 }
+function entriesOf(step, done) {
+	return [...done.entry === void 0 ? [] : [[step.address, done.entry]], ...done.also ?? []];
+}
 function recordsOnly(step) {
 	return step.action === "release" || (step.action === "adopt" || step.action === "update") && (step.changes ?? []).length === 0;
 }
@@ -8894,7 +10349,8 @@ function heldBack(run, step, reports) {
 async function runStep(run, step) {
 	if (step.action === "release") return {
 		report: report$1(step, "done"),
-		entry: null
+		entry: null,
+		also: stagesGone(run, step)
 	};
 	if (recordsOnly(step)) return record$2(run, step);
 	return await write$1(run, step);
@@ -8931,6 +10387,7 @@ async function attemptWrite(run, step, tries) {
 	const moved = before.present && before.resource === void 0 ? ["type"] : staleUnits(step, before.resource);
 	if (moved.length > 0) return stale(run, step, moved);
 	if (halted(run)) return stopped(run, step);
+	if (kindOf(step.address) === "pipeline" && (step.changes ?? []).some((c) => c.unit === "stages")) return await reorderWrite(run, step, before, tries);
 	const sent = await send(run, payload(run, step, before));
 	if (sent.kind === "wait") return waited(run, step, sent, tries);
 	if (sent.kind !== "rejected") return await settle(run, step, sent);
@@ -8997,7 +10454,7 @@ async function settle(run, step, sent) {
 function proven(step, seen, acknowledged, before) {
 	if (step.action === "delete") return seen.archived === true;
 	if (!(seen.present && seen.resource)) return false;
-	if (unverifiedUnits(step, seen.resource).length === 0) return true;
+	if (unverifiedUnits(step, seen.resource).length === 0 && carriedUnverified(step, seen).length === 0) return true;
 	if (!acknowledged) return false;
 	if (step.action === "create" || before === void 0) return true;
 	const fields = (step.changes ?? []).map((c) => fieldOf(c.unit));
@@ -9008,20 +10465,24 @@ function proven(step, seen, acknowledged, before) {
 function verified(run, step, seen) {
 	if (step.action === "delete") return {
 		report: report$1(step, "done"),
-		entry: null
+		entry: null,
+		also: stagesGone(run, step)
 	};
 	const readBack = seen.resource;
-	const bad = unverifiedUnits(step, readBack);
+	const own = unverifiedUnits(step, readBack);
+	const bad = [...own, ...carriedUnverified(step, seen)];
 	if (step.action === "create") run.created.add(step.address);
 	const { rewrites: before, ...entry } = entryOf$1(run, step, verifiedBase(run, step, readBack));
-	const rewrites = rewritesAfter(before, writtenUnits(step, readBack), bad);
+	const rewrites = rewritesAfter(before, writtenUnits(step, readBack), own);
 	const saved = rewrites === void 0 ? entry : {
 		...entry,
 		rewrites
 	};
+	const also = carriedEntries(step, seen);
 	if (bad.length === 0) return {
 		report: report$1(step, "done"),
-		entry: saved
+		entry: saved,
+		also
 	};
 	const units = bad.map((u) => u.unit);
 	const stored = bad.map((u) => `${u.unit} as ${show$1$1(u.observed)}, not ${show$1$1(u.desired)} as sent`).join("; ");
@@ -9036,9 +10497,41 @@ function verified(run, step, seen) {
 			issue: "W_UNVERIFIED"
 		}),
 		entry: saved,
+		also,
 		issues: [issue]
 	};
 }
+function carriedEntries(step, seen) {
+	return (step.stages ?? []).flatMap((st) => {
+		const live = seen.stages?.[st.address];
+		if (live === void 0) return [];
+		const units = classify(void 0, specOf(st.desired), capturedSpec(live), { options: "additive" });
+		const base = advanceBase(void 0, specOf(st.desired), capturedSpec(live));
+		const rewrites = rewritesAfter(void 0, units.map((u) => u.unit), units.filter((u) => u.class !== "converged"));
+		const entry = {
+			origin: "created",
+			id: ownId(st.address),
+			normVersion: NORM_VERSIONS.stage,
+			...base === void 0 ? {} : { base },
+			...rewrites === void 0 ? {} : { rewrites }
+		};
+		return [[st.address, entry]];
+	});
+}
+function carriedUnverified(step, seen) {
+	return (step.stages ?? []).flatMap((st) => {
+		const live = seen.stages?.[st.address];
+		if (live === void 0) return [{
+			unit: `${st.address}`,
+			class: "diverged",
+			desired: st.desired
+		}];
+		return classify(void 0, specOf(st.desired), capturedSpec(live), { options: "additive" }).filter((u) => u.class !== "converged").map((u) => ({
+			...u,
+			unit: `${ownId(st.address)}.${u.unit}`
+		}));
+	});
+}
 function verifiedBase(run, step, readBack) {
 	const live = capturedSpec(readBack);
 	if (step.action === "create") {
@@ -9146,12 +10639,38 @@ function refusal(run, step, sent, plan, otherwise) {
 		why: "HubSpot refuses to archive a group that still holds properties",
 		fix: `run ${plan}: it names the properties the group holds`
 	};
+	const pipelineRefused = pipelineRefusal(step, sent, plan);
+	if (pipelineRefused !== void 0) return pipelineRefused;
 	if (reason === "PROPERTY_WITH_NAME_EXISTS") return {
 		why: `HubSpot refuses the create because a property named ${portalName(run, step)} already exists`,
 		fix: `run ${plan}: it reads the portal again`
 	};
 	return otherwise;
 }
+function pipelineRefusal(step, sent, plan) {
+	const reason = reasonOf(sent);
+	if (reason === "STAGE_ID_IN_USE") {
+		const stages = sent.context?.stageIds?.[0];
+		const records = sent.context?.objectIds?.[0];
+		const held = [stages && `stages ${stages}`, records && `records ${records}`].filter(Boolean).join(", ");
+		return {
+			why: `HubSpot never deletes a stage a record sits in${held ? ` (${held})` : ""}`,
+			fix: `move those records to another stage in HubSpot, or delete them, then run ${plan}`
+		};
+	}
+	if (reason === "MISSING_CLOSED_STAGE") return {
+		why: "HubSpot keeps a closed stage in every ticket pipeline",
+		fix: `mark another stage ticketState: 'CLOSED' first, then run ${plan}`
+	};
+	if (reason === "STAGE_LABEL_EXISTS") return {
+		why: "another stage of the pipeline has that label, ignoring case",
+		fix: `run ${plan}: it reads the portal again`
+	};
+	return (reason === "STAGE_ID_EXISTS_IN_ANOTHER_PIPELINE" || sent.message.includes("already using stage id") || sent.message.includes("There's another pipeline")) && (kindOf(step.address) === "pipeline" || kindOf(step.address) === "stage") ? {
+		why: "HubSpot refuses the ID because another pipeline or stage holds it; deals and tickets share pipeline IDs",
+		fix: `give the pipeline or stage another ID in config, then run ${plan}`
+	} : void 0;
+}
 function usesOf(sent) {
 	const uses = (sent.errors ?? []).filter((e) => e.subCategory?.endsWith("PROPERTY_USAGE")).map((e) => {
 		return sanitize(`${(e.context?.parentDisplayType?.[0] ?? e.context?.parentType?.[0] ?? "use").toLowerCase().replaceAll("_", " ")} ${e.context?.parentName?.[0] ?? ""}`.trim(), USE_MAX);
@@ -9200,6 +10719,7 @@ async function find(run, step, archived) {
 	const key = objectOf(step.address);
 	const objectType = run.names.objectType(key);
 	const name = portalName(run, step);
+	if (kind === "pipeline" || kind === "stage") return await findPipeline(run, step, archived);
 	if (kind === "group") {
 		const group = (await read$1(run, {
 			type: "group",
@@ -9253,10 +10773,51 @@ async function find(run, step, archived) {
 		raw
 	};
 }
+async function findPipeline(run, step, archived) {
+	const key = objectOf(step.address);
+	const pipeline = kindOf(step.address) === "stage" ? pipelineOf(step.address) : step.address;
+	let raw;
+	try {
+		raw = await read$1(run, {
+			type: "pipeline",
+			path: "read",
+			params: {
+				objectType: run.names.objectType(key),
+				pipelineId: run.names.pipelineId(step.address)
+			}
+		});
+	} catch (error) {
+		if (error instanceof HubSpotApiError && error.status === 404) return archived ? {
+			present: false,
+			archived: true
+		} : { present: false };
+		throw error;
+	}
+	const [live] = localPipelines(key, normalizePipelines(key, [raw], !STANDARD_OBJECTS.has(key)), run.names);
+	const resources = Object.fromEntries(pipelineResources(live ? [{
+		...live,
+		id: pipeline.slice(pipeline.lastIndexOf("/") + 1)
+	}] : [], pipeline));
+	const resource = resources[step.address];
+	if (archived) return {
+		present: resource !== void 0,
+		archived: resource === void 0
+	};
+	const stages = Object.fromEntries(Object.entries(resources).filter(([address]) => address !== pipeline));
+	return resource ? {
+		present: true,
+		raw,
+		resource,
+		stages
+	} : {
+		present: false,
+		raw
+	};
+}
 async function appeared(run, step) {
 	try {
 		if ((await find(run, step, false)).present) return true;
-		if (kindOf(step.address) === "group") return false;
+		if (kindOf(step.address) !== "property") return false;
 		const objectType = run.names.objectType(objectOf(step.address));
 		const name = portalName(run, step);
 		for (const dataSensitivity of [
@@ -9277,43 +10838,175 @@ async function appeared(run, step) {
 		if (error instanceof Stopped || error instanceof KalupError) return;
 		throw error;
 	}
-}
-function payload(run, step, before) {
-	const kind = kindOf(step.address);
-	const objectType = run.names.objectType(objectOf(step.address));
-	const name = portalName(run, step);
+}
+function payload(run, step, before) {
+	const kind = kindOf(step.address);
+	const objectType = run.names.objectType(objectOf(step.address));
+	const name = portalName(run, step);
+	if (kind === "pipeline" || kind === "stage") return pipelinePayload(run, step, before, objectType);
+	if (step.action === "create") {
+		const group = (step.desired?.group)?.$ref;
+		const body = createBody(step, {
+			name,
+			...group === void 0 ? {} : { group: run.names.portalName(group) }
+		});
+		return {
+			type: kind,
+			path: "create",
+			params: { objectType },
+			body
+		};
+	}
+	if (step.action === "delete") return {
+		type: kind,
+		path: "delete",
+		params: {
+			objectType,
+			name
+		}
+	};
+	const body = kind === "group" ? groupPatch(step.changes ?? []) : propertyPatch(step, before.raw, (ref) => run.names.portalName(ref));
+	return {
+		type: kind,
+		path: "update",
+		params: {
+			objectType,
+			name
+		},
+		body
+	};
+}
+function pipelinePayload(run, step, before, objectType) {
+	const pipelineId = run.names.pipelineId(step.address);
+	if (kindOf(step.address) === "pipeline") {
+		if (step.action === "create") return {
+			type: "pipeline",
+			path: "create",
+			params: { objectType },
+			body: pipelineCreateBody(step, pipelineId)
+		};
+		if (step.action === "delete") return {
+			type: "pipeline",
+			path: "delete",
+			params: {
+				objectType,
+				pipelineId
+			}
+		};
+		const body = pipelinePatch(step.changes ?? []);
+		return {
+			type: "pipeline",
+			path: "update",
+			params: {
+				objectType,
+				pipelineId
+			},
+			body
+		};
+	}
+	const stageId = portalName(run, step);
 	if (step.action === "create") {
-		const group = (step.desired?.group)?.$ref;
-		const body = createBody(step, {
-			name,
-			...group === void 0 ? {} : { group: run.names.portalName(group) }
-		});
+		const raw = before.raw;
+		const highest = Math.max(-1, ...(raw?.stages ?? []).map((st) => st.displayOrder));
+		const body = stageCreateBody(step.desired ?? {}, stageId, highest + 1);
 		return {
-			type: kind,
+			type: "stage",
 			path: "create",
-			params: { objectType },
+			params: {
+				objectType,
+				pipelineId
+			},
 			body
 		};
 	}
 	if (step.action === "delete") return {
-		type: kind,
+		type: "stage",
 		path: "delete",
 		params: {
 			objectType,
-			name
+			pipelineId,
+			stageId
 		}
 	};
-	const body = kind === "group" ? groupPatch(step.changes ?? []) : propertyPatch(step, before.raw, (ref) => run.names.portalName(ref));
 	return {
-		type: kind,
+		type: "stage",
 		path: "update",
 		params: {
 			objectType,
-			name
+			pipelineId,
+			stageId
 		},
-		body
+		body: stagePatch(step.changes ?? [])
 	};
 }
+/**
+* A pipeline step that writes the stage order: its label and displayOrder first, in one PATCH, then the stage moves.
+* HubSpot never stores two stages at one displayOrder: a write to a taken slot places the stage right after the stage
+* that held it and renumbers the pipeline 0..n-1 (observed 2026-10-05). So with D the order the step leaves
+* (stageOrder), each stage that is not right after its predecessor in D is moved onto that predecessor's slot, one
+* PATCH each, sent once, with a read of the pipeline before each move. The one write of several requests: a pipeline
+* PUT would drop any stage it does not name. Nothing follows a request whose outcome is uncertain: the step settles on
+* it. A wait counts against the step's `tries`; once any request of the step has landed, the retry's read no longer
+* meets the step's expect (the label or the stage order moved), so the step stops stale and the report says to plan
+* again, which shows what is left.
+*/
+async function reorderWrite(run, step, before, tries) {
+	const objectType = run.names.objectType(objectOf(step.address));
+	const pipelineId = run.names.pipelineId(step.address);
+	const fields = pipelinePatch(step.changes ?? []);
+	let last = {
+		kind: "ok",
+		status: 200,
+		body: before.raw
+	};
+	if (Object.keys(fields).length > 0) {
+		const sent = await send(run, {
+			type: "pipeline",
+			path: "update",
+			params: {
+				objectType,
+				pipelineId
+			},
+			body: fields
+		});
+		if (sent.kind !== "ok") return await reorderStopped(run, step, sent, tries);
+		last = sent;
+	}
+	const approved = step.changes?.find((c) => c.unit === "stages")?.after ?? [];
+	let current = before;
+	for (let move = 0;; move += 1) {
+		const live = (current.resource?.definition?.stages ?? []).slice();
+		const target = stageOrder(live, approved);
+		const at = target.findIndex((id, i) => i > 0 && live.indexOf(id) !== live.indexOf(target[i - 1]) + 1);
+		if (at === -1 || move > live.length || halted(run)) break;
+		const raw = current.raw;
+		const portal = (id) => run.names.portalName(`${step.address.replace("pipeline:", "stage:")}/${id}`);
+		const slot = raw.stages.find((st) => st.id === portal(target[at - 1]))?.displayOrder;
+		const sent = await send(run, {
+			type: "stage",
+			path: "update",
+			params: {
+				objectType,
+				pipelineId,
+				stageId: portal(target[at])
+			},
+			body: { displayOrder: slot }
+		});
+		if (sent.kind !== "ok") return await reorderStopped(run, step, sent, tries);
+		last = sent;
+		try {
+			current = await find(run, step, false);
+		} catch (error) {
+			return failedRead(run, step, error);
+		}
+	}
+	return await settle(run, step, last);
+}
+async function reorderStopped(run, step, sent, tries) {
+	if (sent.kind === "rejected") return rejected(run, step, sent);
+	if (sent.kind === "wait") return waited(run, step, sent, tries);
+	return await settle(run, step, sent);
+}
 function dependent(run, step) {
 	return refsOf(step).some((ref) => run.created.has(ref));
 }
@@ -9349,13 +11042,18 @@ function entryOf$1(run, step, base) {
 	if (base !== void 0) entry.base = base;
 	return entry;
 }
+function stagesGone(run, step) {
+	if (kindOf(step.address) !== "pipeline") return [];
+	const prefix = `${step.address.replace("pipeline:", "stage:")}/`;
+	return Object.keys(run.state.resources).filter((address) => address.startsWith(prefix)).map((address) => [address, null]);
+}
 function saveEntries(run, entries) {
 	if (entries.length === 0) return true;
 	try {
 		const changed = save(run, (s) => {
 			const resources = { ...s.resources };
-			for (const [step, entry] of entries) if (entry === null) delete resources[step.address];
-			else resources[step.address] = entry;
+			for (const [address, entry] of entries) if (entry === null) delete resources[address];
+			else resources[address] = entry;
 			return {
 				...s,
 				resources
@@ -9652,7 +11350,8 @@ function covers(written, unit) {
 	return unit === written || unit.startsWith(`${written}.`) || unit.startsWith(`${written}[`);
 }
 function names(body, name) {
-	return typeof body === "object" && body !== null && body.name === name;
+	const named = body;
+	return typeof body === "object" && named !== null && (named.name === name || named.id === name);
 }
 function portalName(run, step) {
 	return run.names.portalName(step.address);
@@ -10069,7 +11768,7 @@ const OVERRIDE_COLUMNS = [
 	"Target",
 	"Value"
 ];
-const OVERRIDE_FIELDS = OVERRIDABLE.property;
+const OVERRIDE_FIELDS = [...OVERRIDABLE.property, ...OVERRIDABLE.stage.filter((f) => !OVERRIDABLE.property.includes(f))];
 const LIFECYCLE_FIELDS = [
 	"options",
 	"removedOptions",
@@ -10110,6 +11809,19 @@ const OPTION_COLUMNS = {
 		"Hidden"
 	]
 };
+const STAGE_COLUMNS = {
+	config: [
+		"Stage ID",
+		"Key",
+		"Label",
+		"Closes"
+	],
+	snapshot: [
+		"Stage ID",
+		"Label",
+		"Closes"
+	]
+};
 /**
 * The page for a config IR, or for a snapshot with the coverage of its read. A config definition lists only the fields
 * it states; a snapshot fills HubSpot's defaults for what the portal left out.
@@ -10182,6 +11894,11 @@ function coverageLines(coverage) {
 			objects.flatMap(([k, o]) => (o.unaddressable ?? []).map((name) => `${md(name)} on ${md(k)}`)),
 			", "
 		],
+		[
+			"Pipelines not read",
+			objects.filter(([, o]) => o.pipelines?.status === "unreadable").map(([k, o]) => o.pipelines?.missingScope === void 0 ? md(k) : `${md(k)} (missing scope ${md(o.pipelines.missingScope)})`),
+			", "
+		],
 		[
 			"Shadowed by name overrides, not captured",
 			objects.flatMap(([k, o]) => o.shadowed ? [`${plural(o.shadowed.length, "name")} on ${md(k)}`] : []),
@@ -10193,8 +11910,13 @@ function coverageLines(coverage) {
 	const fields = [
 		"property",
 		"group",
-		"object"
-	].map((type) => `${type}: ${[...notCaptured[type]].sort(byCodeUnit).map(md).join(", ")}`).join("; ");
+		"object",
+		"pipeline",
+		"stage"
+	].flatMap((type) => {
+		const listed = notCaptured[type];
+		return listed === void 0 ? [] : [`${type}: ${[...listed].sort(byCodeUnit).map(md).join(", ")}`];
+	}).join("; ");
 	return [
 		coverage.complete ? COMPLETE : INCOMPLETE,
 		"",
@@ -10211,17 +11933,22 @@ function byObject(resources) {
 		const key = objectOf(address);
 		const entry = objects.get(key) ?? {
 			groups: [],
-			properties: []
+			properties: [],
+			pipelines: [],
+			stages: /* @__PURE__ */ new Map()
 		};
 		objects.set(key, entry);
 		const resource = resources[address];
 		if (type === "object") entry.object = resource;
 		else if (type === "group") entry.groups.push([nameOf(address), resource]);
 		else if (type === "property") entry.properties.push([nameOf(address), resource]);
+		else if (type === "pipeline") entry.pipelines.push([nameOf(address), resource]);
+		else if (type === "stage") entry.stages.set(address, resource);
 	}
 	return [...objects].sort(([a], [b]) => byCodeUnit(a, b));
 }
-function objectLines(key, { object, groups, properties }, config) {
+function objectLines(key, resources, config) {
+	const { object, groups, properties } = resources;
 	const lines = [`## ${escapeMarkdown(key)}`];
 	if (object?.definition) lines.push("", ...schemaLines(object.definition));
 	if (groups.length > 0) {
@@ -10240,8 +11967,33 @@ function objectLines(key, { object, groups, properties }, config) {
 			lines.push("", `#### Options of ${escapeMarkdown(name)}`, "", ...table(columns, rows));
 		}
 	}
+	for (const [id, p] of resources.pipelines) lines.push("", ...pipelineLines(key, id, p, resources.stages, config));
 	return lines;
 }
+function pipelineLines(key, id, p, stages, config) {
+	const d = p.definition ?? {};
+	const rows = (d.stages ?? []).flatMap((stage) => {
+		const s = stages.get(`stage:${key}/${id}/${stage}`);
+		if (!s) return [];
+		return [[
+			escapeMarkdown(stage),
+			...config ? [escapeMarkdown(s.binding?.key ?? "")] : [],
+			escapeMarkdown(stringOf(s.definition?.label)),
+			closes(s.definition ?? {})
+		]];
+	});
+	return [
+		`### Pipeline ${escapeMarkdown(stringOf(d.label))} (${escapeMarkdown(id)})`,
+		"",
+		`- Display order: ${typeof d.displayOrder === "number" ? d.displayOrder : ""}`,
+		...rows.length > 0 ? ["", ...table(STAGE_COLUMNS[config ? "config" : "snapshot"], rows)] : []
+	];
+}
+function closes(d) {
+	if (typeof d.probability === "number") return `probability ${d.probability}`;
+	const state = d.ticketState ?? d.state;
+	return typeof state === "string" ? escapeMarkdown(state) : "";
+}
 function schemaLines(definition) {
 	const labels = definition.labels ?? {};
 	const names = (value, sort) => {
@@ -10552,7 +12304,8 @@ const scopeKeys = every()([
 	"include",
 	"exclude",
 	"custom",
-	"as"
+	"as",
+	"pipelines"
 ]);
 const targetKeys = every()([
 	"portalId",
@@ -10592,6 +12345,12 @@ const definitionKeys = every()([
 	"dataSensitivity",
 	"lifecycle"
 ]);
+const overrideDefinitionKeys = every()([
+	...definitionKeys,
+	"probability",
+	"ticketState",
+	"state"
+]);
 const optionKeys = every()([
 	"value",
 	"label",
@@ -10599,6 +12358,13 @@ const optionKeys = every()([
 	"hidden",
 	"description"
 ]);
+const stageKeys = every()([
+	"id",
+	"label",
+	"probability",
+	"ticketState",
+	"state"
+]);
 const lifecycleKeys = every()([
 	"options",
 	"removedOptions",
@@ -10629,6 +12395,7 @@ function escapeString(s, quote = "'") {
 }
 function write(kind, data) {
 	if (kind === "object") return writeObjectFile(data);
+	if (kind === "pipeline") return writePipelineFile(data);
 	if (kind === "config") return writeConfigFile(data);
 	if (kind === "removed") return writeRemovedFile(data);
 	return writeBarrel(data);
@@ -10765,9 +12532,31 @@ function writeObjectFile(f) {
 	});
 	return `${out.join("\n")}\n`;
 }
+function writePipelineFile(f) {
+	const out = [
+		...header(f.header),
+		"import { definePipeline } from '@kalup/core'",
+		...f.imports,
+		""
+	];
+	f.exports.forEach((e, i) => {
+		const body = [
+			...wrap("id: ", e.id, ",", "  "),
+			...wrap("label: ", e.label, ",", "  "),
+			`  displayOrder: ${e.displayOrder},`,
+			...block("  stages: ", e.stages.flatMap((st) => [...comment(st.comments, "    "), ...wrap(`${key(st.key)}: `, pick$1(st, stageKeys), ",", "    ")]), "  ", ",")
+		];
+		if (i) out.push("");
+		out.push(...comment(e.comments, ""), ...block(`export const ${e.name} = definePipeline(${q(e.object)}, `, body, "", ")"));
+	});
+	return `${out.join("\n")}\n`;
+}
 function override(o) {
 	const out = pick$1(o, overrideKeys);
-	if (o.definition) out.definition = canon(o.definition);
+	if (o.definition) out.definition = {
+		...canon(o.definition),
+		...pick$1(o.definition, overrideDefinitionKeys.slice(definitionKeys.length))
+	};
 	return out;
 }
 function target(t) {
@@ -10823,9 +12612,11 @@ function writeRemovedFile(r) {
 function writeBarrel(entries) {
 	const byFrom = /* @__PURE__ */ new Map();
 	for (const e of [...entries].sort((a, b) => cmp$1(a.from, b.from) || cmp$1(a.name, b.name))) byFrom.set(e.from, [...byFrom.get(e.from) ?? [], e.name]);
+	const pipelines = new Set(entries.filter((e) => e.pipeline).map((e) => `${e.from}\0${e.name}`));
 	const out = [];
 	for (const [from, names] of byFrom) {
-		out.push(`export type { ${names.map((n) => `${n}Data`).join(", ")} } from ${q(`${from}.js`)}`);
+		const typed = names.filter((n) => !pipelines.has(`${from}\0${n}`));
+		if (typed.length) out.push(`export type { ${typed.map((n) => `${n}Data`).join(", ")} } from ${q(`${from}.js`)}`);
 		out.push(`export { ${names.join(", ")} } from ${q(`${from}.js`)}`);
 	}
 	return `${out.length ? out.join("\n") : "export {}"}\n`;
@@ -11849,7 +13640,7 @@ function createReport() {
 	};
 	const changes = [];
 	const note = (change) => {
-		changes.push(scrub$2(change));
+		changes.push(scrub$1(change));
 	};
 	return {
 		counts,
@@ -12219,7 +14010,7 @@ function resolveUnits(address, mine, merged, fields, r) {
 		const member = MEMBER.exec(u.unit);
 		if (u.unit === "options.order") resolveOrder(at, u);
 		else if (member) resolveMember(at, u, member[1], member[2]);
-		else if (u.unit !== "type" && keepsFile(at, u)) {
+		else if (u.unit !== "type" && keepsFile$1(at, u)) {
 			noteUnit(at, u, mine[u.unit], merged[u.unit]);
 			drop(at, "changed", u.unit);
 			put$1(merged, u.unit, mine[u.unit]);
@@ -12228,7 +14019,7 @@ function resolveUnits(address, mine, merged, fields, r) {
 	if (merged.options?.length === 0 && mine.options === void 0) merged.options = void 0;
 	compactInPlace(merged);
 }
-function keepsFile(at, u) {
+function keepsFile$1(at, u) {
 	return (u.class === "config-change" || u.class === "conflict") && !at.r.accept(u.unit);
 }
 function noteUnit(at, u, before, after) {
@@ -12246,8 +14037,8 @@ function drop(at, kind, field) {
 }
 function resolveOrder(at, u) {
 	const { merged, mine } = at;
-	if (merged.options && keepsFile(at, u)) {
-		const ordered = inFileOrder(mine.options, merged.options);
+	if (merged.options && keepsFile$1(at, u)) {
+		const ordered = inFileOrder$1(mine.options, merged.options);
 		noteUnit(at, u, commonValues(ordered, mine.options), commonValues(merged.options, mine.options));
 		merged.options = ordered;
 	}
@@ -12260,7 +14051,7 @@ function resolveMember(at, u, value, field) {
 		merged.options = merged.options?.filter((o) => o.value !== value);
 	};
 	if (field !== void 0) {
-		if (theirs && ours && keepsFile(at, u)) {
+		if (theirs && ours && keepsFile$1(at, u)) {
 			noteUnit(at, u, ours[field], theirs[field]);
 			drop(at, "changed", u.unit);
 			put$1(theirs, field, ours[field]);
@@ -12313,7 +14104,7 @@ function resolveMember(at, u, value, field) {
 		});
 	}
 }
-function inFileOrder(mine, merged) {
+function inFileOrder$1(mine, merged) {
 	const inFile = new Set((mine ?? []).map((o) => o.value));
 	const byValue = new Map(merged.filter((o) => inFile.has(o.value)).map((o) => [o.value, o]));
 	const queue = (mine ?? []).flatMap((o) => {
@@ -12441,7 +14232,7 @@ function cmp(a, b) {
 	if (a < b) return -1;
 	return a > b ? 1 : 0;
 }
-function scrub$2(change) {
+function scrub$1(change) {
 	return compact({
 		...change,
 		address: sanitize(change.address),
@@ -12551,6 +14342,59 @@ function targetOnly(file, overrides) {
 		};
 	};
 }
+/** A pipeline export as target T sees it: the pipeline's and each stage's overridden fields in place of the file's. */
+function pipelineAsTarget(e, overrides) {
+	const at = `${e.object}/${e.id}`;
+	const d = definitionOf(overrides, `pipeline:${at}`);
+	return {
+		...e,
+		...d ? pickFields(d, OVERRIDABLE.pipeline) : {},
+		stages: e.stages.map((st) => {
+			const sd = definitionOf(overrides, `stage:${at}/${st.id}`);
+			return sd ? {
+				...st,
+				...pickFields(sd, OVERRIDABLE.stage)
+			} : st;
+		})
+	};
+}
+/**
+* Splits a pipeline export merged from pipelineAsTarget's view against `file`, the export as written: each field T
+* overrides takes the merged value into T's override and the file's own value back.
+*/
+function pipelineFromTarget(merged, file, overrides) {
+	const changed = {};
+	const split = (address, fields, value, mine) => {
+		const override = own(overrides, address);
+		const d = definitionOf(overrides, address);
+		if (!(override && d && mine)) return value;
+		const taken = fields.filter((f) => d[f] !== void 0);
+		const definition = { ...d };
+		const out = { ...value };
+		for (const field of taken) {
+			definition[field] = value[field];
+			out[field] = mine[field];
+		}
+		if (stableStringify(definition) !== stableStringify(d)) changed[address] = {
+			...override,
+			definition
+		};
+		return out;
+	};
+	const at = `${merged.object}/${merged.id}`;
+	const pipeline = split(`pipeline:${at}`, OVERRIDABLE.pipeline, merged, file);
+	const stages = merged.stages.map((st) => split(`stage:${at}/${st.id}`, OVERRIDABLE.stage, st, file.stages.find((f) => f.id === st.id)));
+	return {
+		export: {
+			...pipeline,
+			stages
+		},
+		overrides: changed
+	};
+}
+function pickFields(d, fields) {
+	return Object.fromEntries(fields.filter((f) => d[f] !== void 0).map((f) => [f, d[f]]));
+}
 function definitionOf(overrides, address) {
 	const override = own(overrides, address);
 	return override?.skip === true ? void 0 : override?.definition;
@@ -12569,6 +14413,297 @@ function pick$4(d, fields) {
 function own(record, key) {
 	return Object.hasOwn(record, key) ? record[key] : void 0;
 }
+const SLUG = /^[a-z][a-z0-9_]*$/;
+const NOT_ALNUM = /[^A-Za-z0-9]+/;
+const LETTER = /[A-Za-z]/;
+const DIGIT_FIRST = /^[0-9]/;
+function mergePipelines(input) {
+	const { live, local, object, only, removed } = input;
+	const out = {
+		changes: [],
+		counts: {
+			added: 0,
+			changed: 0,
+			unchanged: 0,
+			missing: 0
+		},
+		fresh: [],
+		merged: /* @__PURE__ */ new Map()
+	};
+	const note = (change) => out.changes.push(scrub$3(change));
+	const settle = (fields) => {
+		if (fields.some((c) => c.kind === "changed" || c.kind === "added")) out.counts.changed += 1;
+		else out.counts.unchanged += 1;
+		fields.forEach(note);
+	};
+	const ours = new Set(local.map((p) => p.id));
+	for (const p of local) out.merged.set(p.name, mergeOne$1(input, p, {
+		note,
+		settle,
+		counts: out.counts
+	}));
+	for (const l of live) {
+		const address = `pipeline:${object}/${l.id}`;
+		if (!input.all || ours.has(l.id) || !(only(address) || l.stages.some((st) => only(stageAt(object, l.id, st.id))))) continue;
+		if (removed?.has(address)) {
+			note({
+				kind: "removed",
+				address
+			});
+			continue;
+		}
+		const fresh = freshExport$1(input, l);
+		out.fresh.push(fresh);
+		out.counts.added += 1 + fresh.stages.length;
+		note({
+			kind: "added",
+			address
+		});
+		for (const st of fresh.stages) note({
+			kind: "added",
+			address: stageAt(object, l.id, st.id)
+		});
+	}
+	return out;
+}
+function mergeOne$1(input, p, report) {
+	const { object, only, excluded } = input;
+	const address = `pipeline:${object}/${p.id}`;
+	const l = input.live.find((x) => x.id === p.id);
+	if (!(only(address) || p.stages.some((st) => only(stageAt(object, p.id, st.id))))) return p;
+	if (excluded.has(address)) {
+		report.note({
+			kind: "excluded",
+			address
+		});
+		return p;
+	}
+	if (!l) {
+		report.counts.missing += 1;
+		report.note({
+			kind: "missing",
+			address
+		});
+		return p;
+	}
+	const next = { ...p };
+	if (only(address)) {
+		const fields = [];
+		for (const field of ["label", "displayOrder"]) {
+			if (p[field] !== l[field]) fields.push({
+				kind: "changed",
+				address,
+				field,
+				before: p[field],
+				after: l[field]
+			});
+			Object.assign(next, { [field]: l[field] });
+		}
+		resolveFields(address, p, next, fields, input.resolve?.(address));
+		next.stages = mergeStages(input, p, l, next, fields, report);
+		report.settle(fields);
+	} else next.stages = mergeStages(input, p, l, next, [], report);
+	return next;
+}
+function mergeStages(input, p, l, next, fields, report) {
+	const merged = portalStages(input, p, l, report);
+	keepFileOnly(input, p, merged, report);
+	return orderStages(input, p, merged, next, fields);
+}
+function portalStages(input, p, l, report) {
+	const { object, only, removed } = input;
+	const mine = new Map(p.stages.map((st) => [st.id, st]));
+	const keys = new Set(p.stages.map((st) => st.key));
+	const merged = [];
+	for (const ls of l.stages) {
+		const address = stageAt(object, p.id, ls.id);
+		const st = mine.get(ls.id);
+		const taken = only(address);
+		if (st) merged.push(taken ? mergeStage(input, st, ls, address, report) : st);
+		else if (removed?.has(address)) report.note({
+			kind: "removed",
+			address
+		});
+		else if (taken) {
+			const key = stageKey(ls, keys);
+			keys.add(key);
+			merged.push(stageOf(ls, key, []));
+			report.counts.added += 1;
+			report.note({
+				kind: "added",
+				address
+			});
+		}
+	}
+	return merged;
+}
+function keepFileOnly(input, p, merged, report) {
+	const order = p.stages.map((st) => st.id);
+	for (const [index, st] of p.stages.entries()) {
+		if (merged.some((m) => m.id === st.id)) continue;
+		const address = stageAt(input.object, p.id, st.id);
+		if (input.only(address) && input.excluded.has(address)) report.note({
+			kind: "excluded",
+			address
+		});
+		else if (input.only(address)) {
+			report.counts.missing += 1;
+			report.note({
+				kind: "missing",
+				address
+			});
+		}
+		const before = order.slice(0, index).reverse().find((id) => merged.some((m) => m.id === id));
+		merged.splice(before === void 0 ? 0 : merged.findIndex((m) => m.id === before) + 1, 0, st);
+	}
+}
+function orderStages(input, p, merged, next, fields) {
+	const pipeline = `pipeline:${input.object}/${p.id}`;
+	const order = p.stages.map((st) => st.id);
+	const resolution = input.resolve?.(pipeline);
+	const unit = resolution?.units.find((u) => u.unit === "stages");
+	const ids = (stages) => stages.map((st) => st.id).filter((id) => order.includes(id));
+	if (!input.only(pipeline)) return inFileOrder(order, merged);
+	if (unit && resolution && keepsFile(unit, resolution)) {
+		const kept = inFileOrder(order, merged);
+		const kind = unit.class === "conflict" ? "conflict" : "kept";
+		fields.push({
+			kind,
+			address: pipeline,
+			field: "stages",
+			before: ids(kept),
+			after: ids(merged)
+		});
+		next.stages = kept;
+		return kept;
+	}
+	const was = order.filter((id) => merged.some((m) => m.id === id));
+	const now = ids(merged);
+	if (was.join("\0") !== now.join("\0")) fields.push({
+		kind: "changed",
+		address: pipeline,
+		field: "stages",
+		before: was,
+		after: now
+	});
+	return merged;
+}
+function mergeStage(input, st, ls, address, report) {
+	const fields = [];
+	const next = stageOf(ls, st.key, st.comments);
+	if (st.label !== ls.label) fields.push({
+		kind: "changed",
+		address,
+		field: "label",
+		before: st.label,
+		after: ls.label
+	});
+	for (const field of STAGE_FIELDS) if (st[field] !== ls[field]) fields.push({
+		kind: "changed",
+		address,
+		field,
+		before: st[field],
+		after: ls[field]
+	});
+	const merged = { ...next };
+	resolveFields(address, st, merged, fields, input.resolve?.(address));
+	report.settle(fields);
+	return merged;
+}
+function resolveFields(address, mine, merged, fields, r) {
+	for (const u of r?.units ?? []) {
+		if (u.unit === "stages" || !keepsFile(u, r)) continue;
+		const at = fields.findIndex((c) => c.kind === "changed" && c.field === u.unit);
+		if (at >= 0) fields.splice(at, 1);
+		fields.push({
+			kind: u.class === "conflict" ? "conflict" : "kept",
+			address,
+			field: u.unit,
+			before: mine[u.unit],
+			after: merged[u.unit]
+		});
+		if (mine[u.unit] === void 0) delete merged[u.unit];
+		else merged[u.unit] = mine[u.unit];
+	}
+}
+function keepsFile(u, r) {
+	return (u.class === "config-change" || u.class === "conflict") && !r.accept(u.unit);
+}
+function inFileOrder(order, merged) {
+	const queue = order.flatMap((id) => merged.filter((st) => st.id === id));
+	return merged.map((st) => order.includes(st.id) ? queue.shift() ?? st : st);
+}
+function stageOf(ls, key, comments) {
+	const out = {
+		key,
+		id: ls.id,
+		label: ls.label,
+		comments
+	};
+	for (const field of STAGE_FIELDS) if (ls[field] !== void 0) Object.assign(out, { [field]: ls[field] });
+	return out;
+}
+function freshExport$1(input, l) {
+	const keys = /* @__PURE__ */ new Set();
+	const stages = l.stages.map((ls) => {
+		const key = stageKey(ls, keys);
+		keys.add(key);
+		return stageOf(ls, key, []);
+	});
+	const name = unique$1(pipelineExportName(l.label, l.id), input.taken);
+	input.taken.add(name);
+	return {
+		name,
+		object: input.object,
+		id: l.id,
+		label: l.label,
+		displayOrder: l.displayOrder,
+		stages,
+		comments: []
+	};
+}
+/**
+* The export name pull gives a pipeline: PascalCase of the words of its label, followed by `Pipeline` unless the label
+* ends with that word, `SalesPipeline` for "Sales Pipeline"; the ID's words when the label has no letter.
+*/
+function pipelineExportName(label, id) {
+	const words = (text) => text.split(NOT_ALNUM).filter(Boolean);
+	const name = (words(label).some((w) => LETTER.test(w)) ? words(label) : words(id)).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+	const base = DIGIT_FIRST.test(name) || name === "" ? `Pipeline${name}` : name;
+	return base.endsWith("Pipeline") ? base : `${base}Pipeline`;
+}
+/**
+* The key pull gives a stage: camelCase of its ID when the ID is a lowercase slug, else of its label, with `stage` in
+* front of one that would start with a digit, unique in the pipeline.
+*/
+function stageKey(ls, taken) {
+	const words = (text) => text.toLowerCase().split(NOT_ALNUM).filter(Boolean).join("_");
+	const base = camelCase(SLUG.test(ls.id) ? ls.id : words(ls.label) || words(ls.id)) || "stage";
+	return unique$1(DIGIT_FIRST.test(base) ? `stage${base}` : base, taken);
+}
+function unique$1(name, taken) {
+	if (!taken.has(name)) return name;
+	let n = 2;
+	while (taken.has(`${name}${n}`)) n += 1;
+	return `${name}${n}`;
+}
+function stageAt(object, pipeline, stage) {
+	return `stage:${object}/${pipeline}/${stage}`;
+}
+function scrub$3(change) {
+	const clean = (value) => {
+		if (typeof value === "string") return sanitize(value);
+		return Array.isArray(value) ? value.map(clean) : value;
+	};
+	const out = {
+		...change,
+		address: sanitize(change.address)
+	};
+	if (change.field !== void 0) out.field = sanitize(change.field);
+	if (change.before !== void 0) out.before = clean(change.before);
+	if (change.after !== void 0) out.after = clean(change.after);
+	return out;
+}
 /** The key's scopes, or undefined when HubSpot refused the request, gave no answer, or answered without a scope list. */
 async function readTokenInfo(http, key) {
 	let answer;
@@ -13757,8 +15892,9 @@ function fmt(ctx) {
 }
 /**
 * The canonical text of every file of a project the loader accepted, in path order: kalup.config.ts, <dir>/removed.ts,
-* each object file, and the barrel re-exporting every object. The barrel is left out when there is no object file to
-* re-export. A file that is not TypeScript (the blueprints lock, a stored original) is the tool's own JSON: not here.
+* each object and pipeline file, and the barrel re-exporting every object and pipeline. The barrel is left out when
+* there is no object file to re-export. A file that is not TypeScript (the blueprints lock, a stored original) is the
+* tool's own JSON: not here.
 */
 function canonical(files, at) {
 	const out = [];
@@ -13774,8 +15910,17 @@ function canonical(files, at) {
 			out.push([file, write("removed", result.data)]);
 			continue;
 		}
-		out.push([file, write("object", result.data)]);
 		const from = barrelPath(at, file);
+		if (result.kind === "pipeline") {
+			out.push([file, write("pipeline", result.data)]);
+			entries.push(...result.data.exports.map((e) => ({
+				name: e.name,
+				from,
+				pipeline: true
+			})));
+			continue;
+		}
+		out.push([file, write("object", result.data)]);
 		for (const e of result.data.exports) entries.push({
 			name: e.name,
 			from
@@ -13953,7 +16098,11 @@ async function pull(ctx) {
 async function pullTarget(ctx, pulling) {
 	const { root, loaded, http, target, targetName, via, accepting, warnings } = pulling;
 	const portalId = target.portalId;
-	const portal = await readPortal(http, loaded, target, warnings, { schemas: ctx.flags.discover });
+	const discovering = ctx.flags.discover === true;
+	const portal = await readPortal(http, loaded, target, warnings, {
+		schemas: discovering,
+		pipelines: discovering
+	});
 	if (portal.absent.length > 0) throw unknownObjects(portal.absent, portal.customObjects ?? [], loaded.configLines);
 	if (portal.unknownIncludes.length > 0) throw new KalupError(portal.unknownIncludes.map(unknownInclude(loaded.configLines)), exitCodes.invalid);
 	const incomplete = incompleteIssue(portal.gaps, targetName);
@@ -14196,12 +16345,93 @@ function mergeFiles(files, portal, loaded, merging, warnings) {
 		parsed.set(file, data);
 		next[file] = write("object", data);
 	}
+	mergePipelineFiles({
+		next,
+		objects,
+		overrides,
+		parsed,
+		portal,
+		loaded,
+		merging: {
+			...rest,
+			only,
+			stated,
+			excluded
+		}
+	});
 	return {
 		next,
 		objects,
 		overrides
 	};
 }
+function mergePipelineFiles(m) {
+	const { next, objects, overrides, parsed, portal, loaded } = m;
+	const { stated, ...rest } = m.merging;
+	const files = pipelineFiles(next, loaded.layout);
+	const taken = /* @__PURE__ */ new Set([...[...parsed.values()].flatMap((f) => f.exports.map((e) => e.name)), ...[...files.values()].flatMap((f) => f.exports.map((e) => e.name))]);
+	for (const live of portal.objects) {
+		if (live.pipelines === void 0) continue;
+		const { object } = live;
+		const local = [...files.values()].flatMap((f) => f.exports.filter((e) => e.object === object));
+		const merged = mergePipelines({
+			...rest,
+			all: loaded.config.objects[object]?.pipelines === true,
+			object,
+			live: live.pipelines,
+			local: local.map((e) => pipelineAsTarget(e, stated)),
+			taken
+		});
+		const report = objects[object] ?? {
+			added: 0,
+			changed: 0,
+			unchanged: 0,
+			missing: 0,
+			changes: []
+		};
+		for (const count of [
+			"added",
+			"changed",
+			"unchanged",
+			"missing"
+		]) report[count] += merged.counts[count];
+		report.changes.push(...merged.changes);
+		objects[object] = report;
+		for (const [file, data] of files) {
+			const exports = data.exports.map((e) => {
+				const into = e.object === object ? merged.merged.get(e.name) : void 0;
+				if (!into) return e;
+				const split = pipelineFromTarget(into, e, stated);
+				Object.assign(overrides, split.overrides);
+				return split.export;
+			});
+			files.set(file, {
+				...data,
+				exports
+			});
+		}
+		if (merged.fresh.length > 0) {
+			const file = pipelinePath(loaded.layout, object);
+			const data = files.get(file) ?? {
+				imports: [],
+				exports: []
+			};
+			files.set(file, {
+				...data,
+				exports: [...data.exports, ...merged.fresh]
+			});
+		}
+	}
+	for (const [file, data] of files) next[file] = write("pipeline", data);
+}
+function pipelineFiles(files, at) {
+	const out = /* @__PURE__ */ new Map();
+	for (const [file, text] of Object.entries(files)) if (inDir(at, file) && inPipelines(at, file)) {
+		const result = read(text, file, "pipeline");
+		if (result.kind === "pipeline") out.set(file, result.data);
+	}
+	return out;
+}
 function writeOverrides(next, config, targetName, changed) {
 	if (Object.keys(changed).length === 0) return;
 	const target = config.targets[targetName];
@@ -14263,7 +16493,7 @@ function incompleteIssue(gaps, target) {
 function objectFiles(files, at) {
 	const out = /* @__PURE__ */ new Map();
 	for (const [file, text] of Object.entries(files)) {
-		if (!inDir(at, file) || file === at.barrel) continue;
+		if (!inDir(at, file) || file === at.barrel || inPipelines(at, file)) continue;
 		const result = read(text, file);
 		if (result.kind === "object") out.set(file, result.data);
 	}
@@ -14343,6 +16573,17 @@ function portalSide(c, target) {
 function show$1(value) {
 	return value === void 0 ? "none" : JSON.stringify(value);
 }
+function outsidePipelines(loaded, portal, lines) {
+	const pipelines = {};
+	for (const live of portal.objects) {
+		const defined = (id) => Object.hasOwn(loaded.ir.resources, `pipeline:${live.object}/${id}`);
+		const outside = loaded.config.objects[live.object]?.pipelines === true ? [] : (live.pipelines ?? []).filter((p) => !defined(p.id));
+		if (outside.length === 0) continue;
+		pipelines[live.object] = outside.map((p) => sanitize(p.id));
+		for (const p of outside) lines.push(`  pipeline:${live.object}/${sanitize(p.id)}  (${sanitize(`"${p.label}"`, 200)}; set objects.${live.object}.pipelines to true)`);
+	}
+	return pipelines;
+}
 function discover(target, portalId, loaded, portal, warnings) {
 	const scopes = loaded.config.objects;
 	const lines = [];
@@ -14362,6 +16603,7 @@ function discover(target, portalId, loaded, portal, warnings) {
 			lines.push(`  property:${live.object}/${sanitize(p.name)}  (${sanitize(why, 400)})`);
 		}
 	}
+	const pipelines = outsidePipelines(loaded, portal, lines);
 	let head = `Everything the portal holds for target ${target} is in the pull scope.`;
 	if (lines.length > 0) head = `Outside the pull scope of target ${target} (portal ${portalId}):`;
 	else if (portal.gaps.length > 0) head = `Nothing outside the pull scope of target ${target} in the lists the key could read.`;
@@ -14370,7 +16612,8 @@ function discover(target, portalId, loaded, portal, warnings) {
 			target,
 			portalId,
 			objects,
-			properties
+			properties,
+			pipelines
 		},
 		issues: warnings,
 		text: `${[
@@ -14966,7 +17209,7 @@ async function confirm(prompt, plan, portal) {
 	const { name, protected: guarded } = plan.target;
 	prompt.tell([
 		`Apply plan ${plan.planId} to target ${name}, portal ${portal.portalId} (${portal.accountType}, ${guarded ? "protected" : "not protected"}):`,
-		...effects.map((s) => `  ${s.id} ${s.risk}${s.labels?.length ? ` [${s.labels.join(", ")}]` : ""} ${stepTitle(s, names)}`),
+		...effects.map((s) => `  ${s.id} ${s.risk}${s.labels?.length ? ` [${s.labels.join(", ")}]` : ""} ${stepTitle(s, names, true)}`),
 		[...kinds.filter(([n]) => n > 0).map(([n, noun]) => plural(n, noun)), `${destructive} destructive`].join(", ")
 	]);
 	if ((await prompt.ask("Type the target name to apply:"))?.trim() !== name) throw cancelled("the answer was not the target name");
@@ -15594,6 +17837,8 @@ const LINE_BREAK = /\r?\n/;
 const JSON_INDENT = /^([ \t]+)"/m;
 /** A line of the barrel: `export {}`, or a re-export of one object file's exports. */
 const BARREL_LINE = /^export (?:\{\}|(?:type )?\{ [\w, ]+ \} from '\.\/[\w./-]+')$/;
+/** The objects whose pipelines a new project pulls: those Kalup writes the pipelines of among the standard objects. */
+const PIPELINED = /* @__PURE__ */ new Set(["deals", "tickets"]);
 function init(ctx) {
 	const { cwd, flags } = ctx;
 	const portalId = parsePortal$1(flags.portal);
@@ -15618,7 +17863,7 @@ function init(ctx) {
 	const config = {
 		imports: [],
 		dir,
-		objects: Object.fromEntries(objects.map((object) => [object, {}])),
+		objects: Object.fromEntries(objects.map((object) => [object, PIPELINED.has(object) ? { pipelines: true } : {}])),
 		targets: { [target]: targetConfig }
 	};
 	const files = [];
@@ -16025,8 +18270,6 @@ function ir(ctx) {
 }
 //#endregion
 //#region src/commands/rm.ts
-const REMOVABLE = /* @__PURE__ */ new Set(["property", "group"]);
-const ON_OBJECT = /^[^\s/]+\/[^\s/]+$/;
 function rm(ctx) {
 	const [given] = ctx.args;
 	if (given === void 0) throw usageError("missing argument ADDRESS");
@@ -16079,11 +18322,11 @@ function rm(ctx) {
 			message: `${issue.message}${after}`
 		})), exitCodes.invalid);
 	}
-	const changed = Object.keys(next).filter((file) => next[file] !== files[file]);
+	const changed = [.../* @__PURE__ */ new Set([...Object.keys(next), ...Object.keys(files)])].filter((file) => next[file] !== files[file]);
 	const data = {
 		address,
 		action,
-		files: writeStaged(root, Object.fromEntries(changed.map((file) => [file, next[file] ?? ""]))),
+		files: writeStaged(root, Object.fromEntries(changed.map((file) => [file, next[file] ?? null]))),
 		...from === void 0 ? {} : { from },
 		...previous === void 0 ? {} : { previous: previous.action }
 	};
@@ -16094,18 +18337,19 @@ function rm(ctx) {
 	};
 }
 function checkAddress(given) {
-	const at = { fix: "pass the address of a property or group, such as 'property:companies/legacy_score'" };
+	const at = { fix: "pass the address of a property, group, pipeline or stage, such as 'property:companies/legacy_score'" };
 	if (!isAddress(given)) throw invalidAddress({
 		message: `'${sanitize(given)}' is not an address`,
 		...at
 	});
 	const { type, path } = parseAddress(given);
-	if (!REMOVABLE.has(type)) throw invalidAddress({
-		message: `cannot remove ${sanitize(given)}: this version removes properties and groups only`,
+	const shape = Object.hasOwn(REMOVABLE, type) ? REMOVABLE[type] : void 0;
+	if (!shape) throw invalidAddress({
+		message: `cannot remove ${sanitize(given)}: this version removes properties, groups, pipelines and stages only`,
 		fix: "custom objects are not removed or released in this release"
 	});
-	if (!ON_OBJECT.test(path)) throw invalidAddress({
-		message: `'${sanitize(given)}' is not of the form ${type}:<object>/<name>`,
+	if (!shape.path.test(path)) throw invalidAddress({
+		message: `'${sanitize(given)}' is not of the form ${shape.form}`,
 		...at
 	});
 	return given;
@@ -16134,7 +18378,9 @@ function refuse(loaded, address, resource, action) {
 function dependents(loaded, address) {
 	const { resources } = loaded.ir;
 	const key = objectOf(address);
-	if (parseAddress(address).type === "group") return Object.entries(resources).filter(([, r]) => r.type === "property" && (r.definition?.group)?.$ref === address).map(([a]) => a).sort();
+	const { type } = parseAddress(address);
+	if (type === "pipeline" || type === "stage") return [];
+	if (type === "group") return Object.entries(resources).filter(([, r]) => r.type === "property" && (r.definition?.group)?.$ref === address).map(([a]) => a).sort();
 	const d = (Object.hasOwn(resources, `object:${key}`) ? resources[`object:${key}`] : void 0)?.definition ?? {};
 	return [
 		d.primaryDisplayProperty,
@@ -16147,6 +18393,8 @@ function takeOut(files, loaded, address) {
 	const source = loaded.sources[address];
 	const text = source === void 0 ? void 0 : files[source.file];
 	if (source === void 0 || text === void 0) return;
+	const { type } = parseAddress(address);
+	if (type === "pipeline" || type === "stage") return takeOutPipeline(files, source, text);
 	const result = read(text, source.file);
 	if (result.kind !== "object") return;
 	const [owner] = source.configPath.split(".");
@@ -16168,6 +18416,21 @@ function takeOut(files, loaded, address) {
 	});
 	return source.file;
 }
+function takeOutPipeline(files, source, text) {
+	const result = read(text, source.file, "pipeline");
+	if (result.kind !== "pipeline") return;
+	const [owner, , key] = source.configPath.split(".");
+	const exports = key === void 0 ? result.data.exports.filter((e) => e.name !== owner) : result.data.exports.map((e) => e.name === owner ? {
+		...e,
+		stages: e.stages.filter((st) => st.key !== key)
+	} : e);
+	if (exports.length === 0) delete files[source.file];
+	else files[source.file] = write("pipeline", {
+		...result.data,
+		exports
+	});
+	return source.file;
+}
 function removedFile(text, file) {
 	if (text === void 0) return {
 		imports: [],
@@ -16243,12 +18506,15 @@ function countsOf(document) {
 	return {
 		objects: Object.values(document.observation.coverage.objects).filter((o) => o.status === "read").length,
 		groups: resources.filter((r) => r.type === "group").length,
-		properties: resources.filter((r) => r.type === "property").length
+		pipelines: resources.filter((r) => r.type === "pipeline").length,
+		properties: resources.filter((r) => r.type === "property").length,
+		stages: resources.filter((r) => r.type === "stage").length
 	};
 }
 function summary(data) {
-	const { objects, groups, properties } = data.counts;
-	const held = `${plural(objects, "object")}, ${plural(groups, "group")}, ${plural(properties, "property", "properties")}`;
+	const { objects, groups, properties, pipelines, stages } = data.counts;
+	const piped = pipelines > 0 ? `, ${plural(pipelines, "pipeline")}, ${plural(stages, "stage")}` : "";
+	const held = `${plural(objects, "object")}, ${plural(groups, "group")}, ${plural(properties, "property", "properties")}${piped}`;
 	return `${`Snapshot of target ${sanitize(data.target)}, portal ${data.portalId}, observed at ${data.observedAt}: ${held}`}\n${wrote(data.file)}`;
 }
 //#endregion
@@ -16460,12 +18726,15 @@ async function status(ctx) {
 	const counts = {
 		objects: Object.keys(loaded.config.objects).length,
 		properties: count(loaded.ir, "property"),
-		groups: count(loaded.ir, "group")
+		groups: count(loaded.ir, "group"),
+		pipelines: count(loaded.ir, "pipeline"),
+		stages: count(loaded.ir, "stage")
 	};
+	const piped = counts.pipelines > 0 ? `, ${plural(counts.pipelines, "pipeline")}, ${plural(counts.stages, "stage")}` : "";
 	const exitCode = exitCodeOf(targets);
 	const lines = [
 		`${bin} ${version}`,
-		`Config: valid (${plural(counts.objects, "object")}, ${plural(counts.properties, "property", "properties")}, ${plural(counts.groups, "group")}) in ${loaded.layout.dir}/`,
+		`Config: valid (${plural(counts.objects, "object")}, ${plural(counts.properties, "property", "properties")}, ${plural(counts.groups, "group")}${piped}) in ${loaded.layout.dir}/`,
 		...targets.flatMap((t) => describe(root, t, recommended.scope, writeScopes))
 	];
 	return {
@@ -17095,7 +19364,7 @@ var ApplyCommand = class extends KalupCommand {
 	}
 };
 var RmCommand = class extends KalupCommand {
-	static summary = "Take a property or group out of config and write its tombstone in removed.ts.";
+	static summary = "Take a resource out of config and write its tombstone in removed.ts.";
 	static args = { address: Args.string({
 		description: "The address, for example property:companies/legacy_score.",
 		required: true