@tenonhq/dovetail-servicenow 0.0.33 → 0.0.34

package/dist/cli.js

@@ -893,6 +893,10 @@ function printHelp() {
         "                     A max-length SHRINK is REFUSED while rows hold longer values —\n" +
         "                     ServiceNow silently ignores such a shrink (200 OK, no change).\n" +
         "                     Shorten or clear those values first, then re-run.\n" +
+        "                     An INHERITED column (one defined on a parent table) is narrowed for\n" +
+        "                     YOUR table alone, via sys_dictionary_override / sys_documentation —\n" +
+        "                     the parent and its other children are untouched. max-length is the\n" +
+        "                     exception: it is the parent's physical column and is refused.\n" +
         "                     --element / --internal-type are REFUSED with an explanation:\n" +
         "                     ServiceNow silently ignores both on an existing column.\n" +
         "  set-table          Update an EXISTING TABLE's own dictionary row (the collection row),\n" +
@@ -1214,6 +1218,12 @@ async function runSetColumn(flags, bare) {
             result.table +
             "." +
             result.column +
+            // Say when the change went to an override rather than the column's own row. The
+            // caller asked for a table + column; without this they have no reason to expect
+            // the write landed on a different record type entirely.
+            (result.via === "override"
+                ? " — override (inherited from " + result.definedOn + ")"
+                : "") +
             (result.verified && result.status === "applied" ? " — verified" : "") +
             (result.status === "applied" && !result.capturedInUpdateSet
                 ? " — NOT CAPTURED"

package/dist/mcp/registry.js

@@ -370,7 +370,14 @@ function buildDescriptors(deps = {}) {
                 "refuses such a shrink (200 OK, column unchanged, data preserved), so the tool names the " +
                 "blocking rows instead of issuing a write that would be quietly ignored. Clear those values " +
                 "first, then re-run — there is no override, because forcing it would either do nothing or " +
-                "destroy data. dryRun:true diffs against the instance, flags the blocking rows, and writes nothing.",
+                "destroy data. INHERITED COLUMNS ARE SUPPORTED: on an extended table the column is defined on " +
+                "an ancestor, and set_column narrows it for THAT TABLE ALONE via sys_dictionary_override " +
+                "(mandatory/default/readOnly) or sys_documentation (label) — the ancestor and every sibling " +
+                "table are left untouched, and the result reports via:'override' with definedOn set. Do NOT " +
+                "call set_column against the parent table to change a child's column: that changes it for " +
+                "EVERY descendant. maxLength is the sole exception — it is the ancestor's physical column, has " +
+                "no per-child override, and is refused with an explanation. dryRun:true diffs against the " +
+                "instance, flags the blocking rows, and writes nothing.",
             shape: schemas_1.setColumnSchema.shape,
             handler: async function (args) {
                 var p = schemas_1.setColumnSchema.parse(args);

package/dist/table/index.d.ts

@@ -15,5 +15,7 @@ export { addColumn, deriveElement } from "./addColumn";
 export type { AddColumnParams, AddColumnResult } from "./addColumn";
 export { setColumn, resolveAttributes, toStoredValue, findTruncationRisk, } from "./setColumn";
 export type { SetColumnParams, SetColumnResult, ColumnAttributes, AttributeChange, TruncationRisk, } from "./setColumn";
+export { OVERRIDABLE, LABEL_LANGUAGE, explainMaxLengthNotOverridable, resolveTableScope, findOverrideRow, findLabelRow, effectiveValue, diffInherited, applyInheritedWrites, overrideUpdateName, labelUpdateName, } from "./overrideColumn";
+export type { OverridableAttribute, InheritedChange, InheritedWriteParams, InheritedWriteResult, } from "./overrideColumn";
 export { setTable, resolveTableAttributes } from "./setTable";
 export type { SetTableParams, SetTableResult, TableAttributes, } from "./setTable";

package/dist/table/index.js

@@ -5,7 +5,7 @@
  * live-validation caveat.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveTableAttributes = exports.setTable = exports.findTruncationRisk = exports.toStoredValue = exports.resolveAttributes = exports.setColumn = exports.deriveElement = exports.addColumn = exports.decodeHtmlEntities = exports.scrapeCk = exports.postForm = exports.parseFormInputs = exports.getNewRecordForm = exports.getRecordForm = exports.setCurrentApplication = exports.openFormSession = exports.resolveFormAuth = exports.TYPE_MAP = exports.listEditKey = exports.showInMenuKey = exports.defaultAccessFlags = exports.applyTableSaveOverlay = exports.resolveType = exports.normalizeColumns = exports.xmlEscape = exports.buildColumnXml = exports.DEFAULT_COLUMNS_REL_ID = exports.DEFAULT_SAVE_ACTION = exports.DEFAULT_SUPER_CLASS = exports.parseSysIdFromLocation = exports.projectTableGraph = exports.createTable = void 0;
+exports.resolveTableAttributes = exports.setTable = exports.labelUpdateName = exports.overrideUpdateName = exports.applyInheritedWrites = exports.diffInherited = exports.effectiveValue = exports.findLabelRow = exports.findOverrideRow = exports.resolveTableScope = exports.explainMaxLengthNotOverridable = exports.LABEL_LANGUAGE = exports.OVERRIDABLE = exports.findTruncationRisk = exports.toStoredValue = exports.resolveAttributes = exports.setColumn = exports.deriveElement = exports.addColumn = exports.decodeHtmlEntities = exports.scrapeCk = exports.postForm = exports.parseFormInputs = exports.getNewRecordForm = exports.getRecordForm = exports.setCurrentApplication = exports.openFormSession = exports.resolveFormAuth = exports.TYPE_MAP = exports.listEditKey = exports.showInMenuKey = exports.defaultAccessFlags = exports.applyTableSaveOverlay = exports.resolveType = exports.normalizeColumns = exports.xmlEscape = exports.buildColumnXml = exports.DEFAULT_COLUMNS_REL_ID = exports.DEFAULT_SAVE_ACTION = exports.DEFAULT_SUPER_CLASS = exports.parseSysIdFromLocation = exports.projectTableGraph = exports.createTable = void 0;
 var createTable_1 = require("./createTable");
 Object.defineProperty(exports, "createTable", { enumerable: true, get: function () { return createTable_1.createTable; } });
 Object.defineProperty(exports, "projectTableGraph", { enumerable: true, get: function () { return createTable_1.projectTableGraph; } });
@@ -42,6 +42,18 @@ Object.defineProperty(exports, "setColumn", { enumerable: true, get: function ()
 Object.defineProperty(exports, "resolveAttributes", { enumerable: true, get: function () { return setColumn_1.resolveAttributes; } });
 Object.defineProperty(exports, "toStoredValue", { enumerable: true, get: function () { return setColumn_1.toStoredValue; } });
 Object.defineProperty(exports, "findTruncationRisk", { enumerable: true, get: function () { return setColumn_1.findTruncationRisk; } });
+var overrideColumn_1 = require("./overrideColumn");
+Object.defineProperty(exports, "OVERRIDABLE", { enumerable: true, get: function () { return overrideColumn_1.OVERRIDABLE; } });
+Object.defineProperty(exports, "LABEL_LANGUAGE", { enumerable: true, get: function () { return overrideColumn_1.LABEL_LANGUAGE; } });
+Object.defineProperty(exports, "explainMaxLengthNotOverridable", { enumerable: true, get: function () { return overrideColumn_1.explainMaxLengthNotOverridable; } });
+Object.defineProperty(exports, "resolveTableScope", { enumerable: true, get: function () { return overrideColumn_1.resolveTableScope; } });
+Object.defineProperty(exports, "findOverrideRow", { enumerable: true, get: function () { return overrideColumn_1.findOverrideRow; } });
+Object.defineProperty(exports, "findLabelRow", { enumerable: true, get: function () { return overrideColumn_1.findLabelRow; } });
+Object.defineProperty(exports, "effectiveValue", { enumerable: true, get: function () { return overrideColumn_1.effectiveValue; } });
+Object.defineProperty(exports, "diffInherited", { enumerable: true, get: function () { return overrideColumn_1.diffInherited; } });
+Object.defineProperty(exports, "applyInheritedWrites", { enumerable: true, get: function () { return overrideColumn_1.applyInheritedWrites; } });
+Object.defineProperty(exports, "overrideUpdateName", { enumerable: true, get: function () { return overrideColumn_1.overrideUpdateName; } });
+Object.defineProperty(exports, "labelUpdateName", { enumerable: true, get: function () { return overrideColumn_1.labelUpdateName; } });
 var setTable_1 = require("./setTable");
 Object.defineProperty(exports, "setTable", { enumerable: true, get: function () { return setTable_1.setTable; } });
 Object.defineProperty(exports, "resolveTableAttributes", { enumerable: true, get: function () { return setTable_1.resolveTableAttributes; } });

package/dist/table/overrideColumn.d.ts

@@ -0,0 +1,155 @@
+/**
+ * The INHERITED-column path for `set-column`.
+ *
+ * WHY THIS EXISTS. set-column originally refused every inherited column outright and told
+ * the caller to go change the parent instead, warning in the same breath that doing so
+ * "changes the column for EVERY table that extends" it. That advice was wrong, and
+ * actively dangerous: it is the destructive option, and ServiceNow has shipped the
+ * correct one for years. A child table narrows an inherited column for ITSELF via
+ * sys_dictionary_override (mandatory / default / read-only) or sys_documentation (label),
+ * touching neither the parent nor any sibling.
+ *
+ * The refusal was never verified against an instance — the irony being that the verb's
+ * own thesis is "do not trust a response you have not read back". Everything below was
+ * established live on tenonworkshed, 2026-07-16, by querying real rows:
+ *
+ *   - sys_dictionary_override carries a VALUE column and a paired `<attr>_override`
+ *     boolean, for mandatory / read_only / default_value (plus calculation, dependent,
+ *     reference_qual, attributes — outside this verb's five). The boolean is what
+ *     ACTIVATES the override: a value written without its flag is inert.
+ *
+ *   - There is NO max_length override and NO label override on that table. max_length is
+ *     physical on the defining table's column, so it genuinely cannot be narrowed per
+ *     child — that one refusal was right, for a reason the old message never gave.
+ *
+ *   - LABEL is not an override at all; it is a sys_documentation row keyed on the CHILD
+ *     table. Proof in the platform itself: `problem.short_description` reads "Problem
+ *     statement" while `task.short_description` — the row that actually defines the
+ *     column — still reads "Short description". sys_dictionary has no row for
+ *     problem.short_description whatsoever. OOB ServiceNow does exactly what set-column
+ *     said was impossible.
+ *
+ *   - `base_table` is the table that DEFINES the column, NOT the immediate parent.
+ *     Verified against a deep chain: cmdb_ci_endpoint_sharepoint_service extends
+ *     cmdb_ci_endpoint_inclusion, yet its override rows carry base_table=cmdb_ci.
+ *
+ *   - SCOPE FOLLOWS THE CHILD, not the parent. x_cadso_work_project's overrides of
+ *     task's columns sit in the x_cadso scope while task is global; problem_task's sit
+ *     in global. Resolving scope from the parent's dictionary row — the obvious move,
+ *     and what choices.ts does for its own case — would land a scoped child's override
+ *     in `global`. That is the exact wrong-scope failure Craftsman's CLAUDE.md calls out.
+ *
+ * CAPTURE NAMES ARE NOT ANALOGOUS, and this is a trap worth stating plainly. Three
+ * record types, three different sys_update_xml naming conventions:
+ *
+ *     sys_dictionary            sys_dictionary_<table>_<element>
+ *     sys_dictionary_override   sys_dictionary_override_<SYS_ID>        <- keyed by sys_id
+ *     sys_documentation         sys_documentation_<table>_<element>_<language>
+ *
+ * Deriving the override's name by analogy with the other two produces a query that
+ * matches nothing, so a perfectly-captured change would report itself as uncaptured. Both
+ * names below were read off real update rows, not inferred.
+ *
+ * ES6 only, no optional chaining, no `any`.
+ */
+import type { ServiceNowClient } from "../client";
+import type { AttributeChange } from "./setColumn";
+/** The language a label override is written for. ServiceNow keys sys_documentation by
+ *  language, and the capture name embeds it, so it is explicit rather than implied. */
+export declare var LABEL_LANGUAGE: string;
+export interface OverridableAttribute {
+    /** The sys_dictionary_override column that holds the value. */
+    field: string;
+    /** The boolean that ACTIVATES it. A value written without its flag is inert — the
+     *  child silently keeps inheriting, which would read as a successful no-op. */
+    flag: string;
+}
+/**
+ * The inherited attributes a child can narrow for itself, keyed by the sys_dictionary
+ * column set-column diffs on. Anything absent is NOT overridable per-child:
+ *   - column_label -> sys_documentation instead (see applyLabelOverride)
+ *   - max_length   -> physical on the defining table; no override exists at all
+ */
+export declare var OVERRIDABLE: Record<string, OverridableAttribute>;
+/**
+ * Why max_length — alone among set-column's five attributes — cannot be narrowed on a
+ * child, and what that means for the caller.
+ *
+ * Deliberately max_length-specific rather than a general "attribute X is not
+ * overridable" helper: of the five, the other four ARE overridable, so a generic branch
+ * would be unreachable code speculating about a case that does not exist. If a sixth
+ * attribute is ever added to WRITABLE, this needs revisiting — which a dead generic
+ * branch would have quietly hidden.
+ *
+ * Unlike the old blanket refusal this one is true, and it says WHY rather than
+ * recommending the destructive alternative as though it were routine.
+ */
+export declare function explainMaxLengthNotOverridable(table: string, column: string, definedOn: string): string;
+/** The scope the override belongs to — resolved from the CHILD table, never the parent.
+ *  A scoped child overriding a global parent's column must land in the child's scope. */
+export declare function resolveTableScope(client: ServiceNowClient, table: string): Promise<string>;
+/** The child's existing override row for this column, or null. */
+export declare function findOverrideRow(client: ServiceNowClient, table: string, column: string): Promise<Record<string, unknown> | null>;
+/** The child's existing label row for this column, or null. */
+export declare function findLabelRow(client: ServiceNowClient, table: string, column: string): Promise<Record<string, unknown> | null>;
+/**
+ * The value this child ACTUALLY sees for an attribute today.
+ *
+ * An override's value only counts when its flag is on. A row carrying mandatory=true with
+ * mandatory_override=false is inert — the child still inherits — so reading the value
+ * alone would diff against a number the platform is ignoring, and report `unchanged` for
+ * a column that behaves the opposite way.
+ */
+export declare function effectiveValue(field: string, overrideRow: Record<string, unknown> | null, parentRow: Record<string, unknown>, labelRow: Record<string, unknown> | null): string;
+/** One attribute's before -> after.
+ *
+ * This is setColumn's AttributeChange, imported as a TYPE. setColumn imports values from
+ * here, so a value-import back would close a runtime cycle — but `import type` is erased
+ * at compile time and cannot. Re-declaring the shape would be a second source of truth
+ * for the same three fields, which is worse than the cycle it does not prevent. */
+export type InheritedChange = AttributeChange;
+/**
+ * What would actually change for this child, comparing against the value it sees TODAY
+ * (its override if one is active, otherwise the inherited value).
+ *
+ * Note what is deliberately NOT treated as a change: a requested value that already
+ * matches the INHERITED one. Writing an override there would pin the child to a value it
+ * already has, decoupling it from the parent as an invisible side effect of a request
+ * that asked for no such thing. Reporting `unchanged` — and saying the column still
+ * tracks the parent — is the honest answer.
+ */
+export declare function diffInherited(writes: Record<string, string>, overrideRow: Record<string, unknown> | null, parentRow: Record<string, unknown>, labelRow: Record<string, unknown> | null): Array<InheritedChange>;
+export interface InheritedWriteParams {
+    client: ServiceNowClient;
+    table: string;
+    column: string;
+    /** The table that DEFINES the column — what base_table must be set to. */
+    definedOn: string;
+    changes: Array<InheritedChange>;
+    overrideRow: Record<string, unknown> | null;
+    labelRow: Record<string, unknown> | null;
+    updateSetSysId: string;
+}
+export interface InheritedWriteResult {
+    /** sys_id of the override row touched, "" when no override attribute changed. */
+    overrideSysId: string;
+    /** sys_id of the label row touched, "" when the label did not change. */
+    labelSysId: string;
+    /** True only when every written value was READ BACK from the instance and matched. */
+    verified: boolean;
+    mismatched: Array<string>;
+    /** True when every record written was found in the named update set. */
+    captured: boolean;
+}
+/** Update-set capture name for an override row — keyed by SYS_ID, unlike sys_dictionary.
+ *  Read off real update rows on tenonworkshed; deriving it by analogy yields a query that
+ *  matches nothing and reports a captured change as uncaptured. */
+export declare function overrideUpdateName(overrideSysId: string): string;
+/** Update-set capture name for a label row: sys_documentation_<table>_<element>_<lang>. */
+export declare function labelUpdateName(table: string, column: string): string;
+/**
+ * Write the child's overrides, then READ THEM BACK. The whole verb exists because
+ * ServiceNow returns 200 for writes it silently discards, and that reasoning does not
+ * stop applying just because the target table changed.
+ */
+export declare function applyInheritedWrites(params: InheritedWriteParams): Promise<InheritedWriteResult>;

package/dist/table/overrideColumn.js

@@ -0,0 +1,388 @@
+"use strict";
+/**
+ * The INHERITED-column path for `set-column`.
+ *
+ * WHY THIS EXISTS. set-column originally refused every inherited column outright and told
+ * the caller to go change the parent instead, warning in the same breath that doing so
+ * "changes the column for EVERY table that extends" it. That advice was wrong, and
+ * actively dangerous: it is the destructive option, and ServiceNow has shipped the
+ * correct one for years. A child table narrows an inherited column for ITSELF via
+ * sys_dictionary_override (mandatory / default / read-only) or sys_documentation (label),
+ * touching neither the parent nor any sibling.
+ *
+ * The refusal was never verified against an instance — the irony being that the verb's
+ * own thesis is "do not trust a response you have not read back". Everything below was
+ * established live on tenonworkshed, 2026-07-16, by querying real rows:
+ *
+ *   - sys_dictionary_override carries a VALUE column and a paired `<attr>_override`
+ *     boolean, for mandatory / read_only / default_value (plus calculation, dependent,
+ *     reference_qual, attributes — outside this verb's five). The boolean is what
+ *     ACTIVATES the override: a value written without its flag is inert.
+ *
+ *   - There is NO max_length override and NO label override on that table. max_length is
+ *     physical on the defining table's column, so it genuinely cannot be narrowed per
+ *     child — that one refusal was right, for a reason the old message never gave.
+ *
+ *   - LABEL is not an override at all; it is a sys_documentation row keyed on the CHILD
+ *     table. Proof in the platform itself: `problem.short_description` reads "Problem
+ *     statement" while `task.short_description` — the row that actually defines the
+ *     column — still reads "Short description". sys_dictionary has no row for
+ *     problem.short_description whatsoever. OOB ServiceNow does exactly what set-column
+ *     said was impossible.
+ *
+ *   - `base_table` is the table that DEFINES the column, NOT the immediate parent.
+ *     Verified against a deep chain: cmdb_ci_endpoint_sharepoint_service extends
+ *     cmdb_ci_endpoint_inclusion, yet its override rows carry base_table=cmdb_ci.
+ *
+ *   - SCOPE FOLLOWS THE CHILD, not the parent. x_cadso_work_project's overrides of
+ *     task's columns sit in the x_cadso scope while task is global; problem_task's sit
+ *     in global. Resolving scope from the parent's dictionary row — the obvious move,
+ *     and what choices.ts does for its own case — would land a scoped child's override
+ *     in `global`. That is the exact wrong-scope failure Craftsman's CLAUDE.md calls out.
+ *
+ * CAPTURE NAMES ARE NOT ANALOGOUS, and this is a trap worth stating plainly. Three
+ * record types, three different sys_update_xml naming conventions:
+ *
+ *     sys_dictionary            sys_dictionary_<table>_<element>
+ *     sys_dictionary_override   sys_dictionary_override_<SYS_ID>        <- keyed by sys_id
+ *     sys_documentation         sys_documentation_<table>_<element>_<language>
+ *
+ * Deriving the override's name by analogy with the other two produces a query that
+ * matches nothing, so a perfectly-captured change would report itself as uncaptured. Both
+ * names below were read off real update rows, not inferred.
+ *
+ * ES6 only, no optional chaining, no `any`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OVERRIDABLE = exports.LABEL_LANGUAGE = void 0;
+exports.explainMaxLengthNotOverridable = explainMaxLengthNotOverridable;
+exports.resolveTableScope = resolveTableScope;
+exports.findOverrideRow = findOverrideRow;
+exports.findLabelRow = findLabelRow;
+exports.effectiveValue = effectiveValue;
+exports.diffInherited = diffInherited;
+exports.overrideUpdateName = overrideUpdateName;
+exports.labelUpdateName = labelUpdateName;
+exports.applyInheritedWrites = applyInheritedWrites;
+const setField_1 = require("../setField");
+const choices_1 = require("../choices");
+/** The language a label override is written for. ServiceNow keys sys_documentation by
+ *  language, and the capture name embeds it, so it is explicit rather than implied. */
+exports.LABEL_LANGUAGE = "en";
+/**
+ * The inherited attributes a child can narrow for itself, keyed by the sys_dictionary
+ * column set-column diffs on. Anything absent is NOT overridable per-child:
+ *   - column_label -> sys_documentation instead (see applyLabelOverride)
+ *   - max_length   -> physical on the defining table; no override exists at all
+ */
+exports.OVERRIDABLE = {
+    mandatory: { field: "mandatory", flag: "mandatory_override" },
+    default_value: { field: "default_value", flag: "default_value_override" },
+    read_only: { field: "read_only", flag: "read_only_override" },
+};
+/**
+ * Why max_length — alone among set-column's five attributes — cannot be narrowed on a
+ * child, and what that means for the caller.
+ *
+ * Deliberately max_length-specific rather than a general "attribute X is not
+ * overridable" helper: of the five, the other four ARE overridable, so a generic branch
+ * would be unreachable code speculating about a case that does not exist. If a sixth
+ * attribute is ever added to WRITABLE, this needs revisiting — which a dead generic
+ * branch would have quietly hidden.
+ *
+ * Unlike the old blanket refusal this one is true, and it says WHY rather than
+ * recommending the destructive alternative as though it were routine.
+ */
+function explainMaxLengthNotOverridable(table, column, definedOn) {
+    return ("set-column: refusing to change max_length of '" +
+        column +
+        "' on '" +
+        table +
+        "' — the column is INHERITED from '" +
+        definedOn +
+        "'. max_length is PHYSICAL: it is " +
+        "the real database column on '" +
+        definedOn +
+        "', and sys_dictionary_override has no " +
+        "max_length field, so it cannot be narrowed for '" +
+        table +
+        "' alone. Changing it " +
+        "at the source (set-column --table " +
+        definedOn +
+        " --column " +
+        column +
+        ") resizes " +
+        "the column for EVERY table that extends '" +
+        definedOn +
+        "', so that is a deliberate " +
+        "decision and is not made on your behalf. The other attributes (label, mandatory, " +
+        "default, read-only) CAN be set on '" +
+        table +
+        "' alone and are applied as overrides.");
+}
+/** The scope the override belongs to — resolved from the CHILD table, never the parent.
+ *  A scoped child overriding a global parent's column must land in the child's scope. */
+async function resolveTableScope(client, table) {
+    var rows = await client.table.query("sys_db_object", "name=" + (0, choices_1.encodeQueryValue)(table), { limit: 1, fields: ["sys_scope"] });
+    if (rows.length === 0)
+        return "";
+    var scopeSysId = (0, setField_1.fieldToString)(rows[0].sys_scope);
+    if (!scopeSysId)
+        return "";
+    // "global" is already the namespace; sys_scope has no row to resolve it against.
+    if (scopeSysId === "global")
+        return "global";
+    var scopeRows = await client.table.query("sys_scope", "sys_id=" + (0, choices_1.encodeQueryValue)(scopeSysId), { limit: 1, fields: ["scope", "name"] });
+    if (scopeRows.length === 0)
+        return "";
+    return (0, setField_1.fieldToString)(scopeRows[0].scope) || (0, setField_1.fieldToString)(scopeRows[0].name);
+}
+/** The child's existing override row for this column, or null. */
+async function findOverrideRow(client, table, column) {
+    var fields = ["sys_id", "name", "element", "base_table"];
+    var keys = Object.keys(exports.OVERRIDABLE);
+    for (var i = 0; i < keys.length; i += 1) {
+        fields.push(exports.OVERRIDABLE[keys[i]].field);
+        fields.push(exports.OVERRIDABLE[keys[i]].flag);
+    }
+    var rows = await client.table.query("sys_dictionary_override", "name=" + (0, choices_1.encodeQueryValue)(table) + "^element=" + (0, choices_1.encodeQueryValue)(column), { limit: 1, fields: fields });
+    return rows.length > 0 ? rows[0] : null;
+}
+/** The child's existing label row for this column, or null. */
+async function findLabelRow(client, table, column) {
+    var rows = await client.table.query("sys_documentation", "name=" +
+        (0, choices_1.encodeQueryValue)(table) +
+        "^element=" +
+        (0, choices_1.encodeQueryValue)(column) +
+        "^language=" +
+        (0, choices_1.encodeQueryValue)(exports.LABEL_LANGUAGE), { limit: 1, fields: ["sys_id", "label", "language"] });
+    return rows.length > 0 ? rows[0] : null;
+}
+/**
+ * The value this child ACTUALLY sees for an attribute today.
+ *
+ * An override's value only counts when its flag is on. A row carrying mandatory=true with
+ * mandatory_override=false is inert — the child still inherits — so reading the value
+ * alone would diff against a number the platform is ignoring, and report `unchanged` for
+ * a column that behaves the opposite way.
+ */
+function effectiveValue(field, overrideRow, parentRow, labelRow) {
+    // The label is not an override; it is the child's own sys_documentation row. When the
+    // child has none it simply shows the defining table's label, which sys_dictionary
+    // already surfaces as column_label on the parent row.
+    if (field === "column_label") {
+        if (labelRow)
+            return (0, setField_1.fieldToString)(labelRow.label);
+        return (0, setField_1.fieldToString)(parentRow.column_label);
+    }
+    var spec = exports.OVERRIDABLE[field];
+    if (spec && overrideRow) {
+        var flag = (0, setField_1.fieldToString)(overrideRow[spec.flag]);
+        if (flag === "true")
+            return (0, setField_1.fieldToString)(overrideRow[spec.field]);
+    }
+    return (0, setField_1.fieldToString)(parentRow[field]);
+}
+/**
+ * What would actually change for this child, comparing against the value it sees TODAY
+ * (its override if one is active, otherwise the inherited value).
+ *
+ * Note what is deliberately NOT treated as a change: a requested value that already
+ * matches the INHERITED one. Writing an override there would pin the child to a value it
+ * already has, decoupling it from the parent as an invisible side effect of a request
+ * that asked for no such thing. Reporting `unchanged` — and saying the column still
+ * tracks the parent — is the honest answer.
+ */
+function diffInherited(writes, overrideRow, parentRow, labelRow) {
+    var changes = [];
+    var fields = Object.keys(writes);
+    for (var i = 0; i < fields.length; i += 1) {
+        var field = fields[i];
+        var from = effectiveValue(field, overrideRow, parentRow, labelRow);
+        if (from !== writes[field]) {
+            changes.push({ attribute: field, from: from, to: writes[field] });
+        }
+    }
+    return changes;
+}
+/** Update-set capture name for an override row — keyed by SYS_ID, unlike sys_dictionary.
+ *  Read off real update rows on tenonworkshed; deriving it by analogy yields a query that
+ *  matches nothing and reports a captured change as uncaptured. */
+function overrideUpdateName(overrideSysId) {
+    return "sys_dictionary_override_" + overrideSysId;
+}
+/** Update-set capture name for a label row: sys_documentation_<table>_<element>_<lang>. */
+function labelUpdateName(table, column) {
+    return "sys_documentation_" + table + "_" + column + "_" + exports.LABEL_LANGUAGE;
+}
+async function isCaptured(client, updateSetSysId, name) {
+    var rows = await client.table.query("sys_update_xml", "update_set=" +
+        (0, choices_1.encodeQueryValue)(updateSetSysId) +
+        "^name=" +
+        (0, choices_1.encodeQueryValue)(name), { limit: 1, fields: ["sys_id"] });
+    return rows.length > 0;
+}
+/**
+ * Write the child's overrides, then READ THEM BACK. The whole verb exists because
+ * ServiceNow returns 200 for writes it silently discards, and that reasoning does not
+ * stop applying just because the target table changed.
+ */
+async function applyInheritedWrites(params) {
+    var client = params.client;
+    var overrideChanges = params.changes.filter(function (c) {
+        return Boolean(exports.OVERRIDABLE[c.attribute]);
+    });
+    var labelChange = params.changes.filter(function (c) {
+        return c.attribute === "column_label";
+    })[0];
+    // The sys_ids of any PRE-EXISTING rows — used only to TARGET an update, never reported.
+    // A label-only call must not claim it touched the override row that happened to already
+    // exist, and an override-only call must not claim it touched a pre-existing label row.
+    var existingOverrideSysId = params.overrideRow
+        ? (0, setField_1.fieldToString)(params.overrideRow.sys_id)
+        : "";
+    var existingLabelSysId = params.labelRow
+        ? (0, setField_1.fieldToString)(params.labelRow.sys_id)
+        : "";
+    // What this call actually WROTE. Stays "" unless the matching branch runs, so a returned
+    // sys_id names a row THIS call touched — honouring the InheritedWriteResult docstrings,
+    // which promise "" when the attribute did not change.
+    var overrideSysId = "";
+    var labelSysId = "";
+    // Scope follows the CHILD — taking it from the parent would drop a scoped child's
+    // override into global. Resolved at most once and only when a record is actually
+    // created: a mixed label+mandatory request needs the same answer twice, and an update
+    // to existing rows needs it not at all.
+    var scopeMemo = null;
+    async function childScope() {
+        if (scopeMemo === null) {
+            scopeMemo = await resolveTableScope(client, params.table);
+        }
+        return scopeMemo ? scopeMemo : undefined;
+    }
+    // --- sys_dictionary_override -------------------------------------------------------
+    if (overrideChanges.length > 0) {
+        var overrideFields = {};
+        for (var i = 0; i < overrideChanges.length; i += 1) {
+            var spec = exports.OVERRIDABLE[overrideChanges[i].attribute];
+            overrideFields[spec.field] = overrideChanges[i].to;
+            // The flag is what makes the value count. Writing the value alone leaves the child
+            // inheriting while the row claims otherwise.
+            overrideFields[spec.flag] = "true";
+        }
+        if (existingOverrideSysId) {
+            await client.claude.pushWithUpdateSet({
+                update_set_sys_id: params.updateSetSysId,
+                table: "sys_dictionary_override",
+                record_sys_id: existingOverrideSysId,
+                fields: overrideFields,
+            });
+            overrideSysId = existingOverrideSysId;
+        }
+        else {
+            overrideFields.name = params.table;
+            overrideFields.element = params.column;
+            // base_table is the DEFINING table, not the immediate parent (verified live).
+            overrideFields.base_table = params.definedOn;
+            var created = await client.claude.createRecord({
+                table: "sys_dictionary_override",
+                fields: overrideFields,
+                scope: await childScope(),
+                update_set_sys_id: params.updateSetSysId,
+            });
+            overrideSysId = (0, setField_1.fieldToString)(created.sys_id);
+        }
+    }
+    // --- sys_documentation (label) -----------------------------------------------------
+    if (labelChange) {
+        if (existingLabelSysId) {
+            await client.claude.pushWithUpdateSet({
+                update_set_sys_id: params.updateSetSysId,
+                table: "sys_documentation",
+                record_sys_id: existingLabelSysId,
+                fields: { label: labelChange.to },
+            });
+            labelSysId = existingLabelSysId;
+        }
+        else {
+            var createdLabel = await client.claude.createRecord({
+                table: "sys_documentation",
+                fields: {
+                    name: params.table,
+                    element: params.column,
+                    label: labelChange.to,
+                    language: exports.LABEL_LANGUAGE,
+                },
+                scope: await childScope(),
+                update_set_sys_id: params.updateSetSysId,
+            });
+            labelSysId = (0, setField_1.fieldToString)(createdLabel.sys_id);
+        }
+    }
+    // --- read back ---------------------------------------------------------------------
+    var mismatched = [];
+    if (overrideChanges.length > 0) {
+        var afterOverride = await findOverrideRow(client, params.table, params.column);
+        if (!afterOverride) {
+            mismatched.push("no sys_dictionary_override row for " +
+                params.table +
+                "." +
+                params.column +
+                " could be read back after the write");
+        }
+        else {
+            for (var j = 0; j < overrideChanges.length; j += 1) {
+                var oSpec = exports.OVERRIDABLE[overrideChanges[j].attribute];
+                var got = (0, setField_1.fieldToString)(afterOverride[oSpec.field]);
+                var gotFlag = (0, setField_1.fieldToString)(afterOverride[oSpec.flag]);
+                if (got !== overrideChanges[j].to) {
+                    mismatched.push(overrideChanges[j].attribute +
+                        " reads back as '" +
+                        got +
+                        "', not '" +
+                        overrideChanges[j].to +
+                        "'");
+                }
+                else if (gotFlag !== "true") {
+                    // The value landed but the override is not switched on, so the child still
+                    // inherits. Nothing visibly failed, and the column does not behave as asked.
+                    mismatched.push(oSpec.flag +
+                        " reads back as '" +
+                        gotFlag +
+                        "', so the " +
+                        overrideChanges[j].attribute +
+                        " override is INERT and " +
+                        params.table +
+                        " still inherits from " +
+                        params.definedOn);
+                }
+            }
+        }
+    }
+    if (labelChange) {
+        var afterLabel = await findLabelRow(client, params.table, params.column);
+        var gotLabel = afterLabel ? (0, setField_1.fieldToString)(afterLabel.label) : "";
+        if (gotLabel !== labelChange.to) {
+            mismatched.push("label reads back as '" + gotLabel + "', not '" + labelChange.to + "'");
+        }
+    }
+    // --- capture -----------------------------------------------------------------------
+    var captured = true;
+    if (overrideChanges.length > 0 && overrideSysId) {
+        captured =
+            captured &&
+                (await isCaptured(client, params.updateSetSysId, overrideUpdateName(overrideSysId)));
+    }
+    if (labelChange) {
+        captured =
+            captured &&
+                (await isCaptured(client, params.updateSetSysId, labelUpdateName(params.table, params.column)));
+    }
+    return {
+        overrideSysId: overrideSysId,
+        labelSysId: labelSysId,
+        verified: mismatched.length === 0,
+        mismatched: mismatched,
+        captured: captured,
+    };
+}

package/dist/table/setColumn.d.ts

@@ -50,6 +50,19 @@
  * do nothing. That is why every write is read back and compared, and why nothing is ever
  * reported as applied on the strength of a status code.
  *
+ * INHERITED COLUMNS. On an extended table the column is defined on an ancestor, not here.
+ * That is not an error and not a dead end: mandatory / default / read_only are narrowed
+ * for THIS table alone via sys_dictionary_override, and label via sys_documentation,
+ * leaving the ancestor and every sibling untouched. See overrideColumn.ts, which carries
+ * the live-verified detail. max_length is the one real exception — it is the ancestor's
+ * physical column and has no per-child override, so it is refused with the reason.
+ *
+ * This verb originally refused every inherited column and told the caller to go edit the
+ * ancestor "since that changes it for EVERY table that extends" it. That was the
+ * destructive option offered as the only one, and it was never checked against an
+ * instance — a claim about ServiceNow trusted on reasoning alone, in the one file whose
+ * whole argument is that ServiceNow must be read back rather than believed.
+ *
  * Fields are taken from a strict ALLOWLIST, not an open map — an unbounded write to
  * sys_dictionary lets a caller quietly corrupt the schema.
  *
@@ -95,8 +108,21 @@ export interface SetColumnResult {
     status: "dry-run" | "applied" | "unchanged" | "failed";
     table: string;
     column: string;
-    /** sys_id of the sys_dictionary row. */
+    /** sys_id of the sys_dictionary row that DEFINES the column. On an inherited column
+     *  this is the ancestor's row — the child has none — so it is not what was written;
+     *  see overrideSysId / labelSysId for that. */
     columnSysId: string;
+    /** How the change was made. "dictionary" — written straight to the column's own
+     *  sys_dictionary row. "override" — the column is inherited, so it was narrowed for
+     *  THIS table alone via sys_dictionary_override / sys_documentation, leaving the
+     *  defining table and every sibling untouched. */
+    via: "dictionary" | "override";
+    /** The ancestor that defines the column, when it is inherited; "" when it is local. */
+    definedOn: string;
+    /** sys_id of the sys_dictionary_override row written, when via === "override". */
+    overrideSysId?: string;
+    /** sys_id of the sys_documentation row written, when a label override was applied. */
+    labelSysId?: string;
     updateSetSysId: string;
     /** The attributes that differed and were written (empty when nothing changed). */
     changes: Array<AttributeChange>;

package/dist/table/setColumn.js

@@ -51,6 +51,19 @@
  * do nothing. That is why every write is read back and compared, and why nothing is ever
  * reported as applied on the strength of a status code.
  *
+ * INHERITED COLUMNS. On an extended table the column is defined on an ancestor, not here.
+ * That is not an error and not a dead end: mandatory / default / read_only are narrowed
+ * for THIS table alone via sys_dictionary_override, and label via sys_documentation,
+ * leaving the ancestor and every sibling untouched. See overrideColumn.ts, which carries
+ * the live-verified detail. max_length is the one real exception — it is the ancestor's
+ * physical column and has no per-child override, so it is refused with the reason.
+ *
+ * This verb originally refused every inherited column and told the caller to go edit the
+ * ancestor "since that changes it for EVERY table that extends" it. That was the
+ * destructive option offered as the only one, and it was never checked against an
+ * instance — a claim about ServiceNow trusted on reasoning alone, in the one file whose
+ * whole argument is that ServiceNow must be read back rather than believed.
+ *
  * Fields are taken from a strict ALLOWLIST, not an open map — an unbounded write to
  * sys_dictionary lets a caller quietly corrupt the schema.
  *
@@ -66,6 +79,10 @@ const setField_1 = require("../setField");
 // through this first. A stray "^" or "=" does not error — it silently changes what the
 // query MEANS, which is the worst kind of bug to ship into a schema tool.
 const choices_1 = require("../choices");
+// The inherited-column path. An extended table's columns live on an ancestor's
+// dictionary rows, and ServiceNow's answer for narrowing one per-child is
+// sys_dictionary_override / sys_documentation — not editing the ancestor.
+const overrideColumn_1 = require("./overrideColumn");
 /** How far up a super_class chain to look for an inherited column before giving up. */
 var MAX_INHERITANCE_DEPTH = 20;
 /**
@@ -157,8 +174,12 @@ function resolveAttributes(attributes) {
  * child's — a child of x_cadso_journey_flow carries only a couple of dictionary rows of
  * its own while every real column is inherited. So a plain name+element lookup against
  * the child finds nothing, even though the column is plainly there on the form. Walking
- * super_class turns "no such column" into "it lives on <parent>", which is the
- * difference between a dead end and an answer.
+ * super_class finds the row that really defines it.
+ *
+ * That answer used to end the story: set-column reported "it lives on <parent>, go change
+ * it there" and stopped. It now ROUTES instead — the defining table is where the column's
+ * inherited values are read from for the diff, and what `base_table` is set to on the
+ * override that narrows it for the child. See overrideColumn.ts.
  */
 async function findDefiningTable(client, table, column) {
     var current = table;
@@ -185,31 +206,31 @@ async function findDefiningTable(client, table, column) {
     }
     return "";
 }
-/** Fetch the column's dictionary row, or throw a message that says what to check. */
-async function fetchColumn(client, table, column, fields) {
+/**
+ * Find the column's dictionary row — on the table itself, or on the ancestor that
+ * defines it — or throw a message that says what to check.
+ *
+ * An inherited column is NOT an error. It is the normal shape of an extended table, and
+ * the caller's request ("make this column mandatory on this table") is answerable
+ * exactly as asked, by overriding it for the child. Resolution just reports where the
+ * definition lives; setColumn decides what to write.
+ */
+async function resolveColumn(client, table, column, fields) {
     var rows = await client.table.query("sys_dictionary", "name=" + (0, choices_1.encodeQueryValue)(table) + "^element=" + (0, choices_1.encodeQueryValue)(column), { limit: 1, fields: fields });
     if (rows.length > 0)
-        return rows[0];
+        return { row: rows[0], definedOn: "" };
     // Before declaring the column missing, check whether it is simply inherited. Saying
     // "no such column" about a column the caller can see on the form sends them hunting
     // for a typo that is not there.
     var owner = await findDefiningTable(client, table, column);
     if (owner) {
-        throw new Error("set-column: '" +
-            column +
-            "' is not defined on '" +
-            table +
-            "' — it is INHERITED from '" +
-            owner +
-            "'. Change it there: set-column --table " +
-            owner +
-            " --column " +
-            column +
-            ". Note that doing so changes the column for EVERY table that extends " +
-            owner +
-            ", not just " +
-            table +
-            " — which is why this is not done implicitly on your behalf.");
+        var ownerRows = await client.table.query("sys_dictionary", "name=" +
+            (0, choices_1.encodeQueryValue)(owner) +
+            "^element=" +
+            (0, choices_1.encodeQueryValue)(column), { limit: 1, fields: fields });
+        if (ownerRows.length > 0) {
+            return { row: ownerRows[0], definedOn: owner };
+        }
     }
     throw new Error("set-column: no column '" +
         column +
@@ -357,9 +378,15 @@ async function setColumn(params) {
     var table = String(params.table).trim();
     var column = String(params.column).trim();
     var readFields = ["sys_id", "element", "internal_type"].concat(targets);
-    var row = await fetchColumn(params.client, table, column, readFields);
+    var resolved = await resolveColumn(params.client, table, column, readFields);
+    var row = resolved.row;
     // max_length is meaningless on a type that has no length. ServiceNow would take the
     // write and ignore it (a fourth silent no-op), so refuse it here where we can say why.
+    //
+    // This runs BEFORE the inherited branch on purpose. The type is a property of the
+    // COLUMN, so it is wrong wherever the column is defined — and the inherited refusal
+    // says "change it at the source instead", which for a lengthless type would send the
+    // caller to the parent to attempt something that cannot work there either.
     if (writes.max_length !== undefined) {
         var columnType = (0, setField_1.fieldToString)(row.internal_type);
         if (LENGTHLESS_TYPES.indexOf(columnType) !== -1) {
@@ -371,6 +398,17 @@ async function setColumn(params) {
                 "ServiceNow would accept the write and ignore it. Drop --max-length.");
         }
     }
+    // The column is INHERITED. It is narrowed for this table alone via an override — never
+    // by editing the ancestor, which would change it for every sibling too.
+    if (resolved.definedOn) {
+        return await setInheritedColumn(params, {
+            table: table,
+            column: column,
+            writes: writes,
+            parentRow: row,
+            definedOn: resolved.definedOn,
+        });
+    }
     var columnSysId = (0, setField_1.fieldToString)(row.sys_id);
     // Diff against what the instance actually stores. Only a genuine difference is
     // written: ServiceNow fires the physical ALTER on a CHANGE, and a same-value write
@@ -428,6 +466,8 @@ async function setColumn(params) {
             table: table,
             column: column,
             columnSysId: columnSysId,
+            via: "dictionary",
+            definedOn: "",
             updateSetSysId: params.updateSetSysId ? params.updateSetSysId : "",
             changes: changes,
             verified: false,
@@ -479,6 +519,8 @@ async function setColumn(params) {
             table: table,
             column: column,
             columnSysId: columnSysId,
+            via: "dictionary",
+            definedOn: "",
             updateSetSysId: updateSetSysId,
             changes: [],
             verified: true,
@@ -515,6 +557,8 @@ async function setColumn(params) {
             table: table,
             column: column,
             columnSysId: columnSysId,
+            via: "dictionary",
+            definedOn: "",
             updateSetSysId: updateSetSysId,
             changes: changes,
             verified: false,
@@ -538,7 +582,7 @@ async function setColumn(params) {
     var after;
     var captured;
     try {
-        after = await fetchColumn(params.client, table, column, readFields);
+        after = (await resolveColumn(params.client, table, column, readFields)).row;
         captured = await assertCaptured(params.client, table, column, updateSetSysId);
     }
     catch (e) {
@@ -547,6 +591,8 @@ async function setColumn(params) {
             table: table,
             column: column,
             columnSysId: columnSysId,
+            via: "dictionary",
+            definedOn: "",
             updateSetSysId: updateSetSysId,
             changes: changes,
             verified: false,
@@ -577,6 +623,8 @@ async function setColumn(params) {
             table: table,
             column: column,
             columnSysId: columnSysId,
+            via: "dictionary",
+            definedOn: "",
             updateSetSysId: updateSetSysId,
             changes: changes,
             verified: false,
@@ -603,6 +651,8 @@ async function setColumn(params) {
         table: table,
         column: column,
         columnSysId: columnSysId,
+        via: "dictionary",
+        definedOn: "",
         updateSetSysId: updateSetSysId,
         changes: changes,
         verified: true,
@@ -629,6 +679,201 @@ async function setColumn(params) {
                 "promoted. Check the update set is in progress and in the column's scope.",
     };
 }
+/**
+ * Set an INHERITED column's attributes for this table alone.
+ *
+ * The caller asked to change a column on a child table. ServiceNow's answer to that is an
+ * override on the child — not an edit to the ancestor, which would silently change the
+ * column for every other table extending it. Four of the five attributes set-column
+ * supports can be narrowed this way; max_length cannot, because it is the ancestor's
+ * physical column, and that is the one case where "change it at the source" is the honest
+ * answer (given with its blast radius spelled out, rather than as a casual suggestion).
+ */
+async function setInheritedColumn(params, ctx) {
+    var columnSysId = (0, setField_1.fieldToString)(ctx.parentRow.sys_id);
+    // Refuse before touching anything else, so a dry-run fails identically to a live run.
+    if (ctx.writes.max_length !== undefined) {
+        throw new Error((0, overrideColumn_1.explainMaxLengthNotOverridable)(ctx.table, ctx.column, ctx.definedOn));
+    }
+    var overrideRow = await (0, overrideColumn_1.findOverrideRow)(params.client, ctx.table, ctx.column);
+    var labelRow = await (0, overrideColumn_1.findLabelRow)(params.client, ctx.table, ctx.column);
+    var changes = (0, overrideColumn_1.diffInherited)(ctx.writes, overrideRow, ctx.parentRow, labelRow);
+    var base = {
+        table: ctx.table,
+        column: ctx.column,
+        columnSysId: columnSysId,
+        via: "override",
+        definedOn: ctx.definedOn,
+    };
+    if (params.dryRun) {
+        return Object.assign({}, base, {
+            status: "dry-run",
+            updateSetSysId: params.updateSetSysId ? params.updateSetSysId : "",
+            changes: changes,
+            verified: false,
+            capturedInUpdateSet: false,
+            note: changes.length === 0
+                ? "dry-run: no write. " +
+                    ctx.column +
+                    " is inherited from " +
+                    ctx.definedOn +
+                    " and already presents every requested value on " +
+                    ctx.table +
+                    " — nothing would change."
+                : "dry-run: no write. " +
+                    ctx.column +
+                    " is inherited from " +
+                    ctx.definedOn +
+                    "; would override " +
+                    describeChanges(changes) +
+                    " for " +
+                    ctx.table +
+                    " ALONE (" +
+                    describeTargets(changes) +
+                    "), leaving " +
+                    ctx.definedOn +
+                    " and its other children untouched. Captured into update set " +
+                    (params.updateSetSysId
+                        ? params.updateSetSysId
+                        : "(none provided)") +
+                    ".",
+        });
+    }
+    if (!params.updateSetSysId || !String(params.updateSetSysId).trim()) {
+        throw new Error("set-column: --update-set <sys_id> is required so the schema change is captured " +
+            "and can be promoted. An uncaptured change exists only on this instance.");
+    }
+    var updateSetSysId = String(params.updateSetSysId).trim();
+    await assertUpdateSetOpen(params.client, updateSetSysId);
+    // Nothing differs from what the child already sees. Note WHY no override was written:
+    // pinning a value the column already inherits would decouple it from the ancestor as an
+    // invisible side effect of a request that never asked for that.
+    if (changes.length === 0) {
+        return Object.assign({}, base, {
+            status: "unchanged",
+            updateSetSysId: updateSetSysId,
+            changes: [],
+            verified: true,
+            capturedInUpdateSet: false,
+            note: ctx.table +
+                "." +
+                ctx.column +
+                " already presents every requested value — nothing written. The column is " +
+                "inherited from " +
+                ctx.definedOn +
+                " and no override was created, so it still TRACKS " +
+                ctx.definedOn +
+                ": a later change there will follow through to " +
+                ctx.table +
+                ".",
+        });
+    }
+    var written;
+    try {
+        written = await (0, overrideColumn_1.applyInheritedWrites)({
+            client: params.client,
+            table: ctx.table,
+            column: ctx.column,
+            definedOn: ctx.definedOn,
+            changes: changes,
+            overrideRow: overrideRow,
+            labelRow: labelRow,
+            updateSetSysId: updateSetSysId,
+        });
+    }
+    catch (e) {
+        return Object.assign({}, base, {
+            status: "failed",
+            updateSetSysId: updateSetSysId,
+            changes: changes,
+            verified: false,
+            capturedInUpdateSet: false,
+            note: "the override write for " +
+                ctx.table +
+                "." +
+                ctx.column +
+                " failed: " +
+                (e && e.message ? e.message : String(e)) +
+                ". It is NOT known whether it landed — read sys_dictionary_override for name=" +
+                ctx.table +
+                "^element=" +
+                ctx.column +
+                " on the instance before retrying.",
+        });
+    }
+    if (!written.verified) {
+        return Object.assign({}, base, {
+            status: "failed",
+            updateSetSysId: updateSetSysId,
+            overrideSysId: written.overrideSysId,
+            labelSysId: written.labelSysId,
+            changes: changes,
+            verified: false,
+            capturedInUpdateSet: written.captured,
+            note: "the override write returned success but the instance does NOT reflect it: " +
+                written.mismatched.join("; ") +
+                ". Treat " +
+                ctx.table +
+                "." +
+                ctx.column +
+                " as NOT overridden and reconcile it on the instance.",
+        });
+    }
+    return Object.assign({}, base, {
+        status: "applied",
+        updateSetSysId: updateSetSysId,
+        overrideSysId: written.overrideSysId,
+        labelSysId: written.labelSysId,
+        changes: changes,
+        verified: true,
+        capturedInUpdateSet: written.captured,
+        note: written.captured
+            ? "Overrode " +
+                describeChanges(changes) +
+                " for " +
+                ctx.table +
+                "." +
+                ctx.column +
+                " — inherited from " +
+                ctx.definedOn +
+                ", now narrowed for " +
+                ctx.table +
+                " ALONE (" +
+                describeTargets(changes) +
+                "); " +
+                ctx.definedOn +
+                " and its other children are unchanged. Verified by read-back and captured in " +
+                "update set " +
+                updateSetSysId +
+                "."
+            : "Overrode " +
+                describeChanges(changes) +
+                " for " +
+                ctx.table +
+                "." +
+                ctx.column +
+                " and verified by read-back, but the change was NOT captured in update set " +
+                updateSetSysId +
+                " — it is live on this instance and cannot be promoted. Check the update set is " +
+                "in progress and in " +
+                ctx.table +
+                "'s scope.",
+    });
+}
+/** Which record type each change was written to — the two are not interchangeable, and
+ *  a reader who does not know that will go looking for a label on the override row. */
+function describeTargets(changes) {
+    var hasOverride = changes.some(function (c) {
+        return Boolean(overrideColumn_1.OVERRIDABLE[c.attribute]);
+    });
+    var hasLabel = changes.some(function (c) {
+        return c.attribute === "column_label";
+    });
+    if (hasOverride && hasLabel) {
+        return "sys_dictionary_override + sys_documentation";
+    }
+    return hasLabel ? "sys_documentation" : "sys_dictionary_override";
+}
 /** "max_length 40 -> 4000, mandatory false -> true" */
 function describeChanges(changes) {
     return changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenonhq/dovetail-servicenow",
-  "version": "0.0.33",
+  "version": "0.0.34",
   "engines": {
     "node": ">=22"
   },