@tenonhq/dovetail-core 0.0.121 → 0.0.123

package/README.md

@@ -24,7 +24,7 @@ The full command surface is documented in the [root CLAUDE.md](../../CLAUDE.md#e
 Quick reference:
 
 ```bash
-npx dove watch         # multi-scope watch + dashboard
+npx dove watch         # HUMAN-ONLY local dev: multi-scope watch + dashboard (hidden from --help; stop before git checkout — see #155)
 npx dove push          # build + push current files
 npx dove refresh       # pull manifest + new files (aliases: pull, r)
 npx dove build         # local build only
@@ -35,6 +35,14 @@ npx dove migrate       # migrate a Sincronia project to Dovetail (dry-run by def
 
 See [`UPDATE_SET_COMMANDS.md`](UPDATE_SET_COMMANDS.md) for the full update-set CLI surface.
 
+### `dove create sys_update_set`
+
+`npx dove create <table>` inserts through the generic `createRecord` endpoint — except for `sys_update_set`. A plain insert lets ServiceNow default the set's `application` to the API session's current app, so `--scope` was silently ignored and the set landed in whatever scope the session was in (TenonHQ/Dovetail#231). Update sets therefore route through the atomic, scope-correct `createUpdateSet` server op (`POST /api/cadso/dovetail_core/createUpdateSet`) and the created set is read back: if its `application` does not match the requested scope the command exits non-zero, naming the requested vs. actual scope and the set's sys_id, so a mis-scoped set is never reported as success.
+
+- `--scope` decides the application. It is **required** with `--ci`; interactively it is confirmed in the summary.
+- Only `name` and `description` map onto the op; other `--field` values are ignored with a warning.
+- The set is created, not activated — use `npx dove switchUpdateSet --name "<name>" -s <scope>` (or `npx dove createUpdateSet`, which creates and activates in one step).
+
 ## Plugins
 
 Dovetail's build pipeline is plugin-driven. Each plugin is an npm package implementing `run(context, content, options) => Promise<PluginResults>`. Shipped plugins live in sibling packages (`@tenonhq/dovetail-typescript-plugin`, `-babel-plugin`, `-webpack-plugin`, `-sass-plugin`, `-eslint-plugin`, `-prettier-plugin`, `-babel-preset-servicenow`, `-babel-plugin-remove-modules`).

package/dist/allScopesCommands.js

@@ -47,6 +47,7 @@ const AppUtils = __importStar(require("./appUtils"));
 const wizard_1 = require("./wizard");
 const snClient_1 = require("./snClient");
 const commands_1 = require("./commands");
+const claudeSession_1 = require("./claudeSession");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const child_process_1 = require("child_process");
@@ -371,6 +372,13 @@ async function initScopesCommand(args) {
 }
 async function watchAllScopesCommand(args) {
     (0, commands_1.setLogLevel)(args);
+    // Soft guard, not a hard fail: `watch` is a human-only local-dev tool and a
+    // branch switch mid-watch overwrites instance records. Warn an agent off it
+    // but leave the human path untouched. See TenonHQ/Dovetail#155.
+    if ((0, claudeSession_1.isClaudeCodeSession)()) {
+        Logger_1.logger.warn(claudeSession_1.WATCH_HUMAN_ONLY_WARNING);
+        FileLogger_1.fileLogger.warn("dove watch started inside a Claude Code session (TenonHQ/Dovetail#155)");
+    }
     var dashboardProcess = null;
     try {
         // First check if we have environment variables set. SN_USER stays

package/dist/claudeSession.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Claude Code session detection for human-only CLI surfaces.
+ *
+ * `dove watch` auto-syncs the working tree to the instance, and a git branch
+ * switch mid-watch pushes the post-switch file state over live records. An
+ * agent can't guarantee it stops the watcher before every branch operation, so
+ * the command is hidden from `--help` and warns when it detects it is running
+ * inside a Claude Code session. See TenonHQ/Dovetail#155.
+ *
+ * Pure functions — no I/O — so the detection is unit-testable without touching
+ * `process.env` directly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WATCH_HUMAN_ONLY_WARNING = void 0;
+exports.isClaudeCodeSession = isClaudeCodeSession;
+// Claude Code exports `CLAUDECODE=1` into every tool shell, plus a family of
+// `CLAUDE_CODE_*` variables (e.g. `CLAUDE_CODE_SESSION_ID`, which claude-plans
+// already keys on). Any one of them set to a non-empty value is a session.
+var CLAUDE_SESSION_FLAG = "CLAUDECODE";
+var CLAUDE_SESSION_PREFIX = "CLAUDE_CODE_";
+/**
+ * @description Human-only warning printed when `dove watch` starts inside a
+ * Claude Code session. Non-blocking by design (TenonHQ/Dovetail#155).
+ */
+exports.WATCH_HUMAN_ONLY_WARNING = "⚠ `dove watch` is a human-only local-dev tool — it auto-syncs to the " +
+    "instance and a branch switch mid-watch overwrites records. Don't run this " +
+    "inside Claude Code. Use `npx dove push --diff <branch>` / `npx dove refresh` / " +
+    "`npx dove status` instead. See TenonHQ/Dovetail#155.";
+/**
+ * @description Reports whether the given environment looks like a Claude Code
+ * session: `CLAUDECODE` is set, or any `CLAUDE_CODE_*` variable is set, to a
+ * non-empty value. Empty strings do not count — an unset-but-declared variable
+ * is not a session.
+ * @param {NodeJS.ProcessEnv} env - Environment to inspect (defaults to `process.env`).
+ * @returns {boolean} True when a Claude Code session is detected.
+ */
+function isClaudeCodeSession(env = process.env) {
+    if (!env || typeof env !== "object")
+        return false;
+    if (hasValue(env[CLAUDE_SESSION_FLAG]))
+        return true;
+    var keys = Object.keys(env);
+    for (var i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        if (key.indexOf(CLAUDE_SESSION_PREFIX) === 0 && hasValue(env[key]))
+            return true;
+    }
+    return false;
+}
+/**
+ * @description True when an env value is a non-empty string.
+ * @param {string|undefined} value - Raw env value.
+ * @returns {boolean} Whether the value counts as "set".
+ */
+function hasValue(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}

package/dist/commander.js

@@ -49,7 +49,17 @@ function configureCli(cli) {
         describe: "Write a dovetail-debug-*.log file for this command (off by default; also enabled by DOVETAIL_DEBUG=1).",
     })
         .global("debug")
-        .command(["watch", "w", "watchAllScopes"], "Watch all scopes for file changes and sync to ServiceNow", (cmdArgs) => {
+        // INTENTIONAL: 'watch' is hidden from help + Claude-facing docs. It
+        // auto-syncs to the instance and a branch switch mid-watch silently
+        // overwrites records. Human-only local-dev tool. Do not re-document for
+        // Claude. See TenonHQ/Dovetail#155.
+        //
+        // A `false` description is yargs' hidden-command pattern: the command stays
+        // fully wired (a human typing `dove watch` / `w` / `watchAllScopes` still
+        // gets it, and `dove watch --help` still prints its flags) but it is omitted
+        // from the `dove --help` command index. The handler itself prints a
+        // human-only warning when it detects a Claude Code session (claudeSession.ts).
+        .command(["watch", "w", "watchAllScopes"], false, (cmdArgs) => {
         cmdArgs.options({
             ...sharedOptions,
             noDashboard: {
@@ -204,7 +214,7 @@ function configureCli(cli) {
         await (0, commands_1.buildCommand)(args);
     })
         .command("deploy", "Deploy local build files to the scoped application", sharedOptions, commands_1.deployCommand)
-        .command("create <table>", "Create a new record on the ServiceNow instance", (cmdArgs) => {
+        .command("create <table>", "Create a new record on the ServiceNow instance (sys_update_set goes through the scope-correct createUpdateSet op; --scope decides its application)", (cmdArgs) => {
         cmdArgs.positional("table", {
             describe: "ServiceNow table name (e.g., sys_script_include)",
             type: "string",
@@ -219,7 +229,7 @@ function configureCli(cli) {
             scope: {
                 alias: "s",
                 type: "string",
-                describe: "Target scope (e.g., x_cadso_core)",
+                describe: "Target scope (e.g., x_cadso_core). For sys_update_set this decides the set's application and is required with --ci",
             },
             from: {
                 alias: "f",

package/dist/createRecordCommand.js

@@ -36,6 +36,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateSetScopeMismatchError = exports.UPDATE_SET_TABLE = void 0;
+exports.createUpdateSetRecord = createUpdateSetRecord;
 exports.createRecordCommand = createRecordCommand;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -48,6 +50,55 @@ const commands_1 = require("./commands");
 const ConfigManager = __importStar(require("./config"));
 const AppUtils = __importStar(require("./appUtils"));
 const projectFiles_1 = require("./projectFiles");
+/**
+ * Table whose rows must NOT go through the generic record insert. A plain
+ * insert lets ServiceNow default `application` to the API session's current
+ * app (gs.getCurrentApplicationId()), so `--scope` was silently ignored and
+ * the set landed in whatever scope the session happened to be in
+ * (TenonHQ/Dovetail#231). Rows for this table route through the atomic
+ * `createUpdateSet` server op instead.
+ */
+exports.UPDATE_SET_TABLE = "sys_update_set";
+/** Fields `dove create` can map onto the createUpdateSet server op. */
+const UPDATE_SET_OP_FIELDS = ["name", "description"];
+/** Scope names are identifiers (`x_cadso_core`, `global`) — nothing else. */
+const SCOPE_NAME_PATTERN = /^[A-Za-z0-9_]+$/;
+/**
+ * Raised when a created update set is readable but its `application` does
+ * not match the requested scope. Carries both sides so callers can print an
+ * actionable message and exit non-zero instead of claiming success.
+ */
+class UpdateSetScopeMismatchError extends Error {
+    updateSetSysId;
+    requestedScope;
+    requestedScopeSysId;
+    actualScope;
+    actualScopeSysId;
+    constructor(details) {
+        super('Update set "' +
+            details.updateSetName +
+            '" (' +
+            details.updateSetSysId +
+            ") landed in scope " +
+            details.actualScope +
+            " (" +
+            details.actualScopeSysId +
+            ") but --scope " +
+            details.requestedScope +
+            " (" +
+            details.requestedScopeSysId +
+            ") was requested. The set is MIS-SCOPED: delete it on the instance " +
+            "before it collects captures, then confirm the Dovetail " +
+            "createUpdateSet REST op is installed on this instance and retry.");
+        this.name = "UpdateSetScopeMismatchError";
+        this.updateSetSysId = details.updateSetSysId;
+        this.requestedScope = details.requestedScope;
+        this.requestedScopeSysId = details.requestedScopeSysId;
+        this.actualScope = details.actualScope;
+        this.actualScopeSysId = details.actualScopeSysId;
+    }
+}
+exports.UpdateSetScopeMismatchError = UpdateSetScopeMismatchError;
 const getUpdateSetConfig = () => {
     const configPath = (0, projectFiles_1.getUpdateSetsConfigPath)();
     try {
@@ -155,6 +206,142 @@ async function resolveScope(args) {
     ]);
     return scopeAnswer.scope;
 }
+/**
+ * Normalizes a Table API reference field — a bare sys_id string, or the
+ * `{ value, link }` object the Table API returns without display values —
+ * to its sys_id. Returns undefined for anything else (missing, empty, wrong
+ * shape) so callers never compare against garbage.
+ */
+function referenceSysId(value) {
+    if (typeof value === "string") {
+        return value.trim() === "" ? undefined : value.trim();
+    }
+    if (value !== null && typeof value === "object") {
+        var inner = value.value;
+        if (typeof inner === "string" && inner.trim() !== "") {
+            return inner.trim();
+        }
+    }
+    return undefined;
+}
+/**
+ * Reads the created set back and returns its `application` sys_id. Falls
+ * back to the create response when the read-back fails or carries no
+ * application. Returns undefined when neither source can prove the scope.
+ */
+async function readBackApplication(client, updateSetSysId, createResponseApplication) {
+    try {
+        var rows = await (0, snClient_1.unwrapSNResponse)(client.getUpdateSetById(updateSetSysId));
+        if (Array.isArray(rows) && rows.length > 0) {
+            var fromReadBack = referenceSysId(rows[0].application);
+            if (fromReadBack) {
+                return fromReadBack;
+            }
+        }
+        FileLogger_1.fileLogger.warn("Update set read-back returned no application for " + updateSetSysId);
+    }
+    catch (readErr) {
+        FileLogger_1.fileLogger.warn("Update set read-back failed for " +
+            updateSetSysId +
+            ": " +
+            (readErr instanceof Error ? readErr.message : String(readErr)));
+    }
+    return referenceSysId(createResponseApplication);
+}
+/**
+ * Resolves a scope sys_id back to its name for error messages. Never throws —
+ * falls back to the sys_id itself so a lookup failure can't mask the
+ * mismatch we are about to report.
+ */
+async function scopeNameForSysId(client, scopeSysId) {
+    try {
+        var rows = await (0, snClient_1.unwrapSNResponse)(client.getScopeById(scopeSysId));
+        if (Array.isArray(rows) && rows.length > 0 && rows[0].scope) {
+            return rows[0].scope;
+        }
+    }
+    catch (e) {
+        // fall through to the sys_id
+    }
+    return scopeSysId;
+}
+/**
+ * Creates a `sys_update_set` through the scope-correct `createUpdateSet`
+ * server op and PROVES it landed in the requested scope. Throws on a
+ * mis-scoped or unverifiable set — the caller must never report success.
+ */
+async function createUpdateSetRecord(client, scope, fields) {
+    if (typeof scope !== "string" || !SCOPE_NAME_PATTERN.test(scope)) {
+        throw new Error("Invalid scope name " +
+            JSON.stringify(scope) +
+            ": expected an application scope such as x_cadso_core.");
+    }
+    var name = typeof fields.name === "string" ? fields.name.trim() : "";
+    if (name === "") {
+        throw new Error("Update set name is required.");
+    }
+    var description = typeof fields.description === "string" && fields.description.trim() !== ""
+        ? fields.description
+        : undefined;
+    var unsupported = Object.keys(fields).filter(function (key) {
+        return UPDATE_SET_OP_FIELDS.indexOf(key) === -1;
+    });
+    if (unsupported.length > 0) {
+        Logger_1.logger.warn("sys_update_set is created through the scope-correct createUpdateSet " +
+            "op, which accepts only " +
+            UPDATE_SET_OP_FIELDS.join(", ") +
+            ". Ignoring field(s): " +
+            unsupported.join(", "));
+    }
+    // Resolve the scope name to the application sys_id the op needs.
+    var scopeRows = await (0, snClient_1.unwrapSNResponse)(client.getScopeId(scope));
+    if (!Array.isArray(scopeRows) || scopeRows.length === 0) {
+        throw new Error('Scope "' + scope + '" not found on the instance.');
+    }
+    var scopeSysId = scopeRows[0].sys_id;
+    if (typeof scopeSysId !== "string" || scopeSysId.trim() === "") {
+        throw new Error('Scope "' + scope + '" resolved without a sys_id.');
+    }
+    FileLogger_1.fileLogger.debug("createUpdateSet op:", JSON.stringify({ name: name, scope: scope, application: scopeSysId }));
+    var created = await (0, snClient_1.unwrapSNResponse)(client.createUpdateSet(name, scopeSysId, description));
+    var createdSysId = created && typeof created.sys_id === "string" ? created.sys_id : "";
+    if (createdSysId === "") {
+        throw new Error("createUpdateSet returned no sys_id for " + name);
+    }
+    // Verify on the way out: the whole point of this path is that the set is
+    // in the requested scope, so prove it rather than trust the op.
+    var actualScopeSysId = await readBackApplication(client, createdSysId, created.application);
+    if (!actualScopeSysId) {
+        throw new Error('Update set "' +
+            name +
+            '" (' +
+            createdSysId +
+            ") was created but its application scope could not be verified " +
+            "(requested " +
+            scope +
+            " / " +
+            scopeSysId +
+            "). Inspect the set on the instance before using it.");
+    }
+    if (actualScopeSysId !== scopeSysId) {
+        var actualScope = await scopeNameForSysId(client, actualScopeSysId);
+        throw new UpdateSetScopeMismatchError({
+            updateSetName: name,
+            updateSetSysId: createdSysId,
+            requestedScope: scope,
+            requestedScopeSysId: scopeSysId,
+            actualScope: actualScope,
+            actualScopeSysId: actualScopeSysId,
+        });
+    }
+    var createdName = created.name;
+    return {
+        sysId: createdSysId,
+        name: typeof createdName === "string" && createdName !== "" ? createdName : name,
+        scope: scope,
+        scopeSysId: scopeSysId,
+    };
+}
 /**
  * Main create record command handler.
  */
@@ -167,7 +354,16 @@ async function createRecordCommand(args) {
             Logger_1.logger.error("Table name is required");
             process.exit(1);
         }
+        var isUpdateSet = table === exports.UPDATE_SET_TABLE;
         FileLogger_1.fileLogger.debug("Create record: table=" + table);
+        // An update set's application is decided by --scope alone. In CI there is
+        // no human to confirm a manifest-inferred scope, so require it explicitly
+        // rather than let an inherited scope mis-route every later capture.
+        if (isUpdateSet && typedArgs.ci && !typedArgs.scope) {
+            Logger_1.logger.error("--scope is required when creating sys_update_set in --ci mode: " +
+                "the scope decides the update set's application.");
+            process.exit(1);
+        }
         // 1. Build field values from all sources
         var fields = {};
         // Load from JSON file if provided
@@ -209,13 +405,17 @@ async function createRecordCommand(args) {
         // 3. Resolve scope
         var scope = await resolveScope(typedArgs);
         Logger_1.logger.info("Scope: " + chalk_1.default.cyan(scope));
-        // 4. Check update set configuration
-        var updateSetConfig = getUpdateSetConfig();
-        var updateSet = updateSetConfig[scope];
+        // 4. Check update set configuration. An update set is not itself captured
+        // in an update set, so skip the lookup for sys_update_set.
+        var updateSet;
         var updateSetSysId;
-        if (updateSet) {
-            Logger_1.logger.info("Update set: " + chalk_1.default.cyan(updateSet.name));
-            updateSetSysId = updateSet.sys_id;
+        if (!isUpdateSet) {
+            var updateSetConfig = getUpdateSetConfig();
+            updateSet = updateSetConfig[scope];
+            if (updateSet) {
+                Logger_1.logger.info("Update set: " + chalk_1.default.cyan(updateSet.name));
+                updateSetSysId = updateSet.sys_id;
+            }
         }
         // 5. Confirmation prompt
         if (!typedArgs.ci) {
@@ -224,6 +424,9 @@ async function createRecordCommand(args) {
             Logger_1.logger.info("  Table: " + chalk_1.default.cyan(table));
             Logger_1.logger.info("  Name: " + chalk_1.default.cyan(fields.name));
             Logger_1.logger.info("  Scope: " + chalk_1.default.cyan(scope));
+            if (isUpdateSet) {
+                Logger_1.logger.info("  Via: Dovetail createUpdateSet op (application = scope above)");
+            }
             if (updateSet) {
                 Logger_1.logger.info("  Update Set: " + chalk_1.default.cyan(updateSet.name));
             }
@@ -249,7 +452,29 @@ async function createRecordCommand(args) {
                 return;
             }
         }
-        // 6. Call the create endpoint
+        var client = (0, snClient_1.defaultClient)();
+        // 6a. sys_update_set: the scope-correct server op, verified on the way out.
+        if (isUpdateSet) {
+            Logger_1.logger.info("Creating update set via the Dovetail createUpdateSet op...");
+            var createdSet = await createUpdateSetRecord(client, scope, fields);
+            Logger_1.logger.success(chalk_1.default.green("Update set created: ") +
+                chalk_1.default.bold(createdSet.name) +
+                " (" +
+                createdSet.sysId +
+                ") in scope " +
+                chalk_1.default.cyan(createdSet.scope));
+            Logger_1.logger.info("Verified application = " +
+                createdSet.scope +
+                " (" +
+                createdSet.scopeSysId +
+                ").");
+            Logger_1.logger.info("Not activated. To route pushes to it: npx dove switchUpdateSet --name " +
+                JSON.stringify(createdSet.name) +
+                " -s " +
+                createdSet.scope);
+            return;
+        }
+        // 6b. Every other table: the generic create endpoint
         Logger_1.logger.info("Creating record...");
         FileLogger_1.fileLogger.debug("Create request:", JSON.stringify({
             table: table,
@@ -257,7 +482,6 @@ async function createRecordCommand(args) {
             scope: scope,
             update_set_sys_id: updateSetSysId,
         }));
-        var client = (0, snClient_1.defaultClient)();
         var createResponse = await client.createRecord({
             table: table,
             fields: fields,

package/dist/snClient.js

@@ -352,6 +352,20 @@ const snClient = (baseURL, username, password, apiKey) => {
             },
         });
     };
+    /**
+     * Reads one update set back by sys_id, selecting only `application`, so a
+     * caller can PROVE which application a freshly created set landed in. The
+     * Table API returns the reference as `{ value, link }` (no display value).
+     */
+    const getUpdateSetById = (updateSetSysId) => {
+        const endpoint = "api/now/table/sys_update_set";
+        return client.get(endpoint, {
+            params: {
+                sysparm_query: `sys_id=${updateSetSysId}`,
+                sysparm_fields: "sys_id,name,application",
+            },
+        });
+    };
     const getUserSysId = (userName = process.env.SN_USER) => {
         const endpoint = "api/now/table/sys_user";
         return client.get(endpoint, {
@@ -523,6 +537,7 @@ const snClient = (baseURL, username, password, apiKey) => {
         updateRecord,
         getScopeId,
         getScopeById,
+        getUpdateSetById,
         getUserSysId,
         getCurrentAppUserPrefSysId,
         updateCurrentAppUserPref,

package/dist/tests/claudeSession.test.js

@@ -0,0 +1,42 @@
+"use strict";
+// Tests for the Claude Code session detector behind the `dove watch` soft
+// guard (claudeSession.ts, TenonHQ/Dovetail#155). Pure-function tests — an
+// explicit env object is passed so the real process.env never leaks in.
+Object.defineProperty(exports, "__esModule", { value: true });
+const claudeSession_1 = require("../claudeSession");
+describe("isClaudeCodeSession", function () {
+    it("returns false for an empty environment", function () {
+        expect((0, claudeSession_1.isClaudeCodeSession)({})).toBe(false);
+    });
+    it("returns false when only unrelated variables are set", function () {
+        expect((0, claudeSession_1.isClaudeCodeSession)({ HOME: "/tmp", SN_INSTANCE: "x.service-now.com" })).toBe(false);
+    });
+    it("returns true when CLAUDECODE is set", function () {
+        expect((0, claudeSession_1.isClaudeCodeSession)({ CLAUDECODE: "1" })).toBe(true);
+    });
+    it("returns true when any CLAUDE_CODE_* variable is set", function () {
+        expect((0, claudeSession_1.isClaudeCodeSession)({ CLAUDE_CODE_SESSION_ID: "abc123" })).toBe(true);
+        expect((0, claudeSession_1.isClaudeCodeSession)({ CLAUDE_CODE_ENTRYPOINT: "cli" })).toBe(true);
+    });
+    it("treats empty or whitespace-only values as unset", function () {
+        expect((0, claudeSession_1.isClaudeCodeSession)({ CLAUDECODE: "" })).toBe(false);
+        expect((0, claudeSession_1.isClaudeCodeSession)({ CLAUDE_CODE_SESSION_ID: "   " })).toBe(false);
+    });
+    it("does not match look-alike prefixes", function () {
+        expect((0, claudeSession_1.isClaudeCodeSession)({ CLAUDE: "1", CLAUDECODEX: "1", MY_CLAUDE_CODE_X: "1" })).toBe(false);
+    });
+    it("defaults to process.env and agrees with an explicit copy of it", function () {
+        expect((0, claudeSession_1.isClaudeCodeSession)()).toBe((0, claudeSession_1.isClaudeCodeSession)({ ...process.env }));
+    });
+});
+describe("WATCH_HUMAN_ONLY_WARNING", function () {
+    it("names the hazard, the safe headless verbs, and the tracking issue", function () {
+        expect(claudeSession_1.WATCH_HUMAN_ONLY_WARNING).toContain("human-only");
+        expect(claudeSession_1.WATCH_HUMAN_ONLY_WARNING).toContain("branch switch");
+        expect(claudeSession_1.WATCH_HUMAN_ONLY_WARNING).toContain("Claude Code");
+        expect(claudeSession_1.WATCH_HUMAN_ONLY_WARNING).toContain("dove push");
+        expect(claudeSession_1.WATCH_HUMAN_ONLY_WARNING).toContain("dove refresh");
+        expect(claudeSession_1.WATCH_HUMAN_ONLY_WARNING).toContain("dove status");
+        expect(claudeSession_1.WATCH_HUMAN_ONLY_WARNING).toContain("TenonHQ/Dovetail#155");
+    });
+});