@oxygen-agent/cli 1.1013.94 → 1.1014.18

package/node_modules/@oxygen/shared/dist/agent-sessions.js

@@ -0,0 +1,133 @@
+import { isStaffEmail } from "./staff.js";
+import { OxygenError } from "./cli-result.js";
+import { WORKSPACE_EVENT_CATALOG } from "./workspace-event-catalog.js";
+export function agentSessionsEnabled(env = process.env) {
+    return env.OXYGEN_DEPLOY_ENV === "selfhost-dev" && env.OXYGEN_AGENT_SESSIONS_ENABLED === "staff" && env.OXYGEN_AGENTS_ENABLED?.trim().toLowerCase() === "true";
+}
+export function agentSessionsAvailableTo(env, viewer) {
+    return agentSessionsEnabled(env) && viewer.member && viewer.oxygenRole !== "client" && isStaffEmail(viewer.email, env);
+}
+/** Reviewed native adapters. Unknown tools (including generic dispatch and agent management) fail closed. */
+export const AGENT_SESSION_ADAPTERS = {
+    oxygen_sequences_get: { resource: "sequences", field: "sequence", read: true },
+    oxygen_sequences_analytics: { resource: "sequences", field: "sequence", read: true },
+    oxygen_sequences_contacts: { resource: "sequences", field: "sequence", read: true },
+    oxygen_sequences_enrollments: { resource: "sequences", field: "sequence", read: true },
+    oxygen_sequences_enroll: { resource: "sequences", field: "sequence", read: false },
+    oxygen_sequences_set_status: { resource: "sequences", field: "sequence", read: false },
+    oxygen_tables_describe: { resource: "tables", field: "table", read: true },
+    oxygen_table_rows_page: { resource: "tables", field: "table", read: true },
+    oxygen_table_row_inspect: { resource: "tables", field: "table", read: true },
+    oxygen_rows_upsert: { resource: "tables", field: "table", read: false },
+    oxygen_rows_update: { resource: "tables", field: "table", read: false },
+    oxygen_tables_dedupe: { resource: "tables", field: "table", read: false },
+    oxygen_inbox_get: { resource: "conversations", field: "conversation", read: true },
+    oxygen_inbox_set_status: { resource: "conversations", field: "conversation", read: false },
+    oxygen_inbox_send: { resource: "conversations", field: "conversation", read: false },
+    oxygen_mailboxes_get: { resource: "mailboxes", field: "mailbox", read: true },
+    oxygen_mailboxes_set_status: { resource: "mailboxes", field: "mailbox", read: false },
+    oxygen_mailboxes_set_cap: { resource: "mailboxes", field: "mailbox", read: false },
+    oxygen_crm_record_get: { resource: "records", field: "row_id", read: true },
+    oxygen_crm_notes_list: { resource: "records", field: "row_id", read: true },
+    oxygen_crm_notes_add: { resource: "records", field: "row_id", read: false },
+    oxygen_crm_record_timeline: { resource: "records", field: "row_id", read: true },
+    oxygen_crm_merge: { resource: "objects", field: "object", read: false },
+    oxygen_crm_record_search: { resource: "objects", field: "objects", read: true, array: true },
+    oxygen_crm_pipeline: { resource: "objects", field: "", read: true, fixed: "deals" },
+    oxygen_crm_duplicates: { resource: "objects", field: "object", read: true },
+    oxygen_knowledge_page_get: { resource: "knowledge", field: "slug", read: true },
+    oxygen_knowledge_page_upsert: { resource: "knowledge", field: "page.slug", read: false },
+    oxygen_find_company: { resource: "domains", field: "domain", read: false },
+};
+const CONTEXT_READS = new Set([
+    "oxygen_capabilities_search", "oxygen_capabilities_schema", "oxygen_skills_list", "oxygen_skills_get",
+    "oxygen_knowledge_index", "oxygen_knowledge_search", "oxygen_workspace_get", "oxygen_enrichment_catalog",
+]);
+export function isAgentSessionCapability(name) { return CONTEXT_READS.has(name) || Boolean(AGENT_SESSION_ADAPTERS[name]); }
+export function agentSessionCapabilityDecision(config, name, args) {
+    if (CONTEXT_READS.has(name))
+        return "allow";
+    const adapter = AGENT_SESSION_ADAPTERS[name];
+    if (!adapter)
+        return "deny";
+    // No alternate aggregate scope may widen a resource-specific read.
+    if (["campaigns", "senders", "account", "crm_object", "ignore_sender_bindings"].some(key => args[key] !== undefined && args[key] !== false))
+        return "deny";
+    if (args.from_table !== undefined && args.from_table !== false && name !== "oxygen_sequences_enroll")
+        return "deny";
+    if (name === "oxygen_find_company" && (args.name !== undefined || args.linkedin_url !== undefined || typeof args.domain !== "string" || !/^[a-z0-9.-]+\.[a-z]{2,}$/i.test(args.domain)))
+        return "deny";
+    if (args.sender_account_id !== undefined && (name !== "oxygen_inbox_send" || typeof args.sender_account_id !== "string" || !config.resources.mailboxes.includes(args.sender_account_id)))
+        return "ask";
+    if (name === "oxygen_knowledge_page_upsert" && args.page && typeof args.page === "object" && "id" in args.page)
+        return "deny";
+    if (name === "oxygen_knowledge_page_get" && args.id !== undefined)
+        return "deny";
+    const ref = adapter.fixed ?? adapter.field.split(".").reduce((value, key) => value && typeof value === "object" ? value[key] : undefined, args);
+    if (adapter.array) {
+        if (!Array.isArray(ref) || !ref.length || ref.some(value => typeof value !== "string" || value.includes(",")))
+            return "deny";
+        return ref.every(value => config.resources[adapter.resource].includes(value)) ? "allow" : "ask";
+    }
+    if (typeof ref !== "string" || !ref || ref.includes(","))
+        return "deny";
+    if (!config.resources[adapter.resource].includes(ref))
+        return "ask";
+    if (name === "oxygen_sequences_set_status" && args.status !== "paused")
+        return "ask";
+    return adapter.read || config.actions.includes(name) ? "allow" : "ask";
+}
+export const EMPTY_AGENT_SESSION_RESOURCES = {
+    sequences: [], tables: [], conversations: [], mailboxes: [], records: [], objects: [], knowledge: [], domains: [],
+};
+export const AGENT_SESSION_EVENT_RESOURCES = {
+    sequence_id: "sequences", table_id: "tables", conversation_id: "conversations",
+    mailbox_id: "mailboxes", row_id: "records", record_id: "records",
+};
+export const AGENT_SESSION_EVENTS = WORKSPACE_EVENT_CATALOG.filter(event => Object.keys(AGENT_SESSION_EVENT_RESOURCES).some(key => event.payloadFields.includes(key)));
+export function agentSessionEventIsScoped(config, payload) {
+    return Object.entries(AGENT_SESSION_EVENT_RESOURCES).some(([key, resource]) => typeof payload[key] === "string" && config.resources[resource].includes(payload[key]));
+}
+export const AGENT_SESSION_TEMPLATES = [
+    { id: "campaign-monitor", title: "Campaign monitor", goal: "Watch this native campaign. Compare sends, replies and meetings with earlier reviews; explain changes, propose improvements and schedule the next review.", resources: ["sequences"], actions: ["oxygen_sequences_set_status"], events: ["sequencer.contact_activity.any"] },
+    { id: "lead-replenishment", title: "Lead replenishment", goal: "Maintain a qualified lead pool in the selected Table for this native campaign. Research gaps, deduplicate and enroll only qualified leads within the approved scope.", resources: ["tables", "sequences"], actions: ["oxygen_rows_upsert", "oxygen_sequences_enroll"], events: [] },
+    { id: "reply-handling", title: "Reply handling", goal: "Review the selected conversations, remember prior responses, qualify intent and draft replies. Send only when explicitly authorized; hand off uncertain or sensitive replies.", resources: ["conversations"], actions: ["oxygen_inbox_set_status"], events: ["crm.email_reply_classified"] },
+    { id: "deliverability", title: "Deliverability", goal: "Watch the selected mailboxes for sending health changes. Explain evidence and recommend or apply only approved cap and status adjustments.", resources: ["mailboxes"], actions: ["oxygen_mailboxes_set_cap", "oxygen_mailboxes_set_status"], events: [] },
+    { id: "account-research", title: "Account research", goal: "Maintain cited account research for the selected records and knowledge pages. Track changes and recommend next actions; keep facts separate from hypotheses.", resources: ["records", "knowledge"], actions: ["oxygen_crm_notes_add", "oxygen_knowledge_page_upsert"], events: [] },
+    { id: "inbound-qualification", title: "Inbound qualification", goal: "Qualify the selected inbound conversations and records against workspace ICP and product knowledge. Record evidence and recommendations; hand off high intent to a person.", resources: ["conversations", "records"], actions: ["oxygen_inbox_set_status", "oxygen_crm_notes_add"], events: ["crm.email_reply_classified"] },
+    { id: "crm-hygiene", title: "CRM hygiene", goal: "Review the selected CRM objects for duplicates and missing or inconsistent fields. Propose repairs with evidence, and apply only explicitly authorized changes.", resources: ["objects"], actions: ["oxygen_crm_merge"], events: [] },
+    { id: "pipeline-review", title: "Pipeline review", goal: "Review the selected pipeline and lifecycle stages. Remember earlier reviews, identify stalled opportunities and recommend the next action with evidence.", resources: ["objects", "records"], actions: ["oxygen_crm_notes_add"], events: [] },
+];
+export function validateAgentSessionConfig(config, requireResources = true) {
+    const fail = (message) => { throw new OxygenError("invalid_session_config", message); };
+    if (!config.title?.trim() || !config.goal?.trim())
+        fail("A title and goal are required.");
+    if (config.template !== "custom" && !AGENT_SESSION_TEMPLATES.some(t => t.id === config.template))
+        fail("Unknown session template.");
+    const { per_run_credits: perRun, daily_credits: daily, lifetime_credits: lifetime } = config.budget;
+    if (!Number.isFinite(perRun) || perRun <= 0 || perRun > 25000 || !Number.isFinite(daily) || daily < perRun)
+        fail("Set positive per-run and rolling daily caps; daily must cover one run and per-run cannot exceed 25,000 credits.");
+    if (lifetime !== undefined && (!Number.isFinite(lifetime) || lifetime < perRun))
+        fail("The lifetime cap must cover one run.");
+    const { interval_minutes: interval, min_interval_minutes: min, max_interval_minutes: max } = config.schedule;
+    if (![interval, min, max].every(Number.isFinite) || min < 5 || max < min || interval < min || interval > max || max > 525600)
+        fail("The check interval must fit approved bounds (at least five minutes).");
+    if (config.ends_at && !Number.isFinite(Date.parse(config.ends_at)))
+        fail("Use an ISO date for the end time.");
+    if (config.actions.some(name => !AGENT_SESSION_ADAPTERS[name] || AGENT_SESSION_ADAPTERS[name].read))
+        fail("Choose a reviewed native action.");
+    if (config.events.some(id => !AGENT_SESSION_EVENTS.some(event => event.id === id)))
+        fail("Choose an event that can match the session's selected resources.");
+    for (const values of Object.values(config.resources)) {
+        if (!Array.isArray(values) || values.some(ref => typeof ref !== "string" || !ref.trim() || ref.includes(",") || ref === "*"))
+            fail("Resources require exact native IDs or slugs.");
+    }
+    const template = AGENT_SESSION_TEMPLATES.find(t => t.id === config.template);
+    if (requireResources && config.events.some(id => {
+        const event = AGENT_SESSION_EVENTS.find(entry => entry.id === id);
+        return !Object.entries(AGENT_SESSION_EVENT_RESOURCES).some(([key, resource]) => event.payloadFields.includes(key) && config.resources[resource].length);
+    }))
+        fail("Select a matching resource for each event before activating.");
+    if (requireResources && template?.resources.some(key => !config.resources[key]?.length))
+        fail("Select the template's required resources before activating.");
+}

