- Your local-first AI Career OS.
- Understand every job. Tailor every application. Learn from every interview.
+ Give OfferU a job. Get an evidence-backed application workspace.
+ See what the role really asks for, what you can prove, and what to prepare next.
+
+ A local-first AI Career OS that compounds what you learn across jobs and interviews.
@@ -55,10 +59,25 @@ Most job-search tools solve one step. -Your resume lives in one place. Job research lives in another. Application tracking becomes a spreadsheet. -Interview practice starts from zero every single time. +Your JD lives in the browser. Your resume lives in a file. Research lives in another tab. Application tracking becomes a spreadsheet. Interview learning disappears into another AI chat. + +So every application starts from zero. -OfferU treats the whole search as one evolving system instead of four disconnected chores: +OfferU changes the unit of work from **a chat** to **a durable Job Workspace**: + +```text +Target Job + ↓ +What does this role really care about? + × +What can I actually prove? + ↓ +What should I prepare next? + ↓ +Evidence-backed Job Workspace +``` + +That Workspace then compounds into the larger Career OS: ```text Career Profile @@ -82,6 +101,21 @@ Debrief & Learning Instead of opening a fresh AI chat for every job, OfferU keeps one persistent, evidence-backed career context and carries what it learns across the entire search. +### One Job, one durable Workspace + +A Job is not just a detail page. It is the canonical workspace for one opportunity: + +```text +Job Snapshot +Role Intelligence +Evidence Map +Application Materials +Interview +Timeline / Next Action +``` + +Agent work progressively materializes into these objects, so closing a chat does not make the work disappear. + ### Persistent career context OfferU maintains structured career evidence — experience, achievements, skills, preferences, goals and @@ -164,7 +198,7 @@ The active agent reasons. OfferU controls capabilities, evidence, side effects a | ------------ | -------------------------------------------------------------------------------------------------- | | **Today** | What changed, what OfferU finished, what needs your attention, and what matters next | | **Pipeline** | Every opportunity, application stage, timeline and next action | -| **Job** | Research, Role Intelligence, evidence gaps, resume, application packet and interview preparation | +| **Job** | Durable Job Workspace: snapshot, Role Intelligence, Evidence Map, materials, interview and timeline | | **Profile** | Long-term career evidence, goals, preferences and reviewed learning | Memory is a mechanism for evolving Profile — not a separate product silo. @@ -176,9 +210,31 @@ same Operation Registry instead of scraping or auto-applying on its own. ## AI setup -The product direction is **Connect → Auto → Ready**. +The product has **two front doors and one Career Truth**. + +**Normal users: App-first** + +```text +Install OfferU +→ auto-detect local AI +→ project/register OfferU Skill where supported +→ save a Job +→ work appears in the canonical Job Workspace +``` + +**Power users: Skill-first** + +```text +Open Codex / Claude Code / WorkBuddy / OpenCode / OMP / another supported host +→ enable OfferU Skill +→ "analyze this job for me" +→ Agent creates/resolves the canonical Job +→ open the same Job Workspace in OfferU +``` + +The product direction remains **Connect → Auto → Ready**. -> **Beginner: connect an agent. Advanced: configure the stack.** +> **Skill is the Agent entry; Job Workspace is the user product.** Normal users should not have to understand runtimes, protocol versions, model IDs or custom endpoints. OfferU detects a local agent you already have, checks it, and consumes its own model and account: @@ -294,8 +350,10 @@ The intended public user path is: Download → Install → Auto-detect your local AI +→ Project/register OfferU Skill where supported → Resume + optional authorized AI memory → Profile → Save your first Job from the browser +→ Open the canonical Job Workspace → Optionally connect a job-search inbox → Today tells you what matters next ``` diff --git a/README_ZH.md b/README_ZH.md index d09b827d..b63f97a6 100644 --- a/README_ZH.md +++ b/README_ZH.md @@ -5,8 +5,12 @@
- 一个会持续理解你、自动维护求职流程的本地 AI Career OS
- 保存一个目标岗位，OfferU 围绕你的真实经历完成岗位研究、针对性材料准备、投递管理和面试训练。
+ 给 OfferU 一个岗位，得到一套有证据支撑的申请工作区。
+ 看清岗位真正要什么、你实际能证明什么，以及下一步该准备什么。
+
+ 一个会把每次岗位准备和面试学习持续积累起来的本地 AI Career OS。
@@ -53,10 +57,25 @@
## 为什么是 OfferU
-多数求职工具只解决其中一步：简历在一个地方，岗位研究在另一个地方，投递记录变成一张 Excel，
-面试准备每次都从零开始。
+多数求职工具只解决其中一步：JD 在浏览器，简历在文件里，岗位研究在另一个页面，投递记录变成 Excel，面试复盘又散落在另一个 AI 对话里。
+
+结果是：每投一个岗位，你都像从零开始。
+
+OfferU 把工作的基本单位从“一次聊天”变成一个**持久的 Job Workspace（岗位工作区）**：
+
+```text
+目标岗位
+ ↓
+这个岗位真正看重什么？
+ ×
+我实际上能证明什么？
+ ↓
+我下一步该准备什么？
+ ↓
+有证据支撑的 Job Workspace
+```
-OfferU 把整段求职当成一套持续演进的系统，而不是四件互不相关的杂事：
+然后这套工作区再持续积累成更大的 Career OS：
```text
职业档案
@@ -80,6 +99,21 @@ OfferU 把整段求职当成一套持续演进的系统，而不是四件互不
你不需要为每一个岗位都新开一个 AI 对话。OfferU 保留一份持续积累、有证据支撑的职业上下文，
并把它学到的东西带到后续每一次申请里。
+### 一个岗位，一个持久工作区
+
+Job 不只是详情页，而是一个机会的 canonical 工作区：
+
+```text
+岗位快照
+岗位理解
+证据地图
+申请材料
+面试
+时间线 / 下一动作
+```
+
+Agent 的工作会逐步物化到这些对象里，所以关掉 Agent 对话，已经完成的工作也不会消失。
+
### 持续积累的职业上下文
OfferU 维护结构化的职业证据：经历、成果、技能、偏好、目标和已审核的学习观察。
@@ -156,7 +190,7 @@ Agent 负责推理；第三方简历、招聘、面试 Skill 可以提供方法
| ------------- | -------------------------------------------------------- |
| **Today** | 发生了什么变化、OfferU 完成了什么、需要你关注什么、下一步做什么 |
| **Pipeline** | 所有机会、投递阶段、时间线和下一动作 |
-| **Job** | 岗位研究、岗位理解、证据缺口、简历、申请材料和面试准备 |
+| **Job** | 持久 Job Workspace：岗位快照、岗位理解、证据地图、申请材料、面试与时间线 |
| **Profile** | 长期职业证据、目标、偏好和已审核的学习内容 |
Memory 是 Profile 的演进机制，不是独立的产品孤岛。
@@ -166,9 +200,31 @@ Agent 是全局能力，不是又一个割裂的聊天窗口。
## AI 连接
-产品方向是 **连接 → 自动 → 就绪**。
+OfferU 有**两个入口，但只有一份 Career Truth**。
+
+**普通用户：App-first**
+
+```text
+安装 OfferU
+→ 自动发现本机 Agent
+→ 支持时自动投影/注册 OfferU Skill
+→ 保存一个岗位
+→ 工作结果进入 canonical Job Workspace
+```
+
+**高级用户：Skill-first**
+
+```text
+打开 Codex / Claude Code / WorkBuddy / OpenCode / OMP / 其他支持宿主
+→ 启用 OfferU Skill
+→ “帮我分析这个岗位”
+→ Agent 创建/解析 canonical Job
+→ 回到 OfferU 看到同一个 Job Workspace
+```
+
+产品方向仍然是 **连接 → 自动 → 就绪**。
-> **小白：连接一个 Agent。进阶：配置技术栈。**
+> **Skill 是 Agent 的入口，Job Workspace 才是用户的产品。**
普通用户不需要理解 Runtime、协议版本、模型 ID 或自定义端点。OfferU 会检测你本机已有的 Agent、
完成检查，然后直接使用它自己的模型和账号：
@@ -278,8 +334,10 @@ OfferU 还没有对外发布签名安装包。源码开发与内测请看：
下载
→ 安装
→ 自动发现本机 AI
+→ 支持时自动投影/注册 OfferU Skill
→ 简历 + 可选授权 AI 记忆 → Profile
→ 浏览器保存第一个岗位
+→ 打开 canonical Job Workspace
→ 可选连接求职邮箱
→ Today 主动告诉你下一步
```
diff --git a/docs/README.md b/docs/README.md
index 9b3ef9ea..0b65997f 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -36,7 +36,7 @@ Historical audits and dated reports are evidence of what was true when they were
| Area | Current document | Purpose |
| --- | --- | --- |
-| Product | [Current Product North Star](./product/current-product.md) | Zero-setup, Guided UX, external-first Agent, fallback Agent, Skills ecosystem, browser/email journeys |
+| Product | [Current Product North Star](./product/current-product.md) | Outcome-first Job Workspace, zero-setup App-first UX, Skill-first power-user entry, Guided Today, external-first Agent |
| Goal | [GOAL.md](../GOAL.md) | Public-release goal and durable release gates |
| Domain | [CONTEXT.md](../CONTEXT.md) | Career Truth, candidates, evidence, applications, memory and Agent vocabulary |
| Architecture | [ARCHITECTURE.md](../ARCHITECTURE.md) | Short current system boundary |
@@ -50,6 +50,12 @@ Historical audits and dated reports are evidence of what was true when they were
| Status | [STATUS.md](../STATUS.md) | current implementation state and blockers |
| Handoff | [HANDOFF.md](../HANDOFF.md) | latest continuation context for Coding Agents |
+## Product design rationale
+
+These explain why current product rules exist; they are references, not higher authority.
+
+- [Skill-first Agent Entry, Job Workspace & Product Story](./product/skill-first-job-workspace-story.md) — rationale and external reference patterns behind the now-adopted App-first / Skill-first dual entry, canonical Job Workspace and outcome-first product story.
+
## Document status classes
- **CURRENT AUTHORITY** — actively defines current product/architecture.
@@ -87,9 +93,12 @@ Do not rewrite old eval numbers to make them look current. Preserve the result a
~~~
OfferU Desktop = primary Career OS experience
+Job Workspace = durable product object for one opportunity
+App-first = default normal-user front door
+Skill-first = power-user Agent front door
External local Agent = preferred reasoning host
Built-in OfferU Agent = fallback
-Agent Skills = composable methodology layer
+Agent Skills = composable methodology / Agent entry layer
Operation Registry = execution / permission authority
Career Runtime = canonical truth
Today = guided next-best-action layer
diff --git a/docs/architecture/agent-system.md b/docs/architecture/agent-system.md
index 0a5a376e..51837705 100644
--- a/docs/architecture/agent-system.md
+++ b/docs/architecture/agent-system.md
@@ -37,9 +37,12 @@ Never translate binary found into supported.
4. It installs/projects the OfferU Skill where supported.
5. The host uses its own model/account.
6. OfferU exposes only the relevant Skill/tool surface.
+7. Agent work resolves against canonical Profile / Job / Application state and materializes into the same Job Workspace visible in OfferU Desktop.
A fallback OfferU Agent may be used if no external host is suitable.
+The Skill is an **Agent entry surface**, not a second product database or project system. A power user may begin from a supported Agent, but the result must be the same governed OfferU state that the Desktop app reads.
+
## Skill composition
A host may activate OfferU plus third-party Career Skills. OfferU context should ground third-party methodology. Third-party output is draft/candidate material until accepted through OfferU's normal persistence path.
@@ -57,9 +60,13 @@ manifest
The tool surface must be evaluated with real Agent tasks. Do not optimize for a pretty tool count at the expense of task completion.
-## Confirmation
+## Preparation plan and confirmation
+
+Before broad preparation, paid model work or external side effects, the Agent should surface a compact user-facing plan when scope/cost/irreversibility makes that useful. The plan explains the intended work, evidence basis, proposal status and any known account/rate/cost boundary.
+
+Protected state changes still create Proposals. The Agent may request a protected mutation and wait. It may not self-confirm it. OfferU UI is the authoritative human review surface.
-Protected state changes create Proposals. The Agent may request a protected mutation and wait. It may not self-confirm it. OfferU UI is the authoritative human review surface.
+Do not turn this into confirmation spam: work already inside an agreed safe scope can proceed until account, cost, scope or side-effect risk materially changes.
## Native tools
diff --git a/docs/architecture/workbench-interaction.md b/docs/architecture/workbench-interaction.md
index 720f81ed..8e3499ec 100644
--- a/docs/architecture/workbench-interaction.md
+++ b/docs/architecture/workbench-interaction.md
@@ -12,13 +12,15 @@ A local Agent may be the preferred reasoning environment, but users should not b
~~~
Install
→ Agent auto-discovery
+→ OfferU Skill projected automatically where supported
→ Know Me / Profile
→ Save first Job
+→ Open Job Workspace
→ Connect inbox
→ Today
~~~
-The default interaction is Guided, not command-first.
+The default interaction is Guided, not command-first. The user enters through OfferU Desktop; Skill installation and tool routing stay behind the product unless the user explicitly enters Power Mode.
## Today
@@ -42,7 +44,15 @@ Do not ask every preference on day one. Ask small contextual questions only when
Normal users should not have to choose Agent Skills manually. Natural-language goals and current Career State should route to the relevant Skill.
-Advanced users may open Agent/Skill/CLI controls in Power Mode.
+Advanced users may open Agent/Skill/CLI controls in Power Mode, including a Skill-first lane from a supported external Agent. A Skill-first action must create or update the same canonical Job Workspace visible in OfferU Desktop; it must never create a parallel Agent-only project.
+
+A useful mental model is:
+
+~~~
+Skill = Agent entry
+Job Workspace = user product
+Career Runtime = shared truth
+~~~
## Skill ecosystem UX
@@ -64,9 +74,24 @@ open job page
After inbox connection, OfferU may proactively detect likely career updates but presents ambiguous or important changes for review. The user should see a human-readable card, not IMAP/UID/cursor terminology.
+## Job Workspace
+
+A Job is not merely a detail page. It is the durable workspace for one opportunity.
+
+It should progressively collect:
+
+- Job Snapshot;
+- Role Intelligence;
+- Evidence Map;
+- application materials and versions;
+- interview preparation / debrief;
+- canonical Timeline and next action.
+
+Agent work should materialize into these visible objects as it completes. If the user closes the Agent conversation, the work remains understandable and reviewable in the Workspace.
+
## Focus work
-Resume deep editing, interview practice and complex evidence review may use focused workspaces, but they remain part of the same Job/Profile truth.
+Resume deep editing, interview practice and complex evidence review may use focused sub-workspaces, but they remain projections of the same Job/Profile truth.
## Design rule
diff --git a/docs/product/current-product.md b/docs/product/current-product.md
index 5583c834..34f85d74 100644
--- a/docs/product/current-product.md
+++ b/docs/product/current-product.md
@@ -10,7 +10,25 @@ This document defines the current product shape of OfferU. Historical audits, da
OfferU is a **local-first AI Career OS** for normal job seekers.
-It should reduce both:
+The category is broad; the first-use promise should be concrete:
+
+> **Give OfferU a job. It shows what the role really asks for, what you can prove, and prepares the application around that evidence.**
+
+The core product equation is:
+
+~~~
+Target Job
+ ↓
+What does this role care about?
+ ×
+What can I actually prove?
+ ↓
+What should I prepare next?
+ ↓
+Evidence-backed Job Workspace
+~~~
+
+OfferU should reduce both:
1. **setup burden** — users should not need Python, Node, Git, MCP, CLI, model IDs or provider configuration to start;
2. **decision burden** — users should not need to know which feature, mode, Skill or Agent command to invoke next.
@@ -20,15 +38,18 @@ The default experience is:
~~~
Install
→ Find my local AI automatically
+→ Project / register the OfferU Skill where supported
→ Resume + explicitly authorized AI memory → Profile
→ Save a real job from the browser
-→ Connect a job-search inbox
-→ Today tells me the next best actions
-→ Agent prepares / analyzes / drafts
+→ Create the canonical Job Workspace
+→ Agent prepares / analyzes / drafts into that Workspace
+→ Today tells me what needs attention next
→ User confirms important facts and irreversible actions
→ outcomes feed back into Profile and future decisions
~~~
+The user should experience a durable workspace, not a disposable AI conversation.
+
## Product information architecture
The stable top-level product model is:
@@ -42,11 +63,43 @@ Profile
- **Today** is the guided action layer. It answers “what matters now?” and shows at most a few primary actions.
- **Pipeline** projects application state, timeline and next action from the same canonical events.
-- **Job** contains role understanding, evidence gaps, resume/application material and interview preparation for one opportunity.
+- **Job / Job Workspace** is the durable application workspace for one opportunity: Job Snapshot, Role Intelligence, Evidence Map, application materials, interview preparation and canonical Timeline all converge here. Agent conversations are only one way to modify this workspace.
- **Profile** is the long-lived evidence-backed model of the user. Memory is an evolution mechanism for Profile, not a separate silo.
Agent, Skills, Email, Browser Capture, Resume, Role Intelligence and Interview are capabilities across these surfaces, not competing top-level products.
+## Two front doors, one Career Truth
+
+OfferU has two valid entry lanes that must converge on the same canonical state.
+
+### Normal user: App-first
+
+~~~
+Install OfferU
+→ auto-detect a supported local Agent
+→ project/register OfferU Skill automatically where supported
+→ import resume / core evidence
+→ save first Job
+→ open Job Workspace
+→ Guided Today handles the next decisions
+~~~
+
+Normal users do not need to know what a Skill, MCP server, Registry or provider topology is.
+
+### Power user: Skill-first
+
+A user already inside Codex, Claude Code, WorkBuddy/CodeBuddy, OpenCode, OMP, Pi or another supported host may start from the Agent:
+
+~~~
+enable OfferU Skill
+→ "analyze this job for me"
+→ Agent creates/resolves the canonical Job
+→ governed OfferU operations prepare the role
+→ open the same Job Workspace in OfferU
+~~~
+
+This must never become a second CLI-only product. Skill-first and App-first are two doors into the same Career Runtime, Job, Pipeline, Profile and audit trail.
+
## Reasoning authority: external-first, not external-only
OfferU prefers a **verified local Agent already owned by the user** — for example Codex, WorkBuddy/CodeBuddy, Claude Code, OpenCode, OMP, Pi or another supported host.
@@ -104,6 +157,36 @@ References:
- https://agentskills.io/
- https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills
+## Job Workspace as the durable product object
+
+The unit of work is not a chat transcript. For every target opportunity, OfferU should materialize a persistent, reviewable Job Workspace:
+
+~~~
+Job Workspace
+
+Job Snapshot
+Role Intelligence
+Evidence Map
+Application Materials
+Interview
+Timeline / Next Action
+~~~
+
+The Workspace progressively fills as work completes:
+
+~~~
+Job saved
+→ Job Snapshot ready
+→ Role Intelligence ready
+→ Evidence Map ready
+→ Resume proposals ready
+→ Interview focus ready
+~~~
+
+Long-running Agent work should surface as product state: completed, needs review, blocked/failed, and next action. Closing an Agent chat must not make the work disappear.
+
+Accepted facts, user edits and approved versions are preserved. Re-analysis may update affected preparation, but it must not reset unrelated application state or silently overwrite accepted work.
+
## Guided interaction
The default mode is **Guided**.
@@ -153,6 +236,18 @@ This is not background crawling and not an application event.
BOSS CLI, scraper adapters or other source connectors may exist for research, testing or advanced user workflows, but they are not the default consumer acquisition path and must not weaken platform, privacy or anti-automation boundaries.
+## Plan → Review → Execute
+
+Before a large preparation run, paid model work, or any external side effect, OfferU should show a compact plan at the level a normal user cares about:
+
+- what will be researched or generated;
+- which verified evidence will be used;
+- what is only a proposal;
+- which external actions will **not** happen automatically;
+- account / rate / estimated cost when materially relevant and known.
+
+This is not approval-everywhere. Work already inside an agreed safe scope may proceed; a material change of scope, cost, account or irreversible effect creates a new decision.
+
## Application assistance
OfferU may help prepare and fill an application, but the normal safety boundary remains:
@@ -222,6 +317,32 @@ Do not reintroduce these as defaults:
- a long command/mode menu as the beginner UX;
- treating historical eval/audit numbers as current capability truth.
+## Product story and launch order
+
+Product communication should start from the repeated user problem, not the internal architecture:
+
+1. every application starts from zero;
+2. the JD, resume, research, tracker and interview learning are fragmented;
+3. generic AI can optimize by inventing unless evidence and truth are separately governed;
+4. OfferU turns a target Job + verified Career Profile into one reviewable Job Workspace.
+
+Recommended information order:
+
+~~~
+Concrete Job → Workspace outcome
+→ complete Job-to-Workspace demo
+→ Role × Evidence formula
+→ why job-search AI breaks
+→ Job Workspace
+→ Quickstart
+→ local Agent / Skill entry
+→ Today / Pipeline / Profile compounding loop
+→ evidence / approval model
+→ architecture, security and release status
+~~~
+
+Operation Registry, Reasoning Authority and Career Runtime explain **why the experience can be trusted**; they are not the first reason a normal user cares.
+
## Success test
A new user should be able to understand OfferU without knowing what a Harness, MCP server, Operation Registry or provider is.
@@ -229,11 +350,13 @@ A new user should be able to understand OfferU without knowing what a Harness, M
The product is succeeding when the user experiences:
~~~
-OfferU knows my current career state
-→ tells me what matters next
+I give OfferU a Job
+→ it shows what the role cares about
+→ maps that against what I can actually prove
+→ prepares work into one durable Job Workspace
→ uses the AI I already have
-→ safely composes the Skills I already have
-→ prepares work proactively
+→ tells me what matters next
→ asks me only for decisions that genuinely require me
+→ preserves accepted work
→ learns from confirmed outcomes
~~~
diff --git a/docs/product/skill-first-job-workspace-story.md b/docs/product/skill-first-job-workspace-story.md
new file mode 100644
index 00000000..3321f436
--- /dev/null
+++ b/docs/product/skill-first-job-workspace-story.md
@@ -0,0 +1,424 @@
+# OfferU Skill-first Agent Entry, Job Workspace & Product Story
+
+Status: **DESIGN RATIONALE / DISTILLED REFERENCE**
+Updated: 2026-09-23
+
+This document records the external reference patterns and reasoning behind the Skill-first / Job Workspace direction. The accepted product rules have now been distilled into `GOAL.md`, `docs/product/current-product.md`, `docs/architecture/agent-system.md` and `docs/architecture/workbench-interaction.md`. Those authority documents override this rationale if wording diverges.
+
+The goal is to borrow useful patterns from successful Agent-first tools without copying their domain model: make the Agent entry extremely easy, materialize Agent work inside an editable workspace, and tell the product story from a repeated user pain rather than from architecture.
+
+## 1. Core distinction: Skill is the Agent entry; Workspace is the user product
+
+OfferU should not turn “install a Skill” into a requirement for ordinary users.
+
+The current Product North Star is correct:
+
+```text
+normal user:
+Install OfferU
+→ auto-detect local AI
+→ bootstrap Profile
+→ save a real Job
+→ OfferU prepares
+→ user reviews / acts
+```
+
+The pattern worth borrowing is architectural:
+
+```text
+Agent entry
+OfferU Skill
+ ↓
+OfferU capabilities
+ ↓
+Operation Registry
+ ↓
+Career Runtime
+ ↓
+same Job / Profile / Application state
+ ↑
+OfferU Desktop Workspace
+User entry
+```
+
+So:
+
+- **Skill = knowledge + capability entry for the Agent**
+- **OfferU Desktop = primary product surface for the user**
+- both converge on the same Career Truth;
+- neither creates a hidden parallel project.
+
+For advanced users, a manual Skill install may remain a fast explicit path. For normal users, OfferU should auto-discover the supported Agent and project/register the Skill with minimal interaction.
+
+## 2. Two onboarding lanes, one product state
+
+### Lane A — normal user: App-first, zero-setup
+
+```text
+Download / Install
+→ Launch OfferU
+→ Find supported local AI
+→ OfferU prepares its Skill automatically where supported
+→ Import resume / core career evidence
+→ Save first Job
+→ Job Workspace opens with preparation in progress
+→ Today shows what needs attention next
+```
+
+The user should not need to know:
+
+- what a Skill is;
+- MCP;
+- Operation Registry;
+- provider IDs;
+- model endpoints;
+- Python / Node / Git.
+
+### Lane B — power user: Skill-first
+
+When a user is already working inside Codex / Claude Code / WorkBuddy / OpenCode / OMP or another supported host:
+
+```text
+Install / enable OfferU Skill
+→ Agent checks OfferU availability
+→ "Analyze this job for me"
+→ Agent creates / resolves the canonical Job
+→ preparation runs through governed OfferU operations
+→ open the same Job Workspace in OfferU
+```
+
+Example desired interaction:
+
+```text
+/offeru Use this role:
+