@oxygen-agent/cli 1.1014.1035 → 1.1014.1132

package/node_modules/@oxygen/shared/dist/knowledge-links.d.ts

@@ -14,3 +14,32 @@ export type KnowledgeWikilink = {
  * empty key (e.g. [[---]]) are dropped.
  */
 export declare function extractKnowledgeLinks(body: string | null | undefined): KnowledgeWikilink[];
+/**
+ * The exact vault paths, in priority order, and the basename that
+ * resolveKnowledgeVaultLink can match for a [[wikilink]] target written in the
+ * file at `currentPath`. A store fetches only these files and resolves against
+ * them with the same result as against the whole vault. Null when the target is
+ * empty or absolute.
+ */
+export declare function knowledgeVaultLinkCandidates(target: string, currentPath: string): {
+    paths: string[];
+    basename: string | null;
+} | null;
+/**
+ * Resolve a [[wikilink]] target in a repository vault the way Obsidian does: a
+ * bare name prefers the same folder, then the vault-relative path, a path target
+ * is also tried relative to the current folder, and a bare name finally matches
+ * a basename that is unique in the vault. A target without an extension names a
+ * Markdown note. The web file view and the page-link graph both resolve through
+ * here, so a link that opens a note is the edge the graph shows.
+ */
+export declare function resolveKnowledgeVaultLink<T extends {
+    path: string;
+}>(target: string, currentPath: string, files: readonly T[]): T | null;
+/**
+ * Every link key a [[wikilink]] that resolves to the vault file at `path` can
+ * carry: each trailing path suffix, and for a note also without its .md
+ * extension. A new or moved file can satisfy only dangling links with one of
+ * these keys.
+ */
+export declare function knowledgeVaultLinkKeys(path: string): string[];

package/node_modules/@oxygen/shared/dist/knowledge-links.js

@@ -4,7 +4,8 @@
 // here and nowhere else. The regex + alias/heading stripping mirror the vault
 // component's original parser (apps/web/src/components/vault/vault.ts), which
 // now delegates here — [[Target|alias]] and [[Target#heading]] both link to
-// Target.
+// Target. Links inside a connected repository resolve by vault path first
+// (resolveKnowledgeVaultLink), for the mounted file view and the graph alike.
 import { knowledgeLinkKey } from "./knowledge-constants.js";
 const WIKILINK_RE = /\[\[([^\]]+)\]\]/g;
 /**
@@ -36,3 +37,85 @@ export function extractKnowledgeLinks(body) {
     }
     return [...byKey.values()];
 }
+function normalizedVaultPath(candidate) {
+    const normalized = [];
+    for (const segment of candidate.split("/")) {
+        if (!segment || segment === ".")
+            continue;
+        if (segment === "..") {
+            if (!normalized.pop())
+                return null;
+        }
+        else {
+            normalized.push(segment);
+        }
+    }
+    return normalized.join("/") || null;
+}
+/**
+ * The exact vault paths, in priority order, and the basename that
+ * resolveKnowledgeVaultLink can match for a [[wikilink]] target written in the
+ * file at `currentPath`. A store fetches only these files and resolves against
+ * them with the same result as against the whole vault. Null when the target is
+ * empty or absolute.
+ */
+export function knowledgeVaultLinkCandidates(target, currentPath) {
+    const pathTarget = target.split("#", 1)[0]?.trim();
+    if (!pathTarget || pathTarget.startsWith("/"))
+        return null;
+    const withExtension = /\.[^/]+$/.test(pathTarget) ? pathTarget : `${pathTarget}.md`;
+    const directory = currentPath.includes("/") ? currentPath.slice(0, currentPath.lastIndexOf("/")) : "";
+    const paths = [];
+    if (!pathTarget.includes("/"))
+        paths.push(`${directory ? `${directory}/` : ""}${withExtension}`);
+    const vaultPath = normalizedVaultPath(withExtension);
+    if (vaultPath)
+        paths.push(vaultPath);
+    if (pathTarget.includes("/")) {
+        const relativePath = normalizedVaultPath(`${directory}/${withExtension}`);
+        if (relativePath)
+            paths.push(relativePath);
+    }
+    return { paths, basename: pathTarget.includes("/") ? null : withExtension };
+}
+/**
+ * Resolve a [[wikilink]] target in a repository vault the way Obsidian does: a
+ * bare name prefers the same folder, then the vault-relative path, a path target
+ * is also tried relative to the current folder, and a bare name finally matches
+ * a basename that is unique in the vault. A target without an extension names a
+ * Markdown note. The web file view and the page-link graph both resolve through
+ * here, so a link that opens a note is the edge the graph shows.
+ */
+export function resolveKnowledgeVaultLink(target, currentPath, files) {
+    const candidates = knowledgeVaultLinkCandidates(target, currentPath);
+    if (!candidates)
+        return null;
+    for (const path of candidates.paths) {
+        const file = files.find((candidate) => candidate.path === path);
+        if (file)
+            return file;
+    }
+    if (!candidates.basename)
+        return null;
+    const matches = files.filter((file) => file.path.split("/").at(-1) === candidates.basename);
+    return matches.length === 1 ? matches[0] : null;
+}
+/**
+ * Every link key a [[wikilink]] that resolves to the vault file at `path` can
+ * carry: each trailing path suffix, and for a note also without its .md
+ * extension. A new or moved file can satisfy only dangling links with one of
+ * these keys.
+ */
+export function knowledgeVaultLinkKeys(path) {
+    const segments = path.split("/");
+    const keys = new Set();
+    for (let start = segments.length - 1; start >= 0; start -= 1) {
+        const suffix = segments.slice(start).join("/");
+        for (const form of /\.md$/.test(suffix) ? [suffix, suffix.slice(0, -3)] : [suffix]) {
+            const key = knowledgeLinkKey(form);
+            if (key)
+                keys.add(key);
+        }
+    }
+    return [...keys];
+}