package/node_modules/@oxygen/shared/dist/app-storage-maintenance.d.ts

@@ -0,0 +1,3 @@
+/** Storage cutovers pause writes without disabling reads or observability. */
+export declare function isAppStorageWritePaused(env?: Record<string, string | undefined>): boolean;
+export declare function assertAppStorageWriteAllowed(env?: Record<string, string | undefined>): void;

package/node_modules/@oxygen/shared/dist/app-storage-maintenance.js

@@ -0,0 +1,16 @@
+import { OxygenError } from "./cli-result.js";
+/** Storage cutovers pause writes without disabling reads or observability. */
+export function isAppStorageWritePaused(env = process.env) {
+    return /^(1|true|yes|on)$/i.test(env.OXYGEN_APP_STORAGE_WRITE_PAUSED?.trim() ?? "");
+}
+export function assertAppStorageWriteAllowed(env = process.env) {
+    if (isAppStorageWritePaused(env)) {
+        throw new OxygenError("maintenance_in_progress", "File uploads are temporarily paused. Try again shortly.", {
+            exitCode: 1,
+            details: {
+                retry_after_seconds: 30,
+                next_step: "Retry after file maintenance finishes.",
+            },
+        });
+    }
+}

package/node_modules/@oxygen/shared/dist/capability-discovery.js

