Get Help (Helpdesk)

What it is

The Get Help panel is a conversation-style assistant inside Agent Mission Control. Ask anything — questions about the app are answered using its own help documentation with clickable source chips linking to the exact help page, while general questions (writing a follow-up email, explaining a concept) get a helpful answer without any source citations. The model self-identifies which kind of answer it's giving.

Get Help opens as a small floating chat widget in the corner of the screen — it's non-modal, so the rest of the app stays visible and interactive behind it, and it never takes over the whole window unless you ask it to. On desktop it's anchored to the bottom-left corner by default (the separate Support Chat widget lives in the bottom-right), a move button in the widget's header flips it to the other side of the screen (left ↔ right — the choice persists across restarts), and a full-screen button expands it into a console that fills the app below the title bar (so Omniscio's own window controls stay put): your conversation list on the left (admins get a Conversations / Needs-your-reply switch) and the open chat beside it. For an admin with a thread open, a details rail fills a third column on the right — the sender's contact card (avatar, name, email, plan), then the conversation's private tags (add, colour and remove them right there — they sit at the top so a conversation can be tagged without scrolling), then the same user's other conversations (click one to switch to it), who it is assigned to, the conversation's status and activity times, the sender's local time / time zone / language and their app version + OS (when the escalating app stamped them; older threads fall back to the "System info" note in the thread), which admins have replied, and — at the foot — the admin's private notes. The two outer columns are yours to size: drag the divider beside the conversation list or the one beside the details rail and each keeps its own width across restarts (double-click a divider to put that column back to its default), or focus a divider and use the arrow keys. The chat in the middle always takes whatever space is left. Who the conversation is with and its status also show at the top of the chat itself. While the console is full-screen the "Help Desk Console" row in the app's far-left navigation is highlighted to show that's where you are — and clicking anything else there (a project, the Inbox, Settings) simply closes the Help Desk and takes you to that page, so you're never stuck on the Help page when you try to navigate away. The console never shrinks into the small corner widget: it has no exit-full-screen button, and ✕ or Esc closes it. Inside, a small header has: Chat (the default view — a composer ready to type into), Help Center (browse the help articles), Insights (a small analytics dashboard — see below), and — for developers only — Needs your reply (the escalation queue, with a count badge; each waiting row shows the question, the reporter's name and email when they were signed in, and the date and time it arrived). Your Get Help is a single ongoing conversation — there is no History list and no "New conversation" button; whenever you open Get Help you land back in that one continuous conversation and anything you type is a follow-up in it. A developer thread in Needs your reply opens right in the chat body — while it loads (and while a first question is being answered) the chat shows just your message with a small typing indicator. Messages render through the same chat rendering a regular Omniscio conversation uses — the same bubble shapes, the same markdown engine — with your own on the right and the assistant or developer on the left, each beside the sender's avatar (your profile photo when you're signed in, a friendly bot mark for AI answers, initials otherwise).

You can send follow-up messages within a conversation — the AI answers with the full thread context. If the AI answer didn't help, a "Send to developer" button escalates the conversation. For a developer (with the dev-console gate enabled), escalated questions from users show up in the "Needs your reply" view, switched to via its own header icon. Opening a thread there shows it in the same chat body (the developer's own replies sit on the right, like any normal chat). The reply arrives as a toolbar badge + OS notification and appears in the chat view within a few seconds — while a conversation is waiting on the developer the app checks for replies on a fast cadence, and opening the Get Help panel checks immediately.

Where to find it

On a phone

