@skrr-ai/cli 0.1.87 → 0.1.88

package/dist/commands/machines/share.d.ts

@@ -0,0 +1,29 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr machines share` — grant a person a tier on one of your machines
+ * (design §9, D10; OSK-13558).
+ *
+ * The two tiers are the honest ones: `watch` sees every surface and its
+ * activity; `operate` can also take control and read and write files — "the
+ * machine's account in another person's hands". `power` and grant management
+ * stay with the owner, so there is no tier flag for them. The grantee may be
+ * any user — nothing here assumes a shared workspace.
+ *
+ * One verb for issue and change: the stated tier is the end state asked for.
+ * The server refuses a bare re-issue at a different tier (a retried issue can
+ * never silently escalate a grant), so an existing grant is changed through
+ * PATCH — and the output says which of the two happened.
+ */
+export default class MachinesShare extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        machine: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        user: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        tier: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/share.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const api_fetch_1 = require("../../lib/api-fetch");
+const machines_1 = require("../../lib/machines");
+const machine_grants_1 = require("../../lib/machine-grants");
+/**
+ * `skrr machines share` — grant a person a tier on one of your machines
+ * (design §9, D10; OSK-13558).
+ *
+ * The two tiers are the honest ones: `watch` sees every surface and its
+ * activity; `operate` can also take control and read and write files — "the
+ * machine's account in another person's hands". `power` and grant management
+ * stay with the owner, so there is no tier flag for them. The grantee may be
+ * any user — nothing here assumes a shared workspace.
+ *
+ * One verb for issue and change: the stated tier is the end state asked for.
+ * The server refuses a bare re-issue at a different tier (a retried issue can
+ * never silently escalate a grant), so an existing grant is changed through
+ * PATCH — and the output says which of the two happened.
+ */
+class MachinesShare extends base_command_1.BaseCommand {
+    static description = 'Share a machine with a person — `watch` lets them see every surface; `operate` also gives control and file access';
+    static examples = [
+        '<%= config.bin %> machines share 03548116 68db4b2f0b4f5a9c1d2e3f40 --tier watch',
+        '<%= config.bin %> machines share lease:rtl_abc123 68db4b2f0b4f5a9c1d2e3f40 --tier operate',
+    ];
+    static args = {
+        machine: core_1.Args.string({
+            ignoreStdin: true,
+            description: 'Machine id, uuid, daemon id, name, or a unique prefix',
+            required: true,
+        }),
+        user: core_1.Args.string({
+            ignoreStdin: true,
+            description: 'The user id of the person to share with',
+            required: true,
+        }),
+    };
+    static flags = {
+        tier: core_1.Flags.string({
+            description: 'watch: see every surface and its activity. operate: also take control, open surfaces, and read/write files',
+            required: true,
+            options: [...machine_grants_1.MACHINE_GRANT_TIERS],
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(MachinesShare);
+        const tier = flags.tier;
+        let target;
+        try {
+            target = (0, machines_1.resolveMachineRef)(await (0, machines_1.listMachines)(), args.machine);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (!target) {
+            this.error('Machine not found.', { exit: 1 });
+        }
+        let result;
+        try {
+            result = await (0, machine_grants_1.shareMachine)(target.id, args.user, tier);
+        }
+        catch (err) {
+            // A grant already held at another tier is a change, not an issue: the
+            // user named the tier they want, so PATCH it. The 409 is the server
+            // stopping a retried ISSUE from silently escalating — this is not that.
+            if (err instanceof api_fetch_1.ApiFetchError && err.code === 'COMPUTER_GRANT_EXISTS') {
+                result = await (0, machine_grants_1.changeMachineGrant)(target.id, args.user, tier);
+            }
+            else {
+                this.handleApiError(err);
+            }
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const label = target.preferences?.name || target.name || target.id;
+        if (result?.created === false) {
+            this.log(`${label} is already shared with ${args.user} at ${tier}.`);
+        }
+        else if (result?.changed === false) {
+            this.log(`${label} stays shared with ${args.user} at ${tier}.`);
+        }
+        else if (result?.changed === true) {
+            this.log(`Changed ${args.user} to ${tier} on ${label}.`);
+        }
+        else {
+            this.log(`Shared ${label} with ${args.user} at ${tier}.`);
+            if (tier === 'operate') {
+                this.log("  operate is the machine's account in their hands: control of surfaces, and file read/write.");
+            }
+        }
+    }
+}
+exports.default = MachinesShare;

package/dist/commands/machines/shared.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr machines shared` — the machines other people shared with you
+ * (design §9, D4/D10; OSK-13567): how a grantee finds a computer without being
+ * sent a link. The grantee may be outside every workspace the owner is in, so
+ * nothing here assumes one.
+ *
+ * Each row says who shared it, at which tier (`watch` sees every surface and
+ * its activity; `operate` adds control and file read/write), and the machine's
+ * live power phase. `skrr machines dedicated computer <id>` opens one.
+ */
+export default class MachinesShared extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/shared.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const format_1 = require("../../lib/format");
+const machine_grants_1 = require("../../lib/machine-grants");
+/**
+ * `skrr machines shared` — the machines other people shared with you
+ * (design §9, D4/D10; OSK-13567): how a grantee finds a computer without being
+ * sent a link. The grantee may be outside every workspace the owner is in, so
+ * nothing here assumes one.
+ *
+ * Each row says who shared it, at which tier (`watch` sees every surface and
+ * its activity; `operate` adds control and file read/write), and the machine's
+ * live power phase. `skrr machines dedicated computer <id>` opens one.
+ */
+class MachinesShared extends base_command_1.BaseCommand {
+    static description = 'List the computers shared with you — machine, owner, tier, and live state';
+    static examples = [
+        '<%= config.bin %> machines shared',
+        '<%= config.bin %> machines shared --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(MachinesShared);
+        let result;
+        try {
+            result = await (0, machine_grants_1.listSharedMachines)();
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const machines = result?.machines ?? [];
+        if (machines.length === 0) {
+            this.log('No computers are shared with you.');
+            return;
+        }
+        (0, format_1.renderTable)(machines.map((machine) => ({
+            id: (0, format_1.formatCell)(machine.machineId),
+            name: (0, format_1.formatCell)(machine.name),
+            owner: (0, format_1.formatCell)(machine.owner?.name || machine.owner?.username),
+            tier: (0, format_1.formatCell)(machine.tier),
+            power: (0, format_1.formatCell)(machine.power?.phase),
+            since: (0, format_1.localStamp)(machine.grantedAt),
+        })), [
+            { key: 'id', header: 'ID', verbatim: true },
+            { key: 'name', header: 'NAME', maxWidth: 28 },
+            { key: 'owner', header: 'OWNER' },
+            { key: 'tier', header: 'TIER' },
+            { key: 'power', header: 'STATE' },
+            { key: 'since', header: `SHARED (${(0, format_1.localZone)()})` },
+        ], (line) => this.log(line));
+    }
+}
+exports.default = MachinesShared;

package/dist/commands/machines/shares.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr machines shares` — who a machine is shared with, and at which tier
+ * (design §9; OSK-13558). Owner-only: the server answers 403 to anyone else.
+ */
+export default class MachinesShares extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        machine: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/shares.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const format_1 = require("../../lib/format");
+const machines_1 = require("../../lib/machines");
+const machine_grants_1 = require("../../lib/machine-grants");
+/**
+ * `skrr machines shares` — who a machine is shared with, and at which tier
+ * (design §9; OSK-13558). Owner-only: the server answers 403 to anyone else.
+ */
+class MachinesShares extends base_command_1.BaseCommand {
+    static description = 'List the people a machine is shared with — grantee, tier, and when the grant was made';
+    static examples = [
+        '<%= config.bin %> machines shares 03548116',
+        '<%= config.bin %> machines shares lease:rtl_abc123 --json',
+    ];
+    static args = {
+        machine: core_1.Args.string({
+            ignoreStdin: true,
+            description: 'Machine id, uuid, daemon id, name, or a unique prefix',
+            required: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(MachinesShares);
+        let target;
+        try {
+            target = (0, machines_1.resolveMachineRef)(await (0, machines_1.listMachines)(), args.machine);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (!target) {
+            this.error('Machine not found.', { exit: 1 });
+        }
+        let result;
+        try {
+            result = await (0, machine_grants_1.listMachineGrants)(target.id);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const grants = result?.grants ?? [];
+        if (grants.length === 0) {
+            this.log('Not shared with anyone.');
+            return;
+        }
+        this.log(`Shared with ${grants.length} ${grants.length === 1 ? 'person' : 'people'}:`);
+        (0, format_1.renderTable)(grants.map((grant) => ({
+            user: (0, format_1.formatCell)(grant.granteeUserId),
+            tier: (0, format_1.formatCell)(grant.tier),
+            since: (0, format_1.localStamp)(grant.createdAt),
+        })), [
+            { key: 'user', header: 'USER', verbatim: true },
+            { key: 'tier', header: 'TIER' },
+            { key: 'since', header: `SINCE (${(0, format_1.localZone)()})` },
+        ], (line) => this.log(line));
+    }
+}
+exports.default = MachinesShares;

package/dist/commands/machines/unshare.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr machines unshare` — revoke one person's grant on a machine (design §9;
+ * OSK-13558). Revocation bumps the machine's grant-set version, so its daemon
+ * detaches that person's attachments and releases any lease they hold when
+ * the new set arrives. Reversible — `machines share` grants again.
+ */
+export default class MachinesUnshare extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        machine: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        user: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/machines/unshare.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const machines_1 = require("../../lib/machines");
+const machine_grants_1 = require("../../lib/machine-grants");
+/**
+ * `skrr machines unshare` — revoke one person's grant on a machine (design §9;
+ * OSK-13558). Revocation bumps the machine's grant-set version, so its daemon
+ * detaches that person's attachments and releases any lease they hold when
+ * the new set arrives. Reversible — `machines share` grants again.
+ */
+class MachinesUnshare extends base_command_1.BaseCommand {
+    static description = 'Stop sharing a machine with a person — detaches their surfaces and releases their control lease';
+    static examples = [
+        '<%= config.bin %> machines unshare 03548116 68db4b2f0b4f5a9c1d2e3f40',
+    ];
+    static args = {
+        machine: core_1.Args.string({
+            ignoreStdin: true,
+            description: 'Machine id, uuid, daemon id, name, or a unique prefix',
+            required: true,
+        }),
+        user: core_1.Args.string({
+            ignoreStdin: true,
+            description: 'The user id of the person to stop sharing with',
+            required: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(MachinesUnshare);
+        let target;
+        try {
+            target = (0, machines_1.resolveMachineRef)(await (0, machines_1.listMachines)(), args.machine);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (!target) {
+            this.error('Machine not found.', { exit: 1 });
+        }
+        let result;
+        try {
+            result = await (0, machine_grants_1.unshareMachine)(target.id, args.user);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const label = target.preferences?.name || target.name || target.id;
+        this.log(`Stopped sharing ${label} with ${args.user}.`);
+    }
+}
+exports.default = MachinesUnshare;

package/dist/commands/tasks/labels/create.d.ts

@@ -3,6 +3,7 @@ export default class TasksLabelsCreate extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        'allow-duplicate-name': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'from-json': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/tasks/labels/create.js

@@ -4,6 +4,7 @@ const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
 const prompt_1 = require("../../../lib/prompt");
+const label_scope_1 = require("../../../lib/label-scope");
 // Accept both `#e11d48` and `e11d48` forms; the server's Zod regex
 // (`api/server/routes/tasks.js:206`) is `/^[0-9a-fA-F]{6}$/` — NO leading
 // `#`. We normalize before sending so users can pass either form.
@@ -24,6 +25,7 @@ class TasksLabelsCreate extends base_command_1.BaseCommand {
         color: core_1.Flags.string({
             description: 'Label color as 6-digit hex, e.g. e11d48 (leading # is accepted and stripped)',
         }),
+        ...label_scope_1.allowDuplicateNameFlags,
     };
     async run() {
         this.requireAuth();
@@ -38,6 +40,7 @@ class TasksLabelsCreate extends base_command_1.BaseCommand {
         const payload = (0, prompt_1.mergeDefined)(jsonBody, {
             name: flags.name,
             color: flags.color,
+            allowDuplicateName: flags['allow-duplicate-name'] ? true : undefined,
         });
         if (!payload.name || typeof payload.name !== 'string') {
             this.error('A label name is required. Pass --name "..." or include it in --from-json.', {

package/dist/commands/views/create.d.ts

@@ -14,6 +14,7 @@ export default class ViewsCreate extends BaseCommand {
         priority: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         assignee: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         label: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'label-match': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         goal: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         project: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         search: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;

package/dist/commands/views/create.js

@@ -35,6 +35,10 @@ class ViewsCreate extends base_command_1.BaseCommand {
         }),
         assignee: core_1.Flags.string({ multiple: true, description: 'Filter by agent or user ID' }),
         label: core_1.Flags.string({ multiple: true, description: 'Filter by label ID' }),
+        'label-match': core_1.Flags.string({
+            options: [...vocabulary_1.VIEW_LABEL_MATCH_VALUES],
+            description: 'How --label values combine: any (default) or all',
+        }),
         goal: core_1.Flags.string({ multiple: true, description: 'Filter by goal ID' }),
         project: core_1.Flags.string({ multiple: true, description: 'Filter by project ID' }),
         search: core_1.Flags.string({ description: 'Filter by title, identifier, or description' }),
@@ -67,6 +71,7 @@ class ViewsCreate extends base_command_1.BaseCommand {
             priorities: flags.priority,
             assignees: flags.assignee,
             labels: flags.label,
+            labelMatch: flags['label-match'],
             goalIds: flags.goal,
             projectIds: flags.project,
             search: flags.search,

package/dist/lib/agent-home-workspace.d.ts

@@ -36,3 +36,10 @@ export declare function lookupAgentHomeWorkspaceDefault(agentId: string, lookup:
  * Agent process.
  */
 export declare function commitAgentHomeWorkspaceDefault(workspaceId: string | null, env?: NodeJS.ProcessEnv): string | null;
+/** Does this origin's server default a headerless chat turn's workspace itself? */
+export declare function serverAppliesAgentHomeDefault(cacheDir: string | undefined, baseURL: string | undefined, now?: number): boolean;
+/**
+ * Record what an acceptance says about the server, and return it. Writes only
+ * when the verdict changes or the observation is getting old.
+ */
+export declare function recordAgentHomeDefaultObservation(cacheDir: string | undefined, baseURL: string | undefined, accepted: unknown, now?: number): 'supported' | 'unsupported';

package/dist/lib/agent-home-workspace.js

@@ -1,8 +1,45 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyAgentHomeWorkspaceDefault = applyAgentHomeWorkspaceDefault;
 exports.lookupAgentHomeWorkspaceDefault = lookupAgentHomeWorkspaceDefault;
 exports.commitAgentHomeWorkspaceDefault = commitAgentHomeWorkspaceDefault;
+exports.serverAppliesAgentHomeDefault = serverAppliesAgentHomeDefault;
+exports.recordAgentHomeDefaultObservation = recordAgentHomeDefaultObservation;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
 /**
  * The workspace an `agents chat` turn runs in when the caller named none.
  *
@@ -64,3 +101,113 @@ function commitAgentHomeWorkspaceDefault(workspaceId, env = process.env) {
     env.OVERSKY_WORKSPACE_ID = workspaceId;
     return workspaceId;
 }
+/**
+ * OSK-13599 — whether the server this CLI talks to chooses the agent-home
+ * workspace itself.
+ *
+ * A server that does (it defaults a headerless `POST /api/agentic/chat` to the
+ * agent's CURRENT home workspace, under exactly the checks the header would
+ * pass) makes the pre-flight agent read above redundant, and that read is a
+ * full round trip (~480ms at production RTT) on every turn.
+ *
+ * What is remembered is a fact about the SERVER, never the agent's workspace:
+ * agents move between workspaces, so caching their workspace could start a turn
+ * in the wrong one, while "this origin applies the default" stays true until
+ * the server is rolled back. The evidence is the acceptance itself — a server
+ * that applies the default always answers with a `workspaceSource` key (null
+ * included); an older one never does. So:
+ *
+ *   - first turn against an origin: no observation → the agent read happens,
+ *     exactly as before; the acceptance records the observation;
+ *   - later turns: the read is skipped and the server chooses;
+ *   - a rollback: the acceptance lacks the key, the observation is dropped and
+ *     the NEXT turn reads again. The one turn in between ran with no workspace
+ *     (the pre-OSK-9937 behaviour), which the command reports on stderr.
+ *
+ * Best-effort everywhere: an unreadable or unwritable cache is "not observed",
+ * which is today's behaviour, never an error.
+ */
+const SERVER_FEATURES_FILE = 'server-features.json';
+/** Re-confirm at most this often, so a supported server is not a write per turn. */
+const OBSERVATION_REFRESH_MS = 24 * 60 * 60 * 1000;
+/** An observation nobody has re-confirmed for this long is not trusted. */
+const OBSERVATION_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+function originOf(baseURL) {
+    try {
+        return new URL(baseURL).origin;
+    }
+    catch {
+        return null;
+    }
+}
+function featuresPath(cacheDir) {
+    return path.join(cacheDir, SERVER_FEATURES_FILE);
+}
+function readFeatures(cacheDir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(featuresPath(cacheDir), 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Does this origin's server default a headerless chat turn's workspace itself? */
+function serverAppliesAgentHomeDefault(cacheDir, baseURL, now = Date.now()) {
+    if (!cacheDir || !baseURL)
+        return false;
+    const origin = originOf(baseURL);
+    if (!origin)
+        return false;
+    const seen = readFeatures(cacheDir)[origin];
+    if (seen?.agentHomeWorkspaceDefault !== true)
+        return false;
+    const at = Date.parse(seen.observedAt);
+    return Number.isFinite(at) && now - at <= OBSERVATION_MAX_AGE_MS;
+}
+/**
+ * Record what an acceptance says about the server, and return it. Writes only
+ * when the verdict changes or the observation is getting old.
+ */
+function recordAgentHomeDefaultObservation(cacheDir, baseURL, accepted, now = Date.now()) {
+    const supported = !!accepted && typeof accepted === 'object' && 'workspaceSource' in accepted;
+    const verdict = supported ? 'supported' : 'unsupported';
+    if (!cacheDir || !baseURL)
+        return verdict;
+    const origin = originOf(baseURL);
+    if (!origin)
+        return verdict;
+    try {
+        const features = readFeatures(cacheDir);
+        const previous = features[origin];
+        if (!supported && !previous)
+            return verdict;
+        const previousAt = previous ? Date.parse(previous.observedAt) : NaN;
+        if (supported &&
+            previous?.agentHomeWorkspaceDefault === true &&
+            Number.isFinite(previousAt) &&
+            now - previousAt < OBSERVATION_REFRESH_MS) {
+            return verdict;
+        }
+        if (supported) {
+            features[origin] = {
+                agentHomeWorkspaceDefault: true,
+                observedAt: new Date(now).toISOString(),
+            };
+        }
+        else {
+            delete features[origin];
+        }
+        fs.mkdirSync(cacheDir, { recursive: true, mode: 0o700 });
+        const file = featuresPath(cacheDir);
+        const tmp = `${file}.${process.pid}.${now}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(features), { mode: 0o600 });
+        fs.renameSync(tmp, file);
+    }
+    catch {
+        // Best-effort: the next turn simply reads the agent again.
+    }
+    return verdict;
+}