@@ -382,7 +382,9 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         // The sign-off terms are here because a 2026-09-29 blind user searched
         // "preview rendered message per sender sign-off variable" and landed on
         // collaboration; the {{sender_*}} copy variables live on sequence steps.
-        intentTerms: ["sequence", "campaign", "cadence", "enroll", "outreach", "linkedin message", "linkedin dm", "nurture", "follow up", "sender rotation", "stop on reply", "company replied", "pause company", "pause outreach to a company", "stop outreach to a company", "stop emailing a company", "colleagues", "do not contact a company", "sender identity", "sending identity", "sender profile", "phone number", "dialing", "dialer", "call", "cold call", "smartlead", "instantly", "lemlist", "heyreach", "external sequencer", "push to campaign", "push rows to campaign", "add leads to campaign", "sign-off", "sign off", "signature", "sender name", "sender first name", "sender variable", "sender_first_name"],
+        // A/B tests are Sequence step variants: "pause a losing A/B variant" ranked
+        // Table-run pauses first (2026-10-10 parity audit).
+        intentTerms: ["a/b test", "a/b variant", "ab test", "split test", "auto-winner", "winning variant", "losing variant", "sequence", "campaign", "cadence", "enroll", "outreach", "linkedin message", "linkedin dm", "nurture", "follow up", "sender rotation", "stop on reply", "company replied", "pause company", "pause outreach to a company", "stop outreach to a company", "stop emailing a company", "colleagues", "do not contact a company", "sender identity", "sending identity", "sender profile", "phone number", "dialing", "dialer", "call", "cold call", "smartlead", "instantly", "lemlist", "heyreach", "external sequencer", "push to campaign", "push rows to campaign", "add leads to campaign", "sign-off", "sign off", "signature", "sender name", "sender first name", "sender variable", "sender_first_name"],
     },
     {
         id: "publishing",
@@ -421,13 +423,13 @@ export const OXYGEN_CAPABILITY_ROUTES = [
         primitive: "agents",
         owns: "Adaptive governed worker definitions, versions, authorization, context, triggers, threads, checkpoints, inference, and first-class runs.",
         notFor: "A known deterministic graph that belongs in Workflows or an opaque uploaded runtime.",
-        execution: "Publish and run a hosted governed Agent with explicit tool authority and a separate bounded spend ceiling.",
+        execution: "Publish and run a governed Agent with explicit tool authority and bounded spend. Staff on dev can create ongoing sessions: draft, exact resource scope, per-run and rolling 24-hour caps, preview/activate, continuing conversation and bounded self-scheduling. Inspect agent session templates; pause/resume preserves history.",
         posture: "mixed",
         gatewayTools: ["oxygen_agent_list", "oxygen_agent_create", "oxygen_agent_run"],
         gatewayCommands: ["agent list", "agent create", "agent run"],
         skills: ["oxygen-gtm"],
         endpointSections: ["agent", "notetaker"],
-        intentTerms: ["agent", "adaptive", "goal directed", "autonomous", "persistent thread", "checkpoint", "standing job", "notetaker"],
+        intentTerms: ["agent", "adaptive", "goal directed", "autonomous", "persistent thread", "checkpoint", "standing job", "notetaker", "ongoing worker", "ongoing session", "watch a campaign", "watch one campaign", "campaign monitor", "remember earlier reviews", "rolling daily", "long horizon", "long session"],
     },
     {
         id: "observability",
@@ -1076,6 +1078,12 @@ function routeCardFor(card, query) {
             ...card,
             execution: "Create a workspace-private Table or inspect its schema and rows. Manual rows, column labels, visibility and member favorites cost 0 credits. Change only the display label with columns update (oxygen_columns_update); columns rename (oxygen_columns_rename) requires a new stable key. Favorite one table or folder with tables favorite (oxygen_tables_favorite), then read tables favorites (oxygen_tables_favorites). For tidy guidance, read oxygen-table-tidy with skills get (oxygen_skills_get); tables tidy-suggest (oxygen_tables_tidy_suggest) analyzes without changes. Read the owning schema, apply the requested scope, then describe or query the Table to verify it.",
         };
+    if (card.primitive === "tables" && isTableInventoryIntent(query))
+        card = {
+            ...card,
+            posture: "read_only",
+            execution: "List or count this workspace's Tables with tables list (oxygen_tables_list): `total` counts every Table the filters cover, while each page holds a window (MCP 50) with nextCursor for the rest. Archived Tables are excluded unless include_archived; narrow by project, tag or a name query. Free.",
+        };
     const recordsCopy = card.primitive === "tables" ? recordsTableImportRecommendation(query) : null;
     if (recordsCopy)
         card = { ...card, posture: "workspace_write", execution: recordsCopy.execution };
@@ -1488,6 +1496,21 @@ function isWorkspaceSettingsIntent(query) {
     return /\b(workspace|organi[sz]ations?|orgs?|team)\s+settings?\b/.test(query)
         || /\bsettings?\s+(?:for|of)\s+(?:the |my |our |this )?(workspace|organi[sz]ation|org|team)\b/.test(query);
 }
+/**
+ * "How many tables do I have?", "list my tables": the workspace's own table
+ * inventory, which `tables list` answers with its `total`. Live on dev
+ * (2026-10-10), "How many tables are in this workspace?" routed to
+ * workspace-access on its "workspace" term, and the Tables card led with
+ * creation and enrichment, so a Copilot turn searched three times before it
+ * found the list.
+ */
+function isTableInventoryIntent(query) {
+    if (!/\btables\b/.test(query))
+        return false;
+    if (/\b(create|add|new|build|make|import\w*|enrich\w*|delete|remove|rename|archive|duplicate|copy|link|join|merge|rows?|columns?|cells?|largest|biggest|sizes?|favou?rites?|starred|webhooks?|feeds?|functions?|callables?|views?|crm|records?|agents?|workflows?|sequences?|limits?|plan|allow\w*|quota|capacity|teammates?)\b/.test(query))
+        return false;
+    return /\b(how many|count|number of|list|show|which|what)\b/.test(query);
+}
 function isTableCapacityReadIntent(query) {
     if (/\b(monitor|watch|workflow|automate|automation|increase|resize|upgrade)\b/.test(query))
         return false;
@@ -1844,7 +1867,8 @@ function isSpintaxIntent(query) {
     // unrelated physical variants keep their existing owners.
     if (/\bspintax\b/.test(query))
         return true;
-    if (/\b(posts?|publishing|ugc|visuals?|images?|videos?|scoreboard|stats|statistics|performance|winners?)\b/.test(query))
+    // Rendering copy that exists is sequences render, not new variations.
+    if (/\b(posts?|publishing|ugc|visuals?|images?|videos?|scoreboard|stats|statistics|performance|winners?|render|preview)\b/.test(query))
         return false;
     return /\b(wording|copy|message|draft|subject(?: line)?)\b.{0,45}\b(variations?|variants?|paraphrase|rewrite)\b/.test(query)
         || /\b(paraphrase|rewrite|variations?)\b.{0,45}\b(wording|copy|message|draft|subject(?: line)?)\b/.test(query);
@@ -1901,6 +1925,8 @@ function explicitCapabilityIntent(query) {
         return ROUTE_BY_ID.get("collaboration") ?? null;
     if (tableReadRecommendation(query) || tableMaintenanceRecommendation(query))
         return ROUTE_BY_PRIMITIVE.get("tables") ?? null;
+    if (isTableInventoryIntent(query))
+        return ROUTE_BY_PRIMITIVE.get("tables") ?? null;
     if (/\btables?\b/.test(query) && /\b(navigation|nav|paging|pagination)\b/.test(query)) {
         return ROUTE_BY_PRIMITIVE.get("tables") ?? null;
     }
@@ -2493,6 +2519,13 @@ function recommendationsFor(card, query) {
         const maintenance = tableMaintenanceRecommendation(query);
         if (maintenance)
             return maintenance;
+        if (isTableInventoryIntent(query))
+            return {
+                tools: ["oxygen_tables_list", "oxygen_workspace_map"],
+                commands: ["tables list", "workspace map"],
+                exactCommand: "oxygen tables list --json",
+                exactMcpCall: { tool: "oxygen_tables_list", arguments: {} },
+            };
         const structure = tableStructureRecommendation(query);
         if (structure)
             return structure;
@@ -2694,6 +2727,9 @@ function recommendationsFor(card, query) {
                 commands: ["sequences enrollments", "sequences stats", "sequences list"],
             };
         }
+        const edit = sequenceEditRecommendation(query);
+        if (edit)
+            return edit;
         if (isNetNewLinkedInInitiation(query)) {
             const publicResearch = isPublicLinkedInRead(query);
             const harvestEngagers = publicResearch && isPublicLinkedInEngagerHarvest(query);
@@ -2900,6 +2936,43 @@ function isCompanyUrlRecoveryIntent(query) {
 function isInboxAvatarIntent(query) {
     return /\b(avatar|profile (?:picture|photo)|headshot|hosted (?:picture|image)|mailbox (?:picture|photo))\b/.test(query);
 }
+/**
+ * Changing a Sequence that exists: its copy rendered, a copy of it, its A/B
+ * decisions, or its senders, caps, steps and settings. The 2026-10-10 parity
+ * audit searched "change the sender of my sequence" and "remove the daily send
+ * cap" and got create/enroll/start/list, never oxygen_sequences_update, which
+ * reads as "the API cannot modify the sender".
+ */
+function sequenceEditRecommendation(query) {
+    if (/\b(launch|go live)\b/.test(query))
+        return null;
+    if (/\b(render|preview|see|show|look)\b/.test(query) && /\b(copy|emails?|messages?|variants?|subjects?|body|bodies|notes?)\b/.test(query)) {
+        return {
+            tools: ["oxygen_sequences_render", "oxygen_sequences_variants", "oxygen_sequences_get"],
+            commands: ["sequences render", "sequences variants", "sequences get"],
+        };
+    }
+    if (/\b(duplicate|clone)\b/.test(query) || /\bcopy (?:of )?(?:a |the |my |this )?(?:running |live |started |active )?(?:sequence|campaign)\b/.test(query)) {
+        return {
+            tools: ["oxygen_sequences_duplicate", "oxygen_sequences_get", "oxygen_sequences_update"],
+            commands: ["sequences duplicate", "sequences get", "sequences update"],
+        };
+    }
+    if (/\b(variants?|a\/b|ab tests?|split tests?)\b/.test(query) && /\b(pause|activate|reactivate|reset|winner|winning|losing|loser|auto[- ]?optimi[sz]e|pick)\b/.test(query)) {
+        return {
+            tools: ["oxygen_sequences_variants_action", "oxygen_sequences_variants", "oxygen_sequences_update"],
+            commands: ["sequences variants", "sequences update"],
+        };
+    }
+    if (/\b(change|switch|swap|replace|remove|edit|update|set|clear|unset|turn (?:on|off)|raise|lower|increase|decrease|reduce)\b/.test(query)
+        && /\b(senders?|sending accounts?|accounts?|inbox(?:es)?|mailbox(?:es)?|caps?|limits?|daily|steps?|copy|variants?|delays?|waits?|settings?|tracking)\b/.test(query)) {
+        return {
+            tools: ["oxygen_sequences_update", "oxygen_sequences_get", "oxygen_senders_list"],
+            commands: ["sequences update", "sequences get", "senders list"],
+        };
+    }
+    return null;
+}
 function isSenderProfileIntent(query) {
     return /\b(?:sender|sending|unified)\s+(?:profiles?|identit(?:y|ies))\b/.test(query)
         || (/\bprofiles?\b.{0,64}\b(?:linkedin|whatsapp|mailboxes?|inboxes?|email)\b/.test(query)

package/node_modules/@oxygen/shared/dist/contracts/agent-sessions.d.ts

@@ -0,0 +1,72 @@
+import type { OperationSpec } from "./operations.js";
+export declare const AGENT_SESSION_CONFIG_CONTRACT: import("./schema.js").ContractObject<{
+    readonly title: import("./schema.js").StringProperty;
+    readonly goal: import("./schema.js").StringProperty;
+    readonly template: import("./schema.js").StringProperty;
+    readonly resources: import("./schema.js").ContractObject<{
+        readonly sequences: import("./schema.js").ArrayProperty<import("./schema.js").StringProperty>;
+        readonly tables: import("./schema.js").ArrayProperty<import("./schema.js").StringProperty>;
+        readonly conversations: import("./schema.js").ArrayProperty<import("./schema.js").StringProperty>;
+        readonly mailboxes: import("./schema.js").ArrayProperty<import("./schema.js").StringProperty>;
+        readonly records: import("./schema.js").ArrayProperty<import("./schema.js").StringProperty>;
+        readonly objects: import("./schema.js").ArrayProperty<import("./schema.js").StringProperty>;
+        readonly knowledge: import("./schema.js").ArrayProperty<import("./schema.js").StringProperty>;
+        readonly domains: import("./schema.js").ArrayProperty<import("./schema.js").StringProperty>;
+    }, "conversations" | "domains" | "knowledge" | "mailboxes" | "objects" | "records" | "sequences" | "tables">;
+    readonly actions: {
+        readonly type: "array";
+        readonly items: import("./schema.js").StringProperty;
+        readonly minItems?: number;
+        readonly maxItems?: number;
+        readonly description: "Optional standing write permissions from the template catalog. Empty means scoped reads only; template suggestions are never automatically granted.";
+    };
+    readonly events: import("./schema.js").ArrayProperty<import("./schema.js").StringProperty>;
+    readonly schedule: import("./schema.js").ContractObject<{
+        readonly interval_minutes: {
+            type: "integer";
+            description?: string;
+            minimum?: number;
+            maximum?: number;
+            "x-clamp"?: true;
+        };
+        readonly min_interval_minutes: {
+            type: "integer";
+            description?: string;
+            minimum?: number;
+            maximum?: number;
+            "x-clamp"?: true;
+        };
+        readonly max_interval_minutes: {
+            type: "integer";
+            description?: string;
+            minimum?: number;
+            maximum?: number;
+            "x-clamp"?: true;
+        };
+    }, "interval_minutes" | "max_interval_minutes" | "min_interval_minutes">;
+    readonly budget: import("./schema.js").ContractObject<{
+        readonly per_run_credits: {
+            type: "number";
+            description?: string;
+            minimum?: number;
+            maximum?: number;
+            "x-clamp"?: true;
+        };
+        readonly daily_credits: {
+            type: "number";
+            description?: string;
+            minimum?: number;
+            maximum?: number;
+            "x-clamp"?: true;
+        };
+        readonly lifetime_credits: {
+            type: "number";
+            description?: string;
+            minimum?: number;
+            maximum?: number;
+            "x-clamp"?: true;
+        };
+    }, "daily_credits" | "per_run_credits">;
+    readonly ends_at: import("./schema.js").StringProperty;
+}, "actions" | "budget" | "events" | "goal" | "resources" | "schedule" | "template" | "title">;
+export declare const AGENT_SESSION_OPERATIONS: readonly OperationSpec[];

package/node_modules/@oxygen/shared/dist/contracts/agent-sessions.js

@@ -0,0 +1,35 @@
+import { arr, bool, int, num, obj, str } from "./schema.js";
+const strings = () => arr(str({ minLength: 1 }), { maxItems: 100 });
+export const AGENT_SESSION_CONFIG_CONTRACT = obj({
+    title: str({ minLength: 1, maxLength: 160 }), goal: str({ minLength: 1, maxLength: 16000 }),
+    template: str({ minLength: 1 }),
+    resources: obj({ sequences: strings(), tables: strings(), conversations: strings(), mailboxes: strings(), records: strings(), objects: strings(), knowledge: strings(), domains: strings() }, { required: ["sequences", "tables", "conversations", "mailboxes", "records", "objects", "knowledge", "domains"] }),
+    actions: { ...strings(), description: "Optional standing write permissions from the template catalog. Empty means scoped reads only; template suggestions are never automatically granted." }, events: strings(),
+    schedule: obj({ interval_minutes: int({ minimum: 5, description: "Default cadence in minutes; 1440 means one day." }), min_interval_minutes: int({ minimum: 5, description: "Earliest permitted interval when the Agent requests its next check." }), max_interval_minutes: int({ minimum: 5, maximum: 525600, description: "Latest permitted interval when the Agent requests its next check." }) }, { required: ["interval_minutes", "min_interval_minutes", "max_interval_minutes"] }),
+    budget: obj({ per_run_credits: num({ minimum: 0.01, maximum: 25000, description: "Credit cap for each check, including inference and paid tools. The host reserves this full cap before starting." }), daily_credits: num({ minimum: 0.01, description: "Rolling 24-hour credit cap. Settled costs count for 24 hours; unresolved costs remain held until settled." }), lifetime_credits: num({ minimum: 0.01, description: "Optional total credit cap across all checks in this session." }) }, { required: ["per_run_credits", "daily_credits"] }),
+    ends_at: str({ description: "Optional ISO end time." }),
+}, { required: ["title", "goal", "template", "resources", "actions", "events", "schedule", "budget"] });
+function agentSessionOperation(id, verb, method, suffix, summary, fields = {}, required = [], spends = false) {
+    const route = `/api/cli/agent/{slug}/sessions${suffix}`;
+    return {
+        id, route, method,
+        parameters: [...route.matchAll(/\{(\w+)\}/g)].map(match => match[1]),
+        contract: obj(fields, { required }), cli: { path: ["agent", "session", verb], summary },
+        mcp: { name: `oxygen_agent_session_${verb}`, title: `Oxygen: Agent session ${verb}`, description: summary, pack: "agents" },
+        mutates: method !== "GET", spends,
+    };
+}
+export const AGENT_SESSION_OPERATIONS = [
+    agentSessionOperation("agent.sessions.templates", "templates", "GET", "/templates", "Discover eight ongoing Agent job templates, reviewed actions, required resources, the full config schema and a draft example. Staff on dev only; legacy Agents remain available."),
+    agentSessionOperation("agent.sessions.list", "list", "GET", "", "List independent ongoing sessions under an Agent, including status, next check and spend."),
+    agentSessionOperation("agent.sessions.create", "create", "POST", "", "Create a draft ongoing session. Explicit caps are required; review and activate separately.", { config: AGENT_SESSION_CONFIG_CONTRACT }, ["config"]),
+    agentSessionOperation("agent.sessions.get", "get", "GET", "/{session}", "Read this session's configuration revision, conversation, memory, next check, approvals and budget reservations."),
+    agentSessionOperation("agent.sessions.configure", "configure", "PATCH", "/{session}", "Replace settings at the expected revision. Clears standing authority and pauses active work; review again before activation.", { revision: int({ minimum: 1 }), config: AGENT_SESSION_CONFIG_CONTRACT }, ["revision", "config"]),
+    agentSessionOperation("agent.sessions.preview", "preview", "POST", "/{session}/preview", "Preview the exact pinned Agent version, resource scope, actions, schedule and caps. Returns the revision and approval token; starts no inference."),
+    agentSessionOperation("agent.sessions.activate", "activate", "POST", "/{session}/activate", "Approve the exact preview revision and activate scoped standing authority. Starts bounded inference. A cap above default_max_credits requires separate approve_above_default=true. Later settings changes require a fresh preview.", { revision: int({ minimum: 1 }), preview_token: str({ minLength: 1 }), approved: bool(), approve_above_default: bool({ description: "Separately approve a per-run cap above the workspace's default Agent ceiling." }) }, ["revision", "preview_token", "approved"], true),
+    agentSessionOperation("agent.sessions.message", "message", "POST", "/{session}/messages", "Queue durable human steering. Draft chat proposes settings for review; active chat resumes the same memory. A bounded run reserves the approved per-run cap.", { message: str({ minLength: 1, maxLength: 16000 }), idempotency_key: str({ minLength: 1, maxLength: 200 }) }, ["message", "idempotency_key"], true),
+    agentSessionOperation("agent.sessions.pause", "pause", "POST", "/{session}/pause", "Pause this ongoing session, retaining conversation and run history."),
+    agentSessionOperation("agent.sessions.resume", "resume", "POST", "/{session}/resume", "Resume this ongoing session. Requires unchanged approved settings.", {}, [], true),
+    agentSessionOperation("agent.sessions.complete", "complete", "POST", "/{session}/complete", "Complete this ongoing session, retaining conversation and run history."),
+    agentSessionOperation("agent.sessions.archive", "archive", "POST", "/{session}/archive", "Archive this ongoing session, retaining conversation and run history."),
+];

package/node_modules/@oxygen/shared/dist/contracts/browser-operations.js

@@ -122,4 +122,5 @@ export const BROWSER_OPERATIONS = [
     operation("notetaker.note.edit", "/api/cli/notetaker/sessions/{session}/note", "PATCH", "notetaker notes edit", "oxygen_notetaker_note_edit", "crm", "Save the markdown note for one meeting session and return the committed note.", { markdown: text() }, ["markdown"]),
     operation("orgs.create", "/api/cli/orgs/create", "POST", "orgs create", "oxygen_workspace_create", "workspace", "Create a workspace for the authenticated person's account and begin native company setup. Workspace API keys cannot create personal workspaces.", { name: text(), company_domain: text("Company website or domain, or its LinkedIn company page URL when it has no website."), linkedin_profile_url: text("Creator's LinkedIn profile URL, separate from the company's page.") }, ["name", "company_domain"]),
     operation("onboarding.complete", "/api/cli/onboarding/complete", "POST", "onboarding complete", "oxygen_onboarding_complete", "workspace", "Complete the active workspace's onboarding step and record its discovery-source choices. The other choice requires source_other.", { sources: arr(enumOf(["linkedin_content", "linkedin_dm", "linkedin_ads", "x", "youtube", "google", "email", "word_of_mouth", "referral", "event", "other"])), source_other: text(), redirect_url: text() }, ["sources"]),
+    operation("onboarding.start", "/api/cli/onboarding/start", "POST", "onboarding start", "oxygen_onboarding_start", "workspace", "Answer onboarding's choice card. own_agent continues to connecting your own agent. copilot opens the Workspace Copilot with the onboarding conversation already started, billed in credits like any Copilot turn; choosing again reopens that conversation.", { path: enumOf(["own_agent", "copilot"]), play: text("A play slug carried to the install step.") }, ["path"], { spends: true }),
 ];

package/node_modules/@oxygen/shared/dist/contracts/operations.js

@@ -12,6 +12,7 @@ import { BROWSER_OPERATIONS } from "./browser-operations.js";
 import { TABLE_FEED_UPDATE_OPERATION } from "./table-feed-update.js";
 import { GEO_OPERATIONS } from "./geo.js";
 import { CUSTOMER_OPERATIONS } from "./customer-operations.js";
+import { AGENT_SESSION_OPERATIONS } from "./agent-sessions.js";
 /** The route with its `{param}` segments filled in, each URL-encoded. */
 export function operationPath(spec, params) {
     return spec.route.replace(/\{(\w+)\}/g, (_match, name) => {
@@ -81,6 +82,6 @@ export function operationFormData(spec, body) {
     }
     return form;
 }
-export const OPERATION_SPECS = [SENDER_LIMITS_SET_OPERATION, CONNECTOR_UPDATE_OPERATION, CONNECTOR_EVENTS_REVOKE_OPERATION, WORKSPACE_PAGES_GET_OPERATION, WORKSPACE_PAGES_UPDATE_OPERATION, TABLE_FEED_UPDATE_OPERATION, ...CUSTOMER_OPERATIONS, ...GEO_OPERATIONS, ...BROWSER_OPERATIONS];
-export const CLI_OPERATIONS = [...CUSTOMER_OPERATIONS, ...GEO_OPERATIONS, ...BROWSER_OPERATIONS].filter((spec) => spec.generated?.cli !== false);
-export const MCP_OPERATIONS = [...CUSTOMER_OPERATIONS, ...GEO_OPERATIONS, ...BROWSER_OPERATIONS].filter((spec) => spec.generated?.mcp !== false);
+export const OPERATION_SPECS = [SENDER_LIMITS_SET_OPERATION, CONNECTOR_UPDATE_OPERATION, CONNECTOR_EVENTS_REVOKE_OPERATION, WORKSPACE_PAGES_GET_OPERATION, WORKSPACE_PAGES_UPDATE_OPERATION, TABLE_FEED_UPDATE_OPERATION, ...CUSTOMER_OPERATIONS, ...GEO_OPERATIONS, ...BROWSER_OPERATIONS, ...AGENT_SESSION_OPERATIONS];
+export const CLI_OPERATIONS = [...CUSTOMER_OPERATIONS, ...GEO_OPERATIONS, ...BROWSER_OPERATIONS, ...AGENT_SESSION_OPERATIONS].filter((spec) => spec.generated?.cli !== false);
+export const MCP_OPERATIONS = [...CUSTOMER_OPERATIONS, ...GEO_OPERATIONS, ...BROWSER_OPERATIONS, ...AGENT_SESSION_OPERATIONS].filter((spec) => spec.generated?.mcp !== false);

package/node_modules/@oxygen/shared/dist/contracts/table-query-grid.d.ts

@@ -17,5 +17,8 @@ export declare const TABLE_QUERY_GRID_CONTRACT: import("./schema.js").ContractOb
 }, never>;
 export declare const TABLE_QUERY_GRID_NATIVE_WINDOW = 10000;
 export declare const TABLE_QUERY_GRID_BUILTIN_WINDOW = 4000;
+export declare const TABLE_QUERY_GRID_COPILOT_WINDOW = 24000;
+/** The window a built-in host reads tables in; other clients have none. */
+export declare function tableQueryBuiltinWindow(surface: string | null | undefined): number | undefined;
 /** Measure the complete native receipt and the escaped built-in host receipt. */
 export declare function tableQueryGridResultFits(data: Record<string, unknown>, maxChars: number | undefined, surface: string | null): boolean;

package/node_modules/@oxygen/shared/dist/contracts/table-query-grid.js

@@ -12,16 +12,28 @@ export const TABLE_QUERY_GRID_NATIVE_WINDOW = 10_000;
 // Deliberately below Strands' shipped 6000 default; counts the complete host
 // object rather than only its text. This changes no adapter's outer ceiling.
 export const TABLE_QUERY_GRID_BUILTIN_WINDOW = 4_000;
+// The Copilot hands its model the structured result alone, whole up to 32,000
+// characters (ADR 0013, amendment 2026-10-10). One qualified row measured 4,537
+// on dev, so the Agent window refused even a single row (eval, 2026-10-11).
+export const TABLE_QUERY_GRID_COPILOT_WINDOW = 24_000;
+/** The window a built-in host reads tables in; other clients have none. */
+export function tableQueryBuiltinWindow(surface) {
+    if (surface === "copilot")
+        return TABLE_QUERY_GRID_COPILOT_WINDOW;
+    return surface === "agent" ? TABLE_QUERY_GRID_BUILTIN_WINDOW : undefined;
+}
 /** Measure the complete native receipt and the escaped built-in host receipt. */
 export function tableQueryGridResultFits(data, maxChars, surface) {
     if (maxChars === undefined)
         return true;
     if (JSON.stringify(success("tables query", data)).length > maxChars)
         return false;
-    if (surface === "agent" || surface === "copilot") {
-        return JSON.stringify({
-            ok: true, text: JSON.stringify(data), structured: { ...data, oxygen_version: OXYGEN_VERSION },
-        }).length <= TABLE_QUERY_GRID_BUILTIN_WINDOW;
+    const structured = { ...data, oxygen_version: OXYGEN_VERSION };
+    if (surface === "agent") {
+        return JSON.stringify({ ok: true, text: JSON.stringify(data), structured }).length <= TABLE_QUERY_GRID_BUILTIN_WINDOW;
+    }
+    if (surface === "copilot") {
+        return JSON.stringify({ ok: true, result: structured }).length <= TABLE_QUERY_GRID_COPILOT_WINDOW;
     }
     return true;
 }

package/node_modules/@oxygen/shared/dist/copilot-access.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Who may use the Workspace Copilot on this deployment (founder, 2026-10-10):
+ * one flag, `OXYGEN_COPILOT_ENABLED`, read only on the two self-hosted
+ * deployments that serve customer workspaces.
+ *
+ * - `off`: `0`, `false`, unset or any unknown value, everywhere.
+ * - `staff`: `staff`, plus the legacy `1` / `true` on dev only. Those opened the
+ *   staff-only dev restoration of 2026-10-09, so dev keeps its meaning.
+ * - `all`: `all`, every workspace member except restricted client logins.
+ *
+ * Production opens only on an explicit `staff` or `all`, never on a legacy
+ * value. Shadow carries production-shaped data and its config still holds
+ * `true`, so it never opens, and neither does local.
+ */
+export type CopilotAudience = "off" | "staff" | "all";
+type Env = Record<string, string | undefined>;
+export declare function copilotAudience(env?: Env): CopilotAudience;
+/**
+ * True for any value that turns the Copilot on for someone, on any deployment.
+ * Historical cost reconciliation keys off this so receipts still settle where
+ * the deployment itself cannot run new turns.
+ */
+export declare function isCopilotFlagOn(env?: Env): boolean;
+export type CopilotViewer = {
+    email: string | null | undefined;
+    /** The workspace membership's OXYGEN role; `client` logins never use the Copilot. */
+    oxygenRole?: string | null | undefined;
+    /** False when the person has no current membership in the workspace. */
+    member: boolean;
+};
+/** Whether this person may open and run the Copilot in this workspace. */
+export declare function isCopilotAvailableTo(env: Env, viewer: CopilotViewer): boolean;
+export {};

package/node_modules/@oxygen/shared/dist/copilot-access.js

@@ -0,0 +1,33 @@
+import { isStaffEmail } from "./staff.js";
+export function copilotAudience(env = process.env) {
+    const deployment = env.OXYGEN_DEPLOY_ENV?.trim().toLowerCase();
+    if (deployment !== "selfhost-dev" && deployment !== "selfhost-prod")
+        return "off";
+    const flag = normalizedFlag(env);
+    if (flag === "all")
+        return "all";
+    if (flag === "staff")
+        return "staff";
+    if (deployment === "selfhost-dev" && (flag === "1" || flag === "true"))
+        return "staff";
+    return "off";
+}
+/**
+ * True for any value that turns the Copilot on for someone, on any deployment.
+ * Historical cost reconciliation keys off this so receipts still settle where
+ * the deployment itself cannot run new turns.
+ */
+export function isCopilotFlagOn(env = process.env) {
+    const flag = normalizedFlag(env);
+    return flag === "1" || flag === "true" || flag === "staff" || flag === "all";
+}
+/** Whether this person may open and run the Copilot in this workspace. */
+export function isCopilotAvailableTo(env, viewer) {
+    const audience = copilotAudience(env);
+    if (audience === "off" || !viewer.member || viewer.oxygenRole === "client")
+        return false;
+    return audience === "all" || isStaffEmail(viewer.email, env);
+}
+function normalizedFlag(env) {
+    return env.OXYGEN_COPILOT_ENABLED?.trim().toLowerCase() ?? "";
+}