On the phone web client the Help Desk is an ordinary screen, just like every other integration — it never covers the whole display. Tap Help Desk in the projects list (or the toolbar's Help Desk button) and it opens under the app's usual navigation and header:

• Two tabs along the top switch between your Conversation (or the Queue, for a support operator, with the number of people waiting) and the Help Center. Insights (and Routing, for an operator) sit beside them as buttons. Once a support operator opens a ticket those tabs step aside, so the ticket's own row is the only bar above the conversation.
• Your phone's Back steps out one level at a time — from an open conversation back to the queue, from the Help Center back to the conversation, then out of the Help Desk.
• With a ticket open there is one bar, not two. It carries Back, the person's name, how they reached you, the subject and the assign button, plus a ⋯ menu with Start session, Open session (once a session is working the ticket) and Mark resolved — so the conversation keeps the great majority of the screen.
• The reply box keeps just Reply and Note; Shortcuts, Knowledge Base, AI reply and the Formatting (Aa) toggle move behind the ⋯ button in the box's own toolbar.
• Tapping a Help Desk notification opens that conversation directly.

How to open it

• Press Ctrl+Shift+H — the Get Help widget pops in at the bottom-left of your screen (bottom-right if you've moved it via the header's move button).
• Click the LifeBuoy icon in the toolbar (appears when the feature is enabled), or find it in the overflow menu.
• Click Help Desk in the projects sidebar — an ordinary hub row alongside the other integrations, not a fixed slot of its own. The row is always there while Get Help is enabled, highlights while the panel is open, and carries the same unread count as the toolbar button. (A separate Help Desk Console row sits right beside it for a seat that holds the admin console — see part 2.)

Note: Get Help is currently an in-development feature and is hidden by default. Developers can reveal it by launching Omniscio with the environment variable AMC_SHOW_HELPDESK=1, or by flipping the Labs toggle in Settings once it appears there. Most users will not see it until a future release enables it for everyone.

How it behaves

Full lifecycle

User asks a question
  → AI answer (Omniscio-scope with source chips, or general-scope without)
  → The answer shows in your single ongoing conversation
  → Rate 👍 or 👎 — feedback only; rating never changes the conversation's status

User sends follow-up
  → AI answers with thread context (up to 20 prior messages)
  → Scope may widen general → Omniscio (never narrows)

If the AI answer didn't help (Omniscio-scope only):
  → User clicks "Send to developer"
  → Status: waiting_dev
  → Escalation email sent via resend-service, resolved server-side; its subject
    carries a snippet of the question so each alert is its own email conversation
    (temporarily routed to a single developer inbox — 2026-07-22 owner request;
    normally the owner plus each admin account)
  → Subsequent messages in the chat go to the developer, not AI

Developer (on their machine, gated "Needs your reply" view):
  → New question (or a user follow-up re-queuing a thread) raises a desktop
    notification with a chime, even when Omniscio is in the background —
    clicking it brings the app forward and opens the waiting thread
    (plus an in-app inbox alert and a phone push if a phone is paired)
  → Opening that in-app inbox row lands on the console showing **that** thread.
    An explicit "open this question" outranks the console's load-on-open habit of
    resuming the developer's own most-recent conversation — needed because those
    two share one selection slot, so the resume would otherwise discard the thread
    the row pointed at (and on a single-user install the developer IS a user, so
    they have a most-recent conversation to resume)
  → Opens Get Help widget → clicks the "Needs your reply" header icon → lists waiting questions, load-on-open + Refresh
  → Opens thread → reads question + AI attempt → types reply → sends
  → Status: answered (in cloud); thread refreshes in list
  → When the exchange is done, clicks "Mark resolved" — or presses **E** — to
    close it, and the console moves straight on to the next conversation in the
    queue (the one below, else the one above; none left → an empty console) — and
    "Mark unresolved" reopens a resolved thread, landing it where the last
    speaker left it (customer spoke last → back in the Pending queue;
    developer spoke last → Awaiting customer). Typing a reply
    into a resolved thread reopens it automatically, so a follow-up never
    lands on a closed conversation.

User receives reply:
  → Push listener refreshes the chat view + conversation list in real time
  → Desktop notification with a chime: "Developer replied to your question" —
    clicking it brings the app forward and opens the replied conversation
    (a phone push is sent too if a phone is paired)
  → Inbox notification: "Developer replied to your question"
  → Developer reply shown as accent-tinted bubble in chat

User sends follow-up on escalated thread:
  → Status flips back to: waiting_dev (in cloud AND locally)
  → Thread reappears in the developer's "Needs your reply" view on next open/refresh
  → Developer follow-up alert email sent

Developer resolves (or reopens):
  → "Mark resolved" (or **E**) closes the thread and opens the next conversation
    in the queue; "Mark unresolved" reopens it to wherever the last speaker left
    it (waiting_dev or answered)
  → **E** is the console's resolve key: it works on the conversation that is open,
    never while you are typing in a box (or in the moment after), never with
    Ctrl/Alt/Shift/Cmd held, and never inside a menu or dialog. Hovering Mark
    resolved shows the key. While the full-screen console is open, single-letter
    keys never reach the app behind it — E there can never archive a session
  → A hairline divider marks the resolve/reopen in the developer console only;
    the user's chat shows a single muted "Marked Resolved" note while resolved
  → In the console, a resolved conversation's row (the queue, the Resolved view,
    the person's other conversations, and search) previews its question, not
    the resolve note or a closing line; an open one previews its latest message
  → The user's local copy flips to resolved too; their next message on it goes
    back to the AI (and they can re-escalate afresh)
  → Resolution is a developer action now — the user no longer has a resolve button

No AI is involved after escalation — developer messages come from the developer console only (or the in-memory fake seam in tests).

Who sees which developer replied. Every developer reply is stamped server-side with the replying admin's identity (from their verified sign-in — a client can't forge it). The user sees the developer's first name only — a reply reads "Alex" instead of the generic "Agent" label, which is friendlier without identifying the teammate: the relay that delivers replies to users strips the full identity (email, account id) server-side and passes through just the first name, on both the push and the poll delivery paths. The full attribution is admin-console-only: in the "Needs your reply" thread view, your own replies are labeled "You" and another admin's replies are labeled with their email, so a team of developers can see who answered what. Replies sent before this feature carry no name and render as "Agent".