package/node_modules/@oxygen/shared/dist/linkedin-sequences.d.ts

@@ -202,17 +202,6 @@ export type LinkedInRefusalScope =
  | "already_engaged"
 /** Unrecognised. Callers MUST preserve their existing behaviour. */
  | "unknown";
-/**
- * Classify a LinkedIn refusal from the provider's own account of it.
- *
- * Deliberately a CLOSED set of anchored, full-string matches, in the same
- * discipline as the sequence-recovery allowlists: matching vendor prose is
- * fragile, so an unrecognised message must degrade to `unknown` and leave the
- * caller's behaviour exactly as it was. Extending the set is an evidence-driven
- * act — callers log what they could not classify.
- *
- * Pure and total; never throws.
- */
 export declare function classifyLinkedInRefusal(input: {
     providerType: string | null;
     providerMessage: string | null;
@@ -394,9 +383,11 @@ export declare function linkedInLimitCautionNotices(metadata: Record<string, unk
 export declare const LINKEDIN_REINVITE_COOLDOWN_DAYS = 21;
 /**
  * Whether a refused invitation is LinkedIn's re-invite cooldown: Unipile answers
- * HTTP 422 with the `cannot_resend_yet` error type. Anchored on the type, with
- * the message as a fallback for the provider shapes that carry the type only in
- * the sentence. Pure and total.
+ * HTTP 422 with the `cannot_resend_yet` error type, or with
+ * `provider/unprocessable_entity` and LinkedIn's "already handled a request from
+ * you in the past 3 weeks" sentence. Anchored on the type, with the message as a
+ * fallback for the provider shapes that carry the type only in the sentence.
+ * Pure and total.
  */
 export declare function isLinkedInReinviteCooldownRefusal(input: {
     status: number | null;

package/node_modules/@oxygen/shared/dist/linkedin-sequences.js

@@ -113,6 +113,14 @@ export const LINKEDIN_INVITE_NOTE_LIMIT_BASIC = 200;
  *
  * Pure and total; never throws.
  */
+/**
+ * LinkedIn's sentence when an invitation is refused because the member handled
+ * an earlier one from this account (accepted, ignored or withdrawn) within three
+ * weeks. Unipile returns it as HTTP 422 `provider/unprocessable_entity`, the v2
+ * client prefixes the title. Verified on dev 2026-10-17 (Unipile req-3i5d,
+ * req-7edn, req-7nsa): no invitation was created.
+ */
+const LINKEDIN_RECENTLY_HANDLED_INVITE_MESSAGE = /^(?:Unprocessable entity: )?This user has already handled a request from you in the past 3 weeks\./u;
 export function classifyLinkedInRefusal(input) {
     const message = typeof input.providerMessage === "string" ? input.providerMessage.trim() : "";
     if (message.length === 0)
@@ -146,7 +154,7 @@ export function classifyLinkedInRefusal(input) {
     }
     if (input.status === 422
         && input.providerType === "provider/unprocessable_entity"
-        && /^Unprocessable entity: This user has already handled a request from you in the past 3 weeks\./u.test(message)) {
+        && LINKEDIN_RECENTLY_HANDLED_INVITE_MESSAGE.test(message)) {
         return "already_engaged";
     }
     if (input.status === 409
@@ -440,14 +448,23 @@ export function linkedInLimitCautionNotices(metadata, overrides) {
 export const LINKEDIN_REINVITE_COOLDOWN_DAYS = 21;
 /**
  * Whether a refused invitation is LinkedIn's re-invite cooldown: Unipile answers
- * HTTP 422 with the `cannot_resend_yet` error type. Anchored on the type, with
- * the message as a fallback for the provider shapes that carry the type only in
- * the sentence. Pure and total.
+ * HTTP 422 with the `cannot_resend_yet` error type, or with
+ * `provider/unprocessable_entity` and LinkedIn's "already handled a request from
+ * you in the past 3 weeks" sentence. Anchored on the type, with the message as a
+ * fallback for the provider shapes that carry the type only in the sentence.
+ * Pure and total.
  */
 export function isLinkedInReinviteCooldownRefusal(input) {
     if (input.status !== 422)
         return false;
     if (typeof input.providerType === "string" && /(?:^|\/)cannot_resend_yet$/u.test(input.providerType.trim()))
         return true;
-    return typeof input.providerMessage === "string" && /\bcannot_resend_yet\b/u.test(input.providerMessage);
+    if (typeof input.providerMessage !== "string")
+        return false;
+    if (/\bcannot_resend_yet\b/u.test(input.providerMessage))
+        return true;
+    // The same refusal in LinkedIn's own words. Without it, the BullMQ runtime
+    // read the write as possibly delivered and parked the lead for reconciliation.
+    return input.providerType === "provider/unprocessable_entity"
+        && LINKEDIN_RECENTLY_HANDLED_INVITE_MESSAGE.test(input.providerMessage.trim());
 }

package/node_modules/@oxygen/shared/dist/managed-scraper-backend.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Which vendor serves OXYGEN's managed `scraper.*` LinkedIn rail
+ * (LINKEDIN_SCRAPER_PROVIDER, Philipp 2026-10-17: a pure provider exchange from
+ * Up2Data to HarvestAPI behind a Doppler switch). Up2Data is the default, so an
+ * unset or unrecognised value never moves paid traffic.
+ *
+ * Dependency-free and browser-safe: a bundle without the server environment
+ * reads the default, so a label rendered in the browser must not rely on it.
+ */
+export type ManagedScraperBackend = "up2data" | "harvestapi";
+export declare const MANAGED_SCRAPER_BACKEND_ENV = "LINKEDIN_SCRAPER_PROVIDER";
+type Env = Readonly<Record<string, string | undefined>>;
+/** The server environment, or null in a bundle that has none. */
+export declare function serverEnv(): Env | null;
+/** The configured backend, or null when the value names neither vendor. */
+export declare function parseManagedScraperBackend(value: string | undefined): ManagedScraperBackend | null;
+export declare function readManagedScraperBackend(env?: Env | null): ManagedScraperBackend;
+export {};

package/node_modules/@oxygen/shared/dist/managed-scraper-backend.js

@@ -0,0 +1,17 @@
+export const MANAGED_SCRAPER_BACKEND_ENV = "LINKEDIN_SCRAPER_PROVIDER";
+/** The server environment, or null in a bundle that has none. */
+export function serverEnv() {
+    const env = typeof process !== "undefined" ? process.env : undefined;
+    // `window` is absent from this package's types (no DOM lib), so read it off globalThis.
+    return env && !("window" in globalThis) ? env : null;
+}
+/** The configured backend, or null when the value names neither vendor. */
+export function parseManagedScraperBackend(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized || normalized === "up2data")
+        return "up2data";
+    return normalized === "harvestapi" ? "harvestapi" : null;
+}
+export function readManagedScraperBackend(env = serverEnv()) {
+    return parseManagedScraperBackend(env?.[MANAGED_SCRAPER_BACKEND_ENV]) ?? "up2data";
+}

package/node_modules/@oxygen/shared/dist/teammates.d.ts

@@ -3,12 +3,14 @@
  * per Workspace Oxygent, on the Copilot runtime. Explicit Personal Oxygents
  * are creator-only; the first one stays Workspace (Philipp, 2026-10-16).
  *
- * Staff only: on dev, and in production's staff workspaces, the ones Agents run
- * in (`agentsEnabledIn`; Tim, 2026-10-16). `OXYGEN_TEAMMATES_ENABLED` is the
- * switch; when it is unset the feature follows the Ongoing Agent sessions staff
- * gate, because teammates re-scope those sessions into routines. Shadow never
- * qualifies.
+ * Who has them: `OXYGEN_TEAMMATES_ENABLED` is the switch, "staff" for staff emails
+ * and "all" for every member who is not a client login (the customer launch,
+ * Tim, 2026-10-17). Unset, it follows the Ongoing Agent sessions switch, because
+ * teammates re-scope those sessions into routines. Only workspaces Agents run in
+ * qualify (`agentsEnabledIn`); shadow never does.
  */
+export type TeammatesAudience = "off" | "staff" | "all";
+export declare function teammatesAudience(env?: Record<string, string | undefined>): TeammatesAudience;
 export declare function teammatesEnabled(env?: Record<string, string | undefined>): boolean;
 /** Whether this workspace has Oxygents. */
 export declare function teammatesEnabledIn(organizationId: string | null | undefined, env?: Record<string, string | undefined>): boolean;

package/node_modules/@oxygen/shared/dist/teammates.js

@@ -1,34 +1,25 @@
 import { agentsEnabled, agentsEnabledIn } from "./agents-enabled.js";
 import { guidedActivationEnabled } from "./guided-activation.js";
 import { isStaffEmail } from "./staff.js";
-/**
- * AI teammates (ADR 0032): Agents people talk to in one ongoing shared chat
- * per Workspace Oxygent, on the Copilot runtime. Explicit Personal Oxygents
- * are creator-only; the first one stays Workspace (Philipp, 2026-10-16).
- *
- * Staff only: on dev, and in production's staff workspaces, the ones Agents run
- * in (`agentsEnabledIn`; Tim, 2026-10-16). `OXYGEN_TEAMMATES_ENABLED` is the
- * switch; when it is unset the feature follows the Ongoing Agent sessions staff
- * gate, because teammates re-scope those sessions into routines. Shadow never
- * qualifies.
- */
-export function teammatesEnabled(env = process.env) {
+export function teammatesAudience(env = process.env) {
     if (env.OXYGEN_DEPLOY_ENV !== "selfhost-dev" && env.OXYGEN_DEPLOY_ENV !== "selfhost-prod")
-        return false;
+        return "off";
     if (!agentsEnabled(env))
-        return false;
-    const flag = env.OXYGEN_TEAMMATES_ENABLED?.trim().toLowerCase();
-    if (flag)
-        return flag === "staff";
-    return env.OXYGEN_AGENT_SESSIONS_ENABLED === "staff";
+        return "off";
+    const flag = env.OXYGEN_TEAMMATES_ENABLED?.trim().toLowerCase() || env.OXYGEN_AGENT_SESSIONS_ENABLED?.trim();
+    return flag === "staff" || flag === "all" ? flag : "off";
+}
+export function teammatesEnabled(env = process.env) {
+    return teammatesAudience(env) !== "off";
 }
 /** Whether this workspace has Oxygents. */
 export function teammatesEnabledIn(organizationId, env = process.env) {
     return teammatesEnabled(env) && agentsEnabledIn(organizationId, env);
 }
 export function teammatesAvailableTo(env, viewer) {
-    return teammatesEnabledIn(viewer.organizationId, env) && viewer.member && viewer.oxygenRole !== "client"
-        && (guidedActivationEnabled(env) || isStaffEmail(viewer.email, env));
+    if (!teammatesEnabledIn(viewer.organizationId, env) || !viewer.member || viewer.oxygenRole === "client")
+        return false;
+    return teammatesAudience(env) === "all" || guidedActivationEnabled(env) || isStaffEmail(viewer.email, env);
 }
 /**
  * The Workspace Agent's slug. Every workspace's first Oxygent is that Agent: an

package/node_modules/@oxygen/shared/dist/user-capability-routing.js

@@ -14,6 +14,22 @@ export function capabilityDiscoveryRecovery(query, surface) {
 // connection routes.
 export function inferUserCapabilityRoute(query) {
     const normalized = query.toLowerCase().replace(/[_-]+/g, " ");
+    const journeyAction = savedOnboardingJourneyAction(normalized);
+    if (journeyAction) {
+        const route = getCapabilityRouteMatch("agents");
+        if (route) {
+            const recommendedTools = [`oxygen_onboarding_journey_${journeyAction}`, ...(journeyAction === "get" ? [] : ["oxygen_onboarding_journey_get"])];
+            const recommendedCommands = [`onboarding journey ${journeyAction}`, ...(journeyAction === "get" ? [] : ["onboarding journey get"])];
+            return { ...route, recommendedTools, recommendedCommands, card: { ...route.card,
+                    owns: "Creator-private saved guided onboarding answers, current step and pause/resume position.",
+                    notFor: "Human workspace invitations or permissions, destructive workspace reset, paid Oxygent Start or routine execution.",
+                    gatewayTools: recommendedTools, gatewayCommands: recommendedCommands,
+                    posture: journeyAction === "get" ? "read_only" : "workspace_write",
+                    execution: journeyAction === "get" ? "Read saved onboarding and its current native step. This read starts no research, model, billing reconciliation or message send."
+                        : "Read activationId and current revision first, then hydrate the selected native operation. Use a stable mutation_id; Back and non-destructive restart preserve resources and funding. Company answers prepare native sources and existing bounded research consent. Discovery executes nothing and supplies no approval or billing authority.",
+                } };
+        }
+    }
     // Exact native session activation must outrank the generic Agent gateways.
     // Discovery supplies no approval, preview token or invented session binding.
     if (/\bagent session activate\b/.test(normalized)
@@ -61,6 +77,23 @@ export function inferUserCapabilityRoute(query) {
                 recommendedCommands: ["context profile get", "knowledge bootstrap status", "onboarding activation status"],
                 exactCommand: "oxygen context profile get --json", exactMcpCall: { tool: "oxygen_context_profile_get", arguments: {} } };
     }
+    // Explicit guided-journey discovery precedes the individual campaign,
+    // review and routine nouns that describe its later steps. Consulting keeps
+    // the ordinary onboarding card; this recommendation advertises DEV only.
+    if (isGuidedOnboardingDiscoveryIntent(normalized)) {
+        const route = getCapabilityRouteMatch("onboarding-and-copilot");
+        if (route) {
+            const recommendedTools = ["oxygen_onboarding_activation_status", "oxygen_onboarding_journey_get"];
+            const recommendedCommands = ["onboarding activation status", "onboarding journey get"];
+            return { ...route, recommendedTools, recommendedCommands, card: { ...route.card,
+                    owns: "Creator-owned DEV guided onboarding answers, native resources, current step and saved navigation.",
+                    notFor: "Production onboarding execution, human membership or ordinary GTM consulting.",
+                    posture: "read_only", gatewayTools: recommendedTools, gatewayCommands: recommendedCommands,
+                    execution: "DEV-only two-part guided onboarding; unavailable in production, shadow, local or production-data workspaces. Read your activation first, then use its activationId to read the saved journey and revision. If absent, inspect the free activation-start schema and choose own_agent or oxygent. Resume the native step; answers, prospects, TEST billing, campaigns and routines retain their own schemas, eligibility and approvals. These reads start no research, checkout, model, schedule or send. Ordinary GTM consulting remains with Recipes/Copilot.",
+                }, exactCommand: "oxygen onboarding activation status --json",
+                exactMcpCall: { tool: "oxygen_onboarding_activation_status", arguments: {} } };
+        }
+    }
     if ((/\b(?:linkedin|sequence|campaign)\b/.test(normalized) && /\b(?:preview|review|readiness)\b/.test(normalized)
         && /\b(?:launch|start)\b/.test(normalized) && /\b(?:approval|send limits?|caps?)\b/.test(normalized))
         || (isLinkedInCampaignIntent(normalized) && /\breadiness\b/.test(normalized) && /\bpreview\b/.test(normalized))) {
@@ -159,6 +192,45 @@ export function inferUserCapabilityRoute(query) {
     // intent is exactly what this wrapper exists to answer.
     return getCapabilityRouteMatch("connected-integrations") ?? route;
 }
+/** Saved progress is distinct from general signup research, attended Start,
+ * routine schedules and human membership. Pause wins over a simultaneous resume. */
+function savedOnboardingJourneyAction(query) {
+    if (!/\bonboarding\b/.test(query) || !/\b(?:journey|guided|answers?|steps?|tour)\b/.test(query)
+        || /\b(?:invite|members?|membership|permissions?|roles?|human|colleague|coworker|delete|destroy|wipe)\b/.test(query))
+        return null;
+    if (/\b(?:pause|paused|navigation)\b/.test(query) || (/\btour\b/.test(query) && /\bresume\b/.test(query)))
+        return "navigation";
+    if (/\brestart\b/.test(query))
+        return "restart";
+    if (/\bback\b/.test(query))
+        return "back";
+    if (/\bsave\b/.test(query))
+        return "save";
+    if (/\b(?:resume|read|get)\b/.test(query))
+        return "get";
+    return null;
+}
+/** A saved action is handled first. This is discovery of the multi-step
+ * product journey, not generic advice about improving a GTM operation. */
+function isGuidedOnboardingDiscoveryIntent(query) {
+    if (!/\bonboarding\b/.test(query)
+        || /\b(?:invite|members?|membership|permissions?|roles?|human|colleague|coworker|delete|destroy|wipe|paid)\b/.test(query))
+        return false;
+    if (/^(?:guided )?onboarding$/.test(query.trim()))
+        return true;
+    return /\b(?:first sourcing|daily rhythm)\b/.test(query)
+        || (/\b(?:guide|guided|journey|part [12])\b/.test(query)
+            && /\b(?:business|company|icp|personas?|prospects?|trial|campaign|sequence|briefing)\b/.test(query))
+        || (/\b(?:trial|prospects?|personas?)\b/.test(query)
+            && /\b(?:context|icp|campaign|sequence)\b/.test(query))
+        // Company-statement review is a guided step even without the words guide
+        // or journey. Existing channel conversations keep their message owner.
+        || (/\bcompany profile\b/.test(query)
+            && /\b(?:review|correct|confirm)\b/.test(query)
+            && /\b(?:statement|profile revision)\b/.test(query)
+            && /\b(?:prospects?|evidence|sources?)\b/.test(query)
+            && !/\b(?:inbox|unibox|messages?|threads?|repl(?:y|ies)|email|whatsapp|slack|teams)\b/.test(query));
+}
 function isCompanyOnboardingContextIntent(query) {
     return /\bonboard\w*\b/.test(query)
         && /\bcompany\b/.test(query)
@@ -266,6 +338,22 @@ function oxygentsRoute(normalized) {
     const group = /\bgroups?\b/.test(normalized);
     const verb = (group ? OXYGENT_GROUP_VERBS : OXYGENT_VERBS).find(([, words]) => words.test(normalized))?.[0]
         ?? (group ? "groups" : "list");
+    // Visibility discovery asks about the contract, not existing conversations.
+    // Keep the shared router's create/update/access recommendations even when
+    // the product noun would otherwise select the roster or "history" GET.
+    // Explicit content reads and other operations retain their native verbs.
+    const privacy = /\b(?:visibility|personal|workspace|private|shared)\b/.test(normalized);
+    const rosterRead = /\b(?:list|inventory|roster)\b|\bwhich\b.*\b(?:have|available)\b/.test(normalized);
+    // Bare history asks read content; creation/configuration asks describe its contract.
+    const historyContract = /\b(?:visibility|configur\w*|settings?|privacy|defaults?|create|creating|make|add|new|set up|spawn|hire)\b/.test(normalized);
+    const contentRead = /\b(?:read|see|view|show|transcript)\b/.test(normalized)
+        || (/\bhistory\b/.test(normalized) && !historyContract);
+    const contentSend = /\b(?:messages?|ask|tell|send|talk|continue|resume|handoff|delegat\w*)\b|\b(?:chat with|hand\w* off)\b/.test(normalized);
+    if (!group && privacy && ((verb === "list" && !rosterRead) || verb === "create"
+        || (verb === "update" && /\bvisibility\b/.test(normalized))
+        || (verb === "get" && !contentRead) || (verb === "message" && !contentSend))) {
+        return inferCapabilityRoute(normalized);
+    }
     // Sharing is read and changed as a pair: who has access, then share.
     const pair = verb === "share" ? ["access"] : verb === "access" ? ["share"] : [];
     // A group's id comes from its list; the roster reads follow every ask.

package/node_modules/@oxygen/shared/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const OXYGEN_BUILD_VERSION = "1.1014.1035";
+export declare const OXYGEN_BUILD_VERSION = "1.1014.1132";

package/node_modules/@oxygen/shared/dist/version.generated.js

@@ -1,2 +1,2 @@
 // GENERATED by scripts/ci/version-stamp.mjs from VERSION + git history. Do not edit; do not commit.
-export const OXYGEN_BUILD_VERSION = "1.1014.1035";
+export const OXYGEN_BUILD_VERSION = "1.1014.1132";

package/node_modules/@oxygen/shared/dist/workspace-placement-view.d.ts

@@ -0,0 +1,150 @@
+import { type WorkspacePlacementPlan, type WorkspacePlacementObservation } from "./workspace-placement.js";
+export type WorkspacePlacementView = {
+    id: string;
+    provider: "internal";
+    billing_mode: "internal";
+    credits_used: 0;
+    status: "running" | "completed" | "incomplete";
+    created_at: string;
+    message_count: number;
+    variants: Array<{
+        key: string;
+        planned: number;
+        observed: number;
+        google_primary: number;
+        google_promotions: number;
+        google_social: number;
+        google_updates: number;
+        google_forums: number;
+        microsoft_focused: number;
+        microsoft_other: number;
+        spam: number;
+        other_folder: number;
+        unknown_folder: number;
+        unknown_category: number;
+        not_observed: number;
+        failed: number;
+        send_unknown: number;
+        read_blocked: number;
+    }>;
+    probes: Array<{
+        id: string;
+        sender: string;
+        receiver: string;
+        receiver_provider: string;
+        variant: string;
+        subject: string;
+        sender_name: string | null;
+        body_text_characters: number;
+        body_html_characters: number;
+        state: string;
+        status_label: string;
+        delivery?: {
+            id: string;
+            status: string;
+            sent_at: string | null;
+            provider_message_id: string | null;
+        };
+        observation?: WorkspacePlacementObservation;
+    }>;
+    has_more?: boolean;
+    next_cursor?: string | null;
+    probe_count?: number;
+    plan_hash: string;
+    web_url: string;
+    directional_note: string;
+};
+export declare function workspacePlacementView(input: {
+    id: string;
+    plan: WorkspacePlacementPlan;
+    outcomes: Record<string, {
+        state: string;
+        observation?: WorkspacePlacementObservation;
+    }>;
+    deliveries?: Record<string, {
+        id: string;
+        status: string;
+        sent_at: string | null;
+        provider_message_id: string | null;
+    }>;
+    created_at: Date | string;
+}, webUrl: string): WorkspacePlacementView;
+export declare function workspacePlacementStateLabel(state: string): string;
+export type WorkspacePlacementCopyPart = "body_text" | "body_html";
+export type WorkspacePlacementCopyPage = {
+    id: string;
+    variant: string;
+    sender: string;
+    sender_name: string | null;
+    receiver: string;
+    subject: string;
+    part: WorkspacePlacementCopyPart;
+    offset: number;
+    total_characters: number;
+    text: string;
+    has_more: boolean;
+    next_offset: number | null;
+};
+export declare function workspacePlacementProbeMeta(probe: WorkspacePlacementPlan["probes"][number]): {
+    id: string;
+    sender: string;
+    sender_name: string | null;
+    receiver: string;
+    receiver_provider: "google" | "microsoft";
+    variant: string;
+    subject: string;
+    body_text_characters: number;
+    body_html_characters: number;
+};
+export declare function workspacePlacementCopyPage(plan: WorkspacePlacementPlan, input: {
+    probeId: unknown;
+    part?: unknown;
+    offset?: unknown;
+    limit?: unknown;
+}): WorkspacePlacementCopyPage;
+export declare function workspacePlacementProbePage<T extends {
+    id: string;
+}>(probes: T[], input: {
+    cursor?: unknown;
+    limit?: unknown;
+}, defaultLimit?: number): {
+    probes: T[];
+    probe_count: number;
+    has_more: boolean;
+    next_cursor: string | null;
+};
+export declare function workspacePlacementPreviewPage(plan: WorkspacePlacementPlan, input?: {
+    cursor?: unknown;
+    limit?: unknown;
+}): {
+    request_id: string;
+    organization_id: string;
+    provider: "internal";
+    billing_mode: "internal";
+    credits: 0;
+    allow_paused_probe: boolean;
+    receiver_scope?: "workspace" | "network";
+    rendered_at?: string;
+    rendering?: {
+        tracking_opens: boolean;
+        tracking_clicks: boolean;
+        tracking_host: string | null;
+    };
+    excluded_self_sends: number;
+    message_count: number;
+    plan_hash: string;
+    probes: {
+        id: string;
+        sender: string;
+        sender_name: string | null;
+        receiver: string;
+        receiver_provider: "google" | "microsoft";
+        variant: string;
+        subject: string;
+        body_text_characters: number;
+        body_html_characters: number;
+    }[];
+    probe_count: number;
+    has_more: boolean;
+    next_cursor: string | null;
+};