Conversations are private to your account. Your Get Help history belongs to the account that asked: each conversation is tagged with the signed-in account that created it, and every list and lookup returns only your own. A second person signing into the same computer sees their own (empty) history, not yours — and switching accounts also clears the developer-side incoming-alert cache on that machine. Conversations started while signed out belong to the signed-out state only: they show while you are signed out and are not carried into any account when someone signs in — signing back out shows them again. If a send to the agent fails (for example, offline), the message is not kept locally — retrying sends it once, never as duplicates.

Resolve/reopen markers. When the developer marks your conversation resolved (or reopens it), your copy updates quietly: the conversation's status flips, with no desktop notification or chime. While a conversation is resolved, a single muted "Marked Resolved" note shows at the end of your chat; reopening removes it. The per-event resolve/reopen hairline dividers are developer-console-only — the back-and-forth of resolving and reopening is support-side bookkeeping and is deliberately not replayed in your chat. Once a conversation is resolved, typing a new message hands it back to the AI — you get an instant AI answer again, and you can send it to the developer afresh if you still need a human.

How answers work

When you submit a question, the app:

1. Searches its bundled help documentation (docs/llm-library/) for the most relevant pages.
2. Sends your question — along with those pages as context — to an AI model (source: 'helpdesk-ask'; a single llmProviderService.chat() call, no session spawn).
3. Returns a plain-language answer together with source chips: small tags naming the exact help pages the answer was drawn from. Click any chip to open that help page in the Help & Docs panel (chips are hidden if the page cannot be resolved).

If your question is about Omniscio but not covered by the docs, the answer will say so honestly rather than guessing (covered: false, empty source list — a "couldn't find it" answer never shows source chips). If your question is general (not about the app), the assistant answers it as a helpful AI — no source chips, scope: 'general'.

What the AI answer path needs

The model call pins provider: 'openrouter', whose baked company key is retired — the call is developer-paid through the cloud gateway, which needs the Omniscio cloud (global-auth) sign-in. Without a gateway session the provider layer degrades to its Anthropic backstop, which needs an Anthropic API-key account; a subscription-only (OAuth) Claude sign-in cannot use the Messages API directly. When BOTH of those are missing but a healthy Claude subscription login is signed into Omniscio, the assistant still answers: it runs the question through a one-shot Claude Code print call on the user's own plan (the same subscription bridge the Council and Writer features use) — no API key, no extra dollars, slightly slower than the direct API. Only when there is no gateway session, no API-key account, AND no subscription login does the assistant reply with a friendly "can't reach its AI service" message (never the raw AnthropicFallbackUnavailableError). That error area still helps two ways, because neither needs an AI credential: a "Send to developer" button (one click creates the conversation from your question and sends it through the helpdesk relay) and, when the local doc search found candidates, a row of clickable help-page links ("these help pages might have the answer") that open the Help & Docs panel at the matching section. In a dev checkout the missing-gateway case most often means default-credentials.local.json was never materialized (npm run secrets:pull), so the global-auth config that enables the gateway sign-in is missing.

Things you can do with a conversation

• Copy an answer. Every AI answer and every developer reply has a small copy button — click it to put the full message text on your clipboard; it briefly shows a "Copied" confirmation.
• Rate — and change your mind. The 👍 / 👎 rating is reversible: your chosen rating stays visibly pressed, and you can switch it or clear it at any time. Rating is feedback only — it no longer resolves the conversation (whether a support conversation is resolved is the developer's call).
• Click a source chip. Source chips always open the Help & Docs panel at the exact page the answer drew from (opening the panel if it's closed). A chip is hidden whenever its page can't be resolved — including when the cited doc has no page on the public help site — so you never get a dead click.
• One ongoing conversation. Get Help keeps a single continuous conversation for you — there's no list of past conversations to browse, no "New conversation" button, and no per-conversation delete or history search on the user side. Opening Get Help always returns you to that one conversation, and anything you type continues it. (Developers still get the full queue browse, search, and filters below.)
• Search & filter the queue (developers). The developer console's queue has its own search box beside the queue-view menu. The menu offers All, Unread, Pending, Unresolved, Resolved, Most Recent, and Longest Waiting views. Every view shows one row per person (their newest conversation) EXCEPT Resolved, which is the history of past conversations: every resolved conversation gets its own row, newest first, even when the same person has an open one. Search matches the question, the person's name or email, the row's preview, and your private tags. One clickable chip appears per tag in use; pick one or more to narrow the current view (chips combine with search). Tags and their filters are private to the console and never leave the developer's machine.
• Drafts survive a failed send. If a message fails to send (yours or, for developers, a reply), your typed text stays in the composer so you can retry without re-typing — the retry re-sends that exact message. Pressing Esc while the composer still has text just moves focus out of it rather than closing the whole panel, so you can't lose a draft by accident.

What gets attached when you escalate

When you send a conversation to the developer, Omniscio automatically attaches a short system-info line — your Omniscio version and operating system, e.g. Omniscio v1.2.3 · win32 10.0.19045 — to both the alert email and the conversation the developer sees, so they can triage without asking you what you're running.

Escalation is only offered for questions about Omniscio. On a general-knowledge conversation the panel shows a short caption explaining that "Send to developer" is for app questions only.

Rate limit

The panel is limited to 10 questions per minute. If you reach the limit, an inline message shows a live countdown of the seconds remaining, ticking down until you can ask again — so you're never left guessing when the panel will accept another question. The countdown recovers correctly even if your computer's clock jumps backward.

Insights

The Insights view (the bar-chart icon in the header) is a small, read-only dashboard summarising how Get Help is being used on this computer. It shows:

• Questions — how many questions were asked in the selected window.
• Handled by AI — the share the AI answered without ever escalating to a human (the self-service deflection rate), with how many still needed a person.
• Satisfaction — of the answers you rated 👍/👎, the share that were 👍 (with how many of the total were rated).
• Questions over time — a simple trend line of daily volume.

A 30 days / 90 days / All time switch at the top scopes every figure. Until a few questions have been asked, it shows a friendly empty state.

Insights is entirely local and free: it only reads the questions already stored on your machine — it makes no AI call, sends nothing to the cloud, and costs nothing. It shows only your own questions, so (unlike "Needs your reply") it needs no developer/admin access — anyone who can see Get Help can open it.

Phase 1 note. Insights currently summarises just this install's own questions. A future phase may roll the numbers up across all users of a deployment; that needs additional cloud plumbing and is tracked separately.

Feature gates

There are two separate gates, both using the standard unreleased-feature registry:

Gate	env var	settings key	Purpose
helpdesk	AMC_SHOW_HELPDESK=1	helpdeskEnabled	Entire Get Help feature (user-facing)
helpdesk-dev-console	AMC_SHOW_HELPDESK_DEV_CONSOLE=1	helpdeskDevConsoleEnabled	Adds the "Needs your reply" header icon + view to the widget (developer only)

The helpdesk-dev-console gate stays 'in-development' even after helpdesk ships — ordinary installs never see the developer console. Both gates are checked in Main (not just in the renderer), so hiding them client-side is not the only barrier. Access is now server-enforced, not just client-gated: every developer-console read/write routes through the admin-authed operatorConsole Cloud Function (verified Firebase ID token + requireAdmin from signed claims), so the shipped Firebase admin service account key is retired from the helpdesk operator surface.

For agents

The rest of the Helpdesk — the operator queue's own views and filters, the developer console's status tabs, drafts, routing and aging rules, the boot-time reply listener and the incoming-question watcher, the test seams, and the key files — is in Get Help (Helpdesk) (part 2).

Related

• keyboard-shortcuts.md — full list of Omniscio keyboard shortcuts, including Ctrl+Shift+H
• ask-amc.md — a separate feature that lets you have a full back-and-forth chat with Claude about the app, with the ability to configure settings for you
• Omniscio’s unreleased-feature (“Lab”) gate — how Omniscio hides in-development features until they ship
• report-conversations.md — every report sent from the Feedback button opens a conversation the support team answers here; the reporter reads the replies under "Your reports", even with Get